From d51f798956a9f9fbdd1fc4eeecc483e511b1c3d3 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Sun, 3 May 2020 10:32:30 -0700
Subject: Experimental resubstitution.

---
 src/misc/vec/vecInt.h | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index 514ce455..7125593b 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -1397,6 +1397,14 @@ static inline void Vec_IntSortMulti( Vec_Int_t * p, int nMulti, int fReverse )
         qsort( (void *)p->pArray, (size_t)(p->nSize/nMulti), nMulti*sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
 }
+static inline int Vec_IntIsSorted( Vec_Int_t * p, int fReverse )
+{
+    int i;
+    for ( i = 1; i < p->nSize; i++ )
+        if ( fReverse ? (p->pArray[i-1] < p->pArray[i]) : (p->pArray[i-1] > p->pArray[i]) )
+            return 0;
+    return 1;            
+}
 
 /**Function*************************************************************
 
-- 
cgit v1.2.3


From a7871d24cdcd08c782a3165203ce3e4e76042344 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Fri, 8 May 2020 13:50:29 -0700
Subject: Experimental resubstitution.

---
 src/misc/vec/vecPtr.h | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h
index ed2a481e..adc2f68e 100644
--- a/src/misc/vec/vecPtr.h
+++ b/src/misc/vec/vecPtr.h
@@ -651,6 +651,12 @@ static inline void Vec_PtrPushTwo( Vec_Ptr_t * p, void * Entry1, void * Entry2 )
     Vec_PtrPush( p, Entry1 );
     Vec_PtrPush( p, Entry2 );
 }
+static inline void Vec_PtrAppend( Vec_Ptr_t * vVec1, Vec_Ptr_t * vVec2 )
+{
+    void * Entry; int i;
+    Vec_PtrForEachEntry( void *, vVec2, Entry, i )
+        Vec_PtrPush( vVec1, Entry );
+}
 
 /**Function*************************************************************
 
-- 
cgit v1.2.3


From 0ae0744e73b978593a054e8bf80c35723c9f4b03 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Fri, 15 May 2020 22:11:10 -0700
Subject: Experimental resubstitution.

---
 src/misc/vec/vecInt.h |   2 +
 src/misc/vec/vecWrd.h | 119 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 121 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index 7125593b..01fb3175 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -63,6 +63,8 @@ struct Vec_Int_t_
     for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_IntEntry(vVec, i)), 1); i-- )
 #define Vec_IntForEachEntryTwo( vVec1, vVec2, Entry1, Entry2, i )                           \
     for ( i = 0; (i < Vec_IntSize(vVec1)) && (((Entry1) = Vec_IntEntry(vVec1, i)), 1) && (((Entry2) = Vec_IntEntry(vVec2, i)), 1); i++ )
+#define Vec_IntForEachEntryTwoStart( vVec1, vVec2, Entry1, Entry2, i, Start )               \
+    for ( i = Start; (i < Vec_IntSize(vVec1)) && (((Entry1) = Vec_IntEntry(vVec1, i)), 1) && (((Entry2) = Vec_IntEntry(vVec2, i)), 1); i++ )
 #define Vec_IntForEachEntryDouble( vVec, Entry1, Entry2, i )                                \
     for ( i = 0; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
 #define Vec_IntForEachEntryDoubleStart( vVec, Entry1, Entry2, i, Start )                    \
diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index e123c054..3e25c066 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -167,6 +167,32 @@ static inline Vec_Wrd_t * Vec_WrdStartRandom( int nSize )
         vSims->pArray[i] = Abc_RandomW(0);
     return vSims;
 }
+static inline Vec_Wrd_t * Vec_WrdStartTruthTables( int nVars )
+{
+    Vec_Wrd_t * p;
+    unsigned Masks[5] = { 0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000 };
+    int i, k, nWords;
+    nWords = nVars <= 6 ? 1 : (1 << (nVars - 6));
+    p = Vec_WrdStart( nWords * nVars );
+    for ( i = 0; i < nVars; i++ )
+    {
+        unsigned * pTruth = (unsigned *)(p->pArray + nWords * i);
+        if ( i < 5 )
+        {
+            for ( k = 0; k < 2*nWords; k++ )
+                pTruth[k] = Masks[i];
+        }
+        else
+        {
+            for ( k = 0; k < 2*nWords; k++ )
+                if ( k & (1 << (i-5)) )
+                    pTruth[k] = ~(unsigned)0;
+                else
+                    pTruth[k] = 0;
+        }
+    }
+    return p;
+}
 
 /**Function*************************************************************
 
@@ -1201,6 +1227,99 @@ static inline void Vec_WrdAppend( Vec_Wrd_t * vVec1, Vec_Wrd_t * vVec2 )
         Vec_WrdPush( vVec1, Entry );
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Gia_ManSimPatWriteOne( FILE * pFile, word * pSim, int nWords )
+{
+    int k, Digit, nDigits = nWords*16;
+    for ( k = 0; k < nDigits; k++ )
+    {
+        Digit = (int)((pSim[k/16] >> ((k%16) * 4)) & 15);
+        if ( Digit < 10 )
+            fprintf( pFile, "%d", Digit );
+        else
+            fprintf( pFile, "%c", 'A' + Digit-10 );
+    }
+    fprintf( pFile, "\n" );
+}
+static inline void Vec_WrdPrintHex( Vec_Wrd_t * p, int nWords )
+{
+    int i, nNodes = Vec_WrdSize(p) / nWords;
+    assert( Vec_WrdSize(p) % nWords == 0 );
+    for ( i = 0; i < nNodes; i++ )
+        Gia_ManSimPatWriteOne( stdout, Vec_WrdEntryP(p, i*nWords), nWords );
+}
+static inline void Vec_WrdDumpHex( char * pFileName, Vec_Wrd_t * p, int nWords, int fVerbose )
+{
+    int i, nNodes = Vec_WrdSize(p) / nWords;
+    FILE * pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for writing.\n", pFileName );
+        return;
+    }
+    assert( Vec_WrdSize(p) % nWords == 0 );
+    for ( i = 0; i < nNodes; i++ )
+        Gia_ManSimPatWriteOne( pFile, Vec_WrdEntryP(p, i*nWords), nWords );
+    fclose( pFile );
+    if ( fVerbose )
+        printf( "Written %d words of simulation data for %d objects into file \"%s\".\n", nWords, Vec_WrdSize(p)/nWords, pFileName );
+}
+static inline int Vec_WrdReadHexOne( char c )
+{
+    int Digit = 0;
+    if ( c >= '0' && c <= '9' )
+        Digit = c - '0';
+    else if ( c >= 'A' && c <= 'F' )
+        Digit = c - 'A' + 10;
+    else if ( c >= 'a' && c <= 'f' )
+        Digit = c - 'a' + 10;
+    else assert( 0 );
+    assert( Digit >= 0 && Digit < 16 );
+    return Digit;
+}
+static inline Vec_Wrd_t * Vec_WrdReadHex( char * pFileName, int * pnWords, int fVerbose )
+{
+    Vec_Wrd_t * p = NULL; 
+    int c, nWords = -1, nChars = 0; word Num = 0;
+    FILE * pFile = fopen( pFileName, "rb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
+        return NULL;
+    }
+    p = Vec_WrdAlloc( 1000 );
+    while ( (c = fgetc(pFile)) != EOF )
+    {
+        if ( c == '\n' && nWords == -1 )
+            nWords = Vec_WrdSize(p);
+        if ( c == '\n' || c == '\r' || c == '\t' || c == ' ' )
+            continue;
+        Num |= (word)Vec_WrdReadHexOne((char)c) << (nChars * 4);
+        if ( ++nChars < 16 )
+            continue;
+        Vec_WrdPush( p, Num );
+        nChars = 0; 
+        Num = 0;
+    }
+    assert( Vec_WrdSize(p) % nWords == 0 );
+    fclose( pFile );
+    if ( pnWords )
+        *pnWords = nWords;
+    if ( fVerbose )
+        printf( "Read %d words of simulation data for %d objects.\n", nWords, Vec_WrdSize(p)/nWords );
+    return p;
+}
+
 
 ABC_NAMESPACE_HEADER_END
 
-- 
cgit v1.2.3


From b74b7dfc2d2065eebc800c9165a3e15caeb4453d Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Wed, 12 Aug 2020 15:33:09 -0700
Subject: Extending &sim_read to use non-64-divisible pattern counts.

---
 src/misc/vec/vecWrd.h | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index 3e25c066..663b7a88 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -1300,10 +1300,20 @@ static inline Vec_Wrd_t * Vec_WrdReadHex( char * pFileName, int * pnWords, int f
     p = Vec_WrdAlloc( 1000 );
     while ( (c = fgetc(pFile)) != EOF )
     {
-        if ( c == '\n' && nWords == -1 )
-            nWords = Vec_WrdSize(p);
-        if ( c == '\n' || c == '\r' || c == '\t' || c == ' ' )
+        if ( c == '\r' || c == '\t' || c == ' ' )
             continue;
+        if ( c == '\n' )
+        {
+            if ( nChars > 0 )
+            {
+                Vec_WrdPush( p, Num );
+                nChars = 0; 
+                Num = 0;
+            }
+            if ( nWords == -1 && Vec_WrdSize(p) > 0 )
+                nWords = Vec_WrdSize(p);
+            continue;
+        }
         Num |= (word)Vec_WrdReadHexOne((char)c) << (nChars * 4);
         if ( ++nChars < 16 )
             continue;
-- 
cgit v1.2.3


From 07bf95f48019dd5472ffffbd32587879e1bcbb9f Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Sun, 13 Sep 2020 19:17:16 -0700
Subject: Experiments with iterative synthesis.

---
 src/misc/vec/vecInt.h | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index 01fb3175..5e545698 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -1277,6 +1277,26 @@ static inline int Vec_IntCountZero( Vec_Int_t * p )
     return Counter;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntAddPositive( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] > 0 )
+            Counter += p->pArray[i];
+    return Counter;
+}
+
 /**Function*************************************************************
 
   Synopsis    [Checks if two vectors are equal.]
-- 
cgit v1.2.3


From 083c1218e5a1742e881d0ce9e90c8cd0b53748a7 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Thu, 17 Sep 2020 13:04:09 -0700
Subject: Improving MFFC computation code.

---
 src/misc/vec/vecPtr.h | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h
index adc2f68e..bb9377bb 100644
--- a/src/misc/vec/vecPtr.h
+++ b/src/misc/vec/vecPtr.h
@@ -624,6 +624,26 @@ static inline void Vec_PtrCopy( Vec_Ptr_t * pDest, Vec_Ptr_t * pSour )
     pDest->nSize = pSour->nSize;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Print names stored in the array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrPrintNames( Vec_Ptr_t * p )
+{
+    char * pName; int i;
+    printf( "Vector has %d entries: {", Vec_PtrSize(p) );
+    Vec_PtrForEachEntry( char *, p, pName, i )
+        printf( "%s ", pName );
+    printf( " }\n" );
+}
+
 /**Function*************************************************************
 
   Synopsis    []
-- 
cgit v1.2.3


From 76bed2055cc171109a86bf56c6da00aa4d251a30 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Sat, 8 May 2021 20:10:44 -0700
Subject: Updating LUT synthesis code.

---
 src/misc/vec/vecWrd.h | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index 663b7a88..9fa82f2d 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -1330,6 +1330,63 @@ static inline Vec_Wrd_t * Vec_WrdReadHex( char * pFileName, int * pnWords, int f
     return p;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WrdDumpBin( char * pFileName, Vec_Wrd_t * p, int fVerbose )
+{
+    int RetValue;
+    FILE * pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for writing.\n", pFileName );
+        return;
+    }
+    RetValue = fwrite( Vec_WrdArray(p), 1, 8*Vec_WrdSize(p), pFile );
+    fclose( pFile );
+    if ( RetValue != 8*Vec_WrdSize(p) )
+        printf( "Error reading data from file.\n" );
+    if ( fVerbose )
+        printf( "Written %d words of simulation data into file \"%s\".\n", Vec_WrdSize(p), pFileName );
+}
+static inline Vec_Wrd_t * Vec_WrdReadBin( char * pFileName, int fVerbose )
+{
+    Vec_Wrd_t * p = NULL; int nSize, RetValue;
+    FILE * pFile = fopen( pFileName, "rb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
+        return NULL;
+    }
+    fseek( pFile, 0, SEEK_END );
+    nSize = ftell( pFile );
+    if ( nSize % 8 > 0 )
+    {
+        printf( "Cannot read file with simulation data that is not aligned at 8 bytes (remainder = %d).\n", nSize % 8 );
+        fclose( pFile );
+        return NULL;
+    }
+    else
+    {
+        rewind( pFile );
+        p = Vec_WrdStart( nSize/8 );
+        RetValue = fread( Vec_WrdArray(p), 1, nSize, pFile );
+        fclose( pFile );
+        if ( RetValue != nSize )
+            printf( "Error reading data from file.\n" );
+        if ( fVerbose )
+            printf( "Read %d words of simulation data from file \"%s\".\n", nSize/8, pFileName );
+        return p;
+    }
+}
 
 ABC_NAMESPACE_HEADER_END
 
-- 
cgit v1.2.3


From aa9fe1f24094d0423cc32cbd6e9682ea2a3935cb Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Tue, 11 May 2021 15:04:15 -0700
Subject: Updating LUT synthesis code.

---
 src/misc/vec/vecWrd.h | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index 9fa82f2d..b0123453 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -1368,24 +1368,27 @@ static inline Vec_Wrd_t * Vec_WrdReadBin( char * pFileName, int fVerbose )
     }
     fseek( pFile, 0, SEEK_END );
     nSize = ftell( pFile );
-    if ( nSize % 8 > 0 )
+    if ( nSize == 0 )
     {
-        printf( "Cannot read file with simulation data that is not aligned at 8 bytes (remainder = %d).\n", nSize % 8 );
+        printf( "The input file is empty.\n" );
         fclose( pFile );
         return NULL;
     }
-    else
+    if ( nSize % 8 > 0 )
     {
-        rewind( pFile );
-        p = Vec_WrdStart( nSize/8 );
-        RetValue = fread( Vec_WrdArray(p), 1, nSize, pFile );
+        printf( "Cannot read file with simulation data that is not aligned at 8 bytes (remainder = %d).\n", nSize % 8 );
         fclose( pFile );
-        if ( RetValue != nSize )
-            printf( "Error reading data from file.\n" );
-        if ( fVerbose )
-            printf( "Read %d words of simulation data from file \"%s\".\n", nSize/8, pFileName );
-        return p;
+        return NULL;
     }
+    rewind( pFile );
+    p = Vec_WrdStart( nSize/8 );
+    RetValue = fread( Vec_WrdArray(p), 1, nSize, pFile );
+    fclose( pFile );
+    if ( RetValue != nSize )
+        printf( "Error reading data from file.\n" );
+    if ( fVerbose )
+        printf( "Read %d words of simulation data from file \"%s\".\n", nSize/8, pFileName );
+    return p;
 }
 
 ABC_NAMESPACE_HEADER_END
-- 
cgit v1.2.3


From 3e67d167f5c07315f3d1bb7d8ae6c079cb451ded Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Tue, 13 Jul 2021 19:05:02 -0700
Subject: Experiments with LUT mapping for small functions.

---
 src/misc/vec/vecWec.h | 19 +++++++++++++++++++
 src/misc/vec/vecWrd.h | 26 ++++++++++++++++++++++++++
 2 files changed, 45 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index fdbded9c..1c5ac71d 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -626,6 +626,25 @@ static inline int Vec_WecCountNonTrivial( Vec_Wec_t * p, int * pnUsed )
     return nClasses;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_WecMaxLevelSize( Vec_Wec_t * p )
+{
+    Vec_Int_t * vTemp; int i, Res = 0;
+    Vec_WecForEachLevel( p, vTemp, i )
+        Res = Abc_MaxInt( Res, Vec_IntSize(vTemp) );
+    return Res;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index b0123453..dd030c1a 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -61,6 +61,8 @@ struct Vec_Wrd_t_
     for ( i = Start; (i < Stop) && (((Entry) = Vec_WrdEntry(vVec, i)), 1); i++ )
 #define Vec_WrdForEachEntryReverse( vVec, pEntry, i )                                       \
     for ( i = Vec_WrdSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_WrdEntry(vVec, i)), 1); i-- )
+#define Vec_WrdForEachEntryDouble( vVec, Entry1, Entry2, i )                                \
+    for ( i = 0; (i+1 < Vec_WrdSize(vVec)) && (((Entry1) = Vec_WrdEntry(vVec, i)), 1) && (((Entry2) = Vec_WrdEntry(vVec, i+1)), 1); i += 2 )
 
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
@@ -669,6 +671,30 @@ static inline void Vec_WrdPush( Vec_Wrd_t * p, word Entry )
     }
     p->pArray[p->nSize++] = Entry;
 }
+static inline void Vec_WrdPushTwo( Vec_Wrd_t * p, word Entry1, word Entry2 )
+{
+    Vec_WrdPush( p, Entry1 );
+    Vec_WrdPush( p, Entry2 );
+}
+static inline void Vec_WrdPushThree( Vec_Wrd_t * p, word Entry1, word Entry2, word Entry3 )
+{
+    Vec_WrdPush( p, Entry1 );
+    Vec_WrdPush( p, Entry2 );
+    Vec_WrdPush( p, Entry3 );
+}
+static inline void Vec_WrdPushFour( Vec_Wrd_t * p, word Entry1, word Entry2, word Entry3, word Entry4 )
+{
+    Vec_WrdPush( p, Entry1 );
+    Vec_WrdPush( p, Entry2 );
+    Vec_WrdPush( p, Entry3 );
+    Vec_WrdPush( p, Entry4 );
+}
+static inline void Vec_WrdPushArray( Vec_Wrd_t * p, word * pEntries, int nEntries )
+{
+    int i;
+    for ( i = 0; i < nEntries; i++ )
+        Vec_WrdPush( p, pEntries[i] );
+}
 
 /**Function*************************************************************
 
-- 
cgit v1.2.3


From a162b1f47aa4d3c38439d779c7ad943102c63bc5 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Sun, 25 Jul 2021 14:11:34 -0700
Subject: Experimental simulation commands.

---
 src/misc/vec/vecWec.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index 1c5ac71d..00eda198 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -422,7 +422,7 @@ static inline Vec_Wec_t * Vec_WecDup( Vec_Wec_t * p )
     Vec_Wec_t * vNew;
     Vec_Int_t * vVec;
     int i, k, Entry;
-    vNew = Vec_WecAlloc( Vec_WecSize(p) );
+    vNew = Vec_WecStart( Vec_WecSize(p) );
     Vec_WecForEachLevel( p, vVec, i )
         Vec_IntForEachEntry( vVec, Entry, k )
             Vec_WecPush( vNew, i, Entry );
-- 
cgit v1.2.3


From a718318740a3a50f6058b3d64330dbe8ca1e6303 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Thu, 2 Sep 2021 22:54:19 -0700
Subject: Various changes.

---
 src/misc/vec/vecInt.h | 35 +++++++++++++++++++++++++++++++++++
 src/misc/vec/vecWec.h |  7 +++++++
 2 files changed, 42 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index 5e545698..cbe20903 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -150,6 +150,23 @@ static inline Vec_Int_t * Vec_IntStartRange( int First, int Range )
         p->pArray[i] = First + i;
     return p;
 }
+static inline Vec_Int_t * Vec_IntStartRandomLimit( int nSize, int Upper, int Lower )
+{
+    Vec_Int_t * p = Vec_IntAlloc( nSize );
+    int i, Gap = Upper - Lower + 1;
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = Lower + Abc_Random(0) % Gap;
+    return p;
+}
+static inline void Vec_IntRandomizeOrder( Vec_Int_t * p )
+{
+    int v;
+    for ( v = 0; v < p->nSize; v++ )
+    {
+        int vRand = Abc_Random(0) % p->nSize;
+        ABC_SWAP( int, p->pArray[vRand], p->pArray[v] );
+    }
+}
 
 /**Function*************************************************************
 
@@ -734,6 +751,11 @@ static inline void Vec_IntPush( Vec_Int_t * p, int Entry )
     }
     p->pArray[p->nSize++] = Entry;
 }
+static inline int Vec_IntPushReturn( Vec_Int_t * p, int Entry )
+{
+    Vec_IntPush( p, Entry );
+    return Entry;
+}
 static inline void Vec_IntPushTwo( Vec_Int_t * p, int Entry1, int Entry2 )
 {
     Vec_IntPush( p, Entry1 );
@@ -1318,6 +1340,19 @@ static inline int Vec_IntEqual( Vec_Int_t * p1, Vec_Int_t * p2 )
             return 0;
     return 1;
 }
+static inline int Vec_IntContained( Vec_Int_t * pSmall, Vec_Int_t * pLarge ) 
+{
+    int i, k;
+    for ( i = 0; i < pSmall->nSize; i++ )
+    {
+        for ( k = 0; k < pLarge->nSize; k++ )
+            if ( pSmall->pArray[i] == pLarge->pArray[k] )
+                break;
+        if ( k == pLarge->nSize )
+            return 0;
+    }
+    return 1;
+}
 
 /**Function*************************************************************
 
diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index 00eda198..26d026c7 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -275,6 +275,13 @@ static inline void Vec_WecClear( Vec_Wec_t * p )
         Vec_IntClear( vVec );
     p->nSize = 0;
 }
+static inline void Vec_WecClearLevels( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i;
+    Vec_WecForEachLevel( p, vVec, i )
+        Vec_IntClear( vVec );
+}
 
 /**Function*************************************************************
 
-- 
cgit v1.2.3


From ecda331a2a921bcac30bf3210f56adf9152ca22f Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Tue, 14 Sep 2021 22:01:41 -0700
Subject: Various changes.

---
 src/misc/vec/vecInt.h |  6 ++++++
 src/misc/vec/vecWec.h | 23 +++++++++++++++++++++++
 2 files changed, 29 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index cbe20903..c2f8cd61 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -780,6 +780,12 @@ static inline void Vec_IntPushArray( Vec_Int_t * p, int * pEntries, int nEntries
     for ( i = 0; i < nEntries; i++ )
         Vec_IntPush( p, pEntries[i] );
 }
+static inline void Vec_IntShift( Vec_Int_t * p, int Shift )
+{
+    p->nSize  -= Shift;
+    p->nCap   -= Shift;
+    p->pArray += Shift;
+}
 
 /**Function*************************************************************
 
diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index 26d026c7..2be08d04 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -548,6 +548,29 @@ static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
                 (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+  
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecKeepLevels( Vec_Wec_t * p, int Limit )
+{
+    Vec_Int_t * vLevel; int i, k = 0;
+    Vec_WecForEachLevel( p, vLevel, i )
+        if ( Vec_IntSize(vLevel) > Limit )
+        {
+            ABC_SWAP( Vec_Int_t, Vec_WecArray(p)[i], Vec_WecArray(p)[k] );
+            k++;
+        }
+    Vec_WecShrink( p, k );
+}
+
 /**Function*************************************************************
 
   Synopsis    []
-- 
cgit v1.2.3


From e2f15482175a06a9aa9056a3a54b2bb05de2721a Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Tue, 21 Sep 2021 10:00:46 -0700
Subject: Various changes.

---
 src/misc/vec/vecInt.h | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index c2f8cd61..df90f73f 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -862,6 +862,52 @@ static inline void Vec_IntPushOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * v
     p->pArray[i+1] = Entry;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Check if the array is ordered.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntIsOrdered( Vec_Int_t * p, int fReverse )
+{
+    int i;
+    if ( fReverse )
+    {
+        for ( i = 1; i < p->nSize; i++ )
+            if ( p->pArray[i-1] < p->pArray[i] )
+                return 0;
+    }
+    else
+    {
+        for ( i = 1; i < p->nSize; i++ )
+            if ( p->pArray[i-1] > p->pArray[i] )
+                return 0;
+    }
+    return 1;
+}
+static inline int Vec_IntIsOrderedCost( Vec_Int_t * p, Vec_Int_t * vCost, int fReverse )
+{
+    int i;
+    if ( fReverse )
+    {
+        for ( i = 1; i < p->nSize; i++ )
+            if ( Vec_IntEntry(vCost, p->pArray[i-1]) < Vec_IntEntry(vCost, p->pArray[i]) )
+                return 0;
+    }
+    else
+    {
+        for ( i = 1; i < p->nSize; i++ )
+            if ( Vec_IntEntry(vCost, p->pArray[i-1]) > Vec_IntEntry(vCost, p->pArray[i]) )
+                return 0;
+    }
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    [Inserts the entry while preserving the increasing order.]
-- 
cgit v1.2.3


From ba64e78608064612db61d6515f19dd2cabe69cee Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Sun, 26 Sep 2021 11:30:54 -0700
Subject: Changing declaration of Vec_Ptr_t sorting function to satisfy some
 compilers.

---
 src/misc/vec/vecPtr.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h
index bb9377bb..565e0474 100644
--- a/src/misc/vec/vecPtr.h
+++ b/src/misc/vec/vecPtr.h
@@ -938,8 +938,8 @@ static int Vec_PtrSortComparePtr( void ** pp1, void ** pp2 )
   SeeAlso     []
 
 ***********************************************************************/
-static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() ) ___unused;
-static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
+static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(const void *, const void *) ) ___unused;
+static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(const void *, const void *) )
 {
     if ( p->nSize < 2 )
         return;
@@ -962,8 +962,8 @@ static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
   SeeAlso     []
 
 ***********************************************************************/
-static void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() ) ___unused;
-static void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
+static void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(const void *, const void *) ) ___unused;
+static void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(const void *, const void *) )
 {
     int i, k;
     if ( p->nSize < 2 )
@@ -974,15 +974,15 @@ static void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
             p->pArray[k++] = p->pArray[i];
     p->nSize = k;
 }
-static void Vec_PtrUniqify2( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(void**, void**), void (*Vec_PtrObjFree)(void*), Vec_Int_t * vCounts ) ___unused;
-static void Vec_PtrUniqify2( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(void**, void**), void (*Vec_PtrObjFree)(void*), Vec_Int_t * vCounts )
+static void Vec_PtrUniqify2( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(const void *, const void *), void (*Vec_PtrObjFree)(void*), Vec_Int_t * vCounts ) ___unused;
+static void Vec_PtrUniqify2( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(const void *, const void *), void (*Vec_PtrObjFree)(void*), Vec_Int_t * vCounts )
 {
     int i, k;
     if ( vCounts )
         Vec_IntFill( vCounts, 1, 1 );
     if ( p->nSize < 2 )
         return;
-    Vec_PtrSort( p, (int (*)())Vec_PtrSortCompare );
+    Vec_PtrSort( p, Vec_PtrSortCompare );
     for ( i = k = 1; i < p->nSize; i++ )
         if ( Vec_PtrSortCompare(p->pArray+i, p->pArray+k-1) != 0 )
         {
-- 
cgit v1.2.3


From 674bcbee379b9dcef418ddb62655ee0d3d59f96c Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Thu, 30 Sep 2021 18:02:33 -0700
Subject: Various changes.

---
 src/misc/vec/vecHsh.h |  4 +++
 src/misc/vec/vecInt.h | 90 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/misc/vec/vecQue.h |  4 +++
 src/misc/vec/vecWrd.h |  8 +++++
 4 files changed, 106 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecHsh.h b/src/misc/vec/vecHsh.h
index 00da8450..b87904a2 100644
--- a/src/misc/vec/vecHsh.h
+++ b/src/misc/vec/vecHsh.h
@@ -492,6 +492,10 @@ static inline int Hsh_VecSize( Hsh_VecMan_t * p )
 {
     return Vec_IntSize(p->vMap);
 }
+static inline double Hsh_VecManMemory( Hsh_VecMan_t * p )
+{
+    return !p ? 0.0 : Vec_IntMemory(p->vTable) + Vec_IntMemory(p->vData) + Vec_IntMemory(p->vMap);
+}
 
 /**Function*************************************************************
 
diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index df90f73f..e482ef89 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -1154,6 +1154,17 @@ static inline int Vec_IntFindMax( Vec_Int_t * p )
             Best = p->pArray[i];
     return Best;
 }
+static inline int Vec_IntArgMax( Vec_Int_t * p )
+{
+    int i, Best, Arg = 0;
+    if ( p->nSize == 0 )
+        return -1;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best < p->pArray[i] )
+            Best = p->pArray[i], Arg = i;
+    return Arg;
+}
 
 /**Function*************************************************************
 
@@ -1177,6 +1188,17 @@ static inline int Vec_IntFindMin( Vec_Int_t * p )
             Best = p->pArray[i];
     return Best;
 }
+static inline int Vec_IntArgMin( Vec_Int_t * p )
+{
+    int i, Best, Arg = 0;
+    if ( p->nSize == 0 )
+        return 0;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best > p->pArray[i] )
+            Best = p->pArray[i], Arg = i;
+    return Arg;
+}
 
 /**Function*************************************************************
 
@@ -2149,6 +2171,13 @@ static inline int Vec_IntCompareVec( Vec_Int_t * p1, Vec_Int_t * p2 )
   SeeAlso     []
 
 ***********************************************************************/
+static inline void Vec_IntClearAppend( Vec_Int_t * vVec1, Vec_Int_t * vVec2 )
+{
+    int Entry, i;
+    Vec_IntClear( vVec1 );
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        Vec_IntPush( vVec1, Entry );
+}
 static inline void Vec_IntAppend( Vec_Int_t * vVec1, Vec_Int_t * vVec2 )
 {
     int Entry, i;
@@ -2192,6 +2221,67 @@ static inline void Vec_IntRemapArray( Vec_Int_t * vOld2New, Vec_Int_t * vOld, Ve
             Vec_IntWriteEntry( vNew, iNew, Vec_IntEntry(vOld, iOld) );
 }
 
+/**Function*************************************************************
+
+  Synopsis    [File interface.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntDumpBin( char * pFileName, Vec_Int_t * p, int fVerbose )
+{
+    int RetValue;
+    FILE * pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for writing.\n", pFileName );
+        return;
+    }
+    RetValue = fwrite( Vec_IntArray(p), 1, sizeof(int)*Vec_IntSize(p), pFile );
+    fclose( pFile );
+    if ( RetValue != (int)sizeof(int)*Vec_IntSize(p) )
+        printf( "Error reading data from file.\n" );
+    if ( fVerbose )
+        printf( "Written %d integers into file \"%s\".\n", Vec_IntSize(p), pFileName );
+}
+static inline Vec_Int_t * Vec_IntReadBin( char * pFileName, int fVerbose )
+{
+    Vec_Int_t * p = NULL; int nSize, RetValue;
+    FILE * pFile = fopen( pFileName, "rb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
+        return NULL;
+    }
+    fseek( pFile, 0, SEEK_END );
+    nSize = ftell( pFile );
+    if ( nSize == 0 )
+    {
+        printf( "The input file is empty.\n" );
+        fclose( pFile );
+        return NULL;
+    }
+    if ( nSize % sizeof(int) > 0 )
+    {
+        printf( "Cannot read file with integers because it is not aligned at 4 bytes (remainder = %d).\n", nSize % sizeof(int) );
+        fclose( pFile );
+        return NULL;
+    }
+    rewind( pFile );
+    p = Vec_IntStart( nSize/sizeof(int) );
+    RetValue = fread( Vec_IntArray(p), 1, nSize, pFile );
+    fclose( pFile );
+    if ( RetValue != nSize )
+        printf( "Error reading data from file.\n" );
+    if ( fVerbose )
+        printf( "Read %d integers from file \"%s\".\n", nSize/sizeof(int), pFileName );
+    return p;
+}
+
 ABC_NAMESPACE_HEADER_END
 
 #endif
diff --git a/src/misc/vec/vecQue.h b/src/misc/vec/vecQue.h
index 54a10a29..6a8a68d0 100644
--- a/src/misc/vec/vecQue.h
+++ b/src/misc/vec/vecQue.h
@@ -119,6 +119,10 @@ static inline void Vec_QueClear( Vec_Que_t * p )
     }
     p->nSize = 1;
 }
+static inline double Vec_QueMemory( Vec_Que_t * p )
+{
+    return !p ? 0.0 : 2.0 * sizeof(int) * (size_t)p->nCap + sizeof(Vec_Que_t) ;
+}
 
 /**Function*************************************************************
 
diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index dd030c1a..32c78626 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -903,6 +903,14 @@ static inline void Vec_WrdInsert( Vec_Wrd_t * p, int iHere, word Entry )
         p->pArray[i] = p->pArray[i-1];
     p->pArray[i] = Entry;
 }
+static inline void Vec_WrdDrop( Vec_Wrd_t * p, int i )
+{
+    int k;
+    assert( i >= 0 && i < Vec_WrdSize(p) );
+    p->nSize--;
+    for ( k = i; k < p->nSize; k++ )
+        p->pArray[k] = p->pArray[k+1];
+}
 
 /**Function*************************************************************
 
-- 
cgit v1.2.3


From e76b7ba0ccb0ddb61832727e40a2c7b2318e0244 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Thu, 30 Sep 2021 18:06:42 -0700
Subject: Compiler warnings.

---
 src/misc/vec/vecInt.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index e482ef89..89a9096a 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -2267,18 +2267,18 @@ static inline Vec_Int_t * Vec_IntReadBin( char * pFileName, int fVerbose )
     }
     if ( nSize % sizeof(int) > 0 )
     {
-        printf( "Cannot read file with integers because it is not aligned at 4 bytes (remainder = %d).\n", nSize % sizeof(int) );
+        printf( "Cannot read file with integers because it is not aligned at 4 bytes (remainder = %d).\n", (int)(nSize % sizeof(int)) );
         fclose( pFile );
         return NULL;
     }
     rewind( pFile );
-    p = Vec_IntStart( nSize/sizeof(int) );
+    p = Vec_IntStart( (int)(nSize/sizeof(int)) );
     RetValue = fread( Vec_IntArray(p), 1, nSize, pFile );
     fclose( pFile );
     if ( RetValue != nSize )
         printf( "Error reading data from file.\n" );
     if ( fVerbose )
-        printf( "Read %d integers from file \"%s\".\n", nSize/sizeof(int), pFileName );
+        printf( "Read %d integers from file \"%s\".\n", (int)(nSize/sizeof(int)), pFileName );
     return p;
 }
 
-- 
cgit v1.2.3


From 31f88974e211f9bf9db74dd1dba5b4e026ed173e Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Wed, 6 Oct 2021 17:14:57 -0700
Subject: Various changes.

---
 src/misc/vec/vecStr.h | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecStr.h b/src/misc/vec/vecStr.h
index 12053d3d..16e15761 100644
--- a/src/misc/vec/vecStr.h
+++ b/src/misc/vec/vecStr.h
@@ -561,6 +561,11 @@ static inline void Vec_StrPush( Vec_Str_t * p, char Entry )
     }
     p->pArray[p->nSize++] = Entry;
 }
+static inline void Vec_StrPushTwo( Vec_Str_t * p, char Entry1, char Entry2 )
+{
+    Vec_StrPush( p, Entry1 );
+    Vec_StrPush( p, Entry2 );
+}
 static inline void Vec_StrPushBuffer( Vec_Str_t * p, char * pBuffer, int nSize )
 {
     if ( p->nSize + nSize > p->nCap )
-- 
cgit v1.2.3


From 1afd156dbdf4a0845610bbfd2159e930944b1f57 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Thu, 7 Oct 2021 20:34:58 -0700
Subject: New command &stochsyn for stochastic synthesis.

---
 src/misc/vec/vecWec.h | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index 2be08d04..a97f1ceb 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -303,6 +303,15 @@ static inline void Vec_WecPush( Vec_Wec_t * p, int Level, int Entry )
     }
     Vec_IntPush( Vec_WecEntry(p, Level), Entry );
 }
+static inline void Vec_WecPushTwo( Vec_Wec_t * p, int Level, int Entry1, int Entry2 )
+{
+    if ( p->nSize < Level + 1 )
+    {
+        Vec_WecGrow( p, Abc_MaxInt(2*p->nSize, Level + 1) );
+        p->nSize = Level + 1;
+    }
+    Vec_IntPushTwo( Vec_WecEntry(p, Level), Entry1, Entry2 );
+}
 static inline Vec_Int_t * Vec_WecPushLevel( Vec_Wec_t * p )
 {
     if ( p->nSize == p->nCap )
-- 
cgit v1.2.3


From f0236d5ac1b6d127354b5dd67aba79735bfceaa2 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Sun, 10 Oct 2021 14:43:19 -0700
Subject: Experiments with pattern generation.

---
 src/misc/vec/vecWec.h | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index a97f1ceb..cd463e01 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -791,6 +791,83 @@ static inline void Vec_WecRemoveEmpty( Vec_Wec_t * vCubes )
 }
 
 
+/**Function*************************************************************
+
+  Synopsis    [File interface.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecDumpBin( char * pFileName, Vec_Wec_t * p, int fVerbose )
+{
+    Vec_Int_t * vLevel;
+    int i, nSize, RetValue;
+    FILE * pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for writing.\n", pFileName );
+        return;
+    }
+    nSize = Vec_WecSize(p);
+    RetValue = fwrite( &nSize, 1, sizeof(int), pFile );
+    Vec_WecForEachLevel( p, vLevel, i )
+    {
+        nSize = Vec_IntSize(vLevel);
+        RetValue += fwrite( &nSize, 1, sizeof(int), pFile );
+        RetValue += fwrite( Vec_IntArray(vLevel), 1, sizeof(int)*nSize, pFile );
+    }
+    fclose( pFile );
+    if ( RetValue != (int)sizeof(int)*(Vec_WecSizeSize(p)+Vec_WecSize(p)+1) )
+        printf( "Error writing data into file.\n" );
+    if ( fVerbose )
+        printf( "Written %d integer arrays into file \"%s\".\n", Vec_WecSize(p), pFileName );
+}
+static inline Vec_Wec_t * Vec_WecReadBin( char * pFileName, int fVerbose )
+{
+    Vec_Wec_t * p = NULL; Vec_Int_t * vLevel; int i, nSize, RetValue;
+    FILE * pFile = fopen( pFileName, "rb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
+        return NULL;
+    }
+    fseek( pFile, 0, SEEK_END );
+    nSize = ftell( pFile );
+    if ( nSize == 0 )
+    {
+        printf( "The input file is empty.\n" );
+        fclose( pFile );
+        return NULL;
+    }
+    if ( nSize % sizeof(int) > 0 )
+    {
+        printf( "Cannot read file with integers because it is not aligned at 4 bytes (remainder = %d).\n", (int)(nSize % sizeof(int)) );
+        fclose( pFile );
+        return NULL;
+    }
+    rewind( pFile );
+    RetValue = fread( &nSize, 1, sizeof(int), pFile );
+    assert( RetValue == 4 );
+    p = Vec_WecStart( nSize );
+    Vec_WecForEachLevel( p, vLevel, i )
+    {
+        RetValue = fread( &nSize, 1, sizeof(int), pFile );
+        assert( RetValue == 4 );
+        Vec_IntFill( vLevel, nSize, 0 );
+        RetValue = fread( Vec_IntArray(vLevel), 1, sizeof(int)*nSize, pFile );
+        assert( RetValue == 4*nSize );
+    }
+    fclose( pFile );
+    if ( fVerbose )
+        printf( "Read %d integer arrays from file \"%s\".\n", Vec_WecSize(p), pFileName );
+    return p;
+}
+
+
 ABC_NAMESPACE_HEADER_END
 
 #endif
-- 
cgit v1.2.3


From d4f073bad759874161e2de5952ef7d466bc3eb07 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Fri, 22 Oct 2021 00:00:01 -0700
Subject: Various changes.

---
 src/misc/vec/vecPtr.h | 20 ++++++++++++++++++++
 src/misc/vec/vecWrd.h |  4 ++++
 2 files changed, 24 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h
index 565e0474..0f024f68 100644
--- a/src/misc/vec/vecPtr.h
+++ b/src/misc/vec/vecPtr.h
@@ -605,6 +605,26 @@ static inline void Vec_PtrFreeFree( Vec_Ptr_t * p )
     Vec_PtrFree( p );
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static void Vec_PtrFreeFunc( Vec_Ptr_t * p, void (*pFuncItemFree)(void *) ) ___unused;
+static void Vec_PtrFreeFunc( Vec_Ptr_t * p, void (*pFuncItemFree)(void *) )
+{
+    void * pItem; int i;
+    Vec_PtrForEachEntry( void *, p, pItem, i )
+        if ( pItem ) pFuncItemFree( pItem );
+    Vec_PtrFree( p );
+}
+
 /**Function*************************************************************
 
   Synopsis    [Copies the interger array.]
diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index 32c78626..8275702a 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -382,6 +382,10 @@ static inline int Vec_WrdSize( Vec_Wrd_t * p )
 {
     return p->nSize;
 }
+static inline int Vec_WrdChangeSize( Vec_Wrd_t * p, int Shift )
+{
+    return p->nSize += Shift;
+}
 
 /**Function*************************************************************
 
-- 
cgit v1.2.3


From a80a91e45f5edf59fb7475ae1a461ba3602c6731 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Tue, 2 Nov 2021 20:28:01 -0700
Subject: Bug fix and new procedures.

---
 src/misc/vec/vecInt.h | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index 89a9096a..83122796 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -1930,6 +1930,70 @@ static inline int Vec_IntTwoRemove( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
     return Vec_IntSize(vArr1);
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of merging the two vectors.]
+
+  Description [Keeps only those entries of vArr1, which are in vArr2.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoMerge1( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg  = vArr1->pArray;
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            *pBeg++ = *pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg1++;
+        else 
+            *pBeg2++;
+    }
+    assert( vArr1->nSize >= pBeg - vArr1->pArray );
+    vArr1->nSize = pBeg - vArr1->pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of subtracting for two vectors.]
+
+  Description [Keeps only those entries of vArr1, which are not in vArr2.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoRemove1( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg  = vArr1->pArray;
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            *pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg++ = *pBeg1++;
+        else 
+            *pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg++ = *pBeg1++;
+    assert( vArr1->nSize >= pBeg - vArr1->pArray );
+    vArr1->nSize = pBeg - vArr1->pArray;
+}
+
 /**Function*************************************************************
 
   Synopsis    [Returns the result of merging the two vectors.]
-- 
cgit v1.2.3


From 18b4e8beef9ef330ef336f7070154858e461c916 Mon Sep 17 00:00:00 2001
From: Alan Mishchenko <alanmi@berkeley.edu>
Date: Tue, 2 Nov 2021 20:31:32 -0700
Subject: Bug fix and new procedures.

---
 src/misc/vec/vecInt.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/misc/vec')

diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index 83122796..c15369d2 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -1953,9 +1953,9 @@ static inline void Vec_IntTwoMerge1( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
         if ( *pBeg1 == *pBeg2 )
             *pBeg++ = *pBeg1++, pBeg2++;
         else if ( *pBeg1 < *pBeg2 )
-            *pBeg1++;
+            pBeg1++;
         else 
-            *pBeg2++;
+            pBeg2++;
     }
     assert( vArr1->nSize >= pBeg - vArr1->pArray );
     vArr1->nSize = pBeg - vArr1->pArray;
@@ -1982,11 +1982,11 @@ static inline void Vec_IntTwoRemove1( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
     while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
     {
         if ( *pBeg1 == *pBeg2 )
-            *pBeg1++, pBeg2++;
+            pBeg1++, pBeg2++;
         else if ( *pBeg1 < *pBeg2 )
             *pBeg++ = *pBeg1++;
         else 
-            *pBeg2++;
+            pBeg2++;
     }
     while ( pBeg1 < pEnd1 )
         *pBeg++ = *pBeg1++;
-- 
cgit v1.2.3