Scalable SOP manipulation package.

Makefile

@@ -13,8 +13,8 @@ PROG := abc
 
 MODULES := \
 	$(wildcard src/ext*) \
-	src/base/abc src/base/abci src/base/cmd src/base/io \
-	src/base/main src/base/ver src/base/wlc src/base/cba src/base/test \
+	src/base/abc src/base/abci src/base/cmd src/base/io src/base/main \
+	src/base/ver src/base/wlc src/base/cba src/base/pla src/base/test \
 	src/bdd/cudd src/bdd/dsd src/bdd/epd src/bdd/mtr src/bdd/parse \
 	src/bdd/reo src/bdd/cas \
 	src/map/mapper src/map/mio src/map/super src/map/if \

abclib.dsp

@@ -854,6 +854,38 @@ SOURCE=.\src\base\cba\cbaWriteSmt.c
 SOURCE=.\src\base\cba\cbaWriteVer.c
 # End Source File
 # End Group
+# Begin Group "pla"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\src\base\pla\pla.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\base\pla\plaCom.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\base\pla\plaHash.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\base\pla\plaMan.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\base\pla\plaMerge.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\base\pla\plaRead.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\base\pla\plaWrite.c
+# End Source File
+# End Group
 # End Group
 # Begin Group "bdd"
 

src/base/cba/cbaPrs.h

@@ -241,13 +241,14 @@ static inline char * Prs_ManLoadFile( char * pFileName, char ** ppLimit )
     // move the file current reading position to the beginning
     rewind( pFile ); 
     // load the contents of the file into memory
-    pBuffer = ABC_ALLOC( char, nFileSize + 3 );
+    pBuffer = ABC_ALLOC( char, nFileSize + 16 );
     pBuffer[0] = '\n';
     RetValue = fread( pBuffer+1, nFileSize, 1, pFile );
+    fclose( pFile );
     // terminate the string with '\0'
-    pBuffer[nFileSize + 0] = '\n';
-    pBuffer[nFileSize + 1] = '\0';
-    *ppLimit = pBuffer + nFileSize + 2;
+    pBuffer[nFileSize + 1] = '\n';
+    pBuffer[nFileSize + 2] = '\0';
+    *ppLimit = pBuffer + nFileSize + 3;
     return pBuffer;
 }
 static inline Prs_Man_t * Prs_ManAlloc( char * pFileName )

src/base/main/mainInit.c

@@ -51,6 +51,8 @@ extern void Wlc_Init( Abc_Frame_t * pAbc );
 extern void Wlc_End( Abc_Frame_t * pAbc );
 extern void Cba_Init( Abc_Frame_t * pAbc );
 extern void Cba_End( Abc_Frame_t * pAbc );
+extern void Pla_Init( Abc_Frame_t * pAbc );
+extern void Pla_End( Abc_Frame_t * pAbc );
 extern void Test_Init( Abc_Frame_t * pAbc );
 extern void Test_End( Abc_Frame_t * pAbc );
 extern void Abc2_Init( Abc_Frame_t * pAbc );
@@ -107,6 +109,7 @@ void Abc_FrameInit( Abc_Frame_t * pAbc )
     Scl_Init( pAbc );
     Wlc_Init( pAbc );
     Cba_Init( pAbc );
+    Pla_Init( pAbc );
     Test_Init( pAbc );
     for( p = s_InitializerStart ; p ; p = p->next )
         if(p->init)
@@ -143,6 +146,7 @@ void Abc_FrameEnd( Abc_Frame_t * pAbc )
     Scl_End( pAbc );
     Wlc_End( pAbc );
     Cba_End( pAbc );
+    Pla_End( pAbc );
     Test_End( pAbc );
 }
 

src/base/main/mainInt.h

@@ -128,6 +128,7 @@ struct Abc_Frame_t_
     void *          pAbc85Delay;
     void *          pAbcWlc;
     void *          pAbcCba;
+    void *          pAbcPla;
 };
 
 typedef void (*Abc_Frame_Initialization_Func)( Abc_Frame_t * pAbc );

src/base/pla/module.make

+SRC +=    src/base/pla/plaCom.c \
+    src/base/pla/plaHash.c \
+    src/base/pla/plaMan.c \
+    src/base/pla/plaMerge.c \
+    src/base/pla/plaRead.c \
+    src/base/pla/plaWrite.c 

src/base/pla/pla.c

+/**CFile****************************************************************
+
+  FileName    [pla.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SOP manager.]
+
+  Synopsis    [Scalable SOP transformations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - March 18, 2015.]
+
+  Revision    [$Id: pla.c,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "pla.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/pla/pla.h

+/**CFile****************************************************************
+
+  FileName    [pla.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SOP manager.]
+
+  Synopsis    [Scalable SOP transformations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - March 18, 2015.]
+
+  Revision    [$Id: pla.h,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef ABC__base__wlc__wlc_h
+#define ABC__base__wlc__wlc_h
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "aig/gia/gia.h"
+#include "misc/extra/extra.h"
+#include "base/main/mainInt.h"
+//#include "misc/util/utilTruth.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START 
+
+#define MASK55 ABC_CONST(0x5555555555555555)
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+// file types
+typedef enum { 
+    PLA_FILE_FD = 0, 
+    PLA_FILE_F,      
+    PLA_FILE_FR,     
+    PLA_FILE_FDR,      
+    PLA_FILE_NONE     
+} Pla_File_t; 
+
+// literal types
+typedef enum { 
+    PLA_LIT_DASH = 0, 
+    PLA_LIT_ZERO,     
+    PLA_LIT_ONE,      
+    PLA_LIT_FULL      
+} Pla_Lit_t; 
+
+
+typedef struct Pla_Man_t_ Pla_Man_t;
+struct Pla_Man_t_ 
+{
+    char *           pName;      // model name
+    char *           pSpec;      // input file
+    Pla_File_t       Type;       // file type
+    int              nIns;       // inputs
+    int              nOuts;      // outputs
+    int              nInWords;   // words of input data
+    int              nOutWords;  // words of output data
+    Vec_Int_t        vCubes;     // cubes
+    Vec_Int_t        vHashes;    // hash values
+    Vec_Wrd_t        vInBits;    // input bits
+    Vec_Wrd_t        vOutBits;   // output bits
+    Vec_Wec_t        vLits;      // cubes as interger arrays
+    Vec_Wec_t        vOccurs;    // occurent counters for the literals
+};
+
+static inline int    Pla_ManInNum( Pla_Man_t * p )                   { return p->nIns;                    }
+static inline int    Pla_ManOutNum( Pla_Man_t * p )                  { return p->nOuts;                   }
+static inline int    Pla_ManCubeNum( Pla_Man_t * p )                 { return Vec_IntSize( &p->vCubes );  }
+
+static inline word * Pla_CubeIn( Pla_Man_t * p, int i )              { return Vec_WrdEntryP(&p->vInBits,  i * p->nInWords);  }
+static inline word * Pla_CubeOut( Pla_Man_t * p, int i )             { return Vec_WrdEntryP(&p->vOutBits, i * p->nOutWords); }
+
+static inline int    Pla_CubeGetLit( word * p, int k )               { return (int)(p[k>>5] >> ((k<<1) & 63)) & 3; }
+static inline void   Pla_CubeSetLit( word * p, int k, Pla_Lit_t d )  { p[k>>5] |= (((word)d)<<((k<<1) & 63));      }
+static inline void   Pla_CubeXorLit( word * p, int k, Pla_Lit_t d )  { p[k>>5] ^= (((word)d)<<((k<<1) & 63));      }
+
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                             ITERATORS                            ///
+////////////////////////////////////////////////////////////////////////
+
+#define Pla_ForEachCubeIn( p, pCube, i )                            \
+    for ( i = 0; (i < Pla_ManCubeNum(p))  && (((pCube) = Pla_CubeIn(p, i)), 1); i++ ) 
+#define Pla_ForEachCubeInStart( p, pCube, i, Start )                \
+    for ( i = Start; (i < Pla_ManCubeNum(p))  && (((pCube) = Pla_CubeIn(p, i)), 1); i++ ) 
+
+#define Pla_ForEachCubeOut( p, pCube, i )                           \
+    for ( i = 0; (i < Pla_ManCubeNum(p))  && (((pCube) = Pla_CubeOut(p, i)), 1); i++ ) 
+#define Pla_ForEachCubeInOut( p, pCubeIn, pCubeOut, i )             \
+    for ( i = 0; (i < Pla_ManCubeNum(p))  && (((pCubeIn) = Pla_CubeIn(p, i)), 1)  && (((pCubeOut) = Pla_CubeOut(p, i)), 1); i++ ) 
+
+#define Pla_CubeForEachLit( nVars, pCube, Lit, i )                  \
+    for ( i = 0; (i < nVars)  && (((Lit) = Pla_CubeGetLit(pCube, i)), 1); i++ ) 
+#define Pla_CubeForEachLitIn( p, pCube, Lit, i )                    \
+    Pla_CubeForEachLit( Pla_ManInNum(p), pCube, Lit, i )
+#define Pla_CubeForEachLitOut( p, pCube, Lit, i )                   \
+    Pla_CubeForEachLit( Pla_ManOutNum(p), pCube, Lit, i )
+
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Checks if cubes are distance-1.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Pla_OnlyOneOne( word t )
+{
+    return t ? ((t & (t-1)) == 0) : 0;
+}
+static inline int Pla_CubesAreDistance1( word * p, word * q, int nWords )
+{
+    word Test; int c, fFound = 0;
+    for ( c = 0; c < nWords; c++ )
+    {
+        if ( p[c] == q[c] )
+            continue;
+        if ( fFound )
+            return 0;
+        // check if the number of 1s is one, which means exactly one different literal (0/1, -/1, -/0)
+        Test = ((p[c] ^ q[c]) | ((p[c] ^ q[c]) >> 1)) & MASK55;
+        if ( !Pla_OnlyOneOne(Test) )
+            return 0;
+        fFound = 1;
+    }
+    return fFound;
+}
+static inline int Pla_CubesAreConsensus( word * p, word * q, int nWords, int * piVar )
+{
+    word Test; int c, fFound = 0;
+    for ( c = 0; c < nWords; c++ )
+    {
+        if ( p[c] == q[c] )
+            continue;
+        if ( fFound )
+            return 0;
+        // check if the number of 1s is one, which means exactly one opposite literal (0/1) but may have other diffs (-/0 or -/1)
+        Test = ((p[c] ^ q[c]) & ((p[c] ^ q[c]) >> 1)) & MASK55; 
+        if ( !Pla_OnlyOneOne(Test) )
+            return 0;
+        fFound = 1;
+        if ( piVar ) *piVar = c * 32 + Abc_Tt6FirstBit(Test)/2;
+    }
+    return fFound;
+}
+            
+/**Function*************************************************************
+
+  Synopsis    [Manager APIs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Pla_Man_t * Pla_ManAlloc( char * pFileName, int nIns, int nOuts, int nCubes )
+{
+    Pla_Man_t * p = ABC_CALLOC( Pla_Man_t, 1 );
+    p->pName = Extra_FileDesignName( pFileName );
+    p->pSpec = Abc_UtilStrsav( pFileName );
+    p->nIns  = nIns;
+    p->nOuts = nOuts;
+    p->nInWords  = Abc_Bit6WordNum( 2*nIns );
+    p->nOutWords = Abc_Bit6WordNum( 2*nOuts );
+    Vec_IntFillNatural( &p->vCubes, nCubes );
+    Vec_WrdFill( &p->vInBits,  Pla_ManCubeNum(p) * p->nInWords,  0 );
+    Vec_WrdFill( &p->vOutBits, Pla_ManCubeNum(p) * p->nOutWords, 0 );
+    return p;
+}
+static inline void Pla_ManFree( Pla_Man_t * p )
+{
+    Vec_IntErase( &p->vCubes );
+    Vec_IntErase( &p->vHashes );
+    Vec_WrdErase( &p->vInBits );
+    Vec_WrdErase( &p->vOutBits );
+    Vec_WecErase( &p->vLits );
+    Vec_WecErase( &p->vOccurs );
+    ABC_FREE( p->pName );
+    ABC_FREE( p->pSpec );
+    ABC_FREE( p );
+}
+static inline int Pla_ManLitInNum( Pla_Man_t * p )
+{
+    word * pCube; int i, k, Lit, Count = 0;
+    Pla_ForEachCubeIn( p, pCube, i )
+        Pla_CubeForEachLitIn( p, pCube, Lit, k )
+            Count += Lit != PLA_LIT_DASH;
+    return Count;
+}
+static inline int Pla_ManLitOutNum( Pla_Man_t * p )
+{
+    word * pCube; int i, k, Lit, Count = 0;
+    Pla_ForEachCubeOut( p, pCube, i )
+        Pla_CubeForEachLitOut( p, pCube, Lit, k )
+            Count += Lit == PLA_LIT_ONE;
+    return Count;
+}
+static inline void Pla_ManPrintStats( Pla_Man_t * p, int fVerbose )
+{
+    printf( "%-16s :  ",     p->pName );
+    printf( "In =%4d  ",     Pla_ManInNum(p) );
+    printf( "Out =%4d  ",    Pla_ManOutNum(p) );
+    printf( "Cube =%8d  ",   Pla_ManCubeNum(p) );
+    printf( "LitIn =%8d  ",  Pla_ManLitInNum(p) );
+    printf( "LitOut =%8d  ", Pla_ManLitOutNum(p) );
+    printf( "%\n" );
+}
+
+
+/*=== plaHash.c ========================================================*/
+extern int                 Pla_ManHashDist1NumTest( Pla_Man_t * p );
+/*=== plaMan.c ========================================================*/
+extern Pla_Man_t *         Pla_ManPrimeDetector( int nVars );
+extern Pla_Man_t *         Pla_ManGenerate( int nIns, int nOuts, int nCubes, int fVerbose );
+extern void                Pla_ManConvertFromBits( Pla_Man_t * p );
+extern void                Pla_ManConvertToBits( Pla_Man_t * p );
+extern int                 Pla_ManDist1NumTest( Pla_Man_t * p );
+/*=== plaMerge.c ========================================================*/
+extern int                 Pla_ManDist1Merge( Pla_Man_t * p );
+/*=== plaRead.c ========================================================*/
+extern Pla_Man_t *         Pla_ReadPla( char * pFileName );
+/*=== plaWrite.c ========================================================*/
+extern void                Pla_WritePla( Pla_Man_t * p, char * pFileName );
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+

src/base/pla/plaHash.c

+/**CFile****************************************************************
+
+  FileName    [plaHash.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SOP manager.]
+
+  Synopsis    [Scalable SOP transformations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - March 18, 2015.]
+
+  Revision    [$Id: plaHash.c,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "pla.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+#define PLA_HASH_VALUE_NUM 256
+static unsigned s_PlaHashValues[PLA_HASH_VALUE_NUM] = 
+{
+    0x984b6ad9,0x18a6eed3,0x950353e2,0x6222f6eb,0xdfbedd47,0xef0f9023,0xac932a26,0x590eaf55,
+    0x97d0a034,0xdc36cd2e,0x22736b37,0xdc9066b0,0x2eb2f98b,0x5d9c7baf,0x85747c9e,0x8aca1055,
+    0x50d66b74,0x2f01ae9e,0xa1a80123,0x3e1ce2dc,0xebedbc57,0x4e68bc34,0x855ee0cf,0x17275120,
+    0x2ae7f2df,0xf71039eb,0x7c283eec,0x70cd1137,0x7cf651f3,0xa87bfa7a,0x14d87f02,0xe82e197d,
+    0x8d8a5ebe,0x1e6a15dc,0x197d49db,0x5bab9c89,0x4b55dea7,0x55dede49,0x9a6a8080,0xe5e51035,
+    0xe148d658,0x8a17eb3b,0xe22e4b38,0xe5be2a9a,0xbe938cbb,0x3b981069,0x7f9c0c8e,0xf756df10,
+    0x8fa783f7,0x252062ce,0x3dc46b4b,0xf70f6432,0x3f378276,0x44b137a1,0x2bf74b77,0x04892ed6,
+    0xfd318de1,0xd58c235e,0x94c6d25b,0x7aa5f218,0x35c9e921,0x5732fbbb,0x06026481,0xf584a44f,
+    0x946e1b5f,0x8463d5b2,0x4ebca7b2,0x54887b15,0x08d1e804,0x5b22067d,0x794580f6,0xb351ea43,
+    0xbce555b9,0x19ae2194,0xd32f1396,0x6fc1a7f1,0x1fd8a867,0x3a89fdb0,0xea49c61c,0x25f8a879,
+    0xde1e6437,0x7c74afca,0x8ba63e50,0xb1572074,0xe4655092,0xdb6f8b1c,0xc2955f3c,0x327f85ba,
+    0x60a17021,0x95bd261d,0xdea94f28,0x04528b65,0xbe0109cc,0x26dd5688,0x6ab2729d,0xc4f029ce,
+    0xacf7a0be,0x4c912f55,0x34c06e65,0x4fbb938e,0x1533fb5f,0x03da06bd,0x48262889,0xc2523d7d,
+    0x28a71d57,0x89f9713a,0xf574c551,0x7a99deb5,0x52834d91,0x5a6f4484,0xc67ba946,0x13ae698f,
+    0x3e390f34,0x34fc9593,0x894c7932,0x6cf414a3,0xdb7928ab,0x13a3b8a3,0x4b381c1d,0xa10b54cb,
+    0x55359d9d,0x35a3422a,0x58d1b551,0x0fd4de20,0x199eb3f4,0x167e09e2,0x3ee6a956,0x5371a7fa,
+    0xd424efda,0x74f521c5,0xcb899ff6,0x4a42e4f4,0x747917b6,0x4b08df0b,0x090c7a39,0x11e909e4,
+    0x258e2e32,0xd9fad92d,0x48fe5f69,0x0545cde6,0x55937b37,0x9b4ae4e4,0x1332b40e,0xc3792351,
+    0xaff982ef,0x4dba132a,0x38b81ef1,0x28e641bf,0x227208c1,0xec4bbe37,0xc4e1821c,0x512c9d09,
+    0xdaef1257,0xb63e7784,0x043e04d7,0x9c2cea47,0x45a0e59a,0x281315ca,0x849f0aac,0xa4071ed3,
+    0x0ef707b3,0xfe8dac02,0x12173864,0x471f6d46,0x24a53c0a,0x35ab9265,0xbbf77406,0xa2144e79,
+    0xb39a884a,0x0baf5b6d,0xcccee3dd,0x12c77584,0x2907325b,0xfd1adcd2,0xd16ee972,0x345ad6c1,
+    0x315ebe66,0xc7ad2b8d,0x99e82c8d,0xe52da8c8,0xba50f1d3,0x66689cd8,0x2e8e9138,0x43e15e74,
+    0xf1ced14d,0x188ec52a,0xe0ef3cbb,0xa958aedc,0x4107a1bc,0x5a9e7a3e,0x3bde939f,0xb5b28d5a,
+    0x596fe848,0xe85ad00c,0x0b6b3aae,0x44503086,0x25b5695c,0xc0c31dcd,0x5ee617f0,0x74d40c3a,
+    0xd2cb2b9f,0x1e19f5fa,0x81e24faf,0xa01ed68f,0xcee172fc,0x7fdf2e4d,0x002f4774,0x664f82dd,
+    0xc569c39a,0xa2d4dcbe,0xaadea306,0xa4c947bf,0xa413e4e3,0x81fb5486,0x8a404970,0x752c980c,
+    0x98d1d881,0x5c932c1e,0xeee65dfb,0x37592cdd,0x0fd4e65b,0xad1d383f,0x62a1452f,0x8872f68d,
+    0xb58c919b,0x345c8ee3,0xb583a6d6,0x43d72cb3,0x77aaa0aa,0xeb508242,0xf2db64f8,0x86294328,
+    0x82211731,0x1239a9d5,0x673ba5de,0xaf4af007,0x44203b19,0x2399d955,0xa175cd12,0x595928a7,
+    0x6918928b,0xde3126bb,0x6c99835c,0x63ba1fa2,0xdebbdff0,0x3d02e541,0xd6f7aac6,0xe80b4cd0,
+    0xd0fa29f1,0x804cac5e,0x2c226798,0x462f624c,0xad05b377,0x22924fcd,0xfbea205c,0x1b47586d
+};
+
+static inline int Pla_HashValue( int i )  { assert( i >= 0 && i < PLA_HASH_VALUE_NUM ); return s_PlaHashValues[i] & 0xFFFFFF; }
+
+
+#define PLA_LIT_UNUSED 0xFFFF
+
+typedef struct Tab_Obj_t_ Tab_Obj_t;
+struct Tab_Obj_t_
+{
+    int         Table;
+    int         Next;
+    int         Cube;
+    unsigned    VarA : 16;
+    unsigned    VarB : 16;
+};
+typedef struct Tab_Man_t_ Tab_Man_t;
+struct Tab_Man_t_
+{
+    int         SizeMask; // table size (2^Degree-1)
+    int         nBins;    // number of entries
+    Tab_Obj_t * pBins;    // hash table (lits -> cube + lit + lit)
+    Pla_Man_t * pMan;     // manager
+};
+
+static inline Tab_Obj_t *  Tab_ManBin( Tab_Man_t * p, int Value ) { return p->pBins + (Value & p->SizeMask); }
+static inline Tab_Obj_t *  Tab_ManEntry( Tab_Man_t * p, int i )   { return i ? p->pBins + i : NULL;          }
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Tab_Man_t * Tab_ManAlloc( int LogSize, Pla_Man_t * pMan )
+{
+    Tab_Man_t * p = ABC_CALLOC( Tab_Man_t, 1 );
+    assert( LogSize >= 4 && LogSize <= 24 );
+    p->SizeMask = (1 << LogSize) - 1;
+    p->pBins = ABC_CALLOC( Tab_Obj_t, p->SizeMask + 1 );
+    p->nBins = 1;
+    p->pMan  = pMan;
+    return p;
+}
+static inline void Tab_ManFree( Tab_Man_t * p )
+{
+    ABC_FREE( p->pBins );
+    ABC_FREE( p );
+}
+static inline void Tab_ManHashInsert( Tab_Man_t * p, int Value, int iCube )
+{
+    Tab_Obj_t * pBin  = Tab_ManBin( p, Value );
+    Tab_Obj_t * pCell = p->pBins + p->nBins;
+    pCell->Cube = iCube;
+    pCell->Next = pBin->Table;
+    pBin->Table = p->nBins++;
+}
+static inline int Tab_ManHashLookup( Tab_Man_t * p, int Value, Vec_Int_t * vCube )
+{
+    Tab_Obj_t * pEnt, * pBin = Tab_ManBin( p, Value );
+    for ( pEnt = Tab_ManEntry(p, pBin->Table); pEnt; pEnt = Tab_ManEntry(p, pEnt->Next) )
+       if ( Vec_IntEqual( Vec_WecEntry(&p->pMan->vLits, pEnt->Cube), vCube ) )
+            return 1;
+    return 0;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Pla_CubeHashValue( Vec_Int_t * vCube )
+{
+    int i, Lit, Value = 0;
+    Vec_IntForEachEntry( vCube, Lit, i )
+        Value += Pla_HashValue(Lit);
+    return Value;
+}
+void Pla_ManHashCubes( Pla_Man_t * p, Tab_Man_t * pTab )
+{
+    Vec_Int_t * vCube; int i, Value;
+    Vec_IntClear( &p->vHashes );
+    Vec_IntGrow( &p->vHashes, Pla_ManCubeNum(p) );
+    Vec_WecForEachLevel( &p->vLits, vCube, i )
+    {
+        Value = Pla_CubeHashValue(vCube);
+        Vec_IntPush( &p->vHashes, Value );
+        Tab_ManHashInsert( pTab, Value, i );
+    }
+}
+int Pla_ManHashDistance1( Pla_Man_t * p )
+{
+    Tab_Man_t * pTab;
+    Vec_Int_t * vCube;
+    Vec_Int_t * vCubeCopy = Vec_IntAlloc( p->nIns );
+    int nBits = Abc_Base2Log( Pla_ManCubeNum(p) ) + 2;
+    int i, k, Lit, Value, ValueCopy, Count = 0;
+    assert( nBits <= 24 );
+    pTab = Tab_ManAlloc( nBits, p );
+    Pla_ManConvertFromBits( p );
+    Pla_ManHashCubes( p, pTab );
+    Vec_WecForEachLevel( &p->vLits, vCube, i )
+    {
+        Vec_IntClear( vCubeCopy );
+        Vec_IntAppend( vCubeCopy, vCube );
+        Value = ValueCopy = Vec_IntEntry( &p->vHashes, i );
+        Vec_IntForEachEntry( vCubeCopy, Lit, k )
+        {
+            // create new
+            Value += Pla_HashValue(Abc_LitNot(Lit)) - Pla_HashValue(Lit);
+            Vec_IntWriteEntry( vCubeCopy, k, Abc_LitNot(Lit) );
+            // check the cube
+            Count += Tab_ManHashLookup( pTab, Value, vCubeCopy );
+            // create old
+            Value -= Pla_HashValue(Abc_LitNot(Lit)) - Pla_HashValue(Lit);
+            Vec_IntWriteEntry( vCubeCopy, k, Lit );
+        }
+        assert( Value == ValueCopy );
+    }
+    Vec_IntFree( vCubeCopy );
+    Tab_ManFree( pTab );
+    assert( !(Count & 1) );
+    return Count/2;
+}
+int Pla_ManHashDist1NumTest( Pla_Man_t * p )
+{
+    abctime clk = Abc_Clock();
+    int Count = Pla_ManHashDistance1( p );
+    printf( "Found %d pairs among %d cubes using cube hashing.  ", Count, Pla_ManCubeNum(p) );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+    return 1;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/pla/plaMan.c

+/**CFile****************************************************************
+
+  FileName    [plaMan.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SOP manager.]
+
+  Synopsis    [Scalable SOP transformations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - March 18, 2015.]
+
+  Revision    [$Id: plaMan.c,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "pla.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Generates prime detector for the given bit-widths.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Pla_GenPrimes( int nVars )
+{
+    int i, n, nBits = ( 1 << nVars );
+    Vec_Bit_t * vMap = Vec_BitStart( nBits );
+    Vec_Int_t * vPrimes = Vec_IntAlloc( 1000 );
+    Vec_BitWriteEntry(vMap, 0, 1);
+    Vec_BitWriteEntry(vMap, 1, 1);
+    for ( n = 2; n < nBits; n++ )
+        if ( !Vec_BitEntry(vMap, n) )
+            for ( i = 2*n; i < nBits; i += n )
+                Vec_BitWriteEntry(vMap, i, 1);
+    for ( n = 2; n < nBits; n++ )
+        if ( !Vec_BitEntry(vMap, n) )
+            Vec_IntPush( vPrimes, n );
+    printf( "Primes up to 2^%d = %d\n", nVars, Vec_IntSize(vPrimes) );
+//    Abc_GenCountHits1( vMap, vPrimes, nVars );
+    Vec_BitFree( vMap );
+    return vPrimes;
+}
+Pla_Man_t * Pla_GenFromMinterms( char * pName, Vec_Int_t * vMints, int nVars )
+{
+    Pla_Man_t * p = Pla_ManAlloc( pName, nVars, 1, Vec_IntSize(vMints) );
+    int i, k, Lit, Mint;
+    word * pCube;
+    Pla_ForEachCubeIn( p, pCube, i )
+    {
+        Mint = Vec_IntEntry(vMints, i);
+        Pla_CubeForEachLitIn( p, pCube, Lit, k )
+            Pla_CubeSetLit( pCube, k, ((Mint >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
+    }
+    Pla_ForEachCubeOut( p, pCube, i )
+        Pla_CubeSetLit( pCube, 0, PLA_LIT_ONE );
+    return p;
+}
+Pla_Man_t * Pla_ManPrimeDetector( int nVars )
+{
+    char pName[1000];
+    Pla_Man_t * p;
+    Vec_Int_t * vMints = Pla_GenPrimes( nVars );
+    sprintf( pName, "primes%02d", nVars );
+    p = Pla_GenFromMinterms( pName, vMints, nVars );
+    Vec_IntFree( vMints );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Bit_t * Pla_GenRandom( int nVars, int nNums, int fNonZero )
+{
+    int Mint, Count = 0;
+    Vec_Bit_t * vBits = Vec_BitStart( 1 << nVars );
+    assert( nVars > 0 && nVars <= 30 );
+    assert( nNums > 0 && nNums < (1 << (nVars - 1)) );
+    while ( Count < nNums )
+    {
+        Mint = Gia_ManRandom(0) & ((1 << nVars) - 1);
+        if ( fNonZero && Mint == 0 )
+            continue;
+        if ( Vec_BitEntry(vBits, Mint) )
+            continue;
+        Vec_BitWriteEntry( vBits, Mint, 1 );
+        Count++;
+    }
+    return vBits;
+}
+Pla_Man_t * Pla_ManGenerate( int nInputs, int nOutputs, int nCubes, int fVerbose )
+{
+    Vec_Bit_t * vBits;
+    int i, k, Count;
+    word * pCube;
+    Pla_Man_t * p = Pla_ManAlloc( "rand", nInputs, nOutputs, nCubes );
+    // generate nCube random input minterms
+    vBits = Pla_GenRandom( nInputs, nCubes, 0 );
+    for ( i = Count = 0; i < Vec_BitSize(vBits); i++ )
+        if ( Vec_BitEntry(vBits, i) )
+        {
+            pCube = Pla_CubeIn( p, Count++ );
+            for ( k = 0; k < nInputs; k++ )
+                Pla_CubeSetLit( pCube, k, ((i >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
+        }
+    assert( Count == nCubes );
+    Vec_BitFree( vBits );
+    // generate nCube random output minterms
+    if ( nOutputs > 1 )
+    {
+        vBits = Pla_GenRandom( nOutputs, nCubes, 1 );
+        for ( i = Count = 0; i < Vec_BitSize(vBits); i++ )
+            if ( Vec_BitEntry(vBits, i) )
+            {
+                pCube = Pla_CubeOut( p, Count++ );
+                for ( k = 0; k < nOutputs; k++ )
+                    Pla_CubeSetLit( pCube, k, ((i >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
+            }
+        assert( Count == nCubes );
+        Vec_BitFree( vBits );
+    }
+    else
+    {
+        Pla_ForEachCubeOut( p, pCube, i )
+            Pla_CubeSetLit( pCube, 0, PLA_LIT_ONE );
+    }
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Pla_ManConvertFromBits( Pla_Man_t * p )
+{
+    word * pCube; int i, k, Lit;
+    Vec_WecClear( &p->vLits );
+    Vec_WecClear( &p->vOccurs );
+    Vec_WecInit( &p->vLits, Pla_ManCubeNum(p) );
+    Vec_WecInit( &p->vOccurs, 2*Pla_ManInNum(p) );
+    Pla_ForEachCubeIn( p, pCube, i )
+        Pla_CubeForEachLitIn( p, pCube, Lit, k )
+            if ( Lit != PLA_LIT_DASH )
+            {
+                Lit = Abc_Var2Lit( k, Lit == PLA_LIT_ZERO );
+                Vec_WecPush( &p->vLits,   i, Lit );
+                Vec_WecPush( &p->vOccurs, Lit, i );
+            }
+}
+void Pla_ManConvertToBits( Pla_Man_t * p )
+{
+    Vec_Int_t * vCube; int i, k, Lit;
+    Vec_IntFillNatural( &p->vCubes, Vec_WecSize(&p->vLits) );
+    Vec_WrdFill( &p->vInBits,  Pla_ManCubeNum(p) * p->nInWords,  0 );
+    Vec_WecForEachLevel( &p->vLits, vCube, i )
+        Vec_IntForEachEntry( vCube, Lit, k )
+            Pla_CubeSetLit( Pla_CubeIn(p, i), Abc_Lit2Var(Lit), Abc_LitIsCompl(Lit) ? PLA_LIT_ZERO : PLA_LIT_ONE );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Pla_ManDist1Num( Pla_Man_t * p )
+{
+    word * pCube1, * pCube2; 
+    int i, k, Dist, Count = 0;
+    Pla_ForEachCubeIn( p, pCube1, i )
+    Pla_ForEachCubeInStart( p, pCube2, k, i+1 )
+    {
+        Dist = Pla_CubesAreDistance1( pCube1, pCube2, p->nInWords );
+//        Dist = Pla_CubesAreConsensus( pCube1, pCube2, p->nInWords, NULL );
+        Count += (Dist == 1);
+    }
+    return Count;
+}
+int Pla_ManDist1NumTest( Pla_Man_t * p )
+{
+    abctime clk = Abc_Clock();
+    int Count = Pla_ManDist1Num( p );
+    printf( "Found %d pairs among %d cubes using cube pair enumeration.  ", Count, Pla_ManCubeNum(p) );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+    return 1;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/pla/plaMerge.c

+/**CFile****************************************************************
+
+  FileName    [plaMerge.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SOP manager.]
+
+  Synopsis    [Scalable SOP transformations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - March 18, 2015.]
+
+  Revision    [$Id: plaMerge.c,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "pla.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Pla_ManDist1Merge( Pla_Man_t * p )
+{
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/pla/plaRead.c

+/**CFile****************************************************************
+
+  FileName    [plaRead.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SOP manager.]
+
+  Synopsis    [Scalable SOP transformations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - March 18, 2015.]
+
+  Revision    [$Id: plaRead.c,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "pla.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Pla_ReadFile( char * pFileName, char ** ppLimit )
+{
+    char * pBuffer;
+    int nFileSize, RetValue;
+    FILE * pFile = fopen( pFileName, "rb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open input file.\n" );
+        return NULL;
+    }
+    // get the file size, in bytes
+    fseek( pFile, 0, SEEK_END );  
+    nFileSize = ftell( pFile );  
+    // move the file current reading position to the beginning
+    rewind( pFile ); 
+    // load the contents of the file into memory
+    pBuffer = ABC_ALLOC( char, nFileSize + 16 );
+    pBuffer[0] = '\n';
+    RetValue = fread( pBuffer+1, nFileSize, 1, pFile );
+    fclose( pFile );
+    // terminate the string with '\0'
+    pBuffer[nFileSize + 1] = '\n';
+    pBuffer[nFileSize + 2] = '\0';
+    *ppLimit = pBuffer + nFileSize + 3;
+    return pBuffer;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Pla_ReadPlaRemoveComments( char * pBuffer, char * pLimit )
+{
+    char * pTemp; 
+    for ( pTemp = pBuffer; pTemp < pLimit; pTemp++ )
+        if ( *pTemp == '#' )
+            while ( *pTemp && *pTemp != '\n' )
+                *pTemp++ = ' ';
+}
+int Pla_ReadPlaHeader( char * pBuffer, char * pLimit, int * pnIns, int * pnOuts, int * pnCubes, int * pType )
+{
+    char * pTemp; 
+    *pType = PLA_FILE_FD;
+    *pnIns = *pnOuts = *pnCubes = -1;
+    for ( pTemp = pBuffer; pTemp < pLimit; pTemp++ )
+    {
+        if ( *pTemp != '.' )
+            continue;
+        if ( !strncmp(pTemp, ".i ", 3) )
+            *pnIns = atoi( pTemp + 3 );
+        else if ( !strncmp(pTemp, ".o ", 3) )
+            *pnOuts = atoi( pTemp + 3 );
+        else if ( !strncmp(pTemp, ".p ", 3) )
+            *pnCubes = atoi( pTemp + 3 );
+        else if ( !strncmp(pTemp, ".e ", 3) )
+            break;
+        else if ( !strncmp(pTemp, ".type ", 6) )
+        {
+            char Buffer[100];
+            *pType = PLA_FILE_NONE;
+            sscanf( pTemp+6, "%s", Buffer );
+            if ( !strcmp(Buffer, "f") )
+                *pType = PLA_FILE_F;
+            else if ( !strcmp(Buffer, "fr") )
+                *pType = PLA_FILE_FR;
+            else if ( !strcmp(Buffer, "fd") )
+                *pType = PLA_FILE_FD;
+            else if ( !strcmp(Buffer, "fdr") )
+                *pType = PLA_FILE_FDR;
+        }
+    }
+    if ( *pnIns <= 0 )
+        printf( "The number of inputs (.i) should be positive.\n" );
+    if ( *pnOuts <= 0 )
+        printf( "The number of outputs (.o) should be positive.\n" );
+    return *pnIns > 0 && *pnOuts > 0;
+}
+Vec_Str_t * Pla_ReadPlaBody( char * pBuffer, char * pLimit, Pla_File_t Type )
+{
+    char * pTemp;
+    Vec_Str_t * vLits;
+    vLits = Vec_StrAlloc( 10000 );
+    for ( pTemp = pBuffer; pTemp < pLimit; pTemp++ )
+    {
+        if ( *pTemp == '.' )
+            while ( *pTemp && *pTemp != '\n' )
+                pTemp++;
+        if ( *pTemp == '0' )
+            Vec_StrPush( vLits, (char)PLA_LIT_ZERO );
+        else if ( *pTemp == '1' )
+            Vec_StrPush( vLits, (char)PLA_LIT_ONE );
+        else if ( *pTemp == '-' || *pTemp == '2' )
+            Vec_StrPush( vLits, (char)PLA_LIT_DASH );
+        else if ( *pTemp == '~' ) // no meaning
+        {
+            if ( Type == PLA_FILE_F || Type == PLA_FILE_FD )
+                Vec_StrPush( vLits, (char)PLA_LIT_ZERO );
+            else if ( Type == PLA_FILE_FR )
+                Vec_StrPush( vLits, (char)PLA_LIT_DASH );
+            else if ( Type == PLA_FILE_FDR )
+                Vec_StrPush( vLits, (char)PLA_LIT_FULL );
+            else assert( 0 );
+        }
+    }
+    return vLits;
+}
+void Pla_ReadAddBody( Pla_Man_t * p, Vec_Str_t * vLits )
+{
+    word * pCubeIn, * pCubeOut; 
+    int i, k, Lit, Count = 0; 
+    int nCubesReal = Vec_StrSize(vLits) / (p->nIns + p->nOuts);
+    assert( Vec_StrSize(vLits) % (p->nIns + p->nOuts) == 0 );
+    if ( nCubesReal != Pla_ManCubeNum(p) )
+    {
+        printf( "Warning: Declared number of cubes (%d) differs from the actual (%d).\n", 
+            Pla_ManCubeNum(p), nCubesReal );
+        if ( nCubesReal < Pla_ManCubeNum(p) )
+            Vec_IntShrink( &p->vCubes, nCubesReal );
+        else
+        {
+            assert( nCubesReal > Pla_ManCubeNum(p) );
+            Vec_IntFillNatural( &p->vCubes, nCubesReal );
+            Vec_WrdFillExtra( &p->vInBits,  nCubesReal * p->nInWords,  0 );
+            Vec_WrdFillExtra( &p->vOutBits, nCubesReal * p->nOutWords, 0 );
+        }
+    }
+    Pla_ForEachCubeInOut( p, pCubeIn, pCubeOut, i )
+    {
+        Pla_CubeForEachLit( p->nIns, pCubeIn, Lit, k )
+            Pla_CubeSetLit( pCubeIn, k, (int)Vec_StrEntry(vLits, Count++) );
+        Pla_CubeForEachLit( p->nOuts, pCubeOut, Lit, k )
+            Pla_CubeSetLit( pCubeOut, k, (int)Vec_StrEntry(vLits, Count++) );
+    }
+    assert( Count == Vec_StrSize(vLits) );
+}
+Pla_Man_t * Pla_ReadPla( char * pFileName )
+{   
+    Pla_Man_t * p;
+    Vec_Str_t * vLits;
+    int nIns, nOuts, nCubes, Type;
+    char * pBuffer, * pLimit;   
+    pBuffer = Pla_ReadFile( pFileName, &pLimit );
+    if ( pBuffer == NULL )
+        return NULL;
+    Pla_ReadPlaRemoveComments( pBuffer, pLimit );
+    if ( Pla_ReadPlaHeader( pBuffer, pLimit, &nIns, &nOuts, &nCubes, &Type ) )
+    {
+        vLits = Pla_ReadPlaBody( pBuffer, pLimit, Type );
+        if ( Vec_StrSize(vLits) % (nIns + nOuts) == 0 )
+        {
+            if ( nCubes == -1 )
+                nCubes = Vec_StrSize(vLits) / (nIns + nOuts);
+            p = Pla_ManAlloc( pFileName, nIns, nOuts, nCubes );
+            p->Type = Type;
+            Pla_ReadAddBody( p, vLits );
+            Vec_StrFree( vLits );
+            ABC_FREE( pBuffer );
+            return p;
+        }
+        printf( "Literal count is incorrect (in = %d; out = %d; lit = %d).\n", nIns, nOuts, Vec_StrSize(vLits) );
+        Vec_StrFree( vLits );
+    }
+    ABC_FREE( pBuffer );
+    return NULL;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/pla/plaWrite.c

+/**CFile****************************************************************
+
+  FileName    [plaWrite.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SOP manager.]
+
+  Synopsis    [Scalable SOP transformations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - March 18, 2015.]
+
+  Revision    [$Id: plaWrite.c,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "pla.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Str_t * Pla_WritePlaInt( Pla_Man_t * p )
+{
+    Vec_Str_t * vOut = Vec_StrAlloc( 10000 );
+    char * pLits = "-01?";
+    word * pCubeIn, * pCubeOut; 
+    int i, k, Lit; 
+    // write comments
+    Vec_StrPrintStr( vOut, "# SOP \"" );
+    Vec_StrPrintStr( vOut, p->pName );
+    Vec_StrPrintStr( vOut, "\" written via PLA package in ABC on " );
+    Vec_StrPrintStr( vOut, Extra_TimeStamp() );
+    Vec_StrPrintStr( vOut, "\n\n" );
+    // write header
+    if ( p->Type != PLA_FILE_FD )
+    {
+        if ( p->Type == PLA_FILE_F )
+            Vec_StrPrintStr( vOut, ".type f\n" );
+        else if ( p->Type == PLA_FILE_FR )
+            Vec_StrPrintStr( vOut, ".type fr\n" );
+        else if ( p->Type == PLA_FILE_FDR )
+            Vec_StrPrintStr( vOut, ".type fdr\n" );
+        else if ( p->Type == PLA_FILE_NONE )
+            Vec_StrPrintStr( vOut, ".type ???\n" );
+    }
+    Vec_StrPrintStr( vOut, ".i " );
+    Vec_StrPrintNum( vOut, p->nIns );
+    Vec_StrPrintStr( vOut, "\n.o " );
+    Vec_StrPrintNum( vOut, p->nOuts );
+    Vec_StrPrintStr( vOut, "\n.p " );
+    Vec_StrPrintNum( vOut, Pla_ManCubeNum(p) );
+    Vec_StrPrintStr( vOut, "\n" );
+    // write cube
+    Pla_ForEachCubeInOut( p, pCubeIn, pCubeOut, i )
+    {
+        Pla_CubeForEachLit( p->nIns, pCubeIn, Lit, k )
+            Vec_StrPush( vOut, pLits[Lit] );
+        Vec_StrPush( vOut, ' ' );
+        Pla_CubeForEachLit( p->nOuts, pCubeOut, Lit, k )
+            Vec_StrPush( vOut, pLits[Lit] );
+        Vec_StrPush( vOut, '\n' );
+    }
+    Vec_StrPrintStr( vOut, ".e\n\n\0" );
+    return vOut;
+}   
+void Pla_WritePla( Pla_Man_t * p, char * pFileName )
+{
+    Vec_Str_t * vOut = Pla_WritePlaInt( p );
+    if ( Vec_StrSize(vOut) > 0 )
+    {
+        FILE * pFile = fopen( pFileName, "wb" );
+        if ( pFile == NULL )
+            printf( "Cannot open file \"%s\" for writing.\n", pFileName );
+        else
+        {
+            fwrite( Vec_StrArray(vOut), 1, Vec_StrSize(vOut), pFile );
+            fclose( pFile );
+        }
+    }
+    Vec_StrFreeP( &vOut );
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+

src/base/wlc/wlcReadSmt.c

@@ -709,6 +709,7 @@ static inline char * Smt_PrsLoadFile( char * pFileName, char ** ppLimit )
     pBuffer = ABC_ALLOC( char, nFileSize + 16 );
     pBuffer[0] = '\n';
     RetValue = fread( pBuffer+1, nFileSize, 1, pFile );
+    fclose( pFile );
     // terminate the string with '\0'
     pBuffer[nFileSize + 1] = '\n';
     pBuffer[nFileSize + 2] = '\0';

src/misc/vec/vecInt.h

@@ -573,6 +573,14 @@ static inline void Vec_IntFillTwo( Vec_Int_t * p, int nSize, int FillEven, int F
         p->pArray[i] = (i & 1) ? FillOdd : FillEven;
     p->nSize = nSize;
 }
+static inline void Vec_IntFillNatural( Vec_Int_t * p, int nSize )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = i;
+    p->nSize = nSize;
+}
 
 /**Function*************************************************************