Experiments with word-level data structures.

abclib.dsp

@@ -1127,6 +1127,10 @@ SOURCE=.\src\base\wln\wln.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\src\base\wln\wlnBlast.c
+# End Source File
+# Begin Source File
+
 SOURCE=.\src\base\wln\wlnMem.c
 # End Source File
 # Begin Source File
@@ -1143,6 +1147,10 @@ SOURCE=.\src\base\wln\wlnObj.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\src\base\wln\wlnRead.c
+# End Source File
+# Begin Source File
+
 SOURCE=.\src\base\wln\wlnRetime.c
 # End Source File
 # Begin Source File

src/aig/gia/giaDup.c

@@ -1086,6 +1086,20 @@ Gia_Man_t * Gia_ManDupAppendNew( Gia_Man_t * pOne, Gia_Man_t * pTwo )
     Gia_ManSetRegNum( pNew, Gia_ManRegNum(pOne) + Gia_ManRegNum(pTwo) );
     return pNew;
 }
+void Gia_ManDupRebuild( Gia_Man_t * pNew, Gia_Man_t * p, Vec_Int_t * vLits )
+{
+    Gia_Obj_t * pObj; int i;
+    assert( Vec_IntSize(vLits) == Gia_ManCiNum(p) );
+    Gia_ManConst0(p)->Value = 0;
+    Gia_ManForEachCi( p, pObj, i )
+        pObj->Value = Vec_IntEntry(vLits, i);
+    Gia_ManForEachAnd( p, pObj, i )
+        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+    Vec_IntClear( vLits );
+    Gia_ManForEachCo( p, pObj, i )
+        Vec_IntPush( vLits, Gia_ObjFanin0Copy(pObj) );
+    assert( Vec_IntSize(vLits) == Gia_ManCoNum(p) );
+}
 
 /**Function*************************************************************
 

src/aig/gia/giaPat2.c

@@ -1027,7 +1027,7 @@ Vec_Wec_t * Min_ManComputeCexes( Gia_Man_t * p, Vec_Int_t * vOuts0, int nMaxTrie
     if ( fVerbose )
         Abc_PrintTime( 1, "Simulation time  ", clkSim );
     if ( fVerbose )
-        Abc_PrintTime( 1, "SAT solving time", clkSat );
+        Abc_PrintTime( 1, "SAT solving time ", clkSat );
     //Vec_WecPrint( vCexes, 0 );
     if ( vOuts != vOuts0 )
         Vec_IntFreeP( &vOuts );

src/aig/miniaig/abcOper.h

@@ -226,6 +226,10 @@ static inline const char * Abc_OperName( int Type )
     if ( Type == ABC_OPER_ZEROPAD      )   return "zPad";   
     if ( Type == ABC_OPER_SIGNEXT      )   return "sExt";   
 
+    if ( Type == ABC_OPER_BIT_MUX      )   return "mux";       
+    if ( Type == ABC_OPER_SEL_NMUX     )   return "nmux";   
+    if ( Type == ABC_OPER_SEL_SEL      )   return "pmux";   
+
     if ( Type == ABC_OPER_CONST        )   return "const";  
     if ( Type == ABC_OPER_TABLE        )   return "table";  
     if ( Type == ABC_OPER_LUT          )   return "lut";  

src/base/main/mainInt.h

@@ -145,6 +145,7 @@ struct Abc_Frame_t_
     void *          pAbc85Delay;
     void *          pAbcWlc;
     Vec_Int_t *     pAbcWlcInv;
+    void *          pAbcRtl;
     void *          pAbcBac;
     void *          pAbcCba;
     void *          pAbcPla;

src/base/wlc/wlcCom.c

@@ -32,7 +32,6 @@ ABC_NAMESPACE_IMPL_START
 
 static int  Abc_CommandReadWlc    ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int  Abc_CommandWriteWlc   ( Abc_Frame_t * pAbc, int argc, char ** argv );
-static int  Abc_CommandYosys      ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int  Abc_CommandPs         ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int  Abc_CommandCone       ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int  Abc_CommandAbs        ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -55,12 +54,20 @@ static int  Abc_CommandInvPut     ( Abc_Frame_t * pAbc, int argc, char ** argv )
 static int  Abc_CommandInvMin     ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int  Abc_CommandTest       ( Abc_Frame_t * pAbc, int argc, char ** argv );
 
+static int  Abc_CommandYosys      ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int  Abc_CommandSolve      ( Abc_Frame_t * pAbc, int argc, char ** argv );
+
 static inline Wlc_Ntk_t * Wlc_AbcGetNtk( Abc_Frame_t * pAbc )                       { return (Wlc_Ntk_t *)pAbc->pAbcWlc;                      }
 static inline void        Wlc_AbcFreeNtk( Abc_Frame_t * pAbc )                      { if ( pAbc->pAbcWlc ) Wlc_NtkFree(Wlc_AbcGetNtk(pAbc));  }
 static inline void        Wlc_AbcUpdateNtk( Abc_Frame_t * pAbc, Wlc_Ntk_t * pNtk )  { Wlc_AbcFreeNtk(pAbc); pAbc->pAbcWlc = pNtk;             }
 
 static inline Vec_Int_t * Wlc_AbcGetInv( Abc_Frame_t * pAbc )                       { return pAbc->pAbcWlcInv;                                }
 
+
+static inline Rtl_Lib_t * Wlc_AbcGetRtl( Abc_Frame_t * pAbc )                       { return (Rtl_Lib_t *)pAbc->pAbcRtl;                      }
+static inline void        Wlc_AbcFreeRtl( Abc_Frame_t * pAbc )                      { if ( pAbc->pAbcRtl ) Rtl_LibFree(Wlc_AbcGetRtl(pAbc));  }
+static inline void        Wlc_AbcUpdateRtl( Abc_Frame_t * pAbc, Rtl_Lib_t * pLib )  { Wlc_AbcFreeRtl(pAbc); pAbc->pAbcRtl = pLib;             }
+
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
@@ -80,7 +87,6 @@ void Wlc_Init( Abc_Frame_t * pAbc )
 {
     Cmd_CommandAdd( pAbc, "Word level", "%read",        Abc_CommandReadWlc,    0 );
     Cmd_CommandAdd( pAbc, "Word level", "%write",       Abc_CommandWriteWlc,   0 );
-    Cmd_CommandAdd( pAbc, "Word level", "%yosys",       Abc_CommandYosys,      0 );
     Cmd_CommandAdd( pAbc, "Word level", "%ps",          Abc_CommandPs,         0 );
     Cmd_CommandAdd( pAbc, "Word level", "%cone",        Abc_CommandCone,       0 );
     Cmd_CommandAdd( pAbc, "Word level", "%abs",         Abc_CommandAbs,        0 );
@@ -97,6 +103,9 @@ void Wlc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "Word level", "%show",        Abc_CommandShow,       0 );
     Cmd_CommandAdd( pAbc, "Word level", "%test",        Abc_CommandTest,       0 );
 
+    Cmd_CommandAdd( pAbc, "Word level", "%yosys",       Abc_CommandYosys,      0 );
+    Cmd_CommandAdd( pAbc, "Word level", "%solve",       Abc_CommandSolve,      0 );
+
     Cmd_CommandAdd( pAbc, "Word level", "inv_ps",       Abc_CommandInvPs,      0 );
     Cmd_CommandAdd( pAbc, "Word level", "inv_print",    Abc_CommandInvPrint,   0 );
     Cmd_CommandAdd( pAbc, "Word level", "inv_check",    Abc_CommandInvCheck,   0 );
@@ -308,130 +317,6 @@ usage:
   SeeAlso     []
 
 ******************************************************************************/
-int Abc_CommandYosys( Abc_Frame_t * pAbc, int argc, char ** argv )
-{
-    extern Gia_Man_t * Wln_BlastSystemVerilog( char * pFileName, char * pTopModule, int fSkipStrash, int fInvert, int fTechMap, int fVerbose );
-    extern Wln_Ntk_t * Wln_ReadSystemVerilog( char * pFileName, char * pTopModule, int fVerbose );
-
-    FILE * pFile;
-    char * pFileName = NULL;
-    char * pTopModule= NULL;
-    int fCollapse    =    0;
-    int fBlast       =    0;
-    int fInvert      =    0;
-    int fTechMap     =    0;
-    int fSkipStrash  =    0;
-    int c, fVerbose  =    0;
-    Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "Tcaismvh" ) ) != EOF )
-    {
-        switch ( c )
-        {
-        case 'T':
-            if ( globalUtilOptind >= argc )
-            {
-                Abc_Print( -1, "Command line switch \"-T\" should be followed by a file name.\n" );
-                goto usage;
-            }
-            pTopModule = argv[globalUtilOptind];
-            globalUtilOptind++;
-            break;
-        case 'c':
-            fCollapse ^= 1;
-            break;
-        case 'a':
-            fBlast ^= 1;
-            break;
-        case 'i':
-            fInvert ^= 1;
-            break;
-        case 's':
-            fSkipStrash ^= 1;
-            break;
-        case 'm':
-            fTechMap ^= 1;
-            break;
-        case 'v':
-            fVerbose ^= 1;
-            break;
-        case 'h':
-            goto usage;
-        default:
-            goto usage;
-        }
-    }
-    if ( argc != globalUtilOptind + 1 )
-    {
-        printf( "Abc_CommandReadWlc(): Input file name should be given on the command line.\n" );
-        return 0;
-    }
-    // get the file name
-    pFileName = argv[globalUtilOptind];
-    if ( (pFile = fopen( pFileName, "r" )) == NULL )
-    {
-        Abc_Print( 1, "Cannot open input file \"%s\". ", pFileName );
-        if ( (pFileName = Extra_FileGetSimilarName( pFileName, ".v", ".sv", NULL, NULL, NULL )) )
-            Abc_Print( 1, "Did you mean \"%s\"?", pFileName );
-        Abc_Print( 1, "\n" );
-        return 0;
-    }
-    fclose( pFile );
-
-    // perform reading
-    if ( fBlast )
-    {
-        Gia_Man_t * pNew = NULL;
-        if ( !strcmp( Extra_FileNameExtension(pFileName), "v" )  )
-            pNew = Wln_BlastSystemVerilog( pFileName, pTopModule, fSkipStrash, fInvert, fTechMap, fVerbose );
-        else if ( !strcmp( Extra_FileNameExtension(pFileName), "sv" )  )
-            pNew = Wln_BlastSystemVerilog( pFileName, pTopModule, fSkipStrash, fInvert, fTechMap, fVerbose );
-        else
-        {
-            printf( "Abc_CommandYosys(): Unknown file extension.\n" );
-            return 0;
-        }
-        Abc_FrameUpdateGia( pAbc, pNew );
-    }
-    else
-    {
-        Wln_Ntk_t * pNtk = NULL;
-        if ( !strcmp( Extra_FileNameExtension(pFileName), "v" )  )
-            pNtk = Wln_ReadSystemVerilog( pFileName, pTopModule, fVerbose );
-        else if ( !strcmp( Extra_FileNameExtension(pFileName), "sv" )  )
-            pNtk = Wln_ReadSystemVerilog( pFileName, pTopModule, fVerbose );
-        else
-        {
-            printf( "Abc_CommandYosys(): Unknown file extension.\n" );
-            return 0;
-        }
-        //Wlc_AbcUpdateNtk( pAbc, pNtk );
-    }
-    return 0;
-usage:
-    Abc_Print( -2, "usage: %%yosys [-T <module>] [-caismvh] <file_name>\n" );
-    Abc_Print( -2, "\t         reads Verilog or SystemVerilog using Yosys\n" );
-    Abc_Print( -2, "\t-T     : specify the top module name (default uses \"-auto-top\"\n" );
-    Abc_Print( -2, "\t-c     : toggle collapsing the design using Yosys [default = %s]\n", fCollapse? "yes": "no" );
-    Abc_Print( -2, "\t-a     : toggle bit-blasting the design using Yosys [default = %s]\n", fBlast? "yes": "no" );
-    Abc_Print( -2, "\t-i     : toggle interting the outputs (useful for miters) [default = %s]\n", fInvert? "yes": "no" );
-    Abc_Print( -2, "\t-s     : toggle no structural hashing during bit-blasting [default = %s]\n", fSkipStrash? "no strash": "strash" );
-    Abc_Print( -2, "\t-m     : toggle using \"techmap\" to blast operators [default = %s]\n", fTechMap? "yes": "no" );
-    Abc_Print( -2, "\t-v     : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
-    Abc_Print( -2, "\t-h     : print the command usage\n");
-    return 1;
-}
-
-/**Function********************************************************************
-
-  Synopsis    []
-
-  Description []
-
-  SideEffects []
-
-  SeeAlso     []
-
-******************************************************************************/
 int Abc_CommandPs( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
     Wlc_Ntk_t * pNtk = Wlc_AbcGetNtk(pAbc);
@@ -2097,6 +1982,205 @@ usage:
     return 1;
 }
 
+
+/**Function********************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Abc_CommandYosys( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern Gia_Man_t * Wln_BlastSystemVerilog( char * pFileName, char * pTopModule, int fSkipStrash, int fInvert, int fTechMap, int fVerbose );
+    extern Rtl_Lib_t * Wln_ReadSystemVerilog( char * pFileName, char * pTopModule, int fCollapse, int fVerbose );
+
+    FILE * pFile;
+    char * pFileName = NULL;
+    char * pTopModule= NULL;
+    int fBlast       =    0;
+    int fInvert      =    0;
+    int fTechMap     =    1;
+    int fSkipStrash  =    0;
+    int fCollapse    =    0;
+    int c, fVerbose  =    0;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "Tbismcvh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'T':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-T\" should be followed by a file name.\n" );
+                goto usage;
+            }
+            pTopModule = argv[globalUtilOptind];
+            globalUtilOptind++;
+            break;
+        case 'b':
+            fBlast ^= 1;
+            break;
+        case 'i':
+            fInvert ^= 1;
+            break;
+        case 's':
+            fSkipStrash ^= 1;
+            break;
+        case 'm':
+            fTechMap ^= 1;
+            break;
+        case 'c':
+            fCollapse ^= 1;
+            break;
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+    if ( argc != globalUtilOptind + 1 )
+    {
+        printf( "Abc_CommandReadWlc(): Input file name should be given on the command line.\n" );
+        return 0;
+    }
+    // get the file name
+    pFileName = argv[globalUtilOptind];
+    if ( (pFile = fopen( pFileName, "r" )) == NULL )
+    {
+        Abc_Print( 1, "Cannot open input file \"%s\". ", pFileName );
+        if ( (pFileName = Extra_FileGetSimilarName( pFileName, ".v", ".sv", NULL, NULL, NULL )) )
+            Abc_Print( 1, "Did you mean \"%s\"?", pFileName );
+        Abc_Print( 1, "\n" );
+        return 0;
+    }
+    fclose( pFile );
+
+    // perform reading
+    if ( fBlast )
+    {
+        Gia_Man_t * pNew = NULL;
+        if ( !strcmp( Extra_FileNameExtension(pFileName), "v" )  )
+            pNew = Wln_BlastSystemVerilog( pFileName, pTopModule, fSkipStrash, fInvert, fTechMap, fVerbose );
+        else if ( !strcmp( Extra_FileNameExtension(pFileName), "sv" )  )
+            pNew = Wln_BlastSystemVerilog( pFileName, pTopModule, fSkipStrash, fInvert, fTechMap, fVerbose );
+        else if ( !strcmp( Extra_FileNameExtension(pFileName), "rtlil" )  )
+            pNew = Wln_BlastSystemVerilog( pFileName, pTopModule, fSkipStrash, fInvert, fTechMap, fVerbose );
+        else
+        {
+            printf( "Abc_CommandYosys(): Unknown file extension.\n" );
+            return 0;
+        }
+        Abc_FrameUpdateGia( pAbc, pNew );
+    }
+    else
+    {
+        Rtl_Lib_t * pLib = NULL;
+        if ( !strcmp( Extra_FileNameExtension(pFileName), "v" )  )
+            pLib = Wln_ReadSystemVerilog( pFileName, pTopModule, fCollapse, fVerbose );
+        else if ( !strcmp( Extra_FileNameExtension(pFileName), "sv" )  )
+            pLib = Wln_ReadSystemVerilog( pFileName, pTopModule, fCollapse, fVerbose );
+        else if ( !strcmp( Extra_FileNameExtension(pFileName), "rtlil" )  )
+            pLib = Wln_ReadSystemVerilog( pFileName, pTopModule, fCollapse, fVerbose );
+        else
+        {
+            printf( "Abc_CommandYosys(): Unknown file extension.\n" );
+            return 0;
+        }
+        Wlc_AbcUpdateRtl( pAbc, pLib );
+    }
+    return 0;
+usage:
+    Abc_Print( -2, "usage: %%yosys [-T <module>] [-bismcvh] <file_name>\n" );
+    Abc_Print( -2, "\t         reads Verilog or SystemVerilog using Yosys\n" );
+    Abc_Print( -2, "\t-T     : specify the top module name (default uses \"-auto-top\"\n" );
+    Abc_Print( -2, "\t-b     : toggle bit-blasting the design into an AIG using Yosys [default = %s]\n", fBlast? "yes": "no" );
+    Abc_Print( -2, "\t-i     : toggle interting the outputs (useful for miters) [default = %s]\n", fInvert? "yes": "no" );
+    Abc_Print( -2, "\t-s     : toggle no structural hashing during bit-blasting [default = %s]\n", fSkipStrash? "no strash": "strash" );
+    Abc_Print( -2, "\t-m     : toggle using \"techmap\" to blast operators [default = %s]\n", fTechMap? "yes": "no" );
+    Abc_Print( -2, "\t-c     : toggle collapsing design hierarchy using Yosys [default = %s]\n", fCollapse? "yes": "no" );
+    Abc_Print( -2, "\t-v     : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-h     : print the command usage\n");
+    return 1;
+}
+
+/**Function********************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Abc_CommandSolve( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern void Rtl_LibPrintStats( Rtl_Lib_t * p );
+    extern void Rtl_LibPrint( char * pFileName, Rtl_Lib_t * p );
+    extern void Rtl_LibNormRanges( Rtl_Lib_t * pLib );
+    extern void Rtl_LibOrderWires( Rtl_Lib_t * pLib );
+    extern void Rtl_LibOrderCells( Rtl_Lib_t * pLib );
+    extern void Rtl_LibBlast( Rtl_Lib_t * pLib );
+    extern void Rtl_LibReorderModules( Rtl_Lib_t * pLib );
+    extern void Rtl_LibSolve( Rtl_Lib_t * pLib );
+    extern void Rtl_LibPreprocess( Rtl_Lib_t * pLib );
+
+    Gia_Man_t * pGia = NULL;
+    Rtl_Lib_t * pLib = Wlc_AbcGetRtl(pAbc);
+    int c, fPrepro = 0, fVerbose  = 0;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "pvh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'p':
+            fPrepro ^= 1;
+            break;
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+    Rtl_LibPrintStats( pLib );
+    //Rtl_LibPrint( NULL, pLib );
+    Rtl_LibOrderWires( pLib );
+    Rtl_LibOrderCells( pLib );
+
+    Rtl_LibBlast( pLib );
+    //Rtl_LibReorderModules( pLib );
+    //Rtl_LibPrintStats( pLib );
+
+    if ( fPrepro )
+        Rtl_LibPreprocess( pLib );
+    Rtl_LibSolve( pLib );
+
+    //Rtl_LibPrint( NULL, pLib );
+    Wlc_AbcUpdateRtl( pAbc, NULL );
+    Gia_ManStopP( &pGia );
+    return 0;
+usage:
+    Abc_Print( -2, "usage: %%solve [-pvh]\n" );
+    Abc_Print( -2, "\t         experiments with word-level networks\n" );
+    Abc_Print( -2, "\t-p     : toggle preprocessing for verification [default = %s]\n", fPrepro? "yes": "no" );
+    Abc_Print( -2, "\t-v     : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-h     : print the command usage\n");
+    return 1;
+}
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////

src/base/wln/module.make

 SRC +=    src/base/wln/wln.c \
+    src/base/wln/wlnBlast.c \
     src/base/wln/wlnMem.c \
     src/base/wln/wlnNdr.c \
     src/base/wln/wlnNtk.c \
     src/base/wln/wlnObj.c \
+    src/base/wln/wlnRead.c \
     src/base/wln/wlnRetime.c \
     src/base/wln/wlnRtl.c \
     src/base/wln/wlnWlc.c \

src/base/wln/wln.h

@@ -251,6 +251,10 @@ extern void           Wln_NtkRetimeCreateDelayInfo( Wln_Ntk_t * pNtk );
 /*=== wlcWriteVer.c ========================================================*/
 extern void           Wln_WriteVer( Wln_Ntk_t * p, char * pFileName );
 
+/*=== wlcRead.c ========================================================*/
+typedef struct Rtl_Lib_t_ Rtl_Lib_t;
+extern Rtl_Lib_t *    Rtl_LibReadFile( char * pFileName, char * pFileSpec );
+extern void           Rtl_LibFree( Rtl_Lib_t * p );
 
 ABC_NAMESPACE_HEADER_END
 

src/base/wln/wlnBlast.c

+/**CFile****************************************************************
+
+  FileName    [wlnBlast.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Word-level network.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - September 23, 2018.]
+
+  Revision    [$Id: wlnBlast.c,v 1.00 2018/09/23 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "wln.h"
+#include "base/wlc/wlc.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Rtl_VecExtend( Vec_Int_t * p, int nRange, int fSigned )
+{
+    Vec_IntFillExtra( p, nRange, fSigned ? Vec_IntEntryLast(p) : 0 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Rtl_NtkBlastNode( Gia_Man_t * pNew, int Type, int nIns, Vec_Int_t * vDatas, int nRange, int fSign0, int fSign1 )
+{
+    extern void Wlc_BlastMinus( Gia_Man_t * pNew, int * pNum, int nNum, Vec_Int_t * vRes );
+    extern int  Wlc_BlastReduction( Gia_Man_t * pNew, int * pFans, int nFans, int Type );
+    extern int  Wlc_BlastLess( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits );
+    extern int  Wlc_BlastLessSigned( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits );
+    extern void Wlc_BlastShiftRight( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes );
+    extern void Wlc_BlastShiftLeft( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes );
+    extern int  Wlc_BlastAdder( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits, int Carry ); // result is in pAdd0
+    extern void Wlc_BlastSubtract( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits, int Carry ); // result is in pAdd0
+    extern int  Wlc_NtkCountConstBits( int * pArray, int nSize );
+    extern void Wlc_BlastBooth( Gia_Man_t * pNew, int * pArgA, int * pArgB, int nArgA, int nArgB, Vec_Int_t * vRes, int fSigned, int fCla, Vec_Wec_t ** pvProds );
+    extern void Wlc_BlastMultiplier3( Gia_Man_t * pNew, int * pArgA, int * pArgB, int nArgA, int nArgB, Vec_Int_t * vRes, int fSigned, int fCla, Vec_Wec_t ** pvProds );
+    extern void Wlc_BlastZeroCondition( Gia_Man_t * pNew, int * pDiv, int nDiv, Vec_Int_t * vRes );
+    extern void Wlc_BlastDivider( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes );
+    extern void Wlc_BlastDividerSigned( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes );
+    extern void Wlc_BlastPower( Gia_Man_t * pNew, int * pNum, int nNum, int * pExp, int nExp, Vec_Int_t * vTemp, Vec_Int_t * vRes );
+
+    int k, iLit, iLit0, iLit1;
+    if ( nIns == 1 )
+    {
+        Vec_Int_t * vArg = vDatas;
+        Vec_Int_t * vRes = vDatas+3;
+        assert( Vec_IntSize(vRes) == 0 );
+        if ( Type == ABC_OPER_BIT_INV )   // Y = ~A    $not  
+        {
+            assert( Vec_IntSize(vArg) == nRange );
+            Vec_IntForEachEntry( vArg, iLit, k )
+                Vec_IntPush( vRes, Abc_LitNot(iLit) );
+            return;
+        }
+        if ( Type == ABC_OPER_BIT_BUF )   // Y = +A    $pos 
+        {
+            assert( Vec_IntSize(vArg) == nRange );
+            Vec_IntForEachEntry( vArg, iLit, k )
+                Vec_IntPush( vRes, iLit );
+            return;
+        }
+        if ( Type == ABC_OPER_ARI_MIN )   // Y = -A    $neg 
+        {
+            assert( Vec_IntSize(vArg) == nRange );
+            Wlc_BlastMinus( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), vRes );
+            return;
+        }
+        if ( Type == ABC_OPER_RED_AND )   // Y = &A    $reduce_and
+        {
+            assert( nRange == 1 );
+            Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_AND ) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+        if ( Type == ABC_OPER_RED_OR )    // Y = |A    $reduce_or     $reduce_bool 
+        {
+            assert( nRange == 1 );
+            Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_OR ) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+        if ( Type == ABC_OPER_RED_XOR )   // Y = ^A    $reduce_xor  
+        {
+            assert( nRange == 1 );
+            Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_XOR ) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+        if ( Type == ABC_OPER_RED_NXOR )  // Y = ~^A   $reduce_xnor 
+        {
+            assert( nRange == 1 );
+            Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_NXOR ) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+        if ( Type == ABC_OPER_LOGIC_NOT ) // Y = !A    $logic_not   
+        {
+            int iLit = Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_OR );
+            assert( nRange == 1 );
+            Vec_IntFill( vRes, 1, Abc_LitNot(iLit) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+        assert( 0 );
+        return;
+    }
+
+    if ( nIns == 2 )
+    {
+        Vec_Int_t * vArg0 = vDatas;
+        Vec_Int_t * vArg1 = vDatas+1;
+        Vec_Int_t * vRes  = vDatas+3;
+        int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(Vec_IntSize(vArg0), Vec_IntSize(vArg1)) );
+        int nSizeArg0 = Vec_IntSize(vArg0);
+        int nSizeArg1 = Vec_IntSize(vArg1);
+        Rtl_VecExtend( vArg0, nRangeMax, fSign0 );
+        Rtl_VecExtend( vArg1, nRangeMax, fSign1 );
+        assert( Vec_IntSize(vArg0) == Vec_IntSize(vArg1) );
+        assert( Vec_IntSize(vRes) == 0 );
+        if ( Type == ABC_OPER_LOGIC_AND )     // Y = A && B   $logic_and  
+        {
+            int iLit0 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg0), Vec_IntSize(vArg0), WLC_OBJ_REDUCT_OR );
+            int iLit1 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg1), Vec_IntSize(vArg1), WLC_OBJ_REDUCT_OR );
+            assert( 1 == nRange );
+            Vec_IntFill( vRes, 1, Gia_ManHashAnd(pNew, iLit0, iLit1) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+        if ( Type == ABC_OPER_LOGIC_OR )      // Y = A || B   $logic_or    
+        {
+            int iLit0 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg0), Vec_IntSize(vArg0), WLC_OBJ_REDUCT_OR );
+            int iLit1 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg1), Vec_IntSize(vArg1), WLC_OBJ_REDUCT_OR );
+            assert( 1 == nRange );
+            Vec_IntFill( vRes, 1, Gia_ManHashOr(pNew, iLit0, iLit1) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+
+        if ( Type == ABC_OPER_BIT_AND )     // Y = A & B    $and
+        {
+            Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
+                Vec_IntPush( vRes, Gia_ManHashAnd(pNew, iLit0, iLit1) );
+            Vec_IntShrink( vRes, nRange );
+            return;
+        }
+        if ( Type == ABC_OPER_BIT_OR )      // Y = A | B    $or    
+        {
+            Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
+                Vec_IntPush( vRes, Gia_ManHashOr(pNew, iLit0, iLit1) );
+            Vec_IntShrink( vRes, nRange );
+            return;
+        }
+        if ( Type == ABC_OPER_BIT_XOR )     // Y = A ^ B    $xor
+        { 
+            Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
+                Vec_IntPush( vRes, Gia_ManHashXor(pNew, iLit0, iLit1) );
+            Vec_IntShrink( vRes, nRange );
+            return;
+        }
+        if ( Type == ABC_OPER_BIT_NXOR )    // Y = A ~^ B   $xnor
+        {
+            assert( Vec_IntSize(vArg0) == nRange );
+            Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
+                Vec_IntPush( vRes, Abc_LitNot(Gia_ManHashXor(pNew, iLit0, iLit1)) );
+            Vec_IntShrink( vRes, nRange );
+            return;
+        }
+/*
+        if ( !strcmp(pType, "$lt") )          return ABC_OPER_COMP_LESS;     // Y = A <  B   $lt          
+        if ( !strcmp(pType, "$le") )          return ABC_OPER_COMP_LESSEQU;  // Y = A <= B   $le         
+        if ( !strcmp(pType, "$ge") )          return ABC_OPER_COMP_MOREEQU;  // Y = A >= B   $ge           
+        if ( !strcmp(pType, "$gt") )          return ABC_OPER_COMP_MORE;     // Y = A >  B   $gt        
+        if ( !strcmp(pType, "$eq") )          return ABC_OPER_COMP_EQU;      // Y = A == B   $eq         
+        if ( !strcmp(pType, "$ne") )          return ABC_OPER_COMP_NOTEQU;   // Y = A != B   $ne         
+*/
+        if ( Type == ABC_OPER_COMP_EQU || Type == ABC_OPER_COMP_NOTEQU )
+        {
+            iLit = 0;
+            assert( nRange == 1 );
+            Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
+                iLit = Gia_ManHashOr( pNew, iLit, Gia_ManHashXor(pNew, iLit0, iLit1) ); 
+            Vec_IntFill( vRes, 1, Abc_LitNotCond(iLit, Type == ABC_OPER_COMP_EQU) );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+        if ( Type == ABC_OPER_COMP_LESS || Type == ABC_OPER_COMP_LESSEQU ||
+             Type == ABC_OPER_COMP_MORE || Type == ABC_OPER_COMP_MOREEQU )
+        {
+            int fSigned = fSign0 && fSign1;
+            int fSwap   = (Type == ABC_OPER_COMP_MORE    || Type == ABC_OPER_COMP_LESSEQU);
+            int fCompl  = (Type == ABC_OPER_COMP_MOREEQU || Type == ABC_OPER_COMP_LESSEQU);
+            assert( Vec_IntSize(vArg0) == Vec_IntSize(vArg1) );
+            assert( nRange == 1 );
+            if ( fSwap ) 
+                ABC_SWAP( Vec_Int_t, *vArg0, *vArg1 )
+            if ( fSigned )
+                iLit = Wlc_BlastLessSigned( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0) );
+            else
+                iLit = Wlc_BlastLess( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0) );
+            iLit = Abc_LitNotCond( iLit, fCompl );
+            Vec_IntFill( vRes, 1, iLit );
+            for ( k = 1; k < nRange; k++ )
+                Vec_IntPush( vRes, 0 );
+            return;
+        }
+/*        
+        if ( !strcmp(pType, "$shl") )         return ABC_OPER_SHIFT_L;       // Y = A << B   $shl        
+        if ( !strcmp(pType, "$shr") )         return ABC_OPER_SHIFT_R;       // Y = A >> B   $shr        
+        if ( !strcmp(pType, "$sshl") )        return ABC_OPER_SHIFT_LA;      // Y = A <<< B  $sshl      
+        if ( !strcmp(pType, "$sshr") )        return ABC_OPER_SHIFT_RA;      // Y = A >>> B  $sshr  
+*/
+        if ( Type == ABC_OPER_SHIFT_R || Type == ABC_OPER_SHIFT_RA ||
+             Type == ABC_OPER_SHIFT_L || Type == ABC_OPER_SHIFT_LA )
+        {
+            Vec_IntShrink( vArg1, nSizeArg1 );
+            if ( Type == ABC_OPER_SHIFT_R || Type == ABC_OPER_SHIFT_RA )
+                Wlc_BlastShiftRight( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nSizeArg1, fSign0 && Type == ABC_OPER_SHIFT_RA, vRes );
+            else
+                Wlc_BlastShiftLeft( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nSizeArg1, 0, vRes );
+            Vec_IntShrink( vRes, nRange );
+            return;
+        }
+/*
+        if ( !strcmp(pType, "$add") )         return ABC_OPER_ARI_ADD;       // Y = A + B    $add         
+        if ( !strcmp(pType, "$sub") )         return ABC_OPER_ARI_SUB;       // Y = A - B    $sub         
+        if ( !strcmp(pType, "$mul") )         return ABC_OPER_ARI_MUL;       // Y = A * B    $mul         
+        if ( !strcmp(pType, "$div") )         return ABC_OPER_ARI_DIV;       // Y = A / B    $div         
+        if ( !strcmp(pType, "$mod") )         return ABC_OPER_ARI_MOD;       // Y = A % B    $mod         
+        if ( !strcmp(pType, "$pow") )         return ABC_OPER_ARI_POW;       // Y = A ** B   $pow        
+*/
+        if ( Type == ABC_OPER_ARI_ADD || Type == ABC_OPER_ARI_SUB )
+        {
+            //Vec_IntPrint( vArg0 );
+            //Vec_IntPrint( vArg1 );
+            Vec_IntAppend( vRes, vArg0 );
+            if ( Type == ABC_OPER_ARI_ADD )
+                Wlc_BlastAdder( pNew, Vec_IntArray(vRes), Vec_IntArray(vArg1), nRangeMax, 0 ); // result is in pFan0 (vRes)
+            else 
+                Wlc_BlastSubtract( pNew, Vec_IntArray(vRes), Vec_IntArray(vArg1), nRangeMax, 1 ); // result is in pFan0 (vRes)
+            Vec_IntShrink( vRes, nRange );
+            return;
+        }
+        if ( Type == ABC_OPER_ARI_MUL )
+        {
+            int fBooth  = 1;
+            int fCla    = 0;
+            int fSigned = fSign0 && fSign1;
+            Vec_IntShrink( vArg0, nSizeArg0 );
+            Vec_IntShrink( vArg1, nSizeArg1 );
+            if ( Wlc_NtkCountConstBits(Vec_IntArray(vArg0), Vec_IntSize(vArg0)) < Wlc_NtkCountConstBits(Vec_IntArray(vArg1), Vec_IntSize(vArg1)) )
+                ABC_SWAP( Vec_Int_t, *vArg0, *vArg1 )
+            if ( fBooth )
+                Wlc_BlastBooth( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0), Vec_IntSize(vArg1), vRes, fSigned, fCla, NULL );
+            else
+                Wlc_BlastMultiplier3( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0), Vec_IntSize(vArg1), vRes, fSigned, fCla, NULL );
+            if ( nRange > Vec_IntSize(vRes) )
+                Vec_IntFillExtra( vRes, nRange, fSigned ? Vec_IntEntryLast(vRes) : 0 );
+            else
+                Vec_IntShrink( vRes, nRange );
+            assert( Vec_IntSize(vRes) == nRange );
+            return;
+        }
+        if ( Type == ABC_OPER_ARI_DIV || Type == ABC_OPER_ARI_MOD )
+        {
+            int fDivBy0 = 1; // correct with 1
+            int fSigned = fSign0 && fSign1;
+            if ( fSigned )
+                Wlc_BlastDividerSigned( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nRangeMax, Type == ABC_OPER_ARI_DIV, vRes );
+            else
+                Wlc_BlastDivider( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nRangeMax, Type == ABC_OPER_ARI_DIV, vRes );
+            Vec_IntShrink( vRes, nRange );
+            if ( !fDivBy0 )
+                Wlc_BlastZeroCondition( pNew, Vec_IntArray(vArg1), nRange, vRes );
+            return;
+        }
+        if ( Type == ABC_OPER_ARI_POW )
+        {
+            Vec_Int_t * vTemp = vDatas+4;
+            Vec_IntGrow( vTemp, nRangeMax );
+            Vec_IntGrow( vRes,  nRangeMax );
+            Vec_IntShrink( vArg1, nSizeArg1 );
+            Wlc_BlastPower( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), Vec_IntSize(vArg1), vTemp, vRes );
+            Vec_IntShrink( vRes, nRange );
+            return;
+        }
+    }
+
+    if ( nIns == 3 )
+    {
+        if ( Type == ABC_OPER_SEL_NMUX )    // $mux 
+        {
+            Vec_Int_t * vArg0 = vDatas;
+            Vec_Int_t * vArg1 = vDatas+1;
+            Vec_Int_t * vArgS = vDatas+2;
+            Vec_Int_t * vRes  = vDatas+3;
+            int iCtrl = Vec_IntEntry(vArgS, 0);
+            //Vec_IntPrint( vArg0 );
+            //Vec_IntPrint( vArg1 );
+            //Vec_IntPrint( vArgS );
+            assert( Vec_IntSize(vArg0) == Vec_IntSize(vArg1) );
+            assert( Vec_IntSize(vArg0) == nRange );
+            assert( Vec_IntSize(vArgS) == 1 );
+            assert( Vec_IntSize(vRes) == 0 );
+            Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
+                Vec_IntPush( vRes, Gia_ManHashMux(pNew, iCtrl, iLit1, iLit0) );
+            return;
+        }
+        if ( Type == ABC_OPER_SEL_SEL )    // $pmux 
+        {
+            int i, k, iLit;
+            Vec_Int_t * vArgA = vDatas;
+            Vec_Int_t * vArgB = vDatas+1;
+            Vec_Int_t * vArgS = vDatas+2;
+            Vec_Int_t * vRes  = vDatas+3;
+            Vec_Int_t * vTemp = vDatas+4;
+            assert( Vec_IntSize(vArgA) == nRange ); // widthA = widthY
+            assert( Vec_IntSize(vArgB) == Vec_IntSize(vArgA)*Vec_IntSize(vArgS) ); // widthB == widthA*widthS
+            assert( Vec_IntSize(vRes)  == 0 );
+            for ( i = 0; i < nRange; i++ )
+            {
+                int iCond = 1;
+                Vec_IntClear( vTemp );
+                Vec_IntForEachEntry( vArgS, iLit, k ) // iLit = S[i]
+                {
+                    //Vec_IntPush( vTemp, Abc_LitNot( Gia_ManHashAnd(pNew, iLit, Vec_IntEntry(vArgB, nRange*(Vec_IntSize(vArgS)-1-k)+i)) ) ); // B[widthA*k+i]
+                    Vec_IntPush( vTemp, Abc_LitNot( Gia_ManHashAnd(pNew, iLit, Vec_IntEntry(vArgB, nRange*k+i)) ) ); // B[widthA*k+i]
+                    iCond = Gia_ManHashAnd( pNew, iCond, Abc_LitNot(iLit) );
+                }
+                Vec_IntPush( vTemp, Abc_LitNot( Gia_ManHashAnd(pNew, iCond, Vec_IntEntry(vArgA, i)) ) );
+                Vec_IntPush( vRes, Abc_LitNot( Gia_ManHashAndMulti(pNew, vTemp) ) );
+            }
+            return;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/wln/wlnRead.c

+/**CFile****************************************************************
+
+  FileName    [wln.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Word-level network.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - September 23, 2018.]
+
+  Revision    [$Id: wln.c,v 1.00 2018/09/23 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "wln.h"
+#include "proof/cec/cec.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+#define MAX_LINE 10000
+
+#define MAX_MAP     32
+#define CELL_NUM     8
+#define WIRE_NUM     5
+#define TEMP_NUM     5
+
+//typedef struct Rtl_Lib_t_  Rtl_Lib_t;
+struct Rtl_Lib_t_ 
+{
+    char *                pSpec;     // input file name
+    Vec_Ptr_t *           vNtks;     // modules
+    Abc_Nam_t *           pManName;  // object names
+    Vec_Int_t             vConsts;   // constants
+    Vec_Int_t             vSlices;   // selections
+    Vec_Int_t             vConcats;  // concatenations
+    FILE *                pFile;     // temp file
+    Vec_Int_t *           vTokens;   // temp tokens
+    int                   pMap[MAX_MAP];  // temp map
+    Vec_Int_t *           vMap;      // mapping NameId into wires
+    Vec_Int_t             vAttrTemp; // temp
+    Vec_Int_t             vTemp[TEMP_NUM];  // temp
+};
+
+typedef struct Rtl_Ntk_t_  Rtl_Ntk_t;
+struct Rtl_Ntk_t_ 
+{
+    int                   NameId;    // model name
+    int                   nInputs;   // word-level inputs
+    int                   nOutputs;  // word-level outputs
+    Vec_Int_t             vWires;    // wires (name{upto,signed,in,out}+width+offset+number)
+    Vec_Int_t             vCells;    // instances ([0]type+[1]name+[2]mod+[3]ins+[4]nattr+[5]nparams+[6]nconns+[6]mark+(attr+params+conns))
+    Vec_Int_t             vConns;    // connection pairs
+    Vec_Int_t             vStore;    // storage for cells
+    Vec_Int_t             vAttrs;    // attributes
+    Rtl_Lib_t *           pLib;      // parent
+    Vec_Int_t             vOrder;    // topological order
+    Vec_Int_t             vLits;     // bit-level view
+    Vec_Int_t             vBitTemp;  // storage for bits
+    Gia_Man_t *           pGia;      // derived by bit-blasting
+    int                   Slice0;    // first slice
+    int                   Slice1;    // last slice
+    int                   iCopy;     // place in array
+};
+
+static inline int         Rtl_LibNtkNum( Rtl_Lib_t * pLib )                { return Vec_PtrSize(pLib->vNtks);                  }
+static inline Rtl_Ntk_t * Rtl_LibNtk( Rtl_Lib_t * pLib, int i )            { return (Rtl_Ntk_t *)Vec_PtrEntry(pLib->vNtks, i); }
+static inline Rtl_Ntk_t * Rtl_LibTop( Rtl_Lib_t * pLib )                   { return Rtl_LibNtk( pLib, Rtl_LibNtkNum(pLib)-1 ); }
+
+static inline Rtl_Ntk_t * Rtl_NtkModule( Rtl_Ntk_t * p, int i )            { return Rtl_LibNtk( p->pLib, i );                  }
+
+static inline int         Rtl_NtkStrId( Rtl_Ntk_t * p, char * s )          { return Abc_NamStrFind(p->pLib->pManName, s);      }
+static inline char *      Rtl_NtkStr( Rtl_Ntk_t * p, int h )               { return Abc_NamStr(p->pLib->pManName, h);          }
+static inline char *      Rtl_NtkName( Rtl_Ntk_t * p )                     { return Rtl_NtkStr(p, p->NameId);                  }
+
+static inline FILE *      Rtl_NtkFile( Rtl_Ntk_t * p )                     { return p->pLib->pFile;                            }
+static inline int         Rtl_NtkTokId( Rtl_Ntk_t * p, int i )             { return i < Vec_IntSize(p->pLib->vTokens) ? Vec_IntEntry(p->pLib->vTokens, i) : -1;                  }
+static inline char *      Rtl_NtkTokStr( Rtl_Ntk_t * p, int i )            { return i < Vec_IntSize(p->pLib->vTokens) ? Rtl_NtkStr(p, Vec_IntEntry(p->pLib->vTokens, i)) : NULL; }
+static inline int         Rtl_NtkTokCheck( Rtl_Ntk_t * p, int i, int Tok ) { return i == p->pLib->pMap[Tok];                                    }
+static inline int         Rtl_NtkPosCheck( Rtl_Ntk_t * p, int i, int Tok ) { return Vec_IntEntry(p->pLib->vTokens, i) == p->pLib->pMap[Tok];    }
+
+static inline int         Rtl_NtkInputNum( Rtl_Ntk_t * p )                 { return p->nInputs;                                }
+static inline int         Rtl_NtkOutputNum( Rtl_Ntk_t * p )                { return p->nOutputs;                               }
+static inline int         Rtl_NtkAttrNum( Rtl_Ntk_t * p )                  { return Vec_IntSize(&p->vAttrs)/2;                 }
+static inline int         Rtl_NtkWireNum( Rtl_Ntk_t * p )                  { return Vec_IntSize(&p->vWires)/WIRE_NUM;          }
+static inline int         Rtl_NtkCellNum( Rtl_Ntk_t * p )                  { return Vec_IntSize(&p->vCells);                   }
+static inline int         Rtl_NtkConNum( Rtl_Ntk_t * p )                   { return Vec_IntSize(&p->vConns)/2;                 }
+static inline int         Rtl_NtkObjNum( Rtl_Ntk_t * p )                   { return p->nInputs + p->nOutputs + Rtl_NtkCellNum(p) + Rtl_NtkConNum(p); }
+
+static inline int *       Rtl_NtkWire( Rtl_Ntk_t * p, int i )              { return Vec_IntEntryP(&p->vWires, WIRE_NUM*i);                  }
+static inline int *       Rtl_NtkCell( Rtl_Ntk_t * p, int i )              { return Vec_IntEntryP(&p->vStore, Vec_IntEntry(&p->vCells, i)); }
+static inline int *       Rtl_NtkCon( Rtl_Ntk_t * p, int i )               { return Vec_IntEntryP(&p->vConns, 2*i);                         }
+
+static inline int         Rtl_WireName( Rtl_Ntk_t * p, int i )             { return Vec_IntEntry(&p->vWires, WIRE_NUM*i) >> 4; }
+static inline char *      Rtl_WireNameStr( Rtl_Ntk_t * p, int i )          { return Rtl_NtkStr(p, Rtl_WireName(p, i));         }
+static inline int         Rtl_WireFirst( Rtl_Ntk_t * p, int i )            { return Vec_IntEntry(&p->vWires, WIRE_NUM*i);      }
+static inline int         Rtl_WireWidth( Rtl_Ntk_t * p, int i )            { return Vec_IntEntry(&p->vWires, WIRE_NUM*i+1);    }
+static inline int         Rtl_WireOffset( Rtl_Ntk_t * p, int i )           { return Vec_IntEntry(&p->vWires, WIRE_NUM*i+2);    }
+static inline int         Rtl_WireNumber( Rtl_Ntk_t * p, int i )           { return Vec_IntEntry(&p->vWires, WIRE_NUM*i+3);    }
+static inline int         Rtl_WireBitStart( Rtl_Ntk_t * p, int i )         { return Vec_IntEntry(&p->vWires, WIRE_NUM*i+4);    }
+static inline int         Rtl_WireMapNameToId( Rtl_Ntk_t * p, int i )      { return Vec_IntEntry(p->pLib->vMap, i);            }
+
+static inline int         Rtl_CellType( int * pCell )                      { return pCell[0];                                  }
+static inline int         Rtl_CellName( int * pCell )                      { return pCell[1];                                  }
+static inline int         Rtl_CellModule( int * pCell )                    { return pCell[2];                                  }
+static inline int         Rtl_CellInputNum( int * pCell )                  { return pCell[3];                                  }
+static inline int         Rtl_CellOutputNum( int * pCell )                 { return pCell[6]-pCell[3];                         }
+static inline int         Rtl_CellAttrNum( int * pCell )                   { return pCell[4];                                  }
+static inline int         Rtl_CellParamNum( int * pCell )                  { return pCell[5];                                  }
+static inline int         Rtl_CellConNum( int * pCell )                    { return pCell[6];                                  }
+static inline int         Rtl_CellMark( int * pCell )                      { return pCell[7];                                  }
+static inline Rtl_Ntk_t * Rtl_CellNtk( Rtl_Ntk_t * p, int * pCell )        { return Rtl_CellModule(pCell) >= ABC_INFINITY ? Rtl_NtkModule(p, Rtl_CellModule(pCell)-ABC_INFINITY) : NULL; }
+
+static inline char *      Rtl_CellTypeStr( Rtl_Ntk_t * p, int * pCell )    { return Rtl_NtkStr(p, Rtl_CellType(pCell));        }
+static inline char *      Rtl_CellNameStr( Rtl_Ntk_t * p, int * pCell )    { return Rtl_NtkStr(p, Rtl_CellName(pCell));        }
+
+static inline int         Rtl_SigIsNone( int s )                           { return (s & 0x3) == 0;                            }
+static inline int         Rtl_SigIsConst( int s )                          { return (s & 0x3) == 1;                            }
+static inline int         Rtl_SigIsSlice( int s )                          { return (s & 0x3) == 2;                            }
+static inline int         Rtl_SigIsConcat( int s )                         { return (s & 0x3) == 3;                            }
+
+#define Rtl_NtkForEachAttr( p, Par, Val, i ) \
+    for ( i = 0; i < Rtl_NtkAttrNum(p) && (Par = Vec_IntEntry(&p->vAttrs, 2*i)) && (Val = Vec_IntEntry(&p->vAttrs, 2*i+1)); i++ )
+#define Rtl_NtkForEachWire( p, pWire, i ) \
+    for ( i = 0; i < Rtl_NtkWireNum(p) && (pWire = Vec_IntEntryP(&p->vWires, WIRE_NUM*i)); i++ )
+#define Rtl_NtkForEachCell( p, pCell, i ) \
+    for ( i = 0; i < Rtl_NtkCellNum(p) && (pCell = Rtl_NtkCell(p, i)); i++ )
+#define Rtl_NtkForEachCon( p, pCon, i ) \
+    for ( i = 0; i < Rtl_NtkConNum(p) && (pCon = Vec_IntEntryP(&p->vConns, 2*i)); i++ )
+
+#define Rtl_CellForEachAttr( p, pCell, Par, Val, i ) \
+    for ( i = 0; i < pCell[4] && (Par = pCell[CELL_NUM+2*i]) && (Val = pCell[CELL_NUM+2*i+1]); i++ )
+#define Rtl_CellForEachParam( p, pCell, Par, Val, i ) \
+    for ( i = 0; i < pCell[5] && (Par = pCell[CELL_NUM+2*(pCell[4]+i)]) && (Val = pCell[CELL_NUM+2*(pCell[4]+i)+1]); i++ )
+#define Rtl_CellForEachConnect( p, pCell, Par, Val, i ) \
+    for ( i = 0; i < pCell[6] && (Par = pCell[CELL_NUM+2*(pCell[4]+pCell[5]+i)]) && (Val = pCell[CELL_NUM+2*(pCell[4]+pCell[5]+i)+1]); i++ )
+
+#define Rtl_CellForEachInput( p, pCell, Par, Val, i ) \
+    Rtl_CellForEachConnect( p, pCell, Par, Val, i ) if ( i >= Rtl_CellInputNum(pCell) ) continue; else
+#define Rtl_CellForEachOutput( p, pCell, Par, Val, i ) \
+    Rtl_CellForEachConnect( p, pCell, Par, Val, i ) if ( i <  Rtl_CellInputNum(pCell) ) continue; else
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Rtl_Ntk_t * Rtl_NtkAlloc( Rtl_Lib_t * pLib )
+{
+    Rtl_Ntk_t * p = ABC_CALLOC( Rtl_Ntk_t, 1 );
+    Vec_IntGrow( &p->vWires, 4 );
+    Vec_IntGrow( &p->vCells, 4 );
+    Vec_IntGrow( &p->vConns, 4 );
+    Vec_IntGrow( &p->vStore, 8 );
+    Vec_IntGrow( &p->vAttrs, 8 );
+    Vec_PtrPush( pLib->vNtks, (void *)p );
+    p->pLib = pLib;
+    return p;
+}
+void Rtl_NtkFree( Rtl_Ntk_t * p )
+{
+    Gia_ManStopP( &p->pGia );
+    ABC_FREE( p->vWires.pArray );
+    ABC_FREE( p->vCells.pArray );
+    ABC_FREE( p->vConns.pArray );
+    ABC_FREE( p->vStore.pArray );
+    ABC_FREE( p->vAttrs.pArray );
+    ABC_FREE( p->vOrder.pArray );
+    ABC_FREE( p->vLits.pArray );
+    ABC_FREE( p->vBitTemp.pArray );
+    ABC_FREE( p );
+}
+void Rtl_NtkCountPio( Rtl_Ntk_t * p, int Counts[4] )
+{
+    int i, * pWire;
+    Rtl_NtkForEachWire( p, pWire, i )
+    {
+        if ( pWire[0] & 1 ) // PI
+            Counts[0]++, Counts[1] += pWire[1];
+        if ( pWire[0] & 2 ) // PO
+            Counts[2]++, Counts[3] += pWire[1];
+    }
+    assert( p->nInputs  == Counts[0] );
+    assert( p->nOutputs == Counts[2] );
+}
+void Rtl_NtkPrintOpers( Rtl_Ntk_t * p )
+{
+    int i, * pCell, nBlack = 0, nUser = 0, Counts[ABC_OPER_LAST] = {0};
+    if ( Rtl_NtkCellNum(p) == 0 )
+        return;
+    Rtl_NtkForEachCell( p, pCell, i )
+        if ( Rtl_CellModule(pCell) < ABC_OPER_LAST )
+            Counts[Rtl_CellModule(pCell)]++;
+        else if ( Rtl_CellModule(pCell) == ABC_OPER_LAST-1 )
+            nBlack++;
+        else
+            nUser++;
+    printf( "There are %d instances in this network:\n", Rtl_NtkCellNum(p) );
+    if ( nBlack )
+        printf( "  %s (%d)", "blackbox", nBlack );
+    if ( nUser )
+        printf( "  %s (%d)", "user", nUser );
+    for ( i = 0; i < ABC_OPER_LAST; i++ )
+        if ( Counts[i] )
+            printf( "  %s (%d)", Abc_OperName(i), Counts[i] );
+    printf( "\n" );
+}
+void Rtl_NtkPrintStats( Rtl_Ntk_t * p, int nNameSymbs )
+{
+    int Counts[4] = {0};     Rtl_NtkCountPio( p, Counts );
+    printf( "%*s : ",        nNameSymbs, Rtl_NtkName(p) );
+    printf( "PI = %3d (%3d)  ", Counts[0], Counts[1] );
+    printf( "PO = %3d (%3d)  ", Counts[2], Counts[3] );
+    printf( "Wire = %6d   ", Rtl_NtkWireNum(p) );
+    printf( "Cell = %6d   ", Rtl_NtkCellNum(p) );
+    printf( "Con = %6d",     Rtl_NtkConNum(p) );
+    printf( "\n" );
+    //Rtl_NtkPrintOpers( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Rtl_Lib_t * Rtl_LibAlloc()
+{
+    Rtl_Lib_t * p = ABC_CALLOC( Rtl_Lib_t, 1 );
+    p->vNtks = Vec_PtrAlloc( 100 );
+    Vec_IntGrow( &p->vConsts,  1000 );
+    Vec_IntGrow( &p->vSlices,  1000 );
+    Vec_IntGrow( &p->vConcats, 1000 );
+    return p;
+}
+void Rtl_LibFree( Rtl_Lib_t * p )
+{
+    Rtl_Ntk_t * pNtk; int i;
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        Rtl_NtkFree( pNtk );    
+    ABC_FREE( p->vConsts.pArray );
+    ABC_FREE( p->vSlices.pArray );
+    ABC_FREE( p->vConcats.pArray );
+    ABC_FREE( p->vAttrTemp.pArray );
+    for ( i = 0; i < TEMP_NUM; i++ )
+        ABC_FREE( p->vTemp[i].pArray );
+    Vec_IntFreeP( &p->vMap );
+    Vec_IntFreeP( &p->vTokens );
+    Abc_NamStop( p->pManName );
+    Vec_PtrFree( p->vNtks );
+    ABC_FREE( p->pSpec );
+    ABC_FREE( p );
+}
+int Rtl_LibFindModule( Rtl_Lib_t * p, int NameId )
+{
+    Rtl_Ntk_t * pNtk; int i;
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        if ( pNtk->NameId == NameId )
+            return i;
+    return -1;
+}
+void Rtl_LibPrintStats( Rtl_Lib_t * p )
+{
+    Rtl_Ntk_t * pNtk; int i, nSymbs = 0;
+    printf( "Modules found in \"%s\":\n", p->pSpec );
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        nSymbs = Abc_MaxInt( nSymbs, strlen(Rtl_NtkName(pNtk)) );
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        Rtl_NtkPrintStats( pNtk, nSymbs + 2 );  
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+typedef enum {
+    RTL_NONE = 0,  // 0:  unused
+    RTL_MODULE,    // 1:  "module"
+    RTL_END,       // 2:  "end"
+    RTL_INPUT,     // 3:  "input"
+    RTL_OUTPUT,    // 4:  "output"
+    RTL_INOUT,     // 5:  "inout"
+    RTL_UPTO,      // 6:  "upto"
+    RTL_SIGNED,    // 7:  "signed"
+    RTL_OFFSET,    // 8:  "offset"
+    RTL_PARAMETER, // 9:  "parameter"
+    RTL_WIRE,      // 10: "wire"
+    RTL_CONNECT,   // 11: "connect"
+    RTL_CELL,      // 12: "cell"
+    RTL_WIDTH,     // 13: "width"
+    RTL_ATTRIBUTE, // 14: "attribute"
+    RTL_UNUSED     // 15: unused
+} Rtl_Type_t; 
+
+static inline char * Rtl_Num2Name( int i )
+{
+    if ( i == 1  )  return "module";
+    if ( i == 2  )  return "end";
+    if ( i == 3  )  return "input";
+    if ( i == 4  )  return "output";
+    if ( i == 5  )  return "inout";
+    if ( i == 6  )  return "upto";
+    if ( i == 7  )  return "signed";
+    if ( i == 8  )  return "offset";
+    if ( i == 9  )  return "parameter";
+    if ( i == 10 )  return "wire";
+    if ( i == 11 )  return "connect";
+    if ( i == 12 )  return "cell";
+    if ( i == 13 )  return "width";
+    if ( i == 14 )  return "attribute";
+    return NULL;
+}
+
+static inline void Rtl_LibDeriveMap( Rtl_Lib_t * p )
+{
+    int i;
+    p->pMap[0] = -1;
+    for ( i = 1; i < RTL_UNUSED; i++ )
+        p->pMap[i] = Abc_NamStrFind( p->pManName, Rtl_Num2Name(i) );
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Rtl_LibReadType( char * pType )
+{
+    if ( !strcmp(pType, "$not") )         return ABC_OPER_BIT_INV;       // Y = ~A       $not            
+    if ( !strcmp(pType, "$pos") )         return ABC_OPER_BIT_BUF;       // Y = +A       $pos            
+    if ( !strcmp(pType, "$neg") )         return ABC_OPER_ARI_MIN;       // Y = -A       $neg            
+    if ( !strcmp(pType, "$reduce_and") )  return ABC_OPER_RED_AND;       // Y = &A       $reduce_and     
+    if ( !strcmp(pType, "$reduce_or") )   return ABC_OPER_RED_OR;        // Y = |A       $reduce_or      
+    if ( !strcmp(pType, "$reduce_xor") )  return ABC_OPER_RED_XOR;       // Y = ^A       $reduce_xor     
+    if ( !strcmp(pType, "$reduce_xnor") ) return ABC_OPER_RED_NXOR;      // Y = ~^A      $reduce_xnor   
+    if ( !strcmp(pType, "$reduce_bool") ) return ABC_OPER_RED_OR;        // Y = |A       $reduce_bool    
+    if ( !strcmp(pType, "$logic_not") )   return ABC_OPER_LOGIC_NOT;     // Y = !A       $logic_not      
+
+    if ( !strcmp(pType, "$and") )         return ABC_OPER_BIT_AND;       // Y = A & B    $and         
+    if ( !strcmp(pType, "$or") )          return ABC_OPER_BIT_OR;        // Y = A | B    $or          
+    if ( !strcmp(pType, "$xor") )         return ABC_OPER_BIT_XOR;       // Y = A ^ B    $xor         
+    if ( !strcmp(pType, "$xnor") )        return ABC_OPER_BIT_NXOR;      // Y = A ~^ B   $xnor    
+    
+    if ( !strcmp(pType, "$shl") )         return ABC_OPER_SHIFT_L;       // Y = A << B   $shl        
+    if ( !strcmp(pType, "$shr") )         return ABC_OPER_SHIFT_R;       // Y = A >> B   $shr        
+    if ( !strcmp(pType, "$sshl") )        return ABC_OPER_SHIFT_LA;      // Y = A <<< B  $sshl      
+    if ( !strcmp(pType, "$sshr") )        return ABC_OPER_SHIFT_RA;      // Y = A >>> B  $sshr      
+
+    if ( !strcmp(pType, "$shiftx") )      return ABC_OPER_SHIFT_R;       // Y = A << B   $shl     <== temporary   
+
+    if ( !strcmp(pType, "$logic_and") )   return ABC_OPER_LOGIC_AND;     // Y = A && B   $logic_and  
+    if ( !strcmp(pType, "$logic_or") )    return ABC_OPER_LOGIC_OR;      // Y = A || B   $logic_or  
+    
+    if ( !strcmp(pType, "$lt") )          return ABC_OPER_COMP_LESS;     // Y = A < B    $lt          
+    if ( !strcmp(pType, "$le") )          return ABC_OPER_COMP_LESSEQU;  // Y = A <= B   $le         
+    if ( !strcmp(pType, "$ge") )          return ABC_OPER_COMP_MOREEQU;  // Y = A >= B   $ge           
+    if ( !strcmp(pType, "$gt") )          return ABC_OPER_COMP_MORE;     // Y = A > B    $gt        
+    if ( !strcmp(pType, "$eq") )          return ABC_OPER_COMP_EQU;      // Y = A == B   $eq         
+    if ( !strcmp(pType, "$ne") )          return ABC_OPER_COMP_NOTEQU;   // Y = A != B   $ne         
+    if ( !strcmp(pType, "$eqx") )         return ABC_OPER_COMP_EQU;      // Y = A === B  $eqx       
+    if ( !strcmp(pType, "$nex") )         return ABC_OPER_COMP_NOTEQU;   // Y = A !== B  $nex       
+    
+    if ( !strcmp(pType, "$add") )         return ABC_OPER_ARI_ADD;       // Y = A + B    $add         
+    if ( !strcmp(pType, "$sub") )         return ABC_OPER_ARI_SUB;       // Y = A - B    $sub         
+    if ( !strcmp(pType, "$mul") )         return ABC_OPER_ARI_MUL;       // Y = A * B    $mul         
+    if ( !strcmp(pType, "$div") )         return ABC_OPER_ARI_DIV;       // Y = A / B    $div         
+    if ( !strcmp(pType, "$mod") )         return ABC_OPER_ARI_MOD;       // Y = A % B    $mod         
+    if ( !strcmp(pType, "$pow") )         return ABC_OPER_ARI_POW;       // Y = A ** B   $pow        
+
+    if ( !strcmp(pType, "$modfoor") )     return ABC_OPER_NONE;          // [N/A] $modfoor         
+    if ( !strcmp(pType, "$divfloor") )    return ABC_OPER_NONE;          // [N/A] $divfloor        
+
+    if ( !strcmp(pType, "$mux") )         return ABC_OPER_SEL_NMUX;      // $mux                   
+    if ( !strcmp(pType, "$pmux") )        return ABC_OPER_SEL_SEL;       // $pmux                  
+                                                               
+    if ( !strcmp(pType, "$dff") )         return ABC_OPER_DFF;
+    if ( !strcmp(pType, "$adff") )        return ABC_OPER_DFF;
+    if ( !strcmp(pType, "$sdff") )        return ABC_OPER_DFF;
+    assert( 0 );                                               
+    return -1;                                                 
+}                                                                         
+int Rtl_NtkReadType( Rtl_Ntk_t * p, int Type )                                                                         
+{                                                                         
+    extern int Rtl_LibFindModule( Rtl_Lib_t * p, int NameId );
+    char * pType = Rtl_NtkStr( p, Type );                   
+    if ( pType[0] == '$' && strncmp(pType,"$paramod",strlen("$paramod")) )
+        return Rtl_LibReadType( pType );                    
+    return ABC_INFINITY + Rtl_LibFindModule( p->pLib, Type );
+}                                                           
+                                                            
+/**Function*************************************************************
+                                                            
+  Synopsis    [There is no need to normalize ranges in Yosys.]
+                                                            
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Rtl_NtkRangeWires( Rtl_Ntk_t * p )
+{
+    int i, * pWire, nBits = 0;
+    Rtl_NtkForEachWire( p, pWire, i )
+    {
+        //printf( "%s -> %d\n", Rtl_WireNameStr(p, i), nBits );
+        pWire[4] = nBits, nBits += Rtl_WireWidth(p, i);
+    }
+    return nBits;
+}
+void Rtl_NtkMapWires( Rtl_Ntk_t * p, int fUnmap )
+{
+    int i, Value;
+    assert( Vec_IntSize(p->pLib->vMap) == Abc_NamObjNumMax(p->pLib->pManName) );
+    for ( i = 0; i < Rtl_NtkWireNum(p); i++ )
+    {
+        int NameId = Rtl_WireName( p, i );
+        assert( Vec_IntEntry(p->pLib->vMap, NameId) == (fUnmap ? i : -1) );
+        Vec_IntWriteEntry( p->pLib->vMap, NameId, fUnmap ? -1 : i );
+    }
+    if ( fUnmap )
+        Vec_IntForEachEntry( p->pLib->vMap, Value, i )
+            assert( Value == -1 );
+}
+void Rtl_NtkNormRanges( Rtl_Ntk_t * p )
+{
+    int i, * pWire;
+    Rtl_NtkMapWires( p, 0 );
+    for ( i = p->Slice0; i < p->Slice1; i += 3 )
+    {
+        int NameId = Vec_IntEntry( &p->pLib->vSlices, i );
+        int Left   = Vec_IntEntry( &p->pLib->vSlices, i+1 );
+        int Right  = Vec_IntEntry( &p->pLib->vSlices, i+2 );
+        int Wire   = Rtl_WireMapNameToId( p, NameId );
+        int Offset = Rtl_WireOffset( p, Wire );
+        int First  = Rtl_WireFirst( p, Wire );
+        assert( First >> 4 == NameId );
+        if ( Offset );
+        {
+            Left  -= Offset;
+            Right -= Offset;
+        }
+        if ( First & 8 ) // upto
+        {
+            Vec_IntWriteEntry( &p->pLib->vSlices, i+1, Right );
+            Vec_IntWriteEntry( &p->pLib->vSlices, i+2, Left );
+        }
+    }
+    Rtl_NtkForEachWire( p, pWire, i )
+    {
+        Vec_IntWriteEntry( &p->vWires, WIRE_NUM*i+0, Rtl_WireFirst(p, i) & ~0x8 ); // upto
+        Vec_IntWriteEntry( &p->vWires, WIRE_NUM*i+2, 0 ); // offset
+    }
+    Rtl_NtkMapWires( p, 1 );
+}
+void Rtl_LibNormRanges( Rtl_Lib_t * pLib )
+{
+    Rtl_Ntk_t * p; int i;
+    if ( pLib->vMap == NULL )
+        pLib->vMap = Vec_IntStartFull( Abc_NamObjNumMax(pLib->pManName) );
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p, i )
+        Rtl_NtkNormRanges( p );    
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int * Rlt_NtkFindIOPerm( Rtl_Ntk_t * p )
+{
+    Vec_Int_t * vCost = Vec_IntAlloc( 100 );
+    int i, * pWire, * pPerm = NULL, Count = 0;
+    Rtl_NtkForEachWire( p, pWire, i )
+    {
+        int First  = Rtl_WireFirst( p, i );
+        int Number = Rtl_WireNumber( p, i );
+        int fIsPi  = (int)((First & 1) > 0);
+        int fIsPo  = (int)((First & 2) > 0);
+        assert( (fIsPi || fIsPo) == (Number > 0) );
+        if ( fIsPi || fIsPo )
+            Vec_IntPush( vCost, fIsPo*ABC_INFINITY + Number );
+        else
+            Vec_IntPush( vCost, 2*ABC_INFINITY + Count++ );
+    }
+    pPerm = Abc_MergeSortCost( Vec_IntArray(vCost), Vec_IntSize(vCost) );
+    Vec_IntFree( vCost );
+    return pPerm;
+}
+void Rtl_NtkOrderWires( Rtl_Ntk_t * p )
+{
+    Vec_Int_t * vTemp = Vec_IntAlloc( Vec_IntSize(&p->vWires) );
+    int i, k, * pWire, * pPerm = Rlt_NtkFindIOPerm( p );
+    Rtl_NtkForEachWire( p, pWire, i )
+    {
+        pWire = Vec_IntEntryP( &p->vWires, WIRE_NUM*pPerm[i] );
+        for ( k = 0; k < WIRE_NUM; k++ )
+            Vec_IntPush( vTemp, pWire[k] );
+    }
+    ABC_FREE( pPerm );
+    assert( Vec_IntSize(&p->vWires) == Vec_IntSize(vTemp) );
+    ABC_SWAP( Vec_Int_t, p->vWires, *vTemp ); 
+    Vec_IntFree( vTemp );
+}
+void Rtl_LibUpdateInstances( Rtl_Ntk_t * p )
+{
+    Vec_Int_t * vMap  = p->pLib->vMap;
+    Vec_Int_t * vTemp = &p->pLib->vTemp[2];
+    int i, k, Par, Val, * pCell, Value;
+    Rtl_NtkForEachCell( p, pCell, i )
+        if ( Rtl_CellModule(pCell) >= ABC_INFINITY )
+        {
+            Rtl_Ntk_t * pModel = Rtl_NtkModule( p, Rtl_CellModule(pCell)-ABC_INFINITY );
+            assert( pCell[6] == pModel->nInputs+pModel->nOutputs );
+            Rtl_CellForEachConnect( p, pCell, Par, Val, k )
+                Vec_IntWriteEntry( vMap, Par >> 2, k );
+            Vec_IntClear( vTemp );
+            for ( k = 0; k < pCell[6]; k++ )
+            {
+                int Perm = Vec_IntEntry( vMap, Rtl_WireName(pModel, k) );
+                int Par = pCell[CELL_NUM+2*(pCell[4]+pCell[5]+Perm)];
+                int Val = pCell[CELL_NUM+2*(pCell[4]+pCell[5]+Perm)+1];
+                assert( (Par >> 2) == Rtl_WireName(pModel, k) );
+                Vec_IntWriteEntry( vMap, Par >> 2, -1 );
+                Vec_IntPushTwo( vTemp, Par, Val );
+                assert( Perm >= 0 );
+            }
+            memcpy( pCell+CELL_NUM+2*(pCell[4]+pCell[5]), Vec_IntArray(vTemp), sizeof(int)*Vec_IntSize(vTemp) );
+        }
+    Vec_IntForEachEntry( p->pLib->vMap, Value, i )
+        assert( Value == -1 );
+}
+void Rtl_LibOrderWires( Rtl_Lib_t * pLib )
+{
+    Rtl_Ntk_t * p; int i;
+    if ( pLib->vMap == NULL )
+        pLib->vMap = Vec_IntStartFull( Abc_NamObjNumMax(pLib->pManName) );
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p, i )
+        Rtl_NtkOrderWires( p );    
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p, i )
+        Rtl_LibUpdateInstances( p );    
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+extern int Rtl_NtkCountSignalRange( Rtl_Ntk_t * p, int Sig );
+
+int Rtl_NtkCountWireRange( Rtl_Ntk_t * p, int NameId )
+{
+    int Wire  = Rtl_WireMapNameToId( p, NameId );
+    int Width = Rtl_WireWidth( p, Wire );
+    return Width;
+}
+int Rtl_NtkCountSliceRange( Rtl_Ntk_t * p, int * pSlice )
+{
+    return pSlice[1] - pSlice[2] + 1;
+}
+int Rtl_NtkCountConcatRange( Rtl_Ntk_t * p, int * pConcat )
+{
+    int i, nBits = 0;
+    for ( i = 1; i <= pConcat[0]; i++ )
+        nBits += Rtl_NtkCountSignalRange( p, pConcat[i] );
+    return nBits;
+}
+int Rtl_NtkCountSignalRange( Rtl_Ntk_t * p, int Sig )
+{
+    if ( Rtl_SigIsNone(Sig) )
+        return Rtl_NtkCountWireRange( p, Sig >> 2 );
+    if ( Rtl_SigIsSlice(Sig) )
+        return Rtl_NtkCountSliceRange( p, Vec_IntEntryP(&p->pLib->vSlices, Sig >> 2) );
+    if ( Rtl_SigIsConcat(Sig) )
+        return Rtl_NtkCountConcatRange( p, Vec_IntEntryP(&p->pLib->vConcats, Sig >> 2) );
+    if ( Rtl_SigIsConst(Sig) )
+        assert( 0 );
+    return ABC_INFINITY;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+extern int Rtl_NtkCheckSignalRange( Rtl_Ntk_t * p, int Sig );
+
+int Rtl_NtkCheckWireRange( Rtl_Ntk_t * p, int NameId, int Left, int Right )
+{
+    int Wire  = Rtl_WireMapNameToId( p, NameId );
+    int First = Rtl_WireBitStart( p, Wire );
+    int Width = Rtl_WireWidth( p, Wire ), i;
+    Left  = Left  == -1 ? Width-1 :  Left;
+    Right = Right == -1 ? 0       : Right;
+    assert ( Right <= Left && Right >= 0 );
+    for ( i = Right; i <= Left; i++ )
+        if ( Vec_IntEntry(&p->vLits, First+i) == -1 )
+            return 0;
+    return 1;
+}
+int Rtl_NtkCheckSliceRange( Rtl_Ntk_t * p, int * pSlice )
+{
+    return Rtl_NtkCheckWireRange( p, pSlice[0], pSlice[1], pSlice[2] );
+}
+int Rtl_NtkCheckConcatRange( Rtl_Ntk_t * p, int * pConcat )
+{
+    int i;
+    for ( i = 1; i <= pConcat[0]; i++ )
+        if ( !Rtl_NtkCheckSignalRange( p, pConcat[i] ) )
+            return 0;
+    return 1;
+}
+int Rtl_NtkCheckSignalRange( Rtl_Ntk_t * p, int Sig )
+{
+    if ( Rtl_SigIsNone(Sig) )
+        return Rtl_NtkCheckWireRange( p, Sig >> 2, -1, -1 );
+    else if ( Rtl_SigIsConst(Sig) )
+        return 1;
+    else if ( Rtl_SigIsSlice(Sig) )
+        return Rtl_NtkCheckSliceRange( p, Vec_IntEntryP(&p->pLib->vSlices, Sig >> 2) );
+    else if ( Rtl_SigIsConcat(Sig) )
+        return Rtl_NtkCheckConcatRange( p, Vec_IntEntryP(&p->pLib->vConcats, Sig >> 2) );
+    else assert( 0 );
+    return -1;
+}
+
+
+extern void Rtl_NtkSetSignalRange( Rtl_Ntk_t * p, int Sig, int Value );
+
+void Rtl_NtkSetWireRange( Rtl_Ntk_t * p, int NameId, int Left, int Right, int Value )
+{
+    //char * pName = Rtl_NtkStr( p, NameId );
+    int Wire  = Rtl_WireMapNameToId( p, NameId );
+    int First = Rtl_WireBitStart( p, Wire );
+    int Width = Rtl_WireWidth( p, Wire ), i;
+    Left  = Left  == -1 ? Width-1 :  Left;
+    Right = Right == -1 ? 0       : Right;
+    assert ( Right <= Left && Right >= 0 );
+    for ( i = Right; i <= Left; i++ )
+    {
+        assert( Vec_IntEntry(&p->vLits, First+i) == -1 );
+        Vec_IntWriteEntry(&p->vLits, First+i, Value );
+    }
+    //printf( "Finished setting wire %s\n", Rtl_NtkStr(p, NameId) );
+}
+void Rtl_NtkSetSliceRange( Rtl_Ntk_t * p, int * pSlice, int Value )
+{
+    Rtl_NtkSetWireRange( p, pSlice[0], pSlice[1], pSlice[2], Value );
+}
+void Rtl_NtkSetConcatRange( Rtl_Ntk_t * p, int * pConcat, int Value )
+{
+    int i;
+    for ( i = 1; i <= pConcat[0]; i++ )
+        Rtl_NtkSetSignalRange( p, pConcat[i], Value );
+}
+void Rtl_NtkSetSignalRange( Rtl_Ntk_t * p, int Sig, int Value )
+{
+    if ( Rtl_SigIsNone(Sig) )
+        Rtl_NtkSetWireRange( p, Sig >> 2, -1, -1, Value );
+    else if ( Rtl_SigIsSlice(Sig) )
+        Rtl_NtkSetSliceRange( p, Vec_IntEntryP(&p->pLib->vSlices, Sig >> 2), Value );
+    else if ( Rtl_SigIsConcat(Sig) )
+        Rtl_NtkSetConcatRange( p, Vec_IntEntryP(&p->pLib->vConcats, Sig >> 2), Value );
+    else if ( Rtl_SigIsConst(Sig) )
+        assert( 0 );
+}
+
+
+void Rtl_NtkInitInputs( Rtl_Ntk_t * p )
+{
+    int b, i;
+    for ( i = 0; i < p->nInputs; i++ )
+    {
+        int First = Rtl_WireBitStart( p, i );
+        int Width = Rtl_WireWidth( p, i );
+        for ( b = 0; b < Width; b++ )
+        {
+            assert( Vec_IntEntry(&p->vLits, First+b) == -1 );
+            Vec_IntWriteEntry( &p->vLits, First+b, Vec_IntSize(&p->vOrder) );
+        }
+        Vec_IntPush( &p->vOrder, i );
+        //printf( "Finished setting input %s\n", Rtl_WireNameStr(p, i) );
+    }
+}
+Vec_Int_t * Rtl_NtkCollectOutputs( Rtl_Ntk_t * p )
+{
+    //char * pNtkName = Rtl_NtkName(p);
+    int b, i;
+    Vec_Int_t * vRes = Vec_IntAlloc( 100 );
+    for ( i = 0; i < p->nOutputs; i++ )
+    {
+        //char * pName = Rtl_WireNameStr(p, p->nInputs + i);
+        int First = Rtl_WireBitStart( p, p->nInputs + i );
+        int Width = Rtl_WireWidth( p, p->nInputs + i );
+        for ( b = 0; b < Width; b++ )
+        {
+            assert( Vec_IntEntry(&p->vLits, First+b) != -1 );
+            Vec_IntPush( vRes, Vec_IntEntry(&p->vLits, First+b) );
+        }
+    }
+    return vRes;
+}
+int Rtl_NtkReviewCells( Rtl_Ntk_t * p )
+{
+    int i, k, Par, Val, * pCell, RetValue = 0;
+    Rtl_NtkForEachCell( p, pCell, i )
+    {
+        if ( pCell[7] )
+            continue;
+        Rtl_CellForEachInput( p, pCell, Par, Val, k )
+            if ( !Rtl_NtkCheckSignalRange( p, Val ) )
+                break;
+        if ( k < Rtl_CellInputNum(pCell) )
+            continue;
+        Rtl_CellForEachOutput( p, pCell, Par, Val, k )
+            Rtl_NtkSetSignalRange( p, Val, Vec_IntSize(&p->vOrder) );
+        Vec_IntPush( &p->vOrder, p->nInputs + i );
+        pCell[7] = 1;
+        RetValue = 1;
+        //printf( "Setting cell %s as propagated.\n", Rtl_CellNameStr(p, pCell) );
+    }
+    return RetValue;
+}
+int Rtl_NtkReviewConnections( Rtl_Ntk_t * p )
+{
+    int i, * pCon, RetValue = 0;
+    Rtl_NtkForEachCon( p, pCon, i )
+    {
+        int Status0 = Rtl_NtkCheckSignalRange( p, pCon[0] );
+        int Status1 = Rtl_NtkCheckSignalRange( p, pCon[1] );
+        if ( Status0 == Status1 )
+            continue;
+        if ( !Status0 && Status1 )
+            ABC_SWAP( int, pCon[0], pCon[1] )
+        Rtl_NtkSetSignalRange( p, pCon[1], Vec_IntSize(&p->vOrder) );
+        Vec_IntPush( &p->vOrder, p->nInputs + Rtl_NtkCellNum(p) + i );
+        RetValue = 1;
+    }
+    return RetValue;
+}
+void Rtl_NtkPrintCellOrder( Rtl_Ntk_t * p )
+{
+    int i, iCell;
+    Vec_IntForEachEntry( &p->vOrder, iCell, i )
+    {
+        printf( "%4d :  ", i );
+        printf( "Cell %4d  ", iCell );
+        if ( iCell < p->nInputs )
+            printf( "Type  Input " );
+        else if ( iCell < p->nInputs + Rtl_NtkCellNum(p) )
+        {
+            int * pCell = Rtl_NtkCell( p, iCell - p->nInputs );
+            printf( "Type  %4d  ", Rtl_CellType(pCell) );
+            printf( "%16s ",       Rtl_CellTypeStr(p, pCell) );
+            printf( "%16s ",       Rtl_CellNameStr(p, pCell) );
+        }
+        else
+            printf( "Type  Connection " );
+        printf( "\n" );
+    }
+}
+void Rtl_NtkPrintUnusedCells( Rtl_Ntk_t * p )
+{
+    int i, * pCell;
+    printf( "\n*** Printing unused cells:\n" );
+    Rtl_NtkForEachCell( p, pCell, i )
+    {
+        if ( pCell[7] )
+            continue;
+        printf( "Unused cell %s           %s\n", Rtl_CellTypeStr(p, pCell), Rtl_CellNameStr(p, pCell) );
+    }
+    printf( "\n" );
+}
+void Rtl_NtkOrderCells( Rtl_Ntk_t * p )
+{
+    Vec_Int_t * vRes;
+    int nBits = Rtl_NtkRangeWires( p );
+    Vec_IntFill( &p->vLits, nBits, -1 );
+
+    Vec_IntClear( &p->vOrder );
+    Vec_IntGrow( &p->vOrder, Rtl_NtkObjNum(p) );
+    Rtl_NtkInitInputs( p );
+
+    Rtl_NtkMapWires( p, 0 );
+//Vec_IntPrint(&p->vLits);
+
+    Rtl_NtkReviewConnections( p );
+    while ( Rtl_NtkReviewCells(p) | Rtl_NtkReviewConnections(p) );
+    Rtl_NtkMapWires( p, 1 );
+
+    vRes = Rtl_NtkCollectOutputs( p );
+    Vec_IntFree( vRes );
+
+    //Rtl_NtkPrintCellOrder( p );
+}
+void Rtl_LibOrderCells( Rtl_Lib_t * pLib )
+{
+    Rtl_Ntk_t * p; int i;
+    if ( pLib->vMap == NULL )
+        pLib->vMap = Vec_IntStartFull( Abc_NamObjNumMax(pLib->pManName) );
+    assert( Vec_IntSize(pLib->vMap) == Abc_NamObjNumMax(pLib->pManName) );
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p, i )
+        Rtl_NtkOrderCells( p );    
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Rtl_TokenUnspace( char * p )
+{
+    int i, Length = strlen(p), Quote = 0;
+    for ( i = 0; i < Length; i++ )
+        if ( p[i] == '\"' )
+            Quote ^= 1;
+        else if ( Quote && p[i] == ' ' )
+            p[i] = '\"';
+}
+void Rtl_TokenRespace( char * p )
+{
+    int i, Length = strlen(p);
+    assert( p[0] == '\"' && p[Length-1] == '\"' );
+    for ( i = 1; i < Length-1; i++ )
+        if ( p[i] == '\"' )
+            p[i] = ' ';
+}
+Vec_Int_t * Rtl_NtkReadFile( char * pFileName, Abc_Nam_t * p )
+{
+    Vec_Int_t * vTokens;
+    char * pTemp, Buffer[MAX_LINE]; 
+    FILE * pFile = fopen( pFileName, "rb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
+        return NULL;
+    }
+    Abc_NamStrFindOrAdd( p, "module", NULL );
+    assert( Abc_NamObjNumMax(p) == 2 );
+    vTokens = Vec_IntAlloc( 1000 );
+    while ( fgets( Buffer, MAX_LINE, pFile ) != NULL )
+    {
+        if ( Buffer[0] == '#' )
+            continue;
+        Rtl_TokenUnspace( Buffer );
+        pTemp = strtok( Buffer, " \t\r\n" );
+        if ( pTemp == NULL )
+            continue;
+        while ( pTemp )
+        {
+            if ( *pTemp == '\"' )  Rtl_TokenRespace( pTemp );
+            Vec_IntPush( vTokens, Abc_NamStrFindOrAdd(p, pTemp, NULL) );
+            pTemp = strtok( NULL, " \t\r\n" );
+        }
+        Vec_IntPush( vTokens, -1 );
+    }
+    fclose( pFile );
+    return vTokens;
+}
+
+
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+extern void Rtl_NtkPrintSig( Rtl_Ntk_t * p, int Sig );
+
+void Rtl_NtkPrintConst( Rtl_Ntk_t * p, int * pConst )
+{
+    int i;
+    if ( pConst[0] == -1 )
+    {
+        fprintf( Rtl_NtkFile(p), " %d", pConst[1] );
+        return;
+    }
+    fprintf( Rtl_NtkFile(p), " %d\'", pConst[0] );
+    for ( i = pConst[0] - 1; i >= 0; i-- )
+        fprintf( Rtl_NtkFile(p), "%d", Abc_InfoHasBit(pConst+1,i) );
+}
+void Rtl_NtkPrintSlice( Rtl_Ntk_t * p, int * pSlice )
+{
+    fprintf( Rtl_NtkFile(p), " %s", Rtl_NtkStr(p, pSlice[0]) );
+    if ( pSlice[1] == pSlice[2] )
+        fprintf( Rtl_NtkFile(p), " [%d]", pSlice[1] );
+    else
+        fprintf( Rtl_NtkFile(p), " [%d:%d]", pSlice[1], pSlice[2] );
+}
+void Rtl_NtkPrintConcat( Rtl_Ntk_t * p, int * pConcat )
+{
+    int i;
+    fprintf( Rtl_NtkFile(p), " {" );
+    for ( i = 1; i <= pConcat[0]; i++ )
+        Rtl_NtkPrintSig( p, pConcat[i] );
+    fprintf( Rtl_NtkFile(p), " }" );
+}
+void Rtl_NtkPrintSig( Rtl_Ntk_t * p, int Sig )
+{
+    if ( Rtl_SigIsNone(Sig) )
+        fprintf( Rtl_NtkFile(p), " %s", Rtl_NtkStr(p, Sig >> 2) );
+    else if ( Rtl_SigIsConst(Sig) )
+        Rtl_NtkPrintConst( p, Vec_IntEntryP(&p->pLib->vConsts, Sig >> 2) );
+    else if ( Rtl_SigIsSlice(Sig) )
+        Rtl_NtkPrintSlice( p, Vec_IntEntryP(&p->pLib->vSlices, Sig >> 2) );
+    else if ( Rtl_SigIsConcat(Sig) )
+        Rtl_NtkPrintConcat( p, Vec_IntEntryP(&p->pLib->vConcats, Sig >> 2) );
+    else assert( 0 );
+}
+void Rtl_NtkPrintWire( Rtl_Ntk_t * p, int * pWire )
+{
+    fprintf( Rtl_NtkFile(p), "  wire" );
+    if ( pWire[1] != 1 )  fprintf( Rtl_NtkFile(p), " width %d",  pWire[1] );
+    if ( pWire[2] != 0 )  fprintf( Rtl_NtkFile(p), " offset %d", pWire[2] );
+    if ( pWire[0] & 8 )   fprintf( Rtl_NtkFile(p), " upto" );
+    if ( pWire[0] & 1 )   fprintf( Rtl_NtkFile(p), " input %d",  pWire[3] );
+    if ( pWire[0] & 2 )   fprintf( Rtl_NtkFile(p), " output %d", pWire[3] );
+    if ( pWire[0] & 4 )   fprintf( Rtl_NtkFile(p), " signed" );
+    fprintf( Rtl_NtkFile(p), " %s\n", Rtl_NtkStr(p, pWire[0] >> 4) );
+}
+void Rtl_NtkPrintCell( Rtl_Ntk_t * p, int * pCell )
+{
+    int i, Par, Val;
+    Rtl_CellForEachAttr( p, pCell, Par, Val, i )
+        fprintf( Rtl_NtkFile(p), "  attribute %s %s\n", Rtl_NtkStr(p, Par), Rtl_NtkStr(p, Val) );
+        fprintf( Rtl_NtkFile(p), "  cell %s %s\n", Rtl_NtkStr(p, Rtl_CellType(pCell)), Rtl_NtkStr(p, pCell[1]) );
+    Rtl_CellForEachParam( p, pCell, Par, Val, i )
+        fprintf( Rtl_NtkFile(p), "    parameter" ), Rtl_NtkPrintSig(p, Par), Rtl_NtkPrintSig(p, Val), printf( "\n" );
+    Rtl_CellForEachConnect( p, pCell, Par, Val, i )
+        fprintf( Rtl_NtkFile(p), "    connect" ), Rtl_NtkPrintSig(p, Par), Rtl_NtkPrintSig(p, Val), printf( "\n" );
+        fprintf( Rtl_NtkFile(p), "  end\n" );
+}
+void Rtl_NtkPrintConnection( Rtl_Ntk_t * p, int * pCon )
+{
+    fprintf( Rtl_NtkFile(p), "  connect" );
+    Rtl_NtkPrintSig( p, pCon[0] );
+    Rtl_NtkPrintSig( p, pCon[1] );
+    fprintf( Rtl_NtkFile(p), "\n" );
+}
+void Rtl_NtkPrint( Rtl_Ntk_t * p )
+{
+    int i, Par, Val, * pWire, * pCell, * pCon;
+    fprintf( Rtl_NtkFile(p), "\n" );
+    Rtl_NtkForEachAttr( p, Par, Val, i )
+        fprintf( Rtl_NtkFile(p), "attribute %s %s\n", Rtl_NtkStr(p, Par), Rtl_NtkStr(p, Val) );
+    fprintf( Rtl_NtkFile(p), "module %s\n", Rtl_NtkName(p) );
+    Rtl_NtkForEachWire( p, pWire, i )
+        Rtl_NtkPrintWire( p, pWire );
+    Rtl_NtkForEachCell( p, pCell, i )
+        Rtl_NtkPrintCell( p, pCell );
+    Rtl_NtkForEachCon( p, pCon, i )
+        Rtl_NtkPrintConnection( p, pCon );
+    fprintf( Rtl_NtkFile(p), "end\n" );
+}
+void Rtl_LibPrint( char * pFileName, Rtl_Lib_t * p )
+{
+    p->pFile = pFileName ? fopen( pFileName, "wb" ) : stdout;
+    if ( p->pFile == NULL )
+    {
+        printf( "Cannot open output file \"%s\".\n", pFileName );
+        return;
+    }
+    else
+    {
+        Rtl_Ntk_t * pNtk; int i;
+        fprintf( p->pFile, "\n" );
+        fprintf( p->pFile, "# Generated by ABC on %s\n", Extra_TimeStamp() );
+        Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+            Rtl_NtkPrint( pNtk );    
+        if ( p->pFile != stdout )
+            fclose( p->pFile );
+        p->pFile = NULL;
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+extern int Rtl_NtkReadSig( Rtl_Ntk_t * p, int * pPos );
+
+int Rtl_NtkReadConst( Rtl_Ntk_t * p, char * pConst )
+{
+    Vec_Int_t * vConst = &p->pLib->vConsts;
+    int RetVal = Vec_IntSize( vConst );
+    int Width  = atoi( pConst );
+    assert( pConst[0] >= '0' && pConst[0] <= '9' );
+    if ( strstr(pConst, "\'") )
+    {
+        int Length = strlen(pConst);
+        int nWords = (Width + 31) / 32;
+        int i, * pArray;
+        Vec_IntPush( vConst, Width );
+        Vec_IntFillExtra( vConst, Vec_IntSize(vConst) + nWords, 0 );
+        pArray = Vec_IntEntryP( vConst, RetVal + 1 );
+        for ( i = Length-1; i >= Length-Width; i-- )
+            if ( pConst[i] == '1' )
+                Abc_InfoSetBit( pArray, Length-1-i );
+    }
+    else
+    {
+        Vec_IntPush( vConst, -1 );
+        Vec_IntPush( vConst, Width );
+    }
+    return (RetVal << 2) | 1;
+}
+int Rtl_NtkReadSlice( Rtl_Ntk_t * p, char * pSlice, int NameId )
+{
+    Vec_Int_t * vSlice = &p->pLib->vSlices;
+    int RetVal  = Vec_IntSize( vSlice );
+    int Left    = atoi( pSlice+1 );
+    char * pTwo = strstr( pSlice, ":" );
+    int Right   = pTwo ? atoi( pTwo+1 ) : Left;
+    assert( pSlice[0] == '[' && pSlice[strlen(pSlice)-1] == ']' );
+    Vec_IntPush( vSlice, NameId );
+    Vec_IntPush( vSlice, Left   );
+    Vec_IntPush( vSlice, Right  );
+    return (RetVal << 2) | 2;
+}
+int Rtl_NtkReadConcat( Rtl_Ntk_t * p, int * pPos )
+{
+    Vec_Int_t * vConcat = &p->pLib->vConcats;
+    int RetVal = Vec_IntSize( vConcat ); char * pTok;
+    Vec_IntPush( vConcat, ABC_INFINITY );
+    do {
+        int Sig = Rtl_NtkReadSig( p, pPos );
+        Vec_IntPush( vConcat, Sig );
+        pTok = Rtl_NtkTokStr( p, *pPos );
+    } 
+    while ( pTok[0] != '}' );
+    Vec_IntWriteEntry( vConcat, RetVal, Vec_IntSize(vConcat) - RetVal - 1 );
+    assert( pTok[0] == '}' );
+    (*pPos)++;
+    return (RetVal << 2) | 3;
+}
+int Rtl_NtkReadSig( Rtl_Ntk_t * p, int * pPos )
+{
+    int NameId  = Rtl_NtkTokId( p, *pPos );
+    char * pSig = Rtl_NtkTokStr( p, (*pPos)++ );
+    if ( pSig[0] >= '0' && pSig[0] <= '9' )
+        return Rtl_NtkReadConst( p, pSig );
+    if ( pSig[0] == '{' )
+        return Rtl_NtkReadConcat( p, pPos );
+    else 
+    {
+        char * pNext = Rtl_NtkTokStr( p, *pPos );
+        if ( pNext && pNext[0] == '[' )
+        {
+            (*pPos)++;
+            return Rtl_NtkReadSlice( p, pNext, NameId );
+        }
+        else
+            return NameId << 2;
+    }
+}
+int Rtl_NtkReadWire( Rtl_Ntk_t * p, int iPos )
+{
+    int i, Entry, Prev = -1;
+    int Width = 1, Upto = 0, Offset = 0, Out = 0, In = 0, Number = 0, Signed = 0;
+    assert( Rtl_NtkPosCheck(p, iPos-1, RTL_WIRE) );
+    Vec_IntClear( &p->pLib->vAttrTemp );
+    Vec_IntForEachEntryStart( p->pLib->vTokens, Entry, i, iPos )
+    {
+        char * pTok = Rtl_NtkTokStr(p, i);
+        if ( Entry == -1 )
+            break;
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_WIDTH) )
+            Width = atoi( Rtl_NtkTokStr(p, ++i) );
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_OFFSET) )
+            Offset = atoi( Rtl_NtkTokStr(p, ++i) );
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_INPUT) )
+            Number = atoi( Rtl_NtkTokStr(p, ++i) ), In = 1, p->nInputs++;
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_OUTPUT) )
+            Number = atoi( Rtl_NtkTokStr(p, ++i) ), Out = 1, p->nOutputs++;
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_SIGNED) )
+            Signed = 1;
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_UPTO) )
+            Upto = 1;
+        Prev = Entry;
+    }
+    // add WIRE_NUM=5 entries
+    Vec_IntPush( &p->vWires, (Prev << 4) | (Upto << 3) | (Signed << 2) | (Out << 1) | (In << 0) );
+    Vec_IntPush( &p->vWires, Width  );
+    Vec_IntPush( &p->vWires, Offset );
+    Vec_IntPush( &p->vWires, Number );
+    Vec_IntPush( &p->vWires, -1 );
+    assert( Rtl_NtkPosCheck(p, i, RTL_NONE) );
+    return i;
+}
+int Rtl_NtkReadAttribute( Rtl_Ntk_t * p, int iPos )
+{
+//char * pTok1 = Rtl_NtkTokStr(p, iPos-1);
+//char * pTok2 = Rtl_NtkTokStr(p, iPos);
+//char * pTok3 = Rtl_NtkTokStr(p, iPos+1);
+    assert( Rtl_NtkPosCheck(p, iPos-1, RTL_ATTRIBUTE) );
+    Vec_IntPush( &p->pLib->vAttrTemp, Rtl_NtkTokId(p, iPos++) );
+    Vec_IntPush( &p->pLib->vAttrTemp, Rtl_NtkTokId(p, iPos++) );
+    assert( Rtl_NtkPosCheck(p, iPos, RTL_NONE) );
+    return iPos;
+}
+int Rtl_NtkReadAttribute2( Rtl_Lib_t * p, int iPos )
+{
+//char * pTok1 = Abc_NamStr(p->pManName, Vec_IntEntry(p->vTokens, iPos-1));
+//char * pTok2 = Abc_NamStr(p->pManName, Vec_IntEntry(p->vTokens, iPos)  );
+//char * pTok3 = Abc_NamStr(p->pManName, Vec_IntEntry(p->vTokens, iPos+1));
+    assert( Vec_IntEntry(p->vTokens, iPos-1) == p->pMap[RTL_ATTRIBUTE] );
+    Vec_IntPush( &p->vAttrTemp, Vec_IntEntry(p->vTokens, iPos++) );
+    Vec_IntPush( &p->vAttrTemp, Vec_IntEntry(p->vTokens, iPos++) );
+    assert( Vec_IntEntry(p->vTokens, iPos) == p->pMap[RTL_NONE] );
+    return iPos;
+}
+int Rtl_NtkReadConnect( Rtl_Ntk_t * p, int iPos )
+{
+//char * pTok1 = Rtl_NtkTokStr(p, iPos-1);
+//char * pTok2 = Rtl_NtkTokStr(p, iPos);
+//char * pTok3 = Rtl_NtkTokStr(p, iPos+1);
+    assert( Rtl_NtkPosCheck(p, iPos-1, RTL_CONNECT) );
+    Vec_IntPush( &p->vConns, Rtl_NtkReadSig(p, &iPos) );
+    Vec_IntPush( &p->vConns, Rtl_NtkReadSig(p, &iPos) );
+    assert( Rtl_NtkPosCheck(p, iPos, RTL_NONE) );
+    return iPos;
+}
+int Rtl_NtkReadCell( Rtl_Ntk_t * p, int iPos )
+{
+    Vec_Int_t * vAttrs = &p->pLib->vAttrTemp;
+    int iPosPars, iPosCons, Par, Val, i, Entry;
+    assert( Rtl_NtkPosCheck(p, iPos-1, RTL_CELL) );
+    Vec_IntPush( &p->vCells, Vec_IntSize(&p->vStore) );
+    Vec_IntPush( &p->vStore, Rtl_NtkTokId(p, iPos++) ); // 0
+    Vec_IntPush( &p->vStore, Rtl_NtkTokId(p, iPos++) ); // 1
+    Vec_IntPush( &p->vStore, -1 );
+    Vec_IntPush( &p->vStore, -1 );
+    assert( Vec_IntSize(vAttrs) % 2 == 0 );
+    Vec_IntPush( &p->vStore, Vec_IntSize(vAttrs)/2 );
+    iPosPars = Vec_IntSize(&p->vStore);
+    Vec_IntPush( &p->vStore, 0 );  // 5
+    iPosCons = Vec_IntSize(&p->vStore);
+    Vec_IntPush( &p->vStore, 0 );  // 6
+    Vec_IntPush( &p->vStore, 0 );  // 7
+    assert( Vec_IntSize(&p->vStore) == Vec_IntEntryLast(&p->vCells)+CELL_NUM );
+    Vec_IntAppend( &p->vStore, vAttrs );
+    Vec_IntClear( vAttrs );
+    Vec_IntForEachEntryStart( p->pLib->vTokens, Entry, i, iPos )
+    {
+        if ( Rtl_NtkTokCheck(p, Entry, RTL_END) )
+            break;
+        if ( Rtl_NtkTokCheck(p, Entry, RTL_PARAMETER) || Rtl_NtkTokCheck(p, Entry, RTL_CONNECT) )
+        {
+            int iPosCount = Rtl_NtkTokCheck(p, Entry, RTL_PARAMETER) ? iPosPars : iPosCons;
+            Vec_IntAddToEntry( &p->vStore, iPosCount, 1 );
+            i++;
+            Par = Rtl_NtkReadSig(p, &i);
+            Val = Rtl_NtkReadSig(p, &i);            
+            Vec_IntPushTwo( &p->vStore, Par, Val );
+        }
+        assert( Rtl_NtkPosCheck(p, i, RTL_NONE) );
+    }
+    assert( Rtl_NtkPosCheck(p, i, RTL_END) );
+    i++;
+    assert( Rtl_NtkPosCheck(p, i, RTL_NONE) );
+    return i;
+}
+int Wln_ReadMatchEnd( Rtl_Ntk_t * p, int Mod )
+{
+    int i, Entry, Count = 0;
+    Vec_IntForEachEntryStart( p->pLib->vTokens, Entry, i, Mod )
+        if ( Rtl_NtkTokCheck(p, Entry, RTL_CELL) )
+            Count++;
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_END) )
+        {
+            if ( Count == 0 )
+                return i;
+            Count--;
+        }
+    assert( 0 );
+    return -1;
+}
+int Rtl_NtkReadNtk( Rtl_Lib_t * pLib, int Mod )
+{
+    Rtl_Ntk_t * p = Rtl_NtkAlloc( pLib );
+    Vec_Int_t * vAttrs = &p->pLib->vAttrTemp;
+    int End = Wln_ReadMatchEnd( p, Mod ), i, Entry;
+    assert( Rtl_NtkPosCheck(p, Mod-1, RTL_MODULE) );
+    assert( Rtl_NtkPosCheck(p, End, RTL_END)    );
+    p->NameId = Rtl_NtkTokId( p, Mod );
+    p->Slice0 = Vec_IntSize( &pLib->vSlices );
+    Vec_IntAppend( &p->vAttrs, vAttrs );
+    Vec_IntClear( vAttrs );
+    Vec_IntForEachEntryStartStop( pLib->vTokens, Entry, i, Mod, End )
+    {
+        if ( Rtl_NtkTokCheck(p, Entry, RTL_WIRE) )
+            i = Rtl_NtkReadWire( p, i+1 );
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_ATTRIBUTE) )
+            i = Rtl_NtkReadAttribute( p, i+1 );
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_CELL) )
+            i = Rtl_NtkReadCell( p, i+1 );
+        else if ( Rtl_NtkTokCheck(p, Entry, RTL_CONNECT) )
+            i = Rtl_NtkReadConnect( p, i+1 );
+    }
+    p->Slice1 = Vec_IntSize( &pLib->vSlices );
+    assert( Vec_IntSize(&p->vWires) % WIRE_NUM == 0 );
+    return End;
+}
+void Rtl_NtkReportUndefs( Rtl_Ntk_t * p )
+{
+    Vec_Int_t * vNames, * vCounts;
+    int i, iName, * pCell, nUndef = 0;
+    vNames  = Vec_IntAlloc( 10 );
+    vCounts = Vec_IntAlloc( 10 );
+    Rtl_NtkForEachCell( p, pCell, i )
+        if ( Rtl_CellModule(pCell) == ABC_INFINITY-1 ) 
+        {
+            iName = Vec_IntFind(vNames, Rtl_CellType(pCell));
+            if ( iName == -1 )
+            {
+                iName = Vec_IntSize(vNames);
+                Vec_IntPush( vNames, Rtl_CellType(pCell) );
+                Vec_IntPush( vCounts, 0 );
+            }
+            Vec_IntAddToEntry( vCounts, iName, 1 );
+        }
+    Vec_IntForEachEntry( vNames, iName, i )
+        printf( "  %s (%d)", Rtl_NtkStr(p, iName), Vec_IntEntry(vCounts, i) );
+    printf( "\n" );
+    Vec_IntFree( vNames );
+    Vec_IntFree( vCounts );
+}
+int Rtl_NtkSetParents( Rtl_Ntk_t * p )
+{
+    int i, * pCell, nUndef = 0;
+    Rtl_NtkForEachCell( p, pCell, i )
+    {
+        pCell[2] = Rtl_NtkReadType( p, Rtl_CellType(pCell) );
+        if ( Rtl_CellModule(pCell) == ABC_INFINITY-1 ) 
+            nUndef++;
+        else
+            pCell[3] = Rtl_CellModule(pCell) < ABC_INFINITY ? pCell[6]-1 : Rtl_NtkModule(p, Rtl_CellModule(pCell)-ABC_INFINITY)->nInputs;
+    }
+    if ( !nUndef )
+        return 0;
+    printf( "Module \"%s\" has %d blackbox instances: ", Rtl_NtkName(p), nUndef );
+    Rtl_NtkReportUndefs( p );
+    return nUndef;
+}
+void Rtl_LibSetParents( Rtl_Lib_t * p )
+{
+    Rtl_Ntk_t * pNtk; int i;
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        Rtl_NtkSetParents( pNtk );  
+}
+void Rtl_LibReorderModules_rec( Rtl_Ntk_t * p, Vec_Ptr_t * vNew )
+{
+    int i, * pCell;
+    Rtl_NtkForEachCell( p, pCell, i )
+    {
+        Rtl_Ntk_t * pMod = Rtl_CellNtk( p, pCell );
+        if ( pMod && pMod->iCopy == -1 )
+            Rtl_LibReorderModules_rec( pMod, vNew );
+    }
+    assert( p->iCopy == -1 );
+    p->iCopy = Vec_PtrSize(vNew);
+    Vec_PtrPush( vNew, p );
+}
+void Rtl_NtkUpdateBoxes( Rtl_Ntk_t * p )
+{
+    int i, * pCell;
+    Rtl_NtkForEachCell( p, pCell, i )
+    {
+        Rtl_Ntk_t * pMod = Rtl_CellNtk( p, pCell );
+        if ( pMod ) 
+            pCell[2] = ABC_INFINITY + pMod->iCopy;
+    }
+}
+void Rtl_LibUpdateBoxes( Rtl_Lib_t * p )
+{
+    Rtl_Ntk_t * pNtk; int i;
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        Rtl_NtkUpdateBoxes( pNtk );  
+}
+void Rtl_LibReorderModules( Rtl_Lib_t * p )
+{
+    Vec_Ptr_t * vNew = Vec_PtrAlloc( Vec_PtrSize(p->vNtks) );
+    Rtl_Ntk_t * pNtk; int i;
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        pNtk->iCopy = -1;
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
+        if ( pNtk->iCopy == -1 )
+            Rtl_LibReorderModules_rec( pNtk, vNew );
+    assert( Vec_PtrSize(p->vNtks) == Vec_PtrSize(vNew) );
+    Rtl_LibUpdateBoxes( p );
+    Vec_PtrClear( p->vNtks );
+    Vec_PtrAppend( p->vNtks, vNew );
+    Vec_PtrFree( vNew );
+}
+Rtl_Lib_t * Rtl_LibReadFile( char * pFileName, char * pFileSpec )
+{
+    Rtl_Lib_t * p = Rtl_LibAlloc(); int i, Entry;
+    p->pSpec      = Abc_UtilStrsav( pFileSpec );
+    p->pManName   = Abc_NamStart( 1000, 50 );
+    p->vTokens    = Rtl_NtkReadFile( pFileName, p->pManName );
+    Rtl_LibDeriveMap( p );
+    Vec_IntClear( &p->vAttrTemp );
+    Vec_IntForEachEntry( p->vTokens, Entry, i )
+        if ( Entry == p->pMap[RTL_MODULE] )
+            i = Rtl_NtkReadNtk( p, i+1 );
+        else if ( Entry == p->pMap[RTL_ATTRIBUTE] )
+            i = Rtl_NtkReadAttribute2( p, i+1 );
+    Rtl_LibSetParents( p );
+    Rtl_LibReorderModules( p );
+    return p;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+extern void Rtl_NtkCollectSignalRange( Rtl_Ntk_t * p, int Sig );
+
+void Rtl_NtkCollectWireRange( Rtl_Ntk_t * p, int NameId, int Left, int Right )
+{
+    int Wire  = Rtl_WireMapNameToId( p, NameId );
+    int First = Rtl_WireBitStart( p, Wire );
+    int Width = Rtl_WireWidth( p, Wire ), i;
+    Left  = Left  == -1 ? Width-1 :  Left;
+    Right = Right == -1 ? 0       : Right;
+    assert ( Right >= 0 && Right <= Left );
+    for ( i = Right; i <= Left; i++ )
+    {
+        assert( Vec_IntEntry(&p->vLits, First+i) != -1 );
+        Vec_IntPush( &p->vBitTemp, Vec_IntEntry(&p->vLits, First+i) );
+    }
+}
+void Rtl_NtkCollectConstRange( Rtl_Ntk_t * p, int * pConst )
+{
+    int i, nLimit = pConst[0];
+    if ( nLimit == -1 )
+        nLimit = 32;
+    //assert( pConst[0] > 0 );
+    for ( i = 0; i < nLimit; i++ )
+        Vec_IntPush( &p->vBitTemp, Abc_InfoHasBit(pConst+1,i) );
+}
+void Rtl_NtkCollectSliceRange( Rtl_Ntk_t * p, int * pSlice )
+{
+    Rtl_NtkCollectWireRange( p, pSlice[0], pSlice[1], pSlice[2] );
+}
+void Rtl_NtkCollectConcatRange( Rtl_Ntk_t * p, int * pConcat )
+{
+    int i;
+    for ( i = pConcat[0]; i >= 1; i-- )
+        Rtl_NtkCollectSignalRange( p, pConcat[i] );
+}
+void Rtl_NtkCollectSignalRange( Rtl_Ntk_t * p, int Sig )
+{
+    if ( Rtl_SigIsNone(Sig) )
+        Rtl_NtkCollectWireRange( p, Sig >> 2, -1, -1 );
+    else if ( Rtl_SigIsConst(Sig) )
+        Rtl_NtkCollectConstRange( p, Vec_IntEntryP(&p->pLib->vConsts, Sig >> 2) );
+    else if ( Rtl_SigIsSlice(Sig) )
+        Rtl_NtkCollectSliceRange( p, Vec_IntEntryP(&p->pLib->vSlices, Sig >> 2) );
+    else if ( Rtl_SigIsConcat(Sig) )
+        Rtl_NtkCollectConcatRange( p, Vec_IntEntryP(&p->pLib->vConcats, Sig >> 2) );
+    else assert( 0 );
+}
+
+
+extern int Rtl_NtkInsertSignalRange( Rtl_Ntk_t * p, int Sig, int * pLits, int nLits );
+
+int Rtl_NtkInsertWireRange( Rtl_Ntk_t * p, int NameId, int Left, int Right, int * pLits, int nLits )
+{
+    //char * pName = Rtl_NtkStr( p, NameId );
+    int Wire  = Rtl_WireMapNameToId( p, NameId );
+    int First = Rtl_WireBitStart( p, Wire );
+    int Width = Rtl_WireWidth( p, Wire ), i, k = 0;
+    Left  = Left  == -1 ? Width-1 :  Left;
+    Right = Right == -1 ? 0       : Right;
+    assert ( Right >= 0 && Right <= Left );
+    for ( i = Right; i <= Left; i++ )
+    {
+        assert( Vec_IntEntry(&p->vLits, First+i) == -1 );
+        Vec_IntWriteEntry(&p->vLits, First+i, pLits[k++] );
+    }
+    assert( k <= nLits );
+    return k;
+}
+int Rtl_NtkInsertSliceRange( Rtl_Ntk_t * p, int * pSlice, int * pLits, int nLits )
+{
+    return Rtl_NtkInsertWireRange( p, pSlice[0], pSlice[1], pSlice[2], pLits, nLits );
+}
+int Rtl_NtkInsertConcatRange( Rtl_Ntk_t * p, int * pConcat, int * pLits, int nLits )
+{
+    int i, k = 0;
+    for ( i = 1; i <= pConcat[0]; i++ )
+        k += Rtl_NtkInsertSignalRange( p, pConcat[i], pLits+k, nLits-k );
+    assert( k <= nLits );
+    return k;
+}
+int Rtl_NtkInsertSignalRange( Rtl_Ntk_t * p, int Sig, int * pLits, int nLits )
+{
+    int nBits = ABC_INFINITY;
+    if ( Rtl_SigIsNone(Sig) )
+        nBits = Rtl_NtkInsertWireRange( p, Sig >> 2, -1, -1, pLits, nLits );
+    if ( Rtl_SigIsSlice(Sig) )
+        nBits = Rtl_NtkInsertSliceRange( p, Vec_IntEntryP(&p->pLib->vSlices, Sig >> 2), pLits, nLits );
+    if ( Rtl_SigIsConcat(Sig) )
+        nBits = Rtl_NtkInsertConcatRange( p, Vec_IntEntryP(&p->pLib->vConcats, Sig >> 2), pLits, nLits );
+    if ( Rtl_SigIsConst(Sig) )
+        assert( 0 );
+    assert( nBits == nLits );
+    return nBits;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Rtl_NtkBlastInputs( Gia_Man_t * pNew, Rtl_Ntk_t * p )
+{
+    int b, i;
+    for ( i = 0; i < p->nInputs; i++ )
+    {
+        int First = Rtl_WireBitStart( p, i );
+        int Width = Rtl_WireWidth( p, i );
+        for ( b = 0; b < Width; b++ )
+        {
+            assert( Vec_IntEntry(&p->vLits, First+b) == -1 );
+            Vec_IntWriteEntry( &p->vLits, First+b, Gia_ManAppendCi(pNew) );
+        }
+    }
+}
+void Rtl_NtkBlastOutputs( Gia_Man_t * pNew, Rtl_Ntk_t * p )
+{
+    int b, i;
+    for ( i = 0; i < p->nOutputs; i++ )
+    {
+        int First = Rtl_WireBitStart( p, p->nInputs + i );
+        int Width = Rtl_WireWidth( p, p->nInputs + i );
+        for ( b = 0; b < Width; b++ )
+        {
+            assert( Vec_IntEntry(&p->vLits, First+b) != -1 );
+            Gia_ManAppendCo( pNew, Vec_IntEntry(&p->vLits, First+b) );
+        }
+    }
+}
+void Rtl_NtkBlastConnect( Gia_Man_t * pNew, Rtl_Ntk_t * p, int * pCon )
+{
+    int nBits;
+    Vec_IntClear( &p->vBitTemp );
+    Rtl_NtkCollectSignalRange( p, pCon[0] );
+    nBits = Rtl_NtkInsertSignalRange( p, pCon[1], Vec_IntArray(&p->vBitTemp), Vec_IntSize(&p->vBitTemp) );
+    assert( nBits == Vec_IntSize(&p->vBitTemp) );
+    //printf( "Finished blasting connection (Value = %d).\n", Vec_IntEntry(&p->vBitTemp, 0) );
+}
+void Rtl_NtkBlastHierarchy( Gia_Man_t * pNew, Rtl_Ntk_t * p, int * pCell )
+{
+    extern Gia_Man_t * Rtl_NtkBlast( Rtl_Ntk_t * p );
+    extern void Gia_ManDupRebuild( Gia_Man_t * pNew, Gia_Man_t * p, Vec_Int_t * vLits );
+    Rtl_Ntk_t * pModel = Rtl_NtkModule( p, Rtl_CellModule(pCell)-ABC_INFINITY );
+    int k, Par, Val, nBits = 0;
+    Vec_IntClear( &p->vBitTemp );
+    Rtl_CellForEachInput( p, pCell, Par, Val, k )
+        Rtl_NtkCollectSignalRange( p, Val );
+//    if ( pModel->pGia == NULL )
+//        pModel->pGia = Rtl_NtkBlast( pModel );
+    assert( pModel->pGia );
+    Gia_ManDupRebuild( pNew, pModel->pGia, &p->vBitTemp );
+    Rtl_CellForEachOutput( p, pCell, Par, Val, k )
+        nBits += Rtl_NtkInsertSignalRange( p, Val, Vec_IntArray(&p->vBitTemp)+nBits, Vec_IntSize(&p->vBitTemp)-nBits );
+    assert( nBits == Vec_IntSize(&p->vBitTemp) );
+}
+
+int Rtl_NtkCellParamValue( Rtl_Ntk_t * p, int * pCell, char * pParam )
+{
+    int ParamId = Rtl_NtkStrId( p, pParam );
+    int i, Par, Val, ValOut = ABC_INFINITY, * pConst;
+//    p->pLib->pFile = stdout;
+//    Rtl_CellForEachParam( p, pCell, Par, Val, i )
+//        fprintf( Rtl_NtkFile(p), "    parameter" ), Rtl_NtkPrintSig(p, Par), Rtl_NtkPrintSig(p, Val), printf( "\n" );
+    Rtl_CellForEachParam( p, pCell, Par, Val, i )
+        if ( (Par >> 2) == ParamId )
+        {
+            assert( Rtl_SigIsConst(Val) );
+            pConst = Vec_IntEntryP( &p->pLib->vConsts, Val >> 2 );
+            assert( pConst[0] < 32 );
+            ValOut = pConst[1];
+        }
+    return ValOut;
+}
+void Rtl_NtkBlastOperator( Gia_Man_t * pNew, Rtl_Ntk_t * p, int * pCell )
+{
+    extern void Rtl_NtkBlastNode( Gia_Man_t * pNew, int Type, int nIns, Vec_Int_t * vDatas, int nRange, int fSign0, int fSign1 );
+    Vec_Int_t * vRes = &p->pLib->vTemp[3];
+    int i, Par, Val, ValOut = -1, nBits = 0, nRange = -1;
+    int fSign0 = Rtl_NtkCellParamValue( p, pCell, "\\A_SIGNED" );
+    int fSign1 = Rtl_NtkCellParamValue( p, pCell, "\\B_SIGNED" );
+    Rtl_CellForEachOutput( p, pCell, Par, ValOut, i )
+        nRange = Rtl_NtkCountSignalRange( p, ValOut );
+    assert( nRange > 0 );
+    for ( i = 0; i < TEMP_NUM; i++ )
+        Vec_IntClear( &p->pLib->vTemp[i] );
+    //printf( "Starting blasting cell %s.\n", Rtl_CellNameStr(p, pCell) );
+    Rtl_CellForEachInput( p, pCell, Par, Val, i )
+    {
+        Vec_IntClear( &p->vBitTemp );
+        Rtl_NtkCollectSignalRange( p, Val );
+        Vec_IntAppend( &p->pLib->vTemp[i], &p->vBitTemp );
+    }
+    Rtl_NtkBlastNode( pNew, Rtl_CellModule(pCell), Rtl_CellInputNum(pCell), p->pLib->vTemp, nRange, fSign0, fSign1 );
+    assert( Vec_IntSize(vRes) > 0 );
+    nBits = Rtl_NtkInsertSignalRange( p, ValOut, Vec_IntArray(vRes)+nBits, Vec_IntSize(vRes)-nBits );
+    assert( nBits == Vec_IntSize(vRes) );
+    //printf( "Finished blasting cell %s (Value = %d).\n", Rtl_CellNameStr(p, pCell), Vec_IntEntry(vRes, 0) );
+}
+Gia_Man_t * Rtl_NtkBlast( Rtl_Ntk_t * p )
+{
+    Gia_Man_t * pTemp, * pNew = Gia_ManStart( 1000 );
+    int i, iObj, * pCell, nBits = Rtl_NtkRangeWires( p );
+    char Buffer[100]; static int counter = 0;
+    Vec_IntFill( &p->vLits, nBits, -1 );
+    Rtl_NtkMapWires( p, 0 );
+    Rtl_NtkBlastInputs( pNew, p );
+    Gia_ManHashAlloc( pNew );
+    Vec_IntForEachEntry( &p->vOrder, iObj, i )
+    {
+        iObj -= Rtl_NtkInputNum(p);
+        if ( iObj < 0 )
+            continue;
+        if ( iObj >= Rtl_NtkCellNum(p) )
+        {
+            Rtl_NtkBlastConnect( pNew, p, Rtl_NtkCon(p, iObj - Rtl_NtkCellNum(p)) );
+            continue;
+        }
+        pCell = Rtl_NtkCell(p, iObj);
+        if ( Rtl_CellModule(pCell) >= ABC_INFINITY )
+            Rtl_NtkBlastHierarchy( pNew, p, pCell );
+        else if ( Rtl_CellModule(pCell) < ABC_OPER_LAST )
+            Rtl_NtkBlastOperator( pNew, p, pCell );
+        else
+            printf( "Cannot blast black box %s in module %s.\n", Rtl_NtkStr(p, Rtl_CellType(pCell)), Rtl_NtkName(p) );
+    }
+    Gia_ManHashStop( pNew );
+    Rtl_NtkBlastOutputs( pNew, p );
+    Rtl_NtkMapWires( p, 1 );
+    pNew = Gia_ManCleanup( pTemp = pNew );
+    Gia_ManStop( pTemp );
+
+sprintf( Buffer, "temp%d.aig", counter++ );
+//sprintf( Buffer, "temp%d.aig", counter );
+Gia_AigerWrite( pNew, Buffer, 0, 0, 0 );
+printf( "Dumpted blasted AIG into file \"%s\" for module \"%s\".\n", Buffer, Rtl_NtkName(p) );
+Gia_ManPrintStats( pNew, NULL );
+    return pNew;
+}
+void Rtl_LibBlast( Rtl_Lib_t * pLib )
+{
+    Rtl_Ntk_t * p; int i;
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p, i )
+        if ( p->pGia == NULL )
+            p->pGia = Rtl_NtkBlast( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Rtl_LibPreprocess( Rtl_Lib_t * pLib )
+{
+    abctime clk = Abc_Clock(); 
+    Rtl_Ntk_t * p1, * p2, * p;
+    int i, k, Status, fFound = 0;
+    printf( "Performing preprocessing for verification.\n" );
+    // find similar modules
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p1, i )
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p2, k )
+    {
+        if ( i >= k )  
+            continue;
+        if ( Gia_ManCiNum(p1->pGia) != Gia_ManCiNum(p2->pGia) || 
+             Gia_ManCoNum(p1->pGia) != Gia_ManCoNum(p2->pGia) )
+            continue;
+        // two similar modules
+        Status = Cec_ManVerifyTwo( p1->pGia, p2->pGia, 0 );
+        if ( Status != 1 )
+            continue;
+        printf( "Proved equivalent modules: %s == %s\n", Rtl_NtkName(p1), Rtl_NtkName(p2) );
+        // inline
+        if ( Gia_ManAndNum(p1->pGia) > Gia_ManAndNum(p2->pGia) )
+            ABC_SWAP( Gia_Man_t *, p1->pGia, p2->pGia );
+        assert( Gia_ManAndNum(p1->pGia) <= Gia_ManAndNum(p2->pGia) );
+        Gia_ManStopP( &p2->pGia );
+        p2->pGia = Gia_ManDup( p1->pGia );
+        fFound = 1;
+        goto finish;
+    }
+finish:
+    if ( fFound == 0 )
+        printf( "Preprocessing not succeded.\n" );
+    Abc_PrintTime( 1, "Preprocessing time", Abc_Clock() - clk );
+    // blast AIGs again
+    Vec_PtrForEachEntry( Rtl_Ntk_t *, pLib->vNtks, p, i )
+        if ( p != p1 && p != p2 )
+            Gia_ManStopP( &p->pGia );
+    Rtl_LibBlast( pLib );
+}
+void Rtl_LibSolve( Rtl_Lib_t * pLib )
+{
+    abctime clk = Abc_Clock(); int Status;
+    Rtl_Ntk_t * pTop = Rtl_LibTop( pLib );
+    Gia_Man_t * pCopy = Gia_ManDup( pTop->pGia );
+    Gia_ManInvertPos( pCopy );
+    Gia_ManAppendCo( pCopy, 0 );
+    Status = Cec_ManVerifySimple( pCopy );
+    Gia_ManStop( pCopy );
+    if ( Status == 1 )
+        printf( "Verification problem solved!  " );
+    else
+        printf( "Verification problem is NOT solved!  " );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/wln/wlnRtl.c

@@ -37,21 +37,6 @@ ABC_NAMESPACE_IMPL_START
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Wln_Ntk_t * Wln_ReadRtl( char * pFileName )
-{
-    return NULL;
-}
 
 /**Function*************************************************************
 
@@ -96,28 +81,31 @@ int Wln_ConvertToRtl( char * pCommand, char * pFileTemp )
     fclose( pFile );
     return 1;
 }
-Wln_Ntk_t * Wln_ReadSystemVerilog( char * pFileName, char * pTopModule, int fVerbose )
+Rtl_Lib_t * Wln_ReadSystemVerilog( char * pFileName, char * pTopModule, int fCollapse, int fVerbose )
 {
-    Wln_Ntk_t * pNtk = NULL;
+    Rtl_Lib_t * pNtk = NULL;
     char Command[1000];
     char * pFileTemp = "_temp_.rtlil";
     int fSVlog = strstr(pFileName, ".sv") != NULL;
-    sprintf( Command, "%s -qp \"read_verilog %s%s; hierarchy %s%s; flatten; proc; write_rtlil %s\"", 
+    if ( strstr(pFileName, ".rtl") )
+        return Rtl_LibReadFile( pFileName, pFileName );
+    sprintf( Command, "%s -qp \"read_verilog %s%s; hierarchy %s%s; %sproc; write_rtlil %s\"", 
         Wln_GetYosysName(), fSVlog ? "-sv ":"", pFileName, 
-        pTopModule ? "-top " : "-auto-top", pTopModule ? pTopModule : "", pFileTemp );
+        pTopModule ? "-top " : "-auto-top", 
+        pTopModule ? pTopModule : "", 
+        fCollapse ? "flatten; " : "",
+        pFileTemp );
     if ( fVerbose )
     printf( "%s\n", Command );
     if ( !Wln_ConvertToRtl(Command, pFileTemp) )
-    {
         return NULL;
-    }
-    pNtk = Wln_ReadRtl( pFileTemp );
+    pNtk = Rtl_LibReadFile( pFileTemp, pFileName );
     if ( pNtk == NULL )
     {
         printf( "Dumped the design into file \"%s\".\n", pFileTemp );
         return NULL;
     }
-    unlink( pFileTemp );
+    //unlink( pFileTemp );
     return pNtk;
 }
 Gia_Man_t * Wln_BlastSystemVerilog( char * pFileName, char * pTopModule, int fSkipStrash, int fInvert, int fTechMap, int fVerbose )
@@ -125,10 +113,16 @@ Gia_Man_t * Wln_BlastSystemVerilog( char * pFileName, char * pTopModule, int fSk
     Gia_Man_t * pGia = NULL;
     char Command[1000];
     char * pFileTemp = "_temp_.aig";
+    int fRtlil = strstr(pFileName, ".rtl") != NULL;
     int fSVlog = strstr(pFileName, ".sv")  != NULL;
-    sprintf( Command, "%s -qp \"read_verilog %s%s; hierarchy %s%s; flatten; proc; %saigmap; write_aiger %s\"", 
-        Wln_GetYosysName(), fSVlog ? "-sv ":"", pFileName, 
-        pTopModule ? "-top " : "-auto-top", pTopModule ? pTopModule : "", fTechMap ? "techmap; setundef -zero; " : "", pFileTemp );
+    sprintf( Command, "%s -qp \"%s%s%s; hierarchy %s%s; flatten; proc; %saigmap; write_aiger %s\"", 
+        Wln_GetYosysName(), 
+        fRtlil ? "read_rtlil" : "read_verilog",
+        fSVlog ? " -sv ":" ", 
+        pFileName, 
+        pTopModule ? "-top " : "-auto-top", 
+        pTopModule ? pTopModule : "", 
+        fTechMap ? "techmap; setundef -zero; " : "", pFileTemp );
     if ( fVerbose )
     printf( "%s\n", Command );
     if ( !Wln_ConvertToRtl(Command, pFileTemp) )