Version abc71001

17 files changed, 14444 insertions, 0 deletions

diff --git a/src/misc/extra/extra.h b/src/misc/extra/extra.h
new file mode 100644
index 00000000..314257a2
--- /dev/null
+++ b/src/misc/extra/extra.h
@@ -0,0 +1,626 @@
+/**CFile****************************************************************
+
+  FileName    [extra.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [Various reusable software utilities.]
+
+  Description [This library contains a number of operators and 
+  traversal routines developed to extend the functionality of 
+  CUDD v.2.3.x, by Fabio Somenzi (http://vlsi.colorado.edu/~fabio/)
+  To compile your code with the library, #include "extra.h" 
+  in your source files and link your project to CUDD and this 
+  library. Use the library at your own risk and with caution. 
+  Note that debugging of some operators still continues.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extra.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef __EXTRA_H__
+#define __EXTRA_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#define inline __inline // compatible with MS VS 6.0
+#endif
+
+/*---------------------------------------------------------------------------*/
+/* Nested includes                                                           */
+/*---------------------------------------------------------------------------*/
+
+// this include should be the first one in the list
+// it is used to catch memory leaks on Windows
+#include "leaks.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <time.h>
+#include "st.h"
+#include "cuddInt.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+typedef unsigned char      uint8;
+typedef unsigned short     uint16;
+typedef unsigned int       uint32;
+#ifdef WIN32
+typedef unsigned __int64   uint64;
+#else
+typedef unsigned long long uint64;
+#endif
+
+/* constants of the manager */
+#define     b0     Cudd_Not((dd)->one)
+#define     b1              (dd)->one
+#define     z0              (dd)->zero
+#define     z1              (dd)->one
+#define     a0              (dd)->zero
+#define     a1              (dd)->one
+
+// hash key macros
+#define hashKey1(a,TSIZE) \
+((unsigned)(a) % TSIZE)
+
+#define hashKey2(a,b,TSIZE) \
+(((unsigned)(a) + (unsigned)(b) * DD_P1) % TSIZE)
+
+#define hashKey3(a,b,c,TSIZE) \
+(((((unsigned)(a) + (unsigned)(b)) * DD_P1 + (unsigned)(c)) * DD_P2 ) % TSIZE)
+
+#define hashKey4(a,b,c,d,TSIZE) \
+((((((unsigned)(a) + (unsigned)(b)) * DD_P1 + (unsigned)(c)) * DD_P2 + \
+   (unsigned)(d)) * DD_P3) % TSIZE)
+
+#define hashKey5(a,b,c,d,e,TSIZE) \
+(((((((unsigned)(a) + (unsigned)(b)) * DD_P1 + (unsigned)(c)) * DD_P2 + \
+   (unsigned)(d)) * DD_P3 + (unsigned)(e)) * DD_P1) % TSIZE)
+
+#ifndef PRT
+#define PRT(a,t)  printf("%s = ", (a)); printf("%6.2f sec\n", (float)(t)/(float)(CLOCKS_PER_SEC))
+#define PRTn(a,t)  printf("%s = ", (a)); printf("%6.2f sec  ", (float)(t)/(float)(CLOCKS_PER_SEC))
+#endif
+
+#ifndef PRTP
+#define PRTP(a,t,T)  printf("%s = ", (a)); printf("%6.2f sec (%6.2f %%)\n", (float)(t)/(float)(CLOCKS_PER_SEC), (T)? 100.0*(t)/(T) : 0.0)
+#endif
+
+/*===========================================================================*/
+/*     Various Utilities                                                     */
+/*===========================================================================*/
+
+/*=== extraBddAuto.c ========================================================*/
+
+extern DdNode *     Extra_bddSpaceFromFunctionFast( DdManager * dd, DdNode * bFunc );
+extern DdNode *     Extra_bddSpaceFromFunction( DdManager * dd, DdNode * bF, DdNode * bG );
+extern DdNode *      extraBddSpaceFromFunction( DdManager * dd, DdNode * bF, DdNode * bG );
+extern DdNode *     Extra_bddSpaceFromFunctionPos( DdManager * dd, DdNode * bFunc );
+extern DdNode *      extraBddSpaceFromFunctionPos( DdManager * dd, DdNode * bFunc );
+extern DdNode *     Extra_bddSpaceFromFunctionNeg( DdManager * dd, DdNode * bFunc );
+extern DdNode *      extraBddSpaceFromFunctionNeg( DdManager * dd, DdNode * bFunc );
+
+extern DdNode *     Extra_bddSpaceCanonVars( DdManager * dd, DdNode * bSpace );
+extern DdNode *      extraBddSpaceCanonVars( DdManager * dd, DdNode * bSpace );
+
+extern DdNode *     Extra_bddSpaceEquations( DdManager * dd, DdNode * bSpace );
+extern DdNode *     Extra_bddSpaceEquationsNeg( DdManager * dd, DdNode * bSpace );
+extern DdNode *      extraBddSpaceEquationsNeg( DdManager * dd, DdNode * bSpace );
+extern DdNode *     Extra_bddSpaceEquationsPos( DdManager * dd, DdNode * bSpace );
+extern DdNode *      extraBddSpaceEquationsPos( DdManager * dd, DdNode * bSpace );
+
+extern DdNode *     Extra_bddSpaceFromMatrixPos( DdManager * dd, DdNode * zA );
+extern DdNode *      extraBddSpaceFromMatrixPos( DdManager * dd, DdNode * zA );
+extern DdNode *     Extra_bddSpaceFromMatrixNeg( DdManager * dd, DdNode * zA );
+extern DdNode *      extraBddSpaceFromMatrixNeg( DdManager * dd, DdNode * zA );
+
+extern DdNode *     Extra_bddSpaceReduce( DdManager * dd, DdNode * bFunc, DdNode * bCanonVars );
+extern DdNode **    Extra_bddSpaceExorGates( DdManager * dd, DdNode * bFuncRed, DdNode * zEquations );
+
+/*=== extraBddCas.c =============================================================*/
+
+/* performs the binary encoding of the set of function using the given vars */
+extern DdNode *     Extra_bddEncodingBinary( DdManager * dd, DdNode ** pbFuncs, int nFuncs, DdNode ** pbVars, int nVars );
+/* solves the column encoding problem using a sophisticated method */
+extern DdNode *     Extra_bddEncodingNonStrict( DdManager * dd, DdNode ** pbColumns, int nColumns, DdNode * bVarsCol, DdNode ** pCVars, int nMulti, int * pSimple );
+/* collects the nodes under the cut and, for each node, computes the sum of paths leading to it from the root */
+extern st_table *   Extra_bddNodePathsUnderCut( DdManager * dd, DdNode * bFunc, int CutLevel );
+/* collects the nodes under the cut starting from the given set of ADD nodes */
+extern int          Extra_bddNodePathsUnderCutArray( DdManager * dd, DdNode ** paNodes, DdNode ** pbCubes, int nNodes, DdNode ** paNodesRes, DdNode ** pbCubesRes, int CutLevel );
+/* find the profile of a DD (the number of edges crossing each level) */
+extern int          Extra_ProfileWidth( DdManager * dd, DdNode * F, int * Profile, int CutLevel );
+
+/*=== extraBddMisc.c ========================================================*/
+
+extern DdNode *     Extra_TransferPermute( DdManager * ddSource, DdManager * ddDestination, DdNode * f, int * Permute );
+extern DdNode *     Extra_TransferLevelByLevel( DdManager * ddSource, DdManager * ddDestination, DdNode * f );
+extern DdNode *     Extra_bddRemapUp( DdManager * dd, DdNode * bF );
+extern DdNode *     Extra_bddMove( DdManager * dd, DdNode * bF, int fShiftUp );
+extern DdNode *     extraBddMove( DdManager * dd, DdNode * bF, DdNode * bFlag );
+extern void         Extra_StopManager( DdManager * dd );
+extern void         Extra_bddPrint( DdManager * dd, DdNode * F );
+extern void         extraDecomposeCover( DdManager* dd, DdNode*  zC, DdNode** zC0, DdNode** zC1, DdNode** zC2 );
+extern int          Extra_bddSuppSize( DdManager * dd, DdNode * bSupp );
+extern int          Extra_bddSuppContainVar( DdManager * dd, DdNode * bS, DdNode * bVar );
+extern int          Extra_bddSuppOverlapping( DdManager * dd, DdNode * S1, DdNode * S2 );
+extern int          Extra_bddSuppDifferentVars( DdManager * dd, DdNode * S1, DdNode * S2, int DiffMax );
+extern int          Extra_bddSuppCheckContainment( DdManager * dd, DdNode * bL, DdNode * bH, DdNode ** bLarge, DdNode ** bSmall );
+extern int *        Extra_SupportArray( DdManager * dd, DdNode * F, int * support );
+extern int *        Extra_VectorSupportArray( DdManager * dd, DdNode ** F, int n, int * support );
+extern DdNode *     Extra_bddFindOneCube( DdManager * dd, DdNode * bF );
+extern DdNode *     Extra_bddGetOneCube( DdManager * dd, DdNode * bFunc );
+extern DdNode *     Extra_bddComputeRangeCube( DdManager * dd, int iStart, int iStop );
+extern DdNode *     Extra_bddBitsToCube( DdManager * dd, int Code, int CodeWidth, DdNode ** pbVars, int fMsbFirst );
+extern DdNode *     Extra_bddSupportNegativeCube( DdManager * dd, DdNode * f );
+extern int          Extra_bddIsVar( DdNode * bFunc );
+extern DdNode *     Extra_bddCreateAnd( DdManager * dd, int nVars );
+extern DdNode *     Extra_bddCreateOr( DdManager * dd, int nVars );
+extern DdNode *     Extra_bddCreateExor( DdManager * dd, int nVars );
+extern DdNode *     Extra_zddPrimes( DdManager * dd, DdNode * F );
+extern void         Extra_bddPermuteArray( DdManager * dd, DdNode ** bNodesIn, DdNode ** bNodesOut, int nNodes, int *permut );
+
+/*=== extraBddKmap.c ================================================================*/
+
+/* displays the Karnaugh Map of a function */
+extern void        Extra_PrintKMap( FILE * pFile, DdManager * dd, DdNode * OnSet, DdNode * OffSet, int nVars, DdNode ** XVars, int fSuppType, char ** pVarNames );
+/* displays the Karnaugh Map of a relation */
+extern void        Extra_PrintKMapRelation( FILE * pFile, DdManager * dd, DdNode * OnSet, DdNode * OffSet, int nXVars, int nYVars, DdNode ** XVars, DdNode ** YVars );
+
+/*=== extraBddSymm.c =================================================================*/
+
+typedef struct Extra_SymmInfo_t_  Extra_SymmInfo_t;
+struct Extra_SymmInfo_t_ {
+    int nVars;      // the number of variables in the support
+    int nVarsMax;   // the number of variables in the DD manager
+    int nSymms;     // the number of pair-wise symmetries
+    int nNodes;     // the number of nodes in a ZDD (if applicable)
+    int * pVars;    // the list of all variables present in the support
+    char ** pSymms; // the symmetry information
+};
+
+/* computes the classical symmetry information for the function - recursive */
+extern Extra_SymmInfo_t *  Extra_SymmPairsCompute( DdManager * dd, DdNode * bFunc );
+/* computes the classical symmetry information for the function - using naive approach */
+extern Extra_SymmInfo_t *  Extra_SymmPairsComputeNaive( DdManager * dd, DdNode * bFunc );
+extern int         Extra_bddCheckVarsSymmetricNaive( DdManager * dd, DdNode * bF, int iVar1, int iVar2 );
+
+/* allocates the data structure */
+extern Extra_SymmInfo_t *  Extra_SymmPairsAllocate( int nVars );
+/* deallocates the data structure */
+extern void        Extra_SymmPairsDissolve( Extra_SymmInfo_t * );
+/* print the contents the data structure */
+extern void        Extra_SymmPairsPrint( Extra_SymmInfo_t * );
+/* converts the ZDD into the Extra_SymmInfo_t structure */
+extern Extra_SymmInfo_t *  Extra_SymmPairsCreateFromZdd( DdManager * dd, DdNode * zPairs, DdNode * bVars );
+
+/* computes the classical symmetry information as a ZDD */
+extern DdNode *    Extra_zddSymmPairsCompute( DdManager * dd, DdNode * bF, DdNode * bVars );
+extern DdNode *     extraZddSymmPairsCompute( DdManager * dd, DdNode * bF, DdNode * bVars );
+/* returns a singleton-set ZDD containing all variables that are symmetric with the given one */
+extern DdNode *    Extra_zddGetSymmetricVars( DdManager * dd, DdNode * bF, DdNode * bG, DdNode * bVars );
+extern DdNode *     extraZddGetSymmetricVars( DdManager * dd, DdNode * bF, DdNode * bG, DdNode * bVars );
+/* converts a set of variables into a set of singleton subsets */
+extern DdNode *    Extra_zddGetSingletons( DdManager * dd, DdNode * bVars );
+extern DdNode *     extraZddGetSingletons( DdManager * dd, DdNode * bVars );
+/* filters the set of variables using the support of the function */
+extern DdNode *    Extra_bddReduceVarSet( DdManager * dd, DdNode * bVars, DdNode * bF );
+extern DdNode *     extraBddReduceVarSet( DdManager * dd, DdNode * bVars, DdNode * bF );
+
+/* checks the possibility that the two vars are symmetric */
+extern int         Extra_bddCheckVarsSymmetric( DdManager * dd, DdNode * bF, int iVar1, int iVar2 );
+extern DdNode *     extraBddCheckVarsSymmetric( DdManager * dd, DdNode * bF, DdNode * bVars );
+
+/* build the set of all tuples of K variables out of N from the BDD cube */
+extern DdNode *    Extra_zddTuplesFromBdd( DdManager * dd, int K, DdNode * bVarsN );
+extern DdNode *     extraZddTuplesFromBdd( DdManager * dd, DdNode * bVarsK, DdNode * bVarsN );
+/* selects one subset from a ZDD representing the set of subsets */
+extern DdNode *    Extra_zddSelectOneSubset( DdManager * dd, DdNode * zS );
+extern DdNode *     extraZddSelectOneSubset( DdManager * dd, DdNode * zS );
+
+/*=== extraBddUnate.c =================================================================*/
+
+typedef struct Extra_UnateVar_t_  Extra_UnateVar_t;
+struct Extra_UnateVar_t_ {
+    unsigned    iVar : 30;  // index of the variable
+    unsigned    Pos  :  1;  // 1 if positive unate
+    unsigned    Neg  :  1;  // 1 if negative unate
+};
+
+typedef struct Extra_UnateInfo_t_  Extra_UnateInfo_t;
+struct Extra_UnateInfo_t_ {
+    int nVars;      // the number of variables in the support
+    int nVarsMax;   // the number of variables in the DD manager
+    int nUnate;     // the number of unate variables
+    Extra_UnateVar_t * pVars;    // the array of variables present in the support
+};
+
+/* allocates the data structure */
+extern Extra_UnateInfo_t *  Extra_UnateInfoAllocate( int nVars );
+/* deallocates the data structure */
+extern void        Extra_UnateInfoDissolve( Extra_UnateInfo_t * );
+/* print the contents the data structure */
+extern void        Extra_UnateInfoPrint( Extra_UnateInfo_t * );
+/* converts the ZDD into the Extra_SymmInfo_t structure */
+extern Extra_UnateInfo_t *  Extra_UnateInfoCreateFromZdd( DdManager * dd, DdNode * zUnate, DdNode * bVars );
+/* naive check of unateness of one variable */
+extern int         Extra_bddCheckUnateNaive( DdManager * dd, DdNode * bF, int iVar );
+
+/* computes the unateness information for the function */
+extern Extra_UnateInfo_t *  Extra_UnateComputeFast( DdManager * dd, DdNode * bFunc );
+extern Extra_UnateInfo_t *  Extra_UnateComputeSlow( DdManager * dd, DdNode * bFunc );
+
+/* computes the classical symmetry information as a ZDD */
+extern DdNode *    Extra_zddUnateInfoCompute( DdManager * dd, DdNode * bF, DdNode * bVars );
+extern DdNode *     extraZddUnateInfoCompute( DdManager * dd, DdNode * bF, DdNode * bVars );
+
+/* converts a set of variables into a set of singleton subsets */
+extern DdNode *    Extra_zddGetSingletonsBoth( DdManager * dd, DdNode * bVars );
+extern DdNode *     extraZddGetSingletonsBoth( DdManager * dd, DdNode * bVars );
+
+/*=== extraUtilBitMatrix.c ================================================================*/
+
+typedef struct Extra_BitMat_t_ Extra_BitMat_t;
+extern Extra_BitMat_t * Extra_BitMatrixStart( int nSize );
+extern void         Extra_BitMatrixClean( Extra_BitMat_t * p );
+extern void         Extra_BitMatrixStop( Extra_BitMat_t * p );
+extern void         Extra_BitMatrixPrint( Extra_BitMat_t * p );
+extern int          Extra_BitMatrixReadSize( Extra_BitMat_t * p );
+extern void         Extra_BitMatrixInsert1( Extra_BitMat_t * p, int i, int k );
+extern int          Extra_BitMatrixLookup1( Extra_BitMat_t * p, int i, int k );
+extern void         Extra_BitMatrixDelete1( Extra_BitMat_t * p, int i, int k );
+extern void         Extra_BitMatrixInsert2( Extra_BitMat_t * p, int i, int k );
+extern int          Extra_BitMatrixLookup2( Extra_BitMat_t * p, int i, int k );
+extern void         Extra_BitMatrixDelete2( Extra_BitMat_t * p, int i, int k );
+extern void         Extra_BitMatrixOr( Extra_BitMat_t * p, int i, unsigned * pInfo );
+extern void         Extra_BitMatrixOrTwo( Extra_BitMat_t * p, int i, int j );
+extern int          Extra_BitMatrixCountOnesUpper( Extra_BitMat_t * p );
+extern int          Extra_BitMatrixIsDisjoint( Extra_BitMat_t * p1, Extra_BitMat_t * p2 );
+extern int          Extra_BitMatrixIsClique( Extra_BitMat_t * p );
+
+/*=== extraUtilFile.c ========================================================*/
+
+extern char *       Extra_FileGetSimilarName( char * pFileNameWrong, char * pS1, char * pS2, char * pS3, char * pS4, char * pS5 );
+extern char *       Extra_FileNameExtension( char * FileName );
+extern char *       Extra_FileNameAppend( char * pBase, char * pSuffix );
+extern char *       Extra_FileNameGeneric( char * FileName );
+extern int          Extra_FileSize( char * pFileName );
+extern char *       Extra_FileRead( FILE * pFile );
+extern char *       Extra_TimeStamp();
+extern char *       Extra_StringAppend( char * pStrGiven, char * pStrAdd );
+extern unsigned     Extra_ReadBinary( char * Buffer );
+extern void         Extra_PrintBinary( FILE * pFile, unsigned Sign[], int nBits );
+extern int          Extra_ReadHexadecimal( unsigned Sign[], char * pString, int nVars );
+extern void         Extra_PrintHexadecimal( FILE * pFile, unsigned Sign[], int nVars );
+extern void         Extra_PrintHexadecimalString( char * pString, unsigned Sign[], int nVars );
+extern void         Extra_PrintHex( FILE * pFile, unsigned uTruth, int nVars );
+extern void         Extra_PrintSymbols( FILE * pFile, char Char, int nTimes, int fPrintNewLine );
+
+/*=== extraUtilReader.c ========================================================*/
+
+typedef struct Extra_FileReader_t_ Extra_FileReader_t;
+extern Extra_FileReader_t * Extra_FileReaderAlloc( char * pFileName, 
+    char * pCharsComment, char * pCharsStop, char * pCharsClean );
+extern void         Extra_FileReaderFree( Extra_FileReader_t * p );
+extern char *       Extra_FileReaderGetFileName( Extra_FileReader_t * p );
+extern int          Extra_FileReaderGetFileSize( Extra_FileReader_t * p );
+extern int          Extra_FileReaderGetCurPosition( Extra_FileReader_t * p );
+extern void *       Extra_FileReaderGetTokens( Extra_FileReader_t * p );
+extern int          Extra_FileReaderGetLineNumber( Extra_FileReader_t * p, int iToken );
+
+/*=== extraUtilMemory.c ========================================================*/
+
+typedef struct Extra_MmFixed_t_    Extra_MmFixed_t;    
+typedef struct Extra_MmFlex_t_     Extra_MmFlex_t;     
+typedef struct Extra_MmStep_t_     Extra_MmStep_t;     
+
+// fixed-size-block memory manager
+extern Extra_MmFixed_t *  Extra_MmFixedStart( int nEntrySize );
+extern void        Extra_MmFixedStop( Extra_MmFixed_t * p );
+extern char *      Extra_MmFixedEntryFetch( Extra_MmFixed_t * p );
+extern void        Extra_MmFixedEntryRecycle( Extra_MmFixed_t * p, char * pEntry );
+extern void        Extra_MmFixedRestart( Extra_MmFixed_t * p );
+extern int         Extra_MmFixedReadMemUsage( Extra_MmFixed_t * p );
+extern int         Extra_MmFixedReadMaxEntriesUsed( Extra_MmFixed_t * p );
+// flexible-size-block memory manager
+extern Extra_MmFlex_t * Extra_MmFlexStart();
+extern void        Extra_MmFlexStop( Extra_MmFlex_t * p );
+extern void        Extra_MmFlexPrint( Extra_MmFlex_t * p );
+extern char *      Extra_MmFlexEntryFetch( Extra_MmFlex_t * p, int nBytes );
+extern int         Extra_MmFlexReadMemUsage( Extra_MmFlex_t * p );
+// hierarchical memory manager
+extern Extra_MmStep_t * Extra_MmStepStart( int nSteps );
+extern void        Extra_MmStepStop( Extra_MmStep_t * p );
+extern char *      Extra_MmStepEntryFetch( Extra_MmStep_t * p, int nBytes );
+extern void        Extra_MmStepEntryRecycle( Extra_MmStep_t * p, char * pEntry, int nBytes );
+extern int         Extra_MmStepReadMemUsage( Extra_MmStep_t * p );
+
+/*=== extraUtilMisc.c ========================================================*/
+
+/* finds the smallest integer larger or equal than the logarithm */
+extern int         Extra_Base2Log( unsigned Num );
+extern int         Extra_Base2LogDouble( double Num );
+extern int         Extra_Base10Log( unsigned Num );
+/* returns the power of two as a double */
+extern double      Extra_Power2( int Num );
+extern int         Extra_Power3( int Num );
+/* the number of combinations of k elements out of n */
+extern int         Extra_NumCombinations( int k, int n  );
+extern int *       Extra_DeriveRadixCode( int Number, int Radix, int nDigits );
+/* counts the number of 1s in the bitstring */
+extern int         Extra_CountOnes( unsigned char * pBytes, int nBytes );
+/* the factorial of number */
+extern int         Extra_Factorial( int n );
+/* the permutation of the given number of elements */
+extern char **     Extra_Permutations( int n );
+/* permutation and complementation of a truth table */
+unsigned           Extra_TruthPermute( unsigned Truth, char * pPerms, int nVars, int fReverse );
+unsigned           Extra_TruthPolarize( unsigned uTruth, int Polarity, int nVars );
+/* canonical forms of a truth table */
+extern unsigned    Extra_TruthCanonN( unsigned uTruth, int nVars );
+extern unsigned    Extra_TruthCanonNN( unsigned uTruth, int nVars );
+extern unsigned    Extra_TruthCanonP( unsigned uTruth, int nVars );
+extern unsigned    Extra_TruthCanonNP( unsigned uTruth, int nVars );
+extern unsigned    Extra_TruthCanonNPN( unsigned uTruth, int nVars );
+/* canonical forms of 4-variable functions */
+extern void        Extra_Truth4VarNPN( unsigned short ** puCanons, char ** puPhases, char ** puPerms, unsigned char ** puMap );
+extern void        Extra_Truth4VarN( unsigned short ** puCanons, char *** puPhases, char ** ppCounters, int nPhasesMax );
+/* permutation mapping */
+extern unsigned short Extra_TruthPerm4One( unsigned uTruth, int Phase );
+extern unsigned    Extra_TruthPerm5One( unsigned uTruth, int Phase );
+extern void        Extra_TruthPerm6One( unsigned * uTruth, int Phase, unsigned * uTruthRes );
+extern void        Extra_TruthExpand( int nVars, int nWords, unsigned * puTruth, unsigned uPhase, unsigned * puTruthR );
+/* precomputing tables for permutation mapping */
+extern void **     Extra_ArrayAlloc( int nCols, int nRows, int Size );
+extern unsigned short ** Extra_TruthPerm43();
+extern unsigned ** Extra_TruthPerm53();
+extern unsigned ** Extra_TruthPerm54();
+/* bubble sort for small number of entries */
+extern void        Extra_BubbleSort( int Order[], int Costs[], int nSize, int fIncreasing );
+/* for independence from CUDD */
+extern unsigned int Cudd_PrimeCopy( unsigned int  p );
+
+/*=== extraUtilCanon.c ========================================================*/
+
+/* fast computation of N-canoninical form up to 6 inputs */
+extern int         Extra_TruthCanonFastN( int nVarsMax, int nVarsReal, unsigned * pt, unsigned ** pptRes, char ** ppfRes );
+
+/*=== extraUtilProgress.c ================================================================*/
+
+typedef struct ProgressBarStruct ProgressBar;
+
+extern ProgressBar * Extra_ProgressBarStart( FILE * pFile, int nItemsTotal );
+extern void        Extra_ProgressBarStop( ProgressBar * p );
+extern void        Extra_ProgressBarUpdate_int( ProgressBar * p, int nItemsCur, char * pString );
+
+static inline void Extra_ProgressBarUpdate( ProgressBar * p, int nItemsCur, char * pString ) 
+{  if ( p && nItemsCur < *((int*)p) ) return; Extra_ProgressBarUpdate_int(p, nItemsCur, pString); }
+
+/*=== extraUtilTruth.c ================================================================*/
+
+static inline int   Extra_Float2Int( float Val )     { return *((int *)&Val);               }
+static inline float Extra_Int2Float( int Num )       { return *((float *)&Num);             }
+static inline int   Extra_BitWordNum( int nBits )    { return nBits/(8*sizeof(unsigned)) + ((nBits%(8*sizeof(unsigned))) > 0);  }
+static inline int   Extra_TruthWordNum( int nVars )  { return nVars <= 5 ? 1 : (1 << (nVars - 5)); }
+
+static inline void  Extra_TruthSetBit( unsigned * p, int Bit )   { p[Bit>>5] |= (1<<(Bit & 31));               }
+static inline void  Extra_TruthXorBit( unsigned * p, int Bit )   { p[Bit>>5] ^= (1<<(Bit & 31));               }
+static inline int   Extra_TruthHasBit( unsigned * p, int Bit )   { return (p[Bit>>5] & (1<<(Bit & 31))) > 0;   }
+
+static inline int Extra_WordCountOnes( unsigned uWord )
+{
+    uWord = (uWord & 0x55555555) + ((uWord>>1) & 0x55555555);
+    uWord = (uWord & 0x33333333) + ((uWord>>2) & 0x33333333);
+    uWord = (uWord & 0x0F0F0F0F) + ((uWord>>4) & 0x0F0F0F0F);
+    uWord = (uWord & 0x00FF00FF) + ((uWord>>8) & 0x00FF00FF);
+    return  (uWord & 0x0000FFFF) + (uWord>>16);
+}
+static inline int Extra_TruthCountOnes( unsigned * pIn, int nVars )
+{
+    int w, Counter = 0;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        Counter += Extra_WordCountOnes(pIn[w]);
+    return Counter;
+}
+static inline int Extra_TruthIsEqual( unsigned * pIn0, unsigned * pIn1, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        if ( pIn0[w] != pIn1[w] )
+            return 0;
+    return 1;
+}
+static inline int Extra_TruthIsConst0( unsigned * pIn, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        if ( pIn[w] )
+            return 0;
+    return 1;
+}
+static inline int Extra_TruthIsConst1( unsigned * pIn, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        if ( pIn[w] != ~(unsigned)0 )
+            return 0;
+    return 1;
+}
+static inline int Extra_TruthIsImply( unsigned * pIn1, unsigned * pIn2, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        if ( pIn1[w] & ~pIn2[w] )
+            return 0;
+    return 1;
+}
+static inline void Extra_TruthCopy( unsigned * pOut, unsigned * pIn, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = pIn[w];
+}
+static inline void Extra_TruthClear( unsigned * pOut, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = 0;
+}
+static inline void Extra_TruthFill( unsigned * pOut, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = ~(unsigned)0;
+}
+static inline void Extra_TruthNot( unsigned * pOut, unsigned * pIn, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = ~pIn[w];
+}
+static inline void Extra_TruthAnd( unsigned * pOut, unsigned * pIn0, unsigned * pIn1, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = pIn0[w] & pIn1[w];
+}
+static inline void Extra_TruthOr( unsigned * pOut, unsigned * pIn0, unsigned * pIn1, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = pIn0[w] | pIn1[w];
+}
+static inline void Extra_TruthSharp( unsigned * pOut, unsigned * pIn0, unsigned * pIn1, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = pIn0[w] & ~pIn1[w];
+}
+static inline void Extra_TruthNand( unsigned * pOut, unsigned * pIn0, unsigned * pIn1, int nVars )
+{
+    int w;
+    for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+        pOut[w] = ~(pIn0[w] & pIn1[w]);
+}
+static inline void Extra_TruthAndPhase( unsigned * pOut, unsigned * pIn0, unsigned * pIn1, int nVars, int fCompl0, int fCompl1 )
+{
+    int w;
+    if ( fCompl0 && fCompl1 )
+    {
+        for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+            pOut[w] = ~(pIn0[w] | pIn1[w]);
+    }
+    else if ( fCompl0 && !fCompl1 )
+    {
+        for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+            pOut[w] = ~pIn0[w] & pIn1[w];
+    }
+    else if ( !fCompl0 && fCompl1 )
+    {
+        for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+            pOut[w] = pIn0[w] & ~pIn1[w];
+    }
+    else // if ( !fCompl0 && !fCompl1 )
+    {
+        for ( w = Extra_TruthWordNum(nVars)-1; w >= 0; w-- )
+            pOut[w] = pIn0[w] & pIn1[w];
+    }
+}
+
+extern unsigned ** Extra_TruthElementary( int nVars );
+extern void        Extra_TruthSwapAdjacentVars( unsigned * pOut, unsigned * pIn, int nVars, int Start );
+extern void        Extra_TruthStretch( unsigned * pOut, unsigned * pIn, int nVars, int nVarsAll, unsigned Phase );
+extern void        Extra_TruthShrink( unsigned * pOut, unsigned * pIn, int nVars, int nVarsAll, unsigned Phase );
+extern int         Extra_TruthVarInSupport( unsigned * pTruth, int nVars, int iVar );
+extern int         Extra_TruthSupportSize( unsigned * pTruth, int nVars );
+extern int         Extra_TruthSupport( unsigned * pTruth, int nVars );
+extern void        Extra_TruthCofactor0( unsigned * pTruth, int nVars, int iVar );
+extern void        Extra_TruthCofactor1( unsigned * pTruth, int nVars, int iVar );
+extern void        Extra_TruthExist( unsigned * pTruth, int nVars, int iVar );
+extern void        Extra_TruthForall( unsigned * pTruth, int nVars, int iVar );
+extern void        Extra_TruthMux( unsigned * pOut, unsigned * pCof0, unsigned * pCof1, int nVars, int iVar );
+extern void        Extra_TruthChangePhase( unsigned * pTruth, int nVars, int iVar );
+extern int         Extra_TruthMinCofSuppOverlap( unsigned * pTruth, int nVars, int * pVarMin );
+extern void        Extra_TruthCountOnesInCofs( unsigned * pTruth, int nVars, short * pStore );
+extern unsigned    Extra_TruthHash( unsigned * pIn, int nWords );
+extern unsigned    Extra_TruthSemiCanonicize( unsigned * pInOut, unsigned * pAux, int nVars, char * pCanonPerm, short * pStore );
+
+/*=== extraUtilUtil.c ================================================================*/
+
+#ifndef ABS
+#define ABS(a)            ((a) < 0 ? -(a) : (a))
+#endif
+
+#ifndef MAX
+#define MAX(a,b)        ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef MIN
+#define MIN(a,b)        ((a) < (b) ? (a) : (b))
+#endif
+
+#ifndef ALLOC
+#define ALLOC(type, num)     ((type *) malloc(sizeof(type) * (num)))
+#endif
+
+#ifndef FREE
+#define FREE(obj)             ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
+#endif
+
+#ifndef REALLOC
+#define REALLOC(type, obj, num)    \
+        ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
+         ((type *) malloc(sizeof(type) * (num))))
+#endif
+
+
+extern long        Extra_CpuTime();
+extern int         Extra_GetSoftDataLimit();
+extern void        Extra_UtilGetoptReset();
+extern int         Extra_UtilGetopt( int argc, char *argv[], char *optstring );
+extern char *      Extra_UtilPrintTime( long t );
+extern char *      Extra_UtilStrsav( char *s );
+extern char *      Extra_UtilTildeExpand( char *fname );
+extern char *      Extra_UtilFileSearch( char *file, char *path, char *mode );
+extern void        (*Extra_UtilMMoutOfMemory)();
+
+extern char *      globalUtilOptarg;
+extern int         globalUtilOptind;
+
+/**AutomaticEnd***************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __EXTRA_H__ */
diff --git a/src/misc/extra/extraBddAuto.c b/src/misc/extra/extraBddAuto.c
new file mode 100644
index 00000000..21a969ba
--- /dev/null
+++ b/src/misc/extra/extraBddAuto.c
@@ -0,0 +1,1558 @@
+/**CFile****************************************************************
+
+  FileName    [extraBddAuto.c]
+
+  PackageName [extra]
+
+  Synopsis    [Computation of autosymmetries.]
+
+  Author      [Alan Mishchenko]
+
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 2.0. Started - September 1, 2003.]
+
+  Revision    [$Id: extraBddAuto.c,v 1.0 2003/05/21 18:03:50 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+
+/*
+    LinearSpace(f) = Space(f,f)
+
+    Space(f,g)
+    {
+        if ( f = const )
+        { 
+            if ( f = g )  return 1;
+            else          return 0;
+        }
+        if ( g = const )  return 0;
+        return x' * Space(fx',gx') * Space(fx,gx) + x * Space(fx',gx) * Space(fx,gx');
+    }
+
+    Equations(s) = Pos(s) + Neg(s);
+
+    Pos(s)
+    {
+        if ( s  = 0 )   return 1;
+        if ( s  = 1 )   return 0;
+        if ( sx'= 0 )   return Pos(sx) + x;
+        if ( sx = 0 )   return Pos(sx');
+        return 1 * [Pos(sx') & Pos(sx)] + x * [Pos(sx') & Neg(sx)];
+    }
+
+    Neg(s)
+    {
+        if ( s  = 0 )   return 1;
+        if ( s  = 1 )   return 0;
+        if ( sx'= 0 )   return Neg(sx);
+        if ( sx = 0 )   return Neg(sx') + x;
+        return 1 * [Neg(sx') & Neg(sx)] + x * [Neg(sx') & Pos(sx)];
+    }
+
+
+    SpaceP(A)
+    {
+        if ( A = 0 )    return 1;
+        if ( A = 1 )    return 1;
+        return x' * SpaceP(Ax') * SpaceP(Ax) + x * SpaceP(Ax') * SpaceN(Ax);
+    }
+
+    SpaceN(A)
+    {
+        if ( A = 0 )    return 1;
+        if ( A = 1 )    return 0;
+        return x' * SpaceN(Ax') * SpaceN(Ax) + x * SpaceN(Ax') * SpaceP(Ax);
+    }
+
+
+    LinInd(A)
+    {
+        if ( A = const )     return 1;
+        if ( !LinInd(Ax') )  return 0;
+        if ( !LinInd(Ax)  )  return 0;
+        if (  LinSumOdd(Ax')  & LinSumEven(Ax) != 0 )  return 0;
+        if (  LinSumEven(Ax') & LinSumEven(Ax) != 0 )  return 0;
+        return 1;
+    }
+
+    LinSumOdd(A)
+    {
+        if ( A = 0 )    return 0;                 // Odd0  ---e-- Odd1
+        if ( A = 1 )    return 1;                 //       \   o
+        Odd0  = LinSumOdd(Ax');  // x is absent   //         \ 
+        Even0 = LinSumEven(Ax'); // x is absent   //       /   o  
+        Odd1  = LinSumOdd(Ax);   // x is present  // Even0 ---e-- Even1 
+        Even1 = LinSumEven(Ax);  // x is absent
+        return 1 * [Odd0 + ExorP(Odd0, Even1)] + x * [Odd1 + ExorP(Odd1, Even0)];
+    }
+
+    LinSumEven(A)
+    {
+        if ( A = 0 )    return 0;
+        if ( A = 1 )    return 0;
+        Odd0  = LinSumOdd(Ax');  // x is absent
+        Even0 = LinSumEven(Ax'); // x is absent
+        Odd1  = LinSumOdd(Ax);   // x is present
+        Even1 = LinSumEven(Ax);  // x is absent
+        return 1 * [Even0 + Even1 + ExorP(Even0, Even1)] + x * [ExorP(Odd0, Odd1)];
+    }
+    
+*/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceFromFunctionFast( DdManager * dd, DdNode * bFunc )
+{
+    int * pSupport;
+    int * pPermute;
+    int * pPermuteBack;
+    DdNode ** pCompose;
+    DdNode * bCube, * bTemp;
+    DdNode * bSpace, * bFunc1, * bFunc2, * bSpaceShift;
+    int nSupp, Counter;
+    int i, lev;
+
+    // get the support
+    pSupport = ALLOC( int, ddMax(dd->size,dd->sizeZ) );
+    Extra_SupportArray( dd, bFunc, pSupport );
+    nSupp = 0;
+    for ( i = 0; i < dd->size; i++ )
+        if ( pSupport[i] )
+            nSupp++;
+
+    // make sure the manager has enough variables
+    if ( 2*nSupp > dd->size )
+    {
+        printf( "Cannot derive linear space, because DD manager does not have enough variables.\n" );
+        fflush( stdout );
+        free( pSupport );
+        return NULL;
+    }
+
+    // create the permutation arrays
+    pPermute     = ALLOC( int, dd->size );
+    pPermuteBack = ALLOC( int, dd->size );
+    pCompose     = ALLOC( DdNode *, dd->size );
+    for ( i = 0; i < dd->size; i++ )
+    {
+        pPermute[i]     = i;
+        pPermuteBack[i] = i;
+        pCompose[i]     = dd->vars[i];   Cudd_Ref( pCompose[i] );
+    }
+
+    // remap the function in such a way that the variables are interleaved
+    Counter = 0;
+    bCube = b1;  Cudd_Ref( bCube );
+    for ( lev = 0; lev < dd->size; lev++ )
+        if ( pSupport[ dd->invperm[lev] ] )
+        {   // var "dd->invperm[lev]" on level "lev" should go to level 2*Counter;
+            pPermute[ dd->invperm[lev] ] = dd->invperm[2*Counter];
+            // var from level 2*Counter+1 should go back to the place of this var
+            pPermuteBack[ dd->invperm[2*Counter+1] ] = dd->invperm[lev];
+            // the permutation should be defined in such a way that variable
+            // on level 2*Counter is replaced by an EXOR of itself and var on the next level
+            Cudd_Deref( pCompose[ dd->invperm[2*Counter] ] );
+            pCompose[ dd->invperm[2*Counter] ] = 
+                Cudd_bddXor( dd, dd->vars[ dd->invperm[2*Counter] ], dd->vars[ dd->invperm[2*Counter+1] ] );  
+            Cudd_Ref( pCompose[ dd->invperm[2*Counter] ] );
+            // add this variable to the cube
+            bCube = Cudd_bddAnd( dd, bTemp = bCube, dd->vars[ dd->invperm[2*Counter] ] );  Cudd_Ref( bCube );
+            Cudd_RecursiveDeref( dd, bTemp );
+            // increment the counter
+            Counter ++;
+        }
+
+    // permute the functions
+    bFunc1 = Cudd_bddPermute( dd, bFunc, pPermute );         Cudd_Ref( bFunc1 );
+    // compose to gate the function depending on both vars
+    bFunc2 = Cudd_bddVectorCompose( dd, bFunc1, pCompose );  Cudd_Ref( bFunc2 );
+    // gate the vector space
+    // L(a) = ForAll x [ F(x) = F(x+a) ] = Not( Exist x [ F(x) (+) F(x+a) ] )
+    bSpaceShift = Cudd_bddXorExistAbstract( dd, bFunc1, bFunc2, bCube );  Cudd_Ref( bSpaceShift );
+    bSpaceShift = Cudd_Not( bSpaceShift );
+    // permute the space back into the original mapping
+    bSpace = Cudd_bddPermute( dd, bSpaceShift, pPermuteBack ); Cudd_Ref( bSpace );
+    Cudd_RecursiveDeref( dd, bFunc1 );
+    Cudd_RecursiveDeref( dd, bFunc2 );
+    Cudd_RecursiveDeref( dd, bSpaceShift );
+    Cudd_RecursiveDeref( dd, bCube );
+
+    for ( i = 0; i < dd->size; i++ )
+        Cudd_RecursiveDeref( dd, pCompose[i] );
+    free( pPermute );
+    free( pPermuteBack );
+    free( pCompose );
+    free( pSupport );
+
+    Cudd_Deref( bSpace );
+    return bSpace;
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceFromFunction( DdManager * dd, DdNode * bF, DdNode * bG )
+{
+    DdNode * bRes;
+    do {
+        dd->reordered = 0;
+        bRes = extraBddSpaceFromFunction( dd, bF, bG );
+    } while (dd->reordered == 1);
+    return bRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceFromFunctionPos( DdManager * dd, DdNode * bFunc )
+{
+    DdNode * bRes;
+    do {
+        dd->reordered = 0;
+        bRes = extraBddSpaceFromFunctionPos( dd, bFunc );
+    } while (dd->reordered == 1);
+    return bRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceFromFunctionNeg( DdManager * dd, DdNode * bFunc )
+{
+    DdNode * bRes;
+    do {
+        dd->reordered = 0;
+        bRes = extraBddSpaceFromFunctionNeg( dd, bFunc );
+    } while (dd->reordered == 1);
+    return bRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceCanonVars( DdManager * dd, DdNode * bSpace )
+{
+    DdNode * bRes;
+    do {
+        dd->reordered = 0;
+        bRes = extraBddSpaceCanonVars( dd, bSpace );
+    } while (dd->reordered == 1);
+    return bRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceReduce( DdManager * dd, DdNode * bFunc, DdNode * bCanonVars )
+{
+    DdNode * bNegCube;
+    DdNode * bResult;
+    bNegCube = Extra_bddSupportNegativeCube( dd, bCanonVars );  Cudd_Ref( bNegCube );
+    bResult  = Cudd_Cofactor( dd, bFunc, bNegCube );            Cudd_Ref( bResult );
+    Cudd_RecursiveDeref( dd, bNegCube );
+    Cudd_Deref( bResult );
+    return bResult;
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceEquations( DdManager * dd, DdNode * bSpace )
+{
+    DdNode * zRes;
+    DdNode * zEquPos;
+    DdNode * zEquNeg;
+    zEquPos = Extra_bddSpaceEquationsPos( dd, bSpace );  Cudd_Ref( zEquPos );
+    zEquNeg = Extra_bddSpaceEquationsNeg( dd, bSpace );  Cudd_Ref( zEquNeg );
+    zRes    = Cudd_zddUnion( dd, zEquPos, zEquNeg );     Cudd_Ref( zRes );
+    Cudd_RecursiveDerefZdd( dd, zEquPos );
+    Cudd_RecursiveDerefZdd( dd, zEquNeg );
+    Cudd_Deref( zRes );
+    return zRes;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceEquationsPos( DdManager * dd, DdNode * bSpace )
+{
+    DdNode * zRes;
+    do {
+        dd->reordered = 0;
+        zRes = extraBddSpaceEquationsPos( dd, bSpace );
+    } while (dd->reordered == 1);
+    return zRes;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceEquationsNeg( DdManager * dd, DdNode * bSpace )
+{
+    DdNode * zRes;
+    do {
+        dd->reordered = 0;
+        zRes = extraBddSpaceEquationsNeg( dd, bSpace );
+    } while (dd->reordered == 1);
+    return zRes;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceFromMatrixPos( DdManager * dd, DdNode * zA )
+{
+    DdNode * bRes;
+    do {
+        dd->reordered = 0;
+        bRes = extraBddSpaceFromMatrixPos( dd, zA );
+    } while (dd->reordered == 1);
+    return bRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * Extra_bddSpaceFromMatrixNeg( DdManager * dd, DdNode * zA )
+{
+    DdNode * bRes;
+    do {
+        dd->reordered = 0;
+        bRes = extraBddSpaceFromMatrixNeg( dd, zA );
+    } while (dd->reordered == 1);
+    return bRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of literals in one combination.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_zddLitCountComb( DdManager * dd, DdNode * zComb )
+{
+    int Counter;
+    if ( zComb == z0 )
+        return 0;
+    Counter = 0;
+    for ( ; zComb != z1; zComb = cuddT(zComb) )
+        Counter++;
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description [Returns the array of ZDDs with the number equal to the number of 
+  vars in the DD manager. If the given var is non-canonical, this array contains
+  the referenced ZDD representing literals in the corresponding EXOR equation.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode ** Extra_bddSpaceExorGates( DdManager * dd, DdNode * bFuncRed, DdNode * zEquations )
+{
+    DdNode ** pzRes;
+    int * pVarsNonCan;
+    DdNode * zEquRem;
+    int iVarNonCan;
+    DdNode * zExor, * zTemp;
+
+    // get the set of non-canonical variables
+    pVarsNonCan = ALLOC( int, ddMax(dd->size,dd->sizeZ) );
+    Extra_SupportArray( dd, bFuncRed, pVarsNonCan );
+
+    // allocate storage for the EXOR sets
+    pzRes = ALLOC( DdNode *, dd->size );
+    memset( pzRes, 0, sizeof(DdNode *) * dd->size );
+
+    // go through all the equations
+    zEquRem = zEquations;  Cudd_Ref( zEquRem );
+    while ( zEquRem != z0 )
+    {
+        // extract one product
+        zExor = Extra_zddSelectOneSubset( dd, zEquRem );   Cudd_Ref( zExor );
+        // remove it from the set
+        zEquRem = Cudd_zddDiff( dd, zTemp = zEquRem, zExor );  Cudd_Ref( zEquRem );
+        Cudd_RecursiveDerefZdd( dd, zTemp );
+
+        // locate the non-canonical variable
+        iVarNonCan = -1;
+        for ( zTemp = zExor; zTemp != z1; zTemp = cuddT(zTemp) )
+        {
+            if ( pVarsNonCan[zTemp->index/2] == 1 )
+            {
+                assert( iVarNonCan == -1 );
+                iVarNonCan = zTemp->index/2;
+            }
+        }
+        assert( iVarNonCan != -1 );
+
+        if ( Extra_zddLitCountComb( dd, zExor ) > 1 )
+            pzRes[ iVarNonCan ] = zExor; // takes ref
+        else
+            Cudd_RecursiveDerefZdd( dd, zExor );
+    }
+    Cudd_RecursiveDerefZdd( dd, zEquRem );
+
+    free( pVarsNonCan );
+    return pzRes;
+}
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the recursive steps of Extra_bddSpaceFromFunction.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraBddSpaceFromFunction( DdManager * dd, DdNode * bF, DdNode * bG )
+{
+    DdNode * bRes;
+    DdNode * bFR, * bGR;
+
+    bFR = Cudd_Regular( bF ); 
+    bGR = Cudd_Regular( bG ); 
+    if ( cuddIsConstant(bFR) )
+    {
+        if ( bF == bG )
+            return b1;
+        else 
+            return b0;
+    }
+    if ( cuddIsConstant(bGR) )
+        return b0;
+    // both bFunc and bCore are not constants
+
+    // the operation is commutative - normalize the problem
+    if ( (unsigned)bF > (unsigned)bG )
+        return extraBddSpaceFromFunction(dd, bG, bF);
+
+
+    if ( bRes = cuddCacheLookup2(dd, extraBddSpaceFromFunction, bF, bG) )
+        return bRes;
+    else
+    {
+        DdNode * bF0, * bF1;
+        DdNode * bG0, * bG1;
+        DdNode * bTemp1, * bTemp2;
+        DdNode * bRes0, * bRes1;
+        int LevelF, LevelG;
+        int index;
+
+        LevelF = dd->perm[bFR->index];
+        LevelG = dd->perm[bGR->index];
+        if ( LevelF <= LevelG )
+        {
+            index = dd->invperm[LevelF];
+            if ( bFR != bF )
+            {
+                bF0 = Cudd_Not( cuddE(bFR) );
+                bF1 = Cudd_Not( cuddT(bFR) );
+            }
+            else
+            {
+                bF0 = cuddE(bFR);
+                bF1 = cuddT(bFR);
+            }
+        }
+        else
+        {
+            index = dd->invperm[LevelG];
+            bF0 = bF1 = bF;
+        }
+
+        if ( LevelG <= LevelF )
+        {
+            if ( bGR != bG )
+            {
+                bG0 = Cudd_Not( cuddE(bGR) );
+                bG1 = Cudd_Not( cuddT(bGR) );
+            }
+            else
+            {
+                bG0 = cuddE(bGR);
+                bG1 = cuddT(bGR);
+            }
+        }
+        else
+            bG0 = bG1 = bG;
+
+        bTemp1 = extraBddSpaceFromFunction( dd, bF0, bG0 );
+        if ( bTemp1 == NULL ) 
+            return NULL;
+        cuddRef( bTemp1 );
+
+        bTemp2 = extraBddSpaceFromFunction( dd, bF1, bG1 );
+        if ( bTemp2 == NULL ) 
+        {
+            Cudd_RecursiveDeref( dd, bTemp1 );
+            return NULL;
+        }
+        cuddRef( bTemp2 );
+
+
+        bRes0  = cuddBddAndRecur( dd, bTemp1, bTemp2 );
+        if ( bRes0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bTemp1 );
+            Cudd_RecursiveDeref( dd, bTemp2 );
+            return NULL;
+        }
+        cuddRef( bRes0 );
+        Cudd_RecursiveDeref( dd, bTemp1 );
+        Cudd_RecursiveDeref( dd, bTemp2 );
+
+
+        bTemp1  = extraBddSpaceFromFunction( dd, bF0, bG1 );
+        if ( bTemp1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            return NULL;
+        }
+        cuddRef( bTemp1 );
+
+        bTemp2  = extraBddSpaceFromFunction( dd, bF1, bG0 );
+        if ( bTemp2 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bTemp1 );
+            return NULL;
+        }
+        cuddRef( bTemp2 );
+
+        bRes1  = cuddBddAndRecur( dd, bTemp1, bTemp2 );
+        if ( bRes1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bTemp1 );
+            Cudd_RecursiveDeref( dd, bTemp2 );
+            return NULL;
+        }
+        cuddRef( bRes1 );
+        Cudd_RecursiveDeref( dd, bTemp1 );
+        Cudd_RecursiveDeref( dd, bTemp2 );
+
+
+
+        // consider the case when Res0 and Res1 are the same node 
+        if ( bRes0 == bRes1 )
+            bRes = bRes1;
+        // consider the case when Res1 is complemented 
+        else if ( Cudd_IsComplement(bRes1) ) 
+        {
+            bRes = cuddUniqueInter(dd, index, Cudd_Not(bRes1), Cudd_Not(bRes0));
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+            bRes = Cudd_Not(bRes);
+        } 
+        else 
+        {
+            bRes = cuddUniqueInter( dd, index, bRes1, bRes0 );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+        }
+        cuddDeref( bRes0 );
+        cuddDeref( bRes1 );
+            
+        // insert the result into cache 
+        cuddCacheInsert2(dd, extraBddSpaceFromFunction, bF, bG, bRes);
+        return bRes;
+    }
+}  /* end of extraBddSpaceFromFunction */
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddSpaceFromFunctionPos().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * extraBddSpaceFromFunctionPos( DdManager * dd, DdNode * bF )
+{
+    DdNode * bRes, * bFR;
+    statLine( dd );
+
+    bFR = Cudd_Regular(bF);
+    if ( cuddIsConstant(bFR) )
+        return b1;
+
+    if ( bRes = cuddCacheLookup1(dd, extraBddSpaceFromFunctionPos, bF) )
+        return bRes;
+    else
+    {
+        DdNode * bF0,   * bF1;
+        DdNode * bPos0, * bPos1;
+        DdNode * bNeg0, * bNeg1;
+        DdNode * bRes0, * bRes1; 
+
+        if ( bFR != bF ) // bF is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+
+        bPos0  = extraBddSpaceFromFunctionPos( dd, bF0 );
+        if ( bPos0 == NULL )
+            return NULL;
+        cuddRef( bPos0 );
+
+        bPos1  = extraBddSpaceFromFunctionPos( dd, bF1 );
+        if ( bPos1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bPos0 );
+            return NULL;
+        }
+        cuddRef( bPos1 );
+
+        bRes0  = cuddBddAndRecur( dd, bPos0, bPos1 );
+        if ( bRes0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bPos0 );
+            Cudd_RecursiveDeref( dd, bPos1 );
+            return NULL;
+        }
+        cuddRef( bRes0 );
+        Cudd_RecursiveDeref( dd, bPos0 );
+        Cudd_RecursiveDeref( dd, bPos1 );
+
+
+        bNeg0  = extraBddSpaceFromFunctionNeg( dd, bF0 );
+        if ( bNeg0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            return NULL;
+        }
+        cuddRef( bNeg0 );
+
+        bNeg1  = extraBddSpaceFromFunctionNeg( dd, bF1 );
+        if ( bNeg1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bNeg0 );
+            return NULL;
+        }
+        cuddRef( bNeg1 );
+
+        bRes1  = cuddBddAndRecur( dd, bNeg0, bNeg1 );
+        if ( bRes1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bNeg0 );
+            Cudd_RecursiveDeref( dd, bNeg1 );
+            return NULL;
+        }
+        cuddRef( bRes1 );
+        Cudd_RecursiveDeref( dd, bNeg0 );
+        Cudd_RecursiveDeref( dd, bNeg1 );
+
+
+        // consider the case when Res0 and Res1 are the same node 
+        if ( bRes0 == bRes1 )
+            bRes = bRes1;
+        // consider the case when Res1 is complemented 
+        else if ( Cudd_IsComplement(bRes1) ) 
+        {
+            bRes = cuddUniqueInter( dd, bFR->index, Cudd_Not(bRes1), Cudd_Not(bRes0) );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+            bRes = Cudd_Not(bRes);
+        } 
+        else 
+        {
+            bRes = cuddUniqueInter( dd, bFR->index, bRes1, bRes0 );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+        }
+        cuddDeref( bRes0 );
+        cuddDeref( bRes1 );
+
+        cuddCacheInsert1( dd, extraBddSpaceFromFunctionPos, bF, bRes );
+        return bRes;
+    }
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddSpaceFromFunctionPos().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * extraBddSpaceFromFunctionNeg( DdManager * dd, DdNode * bF )
+{
+    DdNode * bRes, * bFR;
+    statLine( dd );
+
+    bFR = Cudd_Regular(bF);
+    if ( cuddIsConstant(bFR) )
+        return b0;
+
+    if ( bRes = cuddCacheLookup1(dd, extraBddSpaceFromFunctionNeg, bF) )
+        return bRes;
+    else
+    {
+        DdNode * bF0,   * bF1;
+        DdNode * bPos0, * bPos1;
+        DdNode * bNeg0, * bNeg1;
+        DdNode * bRes0, * bRes1; 
+
+        if ( bFR != bF ) // bF is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+
+        bPos0  = extraBddSpaceFromFunctionNeg( dd, bF0 );
+        if ( bPos0 == NULL )
+            return NULL;
+        cuddRef( bPos0 );
+
+        bPos1  = extraBddSpaceFromFunctionNeg( dd, bF1 );
+        if ( bPos1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bPos0 );
+            return NULL;
+        }
+        cuddRef( bPos1 );
+
+        bRes0  = cuddBddAndRecur( dd, bPos0, bPos1 );
+        if ( bRes0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bPos0 );
+            Cudd_RecursiveDeref( dd, bPos1 );
+            return NULL;
+        }
+        cuddRef( bRes0 );
+        Cudd_RecursiveDeref( dd, bPos0 );
+        Cudd_RecursiveDeref( dd, bPos1 );
+
+
+        bNeg0  = extraBddSpaceFromFunctionPos( dd, bF0 );
+        if ( bNeg0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            return NULL;
+        }
+        cuddRef( bNeg0 );
+
+        bNeg1  = extraBddSpaceFromFunctionPos( dd, bF1 );
+        if ( bNeg1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bNeg0 );
+            return NULL;
+        }
+        cuddRef( bNeg1 );
+
+        bRes1  = cuddBddAndRecur( dd, bNeg0, bNeg1 );
+        if ( bRes1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bNeg0 );
+            Cudd_RecursiveDeref( dd, bNeg1 );
+            return NULL;
+        }
+        cuddRef( bRes1 );
+        Cudd_RecursiveDeref( dd, bNeg0 );
+        Cudd_RecursiveDeref( dd, bNeg1 );
+
+
+        // consider the case when Res0 and Res1 are the same node 
+        if ( bRes0 == bRes1 )
+            bRes = bRes1;
+        // consider the case when Res1 is complemented 
+        else if ( Cudd_IsComplement(bRes1) ) 
+        {
+            bRes = cuddUniqueInter( dd, bFR->index, Cudd_Not(bRes1), Cudd_Not(bRes0) );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+            bRes = Cudd_Not(bRes);
+        } 
+        else 
+        {
+            bRes = cuddUniqueInter( dd, bFR->index, bRes1, bRes0 );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+        }
+        cuddDeref( bRes0 );
+        cuddDeref( bRes1 );
+
+        cuddCacheInsert1( dd, extraBddSpaceFromFunctionNeg, bF, bRes );
+        return bRes;
+    }
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddSpaceCanonVars().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * extraBddSpaceCanonVars( DdManager * dd, DdNode * bF )
+{
+    DdNode * bRes, * bFR;
+    statLine( dd );
+
+    bFR = Cudd_Regular(bF);
+    if ( cuddIsConstant(bFR) )
+        return bF;
+
+    if ( bRes = cuddCacheLookup1(dd, extraBddSpaceCanonVars, bF) )
+        return bRes;
+    else
+    {
+        DdNode * bF0,  * bF1;
+        DdNode * bRes, * bRes0; 
+
+        if ( bFR != bF ) // bF is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+        if ( bF0 == b0 )
+        {
+            bRes = extraBddSpaceCanonVars( dd, bF1 );
+            if ( bRes == NULL )
+                return NULL;
+        }
+        else if ( bF1 == b0 )
+        {
+            bRes = extraBddSpaceCanonVars( dd, bF0 );
+            if ( bRes == NULL )
+                return NULL;
+        }
+        else
+        {
+            bRes0 = extraBddSpaceCanonVars( dd, bF0 );
+            if ( bRes0 == NULL )
+                return NULL;
+            cuddRef( bRes0 );
+
+            bRes = cuddUniqueInter( dd, bFR->index, bRes0, b0 );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref( dd,bRes0 );
+                return NULL;
+            }
+            cuddDeref( bRes0 );
+        }
+
+        cuddCacheInsert1( dd, extraBddSpaceCanonVars, bF, bRes );
+        return bRes;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddSpaceEquationsPos().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * extraBddSpaceEquationsPos( DdManager * dd, DdNode * bF )
+{
+    DdNode * zRes;
+    statLine( dd );
+
+    if ( bF == b0 )
+        return z1;
+    if ( bF == b1 )
+        return z0;
+    
+    if ( zRes = cuddCacheLookup1Zdd(dd, extraBddSpaceEquationsPos, bF) )
+        return zRes;
+    else
+    {
+        DdNode * bFR, * bF0,  * bF1;
+        DdNode * zPos0, * zPos1, * zNeg1; 
+        DdNode * zRes, * zRes0, * zRes1;
+
+        bFR = Cudd_Regular(bF);
+        if ( bFR != bF ) // bF is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+        if ( bF0 == b0 )
+        {
+            zRes1 = extraBddSpaceEquationsPos( dd, bF1 );
+            if ( zRes1 == NULL )
+                return NULL;
+            cuddRef( zRes1 );
+
+            // add the current element to the set
+            zRes = cuddZddGetNode( dd, 2*bFR->index, z1, zRes1 );
+            if ( zRes == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd(dd, zRes1);
+                return NULL;
+            }
+            cuddDeref( zRes1 );
+        }
+        else if ( bF1 == b0 )
+        {
+            zRes = extraBddSpaceEquationsPos( dd, bF0 );
+            if ( zRes == NULL )
+                return NULL;
+        }
+        else
+        {
+            zPos0 = extraBddSpaceEquationsPos( dd, bF0 );
+            if ( zPos0 == NULL )
+                return NULL;
+            cuddRef( zPos0 );
+
+            zPos1 = extraBddSpaceEquationsPos( dd, bF1 );
+            if ( zPos1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                return NULL;
+            }
+            cuddRef( zPos1 );
+
+            zNeg1 = extraBddSpaceEquationsNeg( dd, bF1 );
+            if ( zNeg1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                Cudd_RecursiveDerefZdd(dd, zPos1);
+                return NULL;
+            }
+            cuddRef( zNeg1 );
+
+
+            zRes0 = cuddZddIntersect( dd, zPos0, zPos1 );
+            if ( zRes0 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zNeg1);
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                Cudd_RecursiveDerefZdd(dd, zPos1);
+                return NULL;
+            }
+            cuddRef( zRes0 );
+
+            zRes1 = cuddZddIntersect( dd, zPos0, zNeg1 );
+            if ( zRes1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zRes0);
+                Cudd_RecursiveDerefZdd(dd, zNeg1);
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                Cudd_RecursiveDerefZdd(dd, zPos1);
+                return NULL;
+            }
+            cuddRef( zRes1 );
+            Cudd_RecursiveDerefZdd(dd, zNeg1);
+            Cudd_RecursiveDerefZdd(dd, zPos0);
+            Cudd_RecursiveDerefZdd(dd, zPos1);
+            // only zRes0 and zRes1 are refed at this point
+
+            zRes = cuddZddGetNode( dd, 2*bFR->index, zRes1, zRes0 );
+            if ( zRes == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd(dd, zRes0);
+                Cudd_RecursiveDerefZdd(dd, zRes1);
+                return NULL;
+            }
+            cuddDeref( zRes0 );
+            cuddDeref( zRes1 );
+        }
+
+        cuddCacheInsert1( dd, extraBddSpaceEquationsPos, bF, zRes );
+        return zRes;
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddSpaceEquationsNev().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * extraBddSpaceEquationsNeg( DdManager * dd, DdNode * bF )
+{
+    DdNode * zRes;
+    statLine( dd );
+
+    if ( bF == b0 )
+        return z1;
+    if ( bF == b1 )
+        return z0;
+    
+    if ( zRes = cuddCacheLookup1Zdd(dd, extraBddSpaceEquationsNeg, bF) )
+        return zRes;
+    else
+    {
+        DdNode * bFR, * bF0,  * bF1;
+        DdNode * zPos0, * zPos1, * zNeg1; 
+        DdNode * zRes, * zRes0, * zRes1;
+
+        bFR = Cudd_Regular(bF);
+        if ( bFR != bF ) // bF is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+        if ( bF0 == b0 )
+        {
+            zRes = extraBddSpaceEquationsNeg( dd, bF1 );
+            if ( zRes == NULL )
+                return NULL;
+        }
+        else if ( bF1 == b0 )
+        {
+            zRes0 = extraBddSpaceEquationsNeg( dd, bF0 );
+            if ( zRes0 == NULL )
+                return NULL;
+            cuddRef( zRes0 );
+
+            // add the current element to the set
+            zRes = cuddZddGetNode( dd, 2*bFR->index, z1, zRes0 );
+            if ( zRes == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd(dd, zRes0);
+                return NULL;
+            }
+            cuddDeref( zRes0 );
+        }
+        else
+        {
+            zPos0 = extraBddSpaceEquationsNeg( dd, bF0 );
+            if ( zPos0 == NULL )
+                return NULL;
+            cuddRef( zPos0 );
+
+            zPos1 = extraBddSpaceEquationsNeg( dd, bF1 );
+            if ( zPos1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                return NULL;
+            }
+            cuddRef( zPos1 );
+
+            zNeg1 = extraBddSpaceEquationsPos( dd, bF1 );
+            if ( zNeg1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                Cudd_RecursiveDerefZdd(dd, zPos1);
+                return NULL;
+            }
+            cuddRef( zNeg1 );
+
+
+            zRes0 = cuddZddIntersect( dd, zPos0, zPos1 );
+            if ( zRes0 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zNeg1);
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                Cudd_RecursiveDerefZdd(dd, zPos1);
+                return NULL;
+            }
+            cuddRef( zRes0 );
+
+            zRes1 = cuddZddIntersect( dd, zPos0, zNeg1 );
+            if ( zRes1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd(dd, zRes0);
+                Cudd_RecursiveDerefZdd(dd, zNeg1);
+                Cudd_RecursiveDerefZdd(dd, zPos0);
+                Cudd_RecursiveDerefZdd(dd, zPos1);
+                return NULL;
+            }
+            cuddRef( zRes1 );
+            Cudd_RecursiveDerefZdd(dd, zNeg1);
+            Cudd_RecursiveDerefZdd(dd, zPos0);
+            Cudd_RecursiveDerefZdd(dd, zPos1);
+            // only zRes0 and zRes1 are refed at this point
+
+            zRes = cuddZddGetNode( dd, 2*bFR->index, zRes1, zRes0 );
+            if ( zRes == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd(dd, zRes0);
+                Cudd_RecursiveDerefZdd(dd, zRes1);
+                return NULL;
+            }
+            cuddDeref( zRes0 );
+            cuddDeref( zRes1 );
+        }
+
+        cuddCacheInsert1( dd, extraBddSpaceEquationsNeg, bF, zRes );
+        return zRes;
+    }
+}
+
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddSpaceFromFunctionPos().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * extraBddSpaceFromMatrixPos( DdManager * dd, DdNode * zA )
+{
+    DdNode * bRes;
+    statLine( dd );
+
+    if ( zA == z0 )
+        return b1;
+    if ( zA == z1 )
+        return b1;
+
+    if ( bRes = cuddCacheLookup1(dd, extraBddSpaceFromMatrixPos, zA) )
+        return bRes;
+    else
+    {
+        DdNode * bP0, * bP1;
+        DdNode * bN0, * bN1;
+        DdNode * bRes0, * bRes1; 
+
+        bP0  = extraBddSpaceFromMatrixPos( dd, cuddE(zA) );
+        if ( bP0 == NULL )
+            return NULL;
+        cuddRef( bP0 );
+
+        bP1  = extraBddSpaceFromMatrixPos( dd, cuddT(zA) );
+        if ( bP1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bP0 );
+            return NULL;
+        }
+        cuddRef( bP1 );
+
+        bRes0  = cuddBddAndRecur( dd, bP0, bP1 );
+        if ( bRes0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bP0 );
+            Cudd_RecursiveDeref( dd, bP1 );
+            return NULL;
+        }
+        cuddRef( bRes0 );
+        Cudd_RecursiveDeref( dd, bP0 );
+        Cudd_RecursiveDeref( dd, bP1 );
+
+
+        bN0  = extraBddSpaceFromMatrixPos( dd, cuddE(zA) );
+        if ( bN0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            return NULL;
+        }
+        cuddRef( bN0 );
+
+        bN1  = extraBddSpaceFromMatrixNeg( dd, cuddT(zA) );
+        if ( bN1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bN0 );
+            return NULL;
+        }
+        cuddRef( bN1 );
+
+        bRes1  = cuddBddAndRecur( dd, bN0, bN1 );
+        if ( bRes1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bN0 );
+            Cudd_RecursiveDeref( dd, bN1 );
+            return NULL;
+        }
+        cuddRef( bRes1 );
+        Cudd_RecursiveDeref( dd, bN0 );
+        Cudd_RecursiveDeref( dd, bN1 );
+
+
+        // consider the case when Res0 and Res1 are the same node 
+        if ( bRes0 == bRes1 )
+            bRes = bRes1;
+        // consider the case when Res1 is complemented 
+        else if ( Cudd_IsComplement(bRes1) ) 
+        {
+            bRes = cuddUniqueInter( dd, zA->index/2, Cudd_Not(bRes1), Cudd_Not(bRes0) );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+            bRes = Cudd_Not(bRes);
+        } 
+        else 
+        {
+            bRes = cuddUniqueInter( dd, zA->index/2, bRes1, bRes0 );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+        }
+        cuddDeref( bRes0 );
+        cuddDeref( bRes1 );
+
+        cuddCacheInsert1( dd, extraBddSpaceFromMatrixPos, zA, bRes );
+        return bRes;
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddSpaceFromFunctionPos().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+DdNode * extraBddSpaceFromMatrixNeg( DdManager * dd, DdNode * zA )
+{
+    DdNode * bRes;
+    statLine( dd );
+
+    if ( zA == z0 )
+        return b1;
+    if ( zA == z1 )
+        return b0;
+
+    if ( bRes = cuddCacheLookup1(dd, extraBddSpaceFromMatrixNeg, zA) )
+        return bRes;
+    else
+    {
+        DdNode * bP0, * bP1;
+        DdNode * bN0, * bN1;
+        DdNode * bRes0, * bRes1; 
+
+        bP0  = extraBddSpaceFromMatrixNeg( dd, cuddE(zA) );
+        if ( bP0 == NULL )
+            return NULL;
+        cuddRef( bP0 );
+
+        bP1  = extraBddSpaceFromMatrixNeg( dd, cuddT(zA) );
+        if ( bP1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bP0 );
+            return NULL;
+        }
+        cuddRef( bP1 );
+
+        bRes0  = cuddBddAndRecur( dd, bP0, bP1 );
+        if ( bRes0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bP0 );
+            Cudd_RecursiveDeref( dd, bP1 );
+            return NULL;
+        }
+        cuddRef( bRes0 );
+        Cudd_RecursiveDeref( dd, bP0 );
+        Cudd_RecursiveDeref( dd, bP1 );
+
+
+        bN0  = extraBddSpaceFromMatrixNeg( dd, cuddE(zA) );
+        if ( bN0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            return NULL;
+        }
+        cuddRef( bN0 );
+
+        bN1  = extraBddSpaceFromMatrixPos( dd, cuddT(zA) );
+        if ( bN1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bN0 );
+            return NULL;
+        }
+        cuddRef( bN1 );
+
+        bRes1  = cuddBddAndRecur( dd, bN0, bN1 );
+        if ( bRes1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bN0 );
+            Cudd_RecursiveDeref( dd, bN1 );
+            return NULL;
+        }
+        cuddRef( bRes1 );
+        Cudd_RecursiveDeref( dd, bN0 );
+        Cudd_RecursiveDeref( dd, bN1 );
+
+
+        // consider the case when Res0 and Res1 are the same node 
+        if ( bRes0 == bRes1 )
+            bRes = bRes1;
+        // consider the case when Res1 is complemented 
+        else if ( Cudd_IsComplement(bRes1) ) 
+        {
+            bRes = cuddUniqueInter( dd, zA->index/2, Cudd_Not(bRes1), Cudd_Not(bRes0) );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+            bRes = Cudd_Not(bRes);
+        } 
+        else 
+        {
+            bRes = cuddUniqueInter( dd, zA->index/2, bRes1, bRes0 );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref(dd,bRes0);
+                Cudd_RecursiveDeref(dd,bRes1);
+                return NULL;
+            }
+        }
+        cuddDeref( bRes0 );
+        cuddDeref( bRes1 );
+
+        cuddCacheInsert1( dd, extraBddSpaceFromMatrixNeg, zA, bRes );
+        return bRes;
+    }
+}
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static functions                                            */
+/*---------------------------------------------------------------------------*/
+
diff --git a/src/misc/extra/extraBddCas.c b/src/misc/extra/extraBddCas.c
new file mode 100644
index 00000000..29382bfb
--- /dev/null
+++ b/src/misc/extra/extraBddCas.c
@@ -0,0 +1,1230 @@
+/**CFile****************************************************************
+
+  FileName    [extraBddCas.c]
+
+  PackageName [extra]
+
+  Synopsis    [Procedures related to LUT cascade synthesis.]
+
+  Author      [Alan Mishchenko]
+
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 2.0. Started - September 1, 2003.]
+
+  Revision    [$Id: extraBddCas.c,v 1.0 2003/05/21 18:03:50 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+// the table to store cofactor operations
+#define _TABLESIZE_COF  51113
+typedef struct 
+{
+    unsigned Sign;  
+    DdNode * Arg1;  
+} _HashEntry_cof;
+_HashEntry_cof HHTable1[_TABLESIZE_COF];
+
+// the table to store the result of computation of the number of minterms
+#define _TABLESIZE_MINT  15113
+typedef struct 
+{
+    DdNode * Arg1;  
+    unsigned Arg2;  
+    unsigned Res;  
+} _HashEntry_mint;
+_HashEntry_mint HHTable2[_TABLESIZE_MINT];
+
+typedef struct 
+{
+    int      nEdges;  // the number of in-coming edges of the node
+    DdNode * bSum;    // the sum of paths of the incoming edges
+} traventry;
+
+// the signature used for hashing
+static unsigned s_Signature = 1;
+
+static int s_CutLevel = 0;
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+// because the proposed solution to the optimal encoding problem has exponential complexity
+// we limit the depth of the branch and bound procedure to 5 levels
+static int s_MaxDepth = 5;      
+
+static int s_nVarsBest;          // the number of vars in the best ordering
+static int s_VarOrderBest[32];   // storing the best ordering of vars in the "simple encoding"
+static int s_VarOrderCur[32];    // storing the current ordering of vars
+ 
+// the place to store the supports of the encoded function
+static DdNode * s_Field[8][256]; // the size should be K, 2^K, where K is no less than MaxDepth
+static DdNode * s_Encoded;       // this is the original function
+static DdNode * s_VarAll;        // the set of all column variables
+static int s_MultiStart;         // the total number of encoding variables used
+// the array field now stores the supports
+
+static DdNode ** s_pbTemp;       // the temporary storage for the columns
+
+static int s_BackTracks;
+static int s_BackTrackLimit = 100;
+
+static DdNode * s_Terminal;      // the terminal value for counting minterms
+
+
+static int s_EncodingVarsLevel;
+
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+static DdNode * CreateTheCodes_rec( DdManager * dd, DdNode * bEncoded, int Level, DdNode ** pCVars );
+static void EvaluateEncodings_rec( DdManager * dd, DdNode * bVarsCol, int nVarsCol, int nMulti, int Level );
+// functions called from EvaluateEncodings_rec()
+static DdNode * ComputeVarSetAndCountMinterms( DdManager * dd, DdNode * bVars, DdNode * bVarTop, unsigned * Cost );
+static DdNode * ComputeVarSetAndCountMinterms2( DdManager * dd, DdNode * bVars, DdNode * bVarTop, unsigned * Cost );
+unsigned Extra_CountCofactorMinterms( DdManager * dd, DdNode * bFunc, DdNode * bVarsCof, DdNode * bVarsAll );
+static unsigned Extra_CountMintermsSimple( DdNode * bFunc, unsigned max );
+
+static void CountNodeVisits_rec( DdManager * dd, DdNode * aFunc, st_table * Visited );
+static void CollectNodesAndComputePaths_rec( DdManager * dd, DdNode * aFunc, DdNode * bCube, st_table * Visited, st_table * CutNodes );
+
+/**AutomaticEnd***************************************************************/
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the binary encoding of the set of function using the given vars.]
+
+  Description [Performs a straight binary encoding of the set of functions using 
+  the variable cubes formed from the given set of variables. ]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * 
+Extra_bddEncodingBinary( 
+  DdManager * dd, 
+  DdNode ** pbFuncs,    // pbFuncs is the array of columns to be encoded
+  int nFuncs,           // nFuncs is the number of columns in the array
+  DdNode ** pbVars,     // pbVars is the array of variables to use for the codes
+  int nVars )           // nVars is the column multiplicity, [log2(nFuncs)]
+{
+    int i;
+    DdNode * bResult;
+    DdNode * bCube, * bTemp, * bProd;
+
+    assert( nVars >= Extra_Base2Log(nFuncs) );
+
+    bResult = b0;   Cudd_Ref( bResult );
+    for ( i = 0; i < nFuncs; i++ )
+    {
+        bCube   = Extra_bddBitsToCube( dd, i, nVars, pbVars, 1 );   Cudd_Ref( bCube );
+        bProd   = Cudd_bddAnd( dd, bCube, pbFuncs[i] );         Cudd_Ref( bProd );
+        Cudd_RecursiveDeref( dd, bCube );
+
+        bResult = Cudd_bddOr( dd, bProd, bTemp = bResult );     Cudd_Ref( bResult );
+        Cudd_RecursiveDeref( dd, bTemp );
+        Cudd_RecursiveDeref( dd, bProd );
+    }
+
+    Cudd_Deref( bResult );
+    return bResult;
+} /* end of Extra_bddEncodingBinary */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Solves the column encoding problem using a sophisticated method.]
+
+  Description [The encoding is based on the idea of deriving functions which 
+  depend on only one variable, which corresponds to the case of non-disjoint 
+  decompostion. It is assumed that the variables pCVars are ordered below the variables
+  representing the solumns, and the first variable pCVars[0] is the topmost one.]
+
+  SideEffects []
+
+  SeeAlso     [Extra_bddEncodingBinary]
+
+******************************************************************************/
+
+DdNode * 
+Extra_bddEncodingNonStrict( 
+  DdManager * dd, 
+  DdNode ** pbColumns,   // pbColumns is the array of columns to be encoded;
+  int nColumns,          // nColumns is the number of columns in the array
+  DdNode * bVarsCol,     // bVarsCol is the cube of variables on which the columns depend
+  DdNode ** pCVars,      // pCVars is the array of variables to use for the codes
+  int nMulti,            // nMulti is the column multiplicity, [log2(nColumns)]
+  int * pSimple )        // pSimple gets the number of code variables taken from the input varibles without change
+{
+    DdNode * bEncoded, * bResult;
+    int nVarsCol = Cudd_SupportSize(dd,bVarsCol);
+    long clk;
+
+    // cannot work with more that 32-bit codes
+    assert( nMulti < 32 );
+
+    // perform the preliminary encoding using the straight binary code
+    bEncoded = Extra_bddEncodingBinary( dd, pbColumns, nColumns, pCVars, nMulti );   Cudd_Ref( bEncoded );
+    //printf( "Node count = %d", Cudd_DagSize(bEncoded) );
+
+    // set the backgroup value for counting minterms
+    s_Terminal = b0;
+    // set the level of the encoding variables
+    s_EncodingVarsLevel = dd->invperm[pCVars[0]->index];
+
+    // the current number of backtracks
+    s_BackTracks = 0;
+    // the variables that are cofactored on the topmost level where everything starts (no vars)
+    s_Field[0][0] = b1;   
+    // the size of the best set of "simple" encoding variables found so far
+    s_nVarsBest   = 0;
+
+    // set the relation to be accessible to traversal procedures
+    s_Encoded = bEncoded;
+    // the set of all vars to be accessible to traversal procedures
+    s_VarAll  = bVarsCol;
+    // the column multiplicity
+    s_MultiStart  = nMulti;
+
+
+    clk = clock();
+    // find the simplest encoding
+    if ( nColumns > 2 )
+    EvaluateEncodings_rec( dd, bVarsCol, nVarsCol, nMulti, 1 );
+//    printf( "The number of backtracks = %d\n", s_BackTracks );
+//    s_EncSearchTime += clock() - clk;
+
+    // allocate the temporary storage for the columns
+    s_pbTemp = (DdNode **) malloc( nColumns * sizeof(DdNode *) );
+
+//    clk = clock();
+    bResult = CreateTheCodes_rec( dd, bEncoded, 0, pCVars );   Cudd_Ref( bResult );
+//    s_EncComputeTime += clock() - clk;
+    
+    // delocate the preliminarily encoded set
+    Cudd_RecursiveDeref( dd, bEncoded );
+//    Cudd_RecursiveDeref( dd, aEncoded );
+
+    free( s_pbTemp );
+
+    *pSimple = s_nVarsBest;
+    Cudd_Deref( bResult );
+    return bResult;
+}
+ 
+/**Function********************************************************************
+
+  Synopsis    [Collects the nodes under the cut and, for each node, computes the sum of paths leading to it from the root.]
+
+  Description [The table returned contains the set of BDD nodes pointed to under the cut
+  and, for each node, the BDD of the sum of paths leading to this node from the root
+  The sums of paths in the table are referenced. CutLevel is the first DD level 
+  considered to be under the cut.]
+
+  SideEffects []
+
+  SeeAlso     [Extra_bddNodePaths]
+
+******************************************************************************/
+st_table * Extra_bddNodePathsUnderCut( DdManager * dd, DdNode * bFunc, int CutLevel )
+{
+    st_table * Visited;  // temporary table to remember the visited nodes
+    st_table * CutNodes; // the result goes here
+    st_table * Result; // the result goes here
+    DdNode * aFunc;
+
+    s_CutLevel = CutLevel;
+
+    Result  = st_init_table(st_ptrcmp,st_ptrhash);
+    // the terminal cases
+    if ( Cudd_IsConstant( bFunc ) )
+    {
+        if ( bFunc == b1 )
+        {
+            st_insert( Result, (char*)b1, (char*)b1 );
+            Cudd_Ref( b1 );
+            Cudd_Ref( b1 );
+        }
+        else
+        {
+            st_insert( Result, (char*)b0, (char*)b0 );
+            Cudd_Ref( b0 );
+            Cudd_Ref( b0 );
+        }
+        return Result;
+    }
+
+    // create the ADD to simplify processing (no complemented edges)
+    aFunc = Cudd_BddToAdd( dd, bFunc );   Cudd_Ref( aFunc );
+
+    // Step 1: Start the tables and collect information about the nodes above the cut 
+    // this information tells how many edges point to each node
+    Visited  = st_init_table(st_ptrcmp,st_ptrhash);
+    CutNodes = st_init_table(st_ptrcmp,st_ptrhash);
+
+    CountNodeVisits_rec( dd, aFunc, Visited );
+
+    // Step 2: Traverse the BDD using the visited table and compute the sum of paths
+    CollectNodesAndComputePaths_rec( dd, aFunc, b1, Visited, CutNodes );
+
+    // at this point the table of cut nodes is ready and the table of visited is useless
+    {
+        st_generator * gen;
+        DdNode * aNode;
+        traventry * p;
+        st_foreach_item( Visited, gen, (char**)&aNode, (char**)&p ) 
+        {
+            Cudd_RecursiveDeref( dd, p->bSum );
+            free( p );
+        }
+        st_free_table( Visited );
+    }
+
+    // go through the table CutNodes and create the BDD and the path to be returned
+    {
+        st_generator * gen;
+        DdNode * aNode, * bNode, * bSum;
+        st_foreach_item( CutNodes, gen, (char**)&aNode, (char**)&bSum) 
+        {
+            // aNode is not referenced, because aFunc is holding it
+            bNode = Cudd_addBddPattern( dd, aNode );  Cudd_Ref( bNode ); 
+            st_insert( Result, (char*)bNode, (char*)bSum );
+            // the new table takes both refs
+        }
+        st_free_table( CutNodes );
+    }
+
+    // dereference the ADD
+    Cudd_RecursiveDeref( dd, aFunc );
+
+    // return the table
+    return Result;
+
+} /* end of Extra_bddNodePathsUnderCut */
+
+/**Function********************************************************************
+
+  Synopsis    [Collects the nodes under the cut in the ADD starting from the given set of ADD nodes.]
+
+  Description [Takes the array, paNodes, of ADD nodes to start the traversal,
+  the array, pbCubes, of BDD cubes to start the traversal with in each node, 
+  and the number, nNodes, of ADD nodes and BDD cubes in paNodes and pbCubes. 
+  Returns the number of columns found. Fills in paNodesRes (pbCubesRes) 
+  with the set of ADD columns (BDD paths). These arrays should be allocated 
+  by the user.]
+
+  SideEffects []
+
+  SeeAlso     [Extra_bddNodePaths]
+
+******************************************************************************/
+int Extra_bddNodePathsUnderCutArray( DdManager * dd, DdNode ** paNodes, DdNode ** pbCubes, int nNodes, DdNode ** paNodesRes, DdNode ** pbCubesRes, int CutLevel )
+{
+    st_table * Visited;  // temporary table to remember the visited nodes
+    st_table * CutNodes; // the nodes under the cut go here
+    int i, Counter;
+
+    s_CutLevel = CutLevel;
+
+    // there should be some nodes
+    assert( nNodes > 0 );
+    if ( nNodes == 1 && Cudd_IsConstant( paNodes[0] ) )
+    {
+        if ( paNodes[0] == a1 )
+        {
+            paNodesRes[0] = a1;          Cudd_Ref( a1 );
+            pbCubesRes[0] = pbCubes[0];  Cudd_Ref( pbCubes[0] );
+        }
+        else
+        {
+            paNodesRes[0] = a0;          Cudd_Ref( a0 );
+            pbCubesRes[0] = pbCubes[0];  Cudd_Ref( pbCubes[0] );
+        }
+        return 1;
+    }
+
+    // Step 1: Start the table and collect information about the nodes above the cut 
+    // this information tells how many edges point to each node
+    CutNodes = st_init_table(st_ptrcmp,st_ptrhash);
+    Visited  = st_init_table(st_ptrcmp,st_ptrhash);
+
+    for ( i = 0; i < nNodes; i++ )
+        CountNodeVisits_rec( dd, paNodes[i], Visited );
+
+    // Step 2: Traverse the BDD using the visited table and compute the sum of paths
+    for ( i = 0; i < nNodes; i++ )
+        CollectNodesAndComputePaths_rec( dd, paNodes[i], pbCubes[i], Visited, CutNodes );
+
+    // at this point, the table of cut nodes is ready and the table of visited is useless
+    {
+        st_generator * gen;
+        DdNode * aNode;
+        traventry * p;
+        st_foreach_item( Visited, gen, (char**)&aNode, (char**)&p ) 
+        {
+            Cudd_RecursiveDeref( dd, p->bSum );
+            free( p );
+        }
+        st_free_table( Visited );
+    }
+
+    // go through the table CutNodes and create the BDD and the path to be returned
+    {
+        st_generator * gen;
+        DdNode * aNode, * bSum;
+        Counter = 0;
+        st_foreach_item( CutNodes, gen, (char**)&aNode, (char**)&bSum) 
+        {
+            paNodesRes[Counter] = aNode;   Cudd_Ref( aNode ); 
+            pbCubesRes[Counter] = bSum;
+            Counter++;
+        }
+        st_free_table( CutNodes );
+    }
+
+    // return the number of cofactors found
+    return Counter;
+
+} /* end of Extra_bddNodePathsUnderCutArray */
+
+/**Function*************************************************************
+
+  Synopsis    [Collects all the BDD nodes into the table.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void extraCollectNodes( DdNode * Func, st_table * tNodes )
+{
+    DdNode * FuncR;
+    FuncR = Cudd_Regular(Func);
+    if ( st_find_or_add( tNodes, (char*)FuncR, NULL ) )
+        return;
+    if ( cuddIsConstant(FuncR) )
+        return;
+    extraCollectNodes( cuddE(FuncR), tNodes );
+    extraCollectNodes( cuddT(FuncR), tNodes );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects all the nodes of one DD into the table.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+st_table * Extra_CollectNodes( DdNode * Func )
+{
+    st_table * tNodes;
+    tNodes = st_init_table( st_ptrcmp, st_ptrhash );
+    extraCollectNodes( Func, tNodes );
+    return tNodes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Updates the topmost level from which the given node is referenced.]
+
+  Description [Takes the table which maps each BDD nodes (including the constants)
+  into the topmost level on which this node counts as a cofactor. Takes the topmost
+  level, on which this node counts as a cofactor (see Extra_ProfileWidthFast(). 
+  Takes the node, for which the table entry should be updated.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void extraProfileUpdateTopLevel( st_table * tNodeTopRef, int TopLevelNew, DdNode * node )
+{
+    int * pTopLevel;
+
+    if ( st_find_or_add( tNodeTopRef, (char*)node, (char***)&pTopLevel ) )
+    { // the node is already referenced
+        // the current top level should be updated if it is larger than the new level
+        if ( *pTopLevel > TopLevelNew ) 
+             *pTopLevel = TopLevelNew;
+    }
+    else
+    { // the node is not referenced
+        // its level should be set to the current new level
+        *pTopLevel = TopLevelNew;
+    }
+}
+/**Function*************************************************************
+
+  Synopsis    [Fast computation of the BDD profile.]
+
+  Description [The array to store the profile is given by the user and should
+  contain at least as many entries as there is the maximum of the BDD/ZDD
+  size of the manager PLUS ONE.
+  When we say that the widths of the DD on level L is W, we mean the following.
+  Let us create the cut between the level L-1 and the level L and count the number
+  of different DD nodes pointed to across the cut. This number is the width W.
+  From this it follows the on level 0, the width is equal to the number of external
+  pointers to the considered DDs. If there is only one DD, then the profile on 
+  level 0 is always 1. If this DD is rooted in the topmost variable, then the width
+  on level 1 is always 2, etc. The width at the level equal to dd->size is the
+  number of terminal nodes in the DD. (Because we consider the first level #0
+  and the last level #dd->size, the profile array should contain dd->size+1 entries.)
+  ]
+
+  SideEffects [This procedure will not work for BDDs w/ complement edges, only for ADDs and ZDDs]
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_ProfileWidth( DdManager * dd, DdNode * Func, int * pProfile, int CutLevel )
+{
+    st_generator * gen;
+    st_table * tNodeTopRef; // this table stores the top level from which this node is pointed to
+    st_table * tNodes;
+    DdNode * node;
+    DdNode * nodeR;
+    int LevelStart, Limit;
+    int    i, size;
+    int WidthMax;
+  
+    // start the mapping table
+    tNodeTopRef = st_init_table(st_ptrcmp,st_ptrhash);
+    // add the topmost node to the profile
+    extraProfileUpdateTopLevel( tNodeTopRef, 0, Func );
+
+    // collect all nodes
+    tNodes = Extra_CollectNodes( Func );
+    // go though all the nodes and set the top level the cofactors are pointed from
+//    Cudd_ForeachNode( dd, Func, genDD, node )
+    st_foreach_item( tNodes, gen, (char**)&node, NULL )
+    {
+//        assert( Cudd_Regular(node) );  // this procedure works only with ADD/ZDD (not BDD w/ compl.edges)
+        nodeR = Cudd_Regular(node);
+        if ( cuddIsConstant(nodeR) )
+            continue;
+        // this node is not a constant - consider its cofactors
+        extraProfileUpdateTopLevel( tNodeTopRef, dd->perm[node->index]+1, cuddE(nodeR) );
+        extraProfileUpdateTopLevel( tNodeTopRef, dd->perm[node->index]+1, cuddT(nodeR) );
+    }
+    st_free_table( tNodes );
+
+    // clean the profile
+    size = ddMax(dd->size, dd->sizeZ) + 1;
+    for ( i = 0; i < size; i++ ) 
+        pProfile[i] = 0;
+
+    // create the profile
+    st_foreach_item( tNodeTopRef, gen, (char**)&node, (char**)&LevelStart )
+    {
+        nodeR = Cudd_Regular(node);
+        Limit = (cuddIsConstant(nodeR))? dd->size: dd->perm[nodeR->index];
+        for ( i = LevelStart; i <= Limit; i++ )
+            pProfile[i]++;
+    }
+
+    if ( CutLevel != -1 && CutLevel != 0  )
+        size = CutLevel;
+
+    // get the max width
+    WidthMax = 0;
+    for ( i = 0; i < size; i++ ) 
+        if ( WidthMax < pProfile[i] )
+            WidthMax = pProfile[i];
+
+    // deref the table
+    st_free_table( tNodeTopRef );
+
+    return WidthMax;
+} /* end of Extra_ProfileWidth */
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static functions                                            */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the non-strict codes when evaluation is finished.]
+
+  Description [The information about the best code is stored in s_VarOrderBest,
+  which has s_nVarsBest entries.]
+
+  SideEffects [None]
+
+******************************************************************************/
+DdNode * CreateTheCodes_rec( DdManager * dd, DdNode * bEncoded, int Level, DdNode ** pCVars )
+// bEncoded is the preliminarily encoded set of columns
+// Level is the current level in the recursion
+// pCVars are the variables to be used for encoding
+{
+    DdNode * bRes;
+    if ( Level == s_nVarsBest )
+    { // the terminal case, when we need to remap the encoded function 
+        // from the preliminary encoded variables to the new ones
+        st_table * CutNodes;
+        int nCols;
+//        double nMints;
+/*
+#ifdef _DEBUG
+
+        {
+        DdNode * bTemp;
+        // make sure that the given number of variables is enough
+        bTemp  = Cudd_bddExistAbstract( dd, bEncoded, s_VarAll );           Cudd_Ref( bTemp );
+//        nMints = Cudd_CountMinterm( dd, bTemp, s_MultiStart );
+        nMints = Extra_CountMintermsSimple( bTemp, (1<<s_MultiStart) );
+        if ( nMints > Extra_Power2( s_MultiStart-Level ) ) 
+        {  // the number of minterms is too large to encode the columns 
+           // using the given minimum number of encoding variables
+            assert( 0 );
+        }
+        Cudd_RecursiveDeref( dd, bTemp );
+        }
+#endif
+*/
+        // get the columns to be re-encoded
+        CutNodes = Extra_bddNodePathsUnderCut( dd, bEncoded, s_EncodingVarsLevel );
+        // LUT size is the cut level because because the temporary encoding variables 
+        // are above the functional variables - this is not true!!!
+        // the temporary variables are below!
+
+        // put the entries from the table into the temporary array
+        { 
+            st_generator * gen;
+            DdNode * bColumn, * bCode;
+            nCols = 0;
+            st_foreach_item( CutNodes, gen, (char**)&bCode, (char**)&bColumn ) 
+            {
+                if ( bCode == b0 )
+                { // the unused part of the columns
+                    Cudd_RecursiveDeref( dd, bColumn );
+                    Cudd_RecursiveDeref( dd, bCode );
+                    continue;
+                }
+                else
+                {
+                    s_pbTemp[ nCols ] = bColumn; // takes ref
+                    Cudd_RecursiveDeref( dd, bCode );
+                    nCols++;
+                }
+            }
+            st_free_table( CutNodes );
+//            assert( nCols == (int)nMints );
+        }
+
+        // encode the columns
+        if ( s_MultiStart-Level == 0 ) // we reached the bottom level of recursion
+        {
+            assert( nCols       == 1 );
+//            assert( (int)nMints == 1 );
+            bRes = s_pbTemp[0];     Cudd_Ref( bRes );
+        }
+        else
+        {
+            bRes = Extra_bddEncodingBinary( dd, s_pbTemp, nCols, pCVars+Level, s_MultiStart-Level ); Cudd_Ref( bRes );
+        }
+
+        // deref the columns
+        {
+            int i;
+            for ( i = 0; i < nCols; i++ )
+                Cudd_RecursiveDeref( dd, s_pbTemp[i] );
+        }
+    }
+    else
+    {
+        // cofactor the problem as specified in the best solution
+        DdNode * bCof0,  * bCof1;
+        DdNode * bRes0,  * bRes1;
+        DdNode * bProd0, * bProd1;
+        DdNode * bTemp;
+        DdNode * bVarNext = dd->vars[ s_VarOrderBest[Level] ];
+
+        bCof0  = Cudd_Cofactor( dd, bEncoded,  Cudd_Not( bVarNext ) );   Cudd_Ref( bCof0 );
+        bCof1  = Cudd_Cofactor( dd, bEncoded,            bVarNext   );   Cudd_Ref( bCof1 );
+
+        // call recursively
+        bRes0 = CreateTheCodes_rec( dd, bCof0, Level+1, pCVars );  Cudd_Ref( bRes0 );
+        bRes1 = CreateTheCodes_rec( dd, bCof1, Level+1, pCVars );  Cudd_Ref( bRes1 );
+
+        Cudd_RecursiveDeref( dd, bCof0 );
+        Cudd_RecursiveDeref( dd, bCof1 );
+
+        // compose the result using the identity (bVarNext <=> pCVars[Level])  - this is wrong!
+        // compose the result as follows: x'y'F0 + xyF1
+        bProd0 = Cudd_bddAnd( dd, Cudd_Not(bVarNext), Cudd_Not(pCVars[Level]) );   Cudd_Ref( bProd0 );
+        bProd1 = Cudd_bddAnd( dd,          bVarNext ,          pCVars[Level]  );   Cudd_Ref( bProd1 );
+
+        bProd0 = Cudd_bddAnd( dd, bTemp = bProd0, bRes0 );   Cudd_Ref( bProd0 );
+        Cudd_RecursiveDeref( dd, bTemp );
+        Cudd_RecursiveDeref( dd, bRes0 );
+
+        bProd1 = Cudd_bddAnd( dd, bTemp = bProd1, bRes1 );   Cudd_Ref( bProd1 );
+        Cudd_RecursiveDeref( dd, bTemp );
+        Cudd_RecursiveDeref( dd, bRes1 );
+
+        bRes = Cudd_bddOr( dd, bProd0, bProd1 );             Cudd_Ref( bRes );
+
+        Cudd_RecursiveDeref( dd, bProd0 );
+        Cudd_RecursiveDeref( dd, bProd1 );
+    }
+    Cudd_Deref( bRes );
+    return bRes;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the current set of variables and counts the number of minterms.]
+
+  Description [Old implementation.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void EvaluateEncodings_rec( DdManager * dd, DdNode * bVarsCol, int nVarsCol, int nMulti, int Level )
+// bVarsCol is the set of remaining variables
+// nVarsCol is the number of remaining variables
+// nMulti is the number of encoding variables to be used
+// Level is the level of recursion, from which this function is called
+// if we successfully finish this procedure, Level also stands for how many encoding variabled we saved
+{
+    int i, k;
+    int nEntries = (1<<(Level-1)); // the number of entries in the field of the previous level
+    DdNode * bVars0, * bVars1; // the cofactors
+    unsigned nMint0, nMint1;   // the number of minterms
+    DdNode * bTempV;
+    DdNode * bVarTop;
+    int fBreak;
+
+
+    // there is no need to search above this level
+    if ( Level > s_MaxDepth )
+        return;
+
+    // if there are no variables left, quit the research
+    if ( bVarsCol == b1 )
+        return;
+
+    if ( s_BackTracks > s_BackTrackLimit )
+        return;
+
+    s_BackTracks++;
+
+    // otherwise, go through the remaining variables
+    for ( bTempV = bVarsCol; bTempV != b1; bTempV = cuddT(bTempV) )
+    {
+        // the currently tested variable
+        bVarTop = dd->vars[bTempV->index];
+
+        // put it into the array
+        s_VarOrderCur[Level-1] = bTempV->index;
+
+        // go through the entries and fill them out by cofactoring
+        fBreak = 0;
+        for ( i = 0; i < nEntries; i++ )
+        {
+            bVars0 = ComputeVarSetAndCountMinterms( dd, s_Field[Level-1][i], Cudd_Not(bVarTop), &nMint0 );
+            Cudd_Ref( bVars0 );
+
+            if ( nMint0 > Extra_Power2( nMulti-1 ) ) 
+            {
+                // there is no way to encode - dereference and return
+                Cudd_RecursiveDeref( dd, bVars0 );
+                fBreak = 1;
+                break;
+            }
+
+            bVars1 = ComputeVarSetAndCountMinterms( dd, s_Field[Level-1][i], bVarTop, &nMint1 );
+            Cudd_Ref( bVars1 );
+
+            if ( nMint1 > Extra_Power2( nMulti-1 ) ) 
+            {
+                // there is no way to encode - dereference and return
+                Cudd_RecursiveDeref( dd, bVars0 );
+                Cudd_RecursiveDeref( dd, bVars1 );
+                fBreak = 1;
+                break;
+            }
+
+            // otherwise, add these two cofactors
+            s_Field[Level][2*i + 0] = bVars0; // takes ref
+            s_Field[Level][2*i + 1] = bVars1; // takes ref
+        } 
+
+        if ( !fBreak )
+        {
+            DdNode * bVarsRem;
+            // if we ended up here, it means that the cofactors w.r.t. variable bVarTop satisfy the condition
+            // save this situation
+            if ( s_nVarsBest < Level )
+            {
+                s_nVarsBest = Level;
+                // copy the variable assignment
+                for ( k = 0; k < Level; k++ )
+                    s_VarOrderBest[k] = s_VarOrderCur[k];
+            }
+
+            // call recursively
+            // get the new variable set
+            if ( nMulti-1 > 0 )
+            {
+                bVarsRem = Cudd_bddExistAbstract( dd, bVarsCol, bVarTop );   Cudd_Ref( bVarsRem );
+                EvaluateEncodings_rec( dd, bVarsRem, nVarsCol-1, nMulti-1, Level+1 );
+                Cudd_RecursiveDeref( dd, bVarsRem );
+            }
+        }
+
+        // deref the contents of the array
+        for ( k = 0; k < i; k++ )
+        {
+            Cudd_RecursiveDeref( dd, s_Field[Level][2*k + 0] );
+            Cudd_RecursiveDeref( dd, s_Field[Level][2*k + 1] );
+        }
+
+        // if the solution is found, there is no need to continue
+        if ( s_nVarsBest == s_MaxDepth )
+            return;
+
+        // if the solution is found, there is no need to continue
+        if ( s_nVarsBest == s_MultiStart )
+            return;
+    }
+    // at this point, we have tried all possible directions in the space of variables
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the current set of variables and counts the number of minterms.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * ComputeVarSetAndCountMinterms( DdManager * dd, DdNode * bVars, DdNode * bVarTop, unsigned * Cost )
+// takes bVars - the variables cofactored so far (some of them may be in negative polarity)
+// bVarTop - the topmost variable w.r.t. which to cofactor (may be in negative polarity)
+// returns the cost and the new set of variables (bVars & bVarTop)
+{
+    DdNode * bVarsRes;
+
+    // get the resulting set of variables
+    bVarsRes = Cudd_bddAnd( dd, bVars, bVarTop );  Cudd_Ref( bVarsRes );
+
+    // increment signature before calling Cudd_CountCofactorMinterms()
+    s_Signature++;
+    *Cost = Extra_CountCofactorMinterms( dd, s_Encoded, bVarsRes, s_VarAll );
+
+    Cudd_Deref( bVarsRes );
+//    s_CountCalls++;
+    return bVarsRes;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the current set of variables and counts the number of minterms.]
+
+  Description [The old implementation, which is approximately 4 times slower.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * ComputeVarSetAndCountMinterms2( DdManager * dd, DdNode * bVars, DdNode * bVarTop, unsigned * Cost )
+{
+    DdNode * bVarsRes;
+    DdNode * bCof, * bFun;
+
+    bVarsRes = Cudd_bddAnd( dd, bVars, bVarTop );             Cudd_Ref( bVarsRes );
+
+    bCof  = Cudd_Cofactor( dd, s_Encoded,  bVarsRes );        Cudd_Ref( bCof );
+    bFun  = Cudd_bddExistAbstract( dd, bCof, s_VarAll );      Cudd_Ref( bFun );
+    *Cost = (unsigned)Cudd_CountMinterm( dd, bFun, s_MultiStart );
+    Cudd_RecursiveDeref( dd, bFun );
+    Cudd_RecursiveDeref( dd, bCof );
+
+    Cudd_Deref( bVarsRes );
+//    s_CountCalls++;
+    return bVarsRes;
+}
+
+
+/**Function********************************************************************
+
+  Synopsis    [Counts the number of encoding minterms pointed to by the cofactor of the function.]
+
+  Description []
+
+  SideEffects [None]
+
+******************************************************************************/
+unsigned Extra_CountCofactorMinterms( DdManager * dd, DdNode * bFunc, DdNode * bVarsCof, DdNode * bVarsAll )
+// this function computes how many minterms depending on the encoding variables
+// are there in the cofactor of bFunc w.r.t. variables bVarsCof
+// bFunc is assumed to depend on variables s_VarsAll
+// the variables s_VarsAll should be ordered above the encoding variables
+{
+    unsigned HKey;
+    DdNode * bFuncR;
+
+    // if the function is zero, there are no minterms
+//    if ( bFunc == b0 )
+//        return 0;
+
+//    if ( st_lookup(Visited, (char*)bFunc, NULL) )
+//        return 0;
+
+//    HKey = hashKey2c( s_Signature, bFuncR );
+//    if ( HHTable1[HKey].Sign == s_Signature && HHTable1[HKey].Arg1 == bFuncR ) // this node is visited
+//        return 0;
+
+
+    // check the hash-table 
+    bFuncR = Cudd_Regular(bFunc);
+//    HKey = hashKey2( s_Signature, bFuncR, _TABLESIZE_COF );
+    HKey = hashKey2( s_Signature, bFunc, _TABLESIZE_COF );
+    for ( ;  HHTable1[HKey].Sign == s_Signature; HKey = (HKey+1) % _TABLESIZE_COF )
+//        if ( HHTable1[HKey].Arg1 == bFuncR ) // this node is visited
+        if ( HHTable1[HKey].Arg1 == bFunc ) // this node is visited
+            return 0;
+
+
+    // if the function is already the code
+    if ( dd->perm[bFuncR->index] >= s_EncodingVarsLevel )
+    {
+//        st_insert(Visited, (char*)bFunc, NULL);
+
+//        HHTable1[HKey].Sign = s_Signature;
+//        HHTable1[HKey].Arg1 = bFuncR;
+
+        assert( HHTable1[HKey].Sign != s_Signature );
+        HHTable1[HKey].Sign = s_Signature;
+//        HHTable1[HKey].Arg1 = bFuncR;
+        HHTable1[HKey].Arg1 = bFunc;
+
+        return Extra_CountMintermsSimple( bFunc, (1<<s_MultiStart) );
+    }
+    else
+    {
+        DdNode * bFunc0,    * bFunc1;
+        DdNode * bVarsCof0, * bVarsCof1;
+        DdNode * bVarsCofR = Cudd_Regular(bVarsCof);
+        unsigned Res;
+
+        // get the levels
+        int LevelF = dd->perm[bFuncR->index];
+        int LevelC = cuddI(dd,bVarsCofR->index);
+        int LevelA = dd->perm[bVarsAll->index];
+
+        int LevelTop = LevelF;
+
+        if ( LevelTop > LevelC )
+             LevelTop = LevelC;
+
+        if ( LevelTop > LevelA )
+             LevelTop = LevelA;
+
+        // the top var in the function or in cofactoring vars always belongs to the set of all vars
+        assert( !( LevelTop == LevelF || LevelTop == LevelC ) || LevelTop == LevelA );
+
+        // cofactor the function
+        if ( LevelTop == LevelF )
+        {
+            if ( bFuncR != bFunc ) // bFunc is complemented 
+            {
+                bFunc0 = Cudd_Not( cuddE(bFuncR) );
+                bFunc1 = Cudd_Not( cuddT(bFuncR) );
+            }
+            else
+            {
+                bFunc0 = cuddE(bFuncR);
+                bFunc1 = cuddT(bFuncR);
+            }
+        }
+        else // bVars is higher in the variable order 
+            bFunc0 = bFunc1 = bFunc;
+
+        // cofactor the cube
+        if ( LevelTop == LevelC )
+        {
+            if ( bVarsCofR != bVarsCof ) // bFunc is complemented 
+            {
+                bVarsCof0 = Cudd_Not( cuddE(bVarsCofR) );
+                bVarsCof1 = Cudd_Not( cuddT(bVarsCofR) );
+            }
+            else
+            {
+                bVarsCof0 = cuddE(bVarsCofR);
+                bVarsCof1 = cuddT(bVarsCofR);
+            }
+        }
+        else // bVars is higher in the variable order 
+            bVarsCof0 = bVarsCof1 = bVarsCof;
+
+        // there are two cases: 
+        // (1) the top variable belongs to the cofactoring variables
+        // (2) the top variable does not belong to the cofactoring variables
+
+        // (1) the top variable belongs to the cofactoring variables
+        Res = 0;
+        if ( LevelTop == LevelC )
+        {
+            if ( bVarsCof1 == b0 ) // this is a negative cofactor
+            {
+                if ( bFunc0 != b0 )
+                Res = Extra_CountCofactorMinterms( dd, bFunc0, bVarsCof0, cuddT(bVarsAll) );
+            }
+            else                        // this is a positive cofactor
+            {
+                if ( bFunc1 != b0 )
+                Res = Extra_CountCofactorMinterms( dd, bFunc1, bVarsCof1, cuddT(bVarsAll) );
+            }
+        }
+        else
+        {
+            if ( bFunc0 != b0 )
+            Res += Extra_CountCofactorMinterms( dd, bFunc0, bVarsCof0, cuddT(bVarsAll) );
+            
+            if ( bFunc1 != b0 )
+            Res += Extra_CountCofactorMinterms( dd, bFunc1, bVarsCof1, cuddT(bVarsAll) );
+        }
+
+//        st_insert(Visited, (char*)bFunc, NULL);
+
+//        HHTable1[HKey].Sign = s_Signature;
+//        HHTable1[HKey].Arg1 = bFuncR;
+
+        // skip through the entries with the same signatures 
+        // (these might have been created at the time of recursive calls)
+        for ( ; HHTable1[HKey].Sign == s_Signature; HKey = (HKey+1) % _TABLESIZE_COF );
+        assert( HHTable1[HKey].Sign != s_Signature );
+        HHTable1[HKey].Sign = s_Signature;
+//        HHTable1[HKey].Arg1 = bFuncR;
+        HHTable1[HKey].Arg1 = bFunc;
+
+        return Res;
+    }
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Counts the number of minterms.]
+
+  Description [This function counts minterms for functions up to 32 variables
+  using a local cache. The terminal value (s_Termina) should be adjusted for
+  BDDs and ADDs.]
+
+  SideEffects [None]
+
+******************************************************************************/
+unsigned Extra_CountMintermsSimple( DdNode * bFunc, unsigned max )
+{
+    unsigned HKey;
+
+    // normalize
+    if ( Cudd_IsComplement(bFunc) )
+        return max - Extra_CountMintermsSimple( Cudd_Not(bFunc), max );
+
+    // now it is known that the function is not complemented
+    if ( cuddIsConstant(bFunc) )
+        return ((bFunc==s_Terminal)? 0: max);
+
+    // check cache
+    HKey = hashKey2( bFunc, max, _TABLESIZE_MINT );
+    if ( HHTable2[HKey].Arg1 == bFunc && HHTable2[HKey].Arg2 == max )
+        return HHTable2[HKey].Res;
+    else
+    {
+        // min = min0/2 + min1/2;
+        unsigned min = (Extra_CountMintermsSimple( cuddE(bFunc), max ) >> 1) +
+                       (Extra_CountMintermsSimple( cuddT(bFunc), max ) >> 1);
+
+        HHTable2[HKey].Arg1 = bFunc;
+        HHTable2[HKey].Arg2 = max;
+        HHTable2[HKey].Res  = min;
+
+        return min;
+    }
+}    /* end of Extra_CountMintermsSimple */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Visits the nodes.]
+
+  Description [Visits the nodes above the cut and the nodes pointed to below the cut;
+  collects the visited nodes, counts how many times each node is visited, and sets 
+  the path-sum to be the constant zero BDD.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void CountNodeVisits_rec( DdManager * dd, DdNode * aFunc, st_table * Visited )
+
+{
+    traventry * p;
+    char **slot;
+    if ( st_find_or_add(Visited, (char*)aFunc, &slot) )
+    { // the entry already exists
+        p = (traventry*) *slot;
+        // increment the counter of incoming edges
+        p->nEdges++;
+        return; 
+    }
+    // this node has not been visited
+    assert( !Cudd_IsComplement(aFunc) );
+
+    // create the new traversal entry
+    p = (traventry *) malloc( sizeof(traventry) );
+    // set the initial sum of edges to zero BDD
+    p->bSum = b0;   Cudd_Ref( b0 );
+    // set the starting number of incoming edges
+    p->nEdges = 1;
+    // set this entry into the slot
+    *slot = (char*)p;
+
+    // recur if the node is above the cut
+    if ( cuddI(dd,aFunc->index) < s_CutLevel )
+    {
+        CountNodeVisits_rec( dd, cuddE(aFunc), Visited );
+        CountNodeVisits_rec( dd, cuddT(aFunc), Visited );
+    }
+} /* end of CountNodeVisits_rec */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Revisits the nodes and computes the paths.]
+
+  Description [This function visits the nodes above the cut having the goal of 
+  summing all the incomming BDD edges; when this function comes across the node 
+  below the cut, it saves this node in the CutNode table.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void CollectNodesAndComputePaths_rec( DdManager * dd, DdNode * aFunc, DdNode * bCube, st_table * Visited, st_table * CutNodes )
+{    
+    // find the node in the visited table
+    DdNode * bTemp;
+    traventry * p;
+    char **slot;
+    if ( st_find_or_add(Visited, (char*)aFunc, &slot) )
+    { // the node is found
+        // get the pointer to the traversal entry
+        p = (traventry*) *slot;
+
+        // make sure that the counter of incoming edges is positive
+        assert( p->nEdges > 0 );
+
+        // add the cube to the currently accumulated cubes
+        p->bSum = Cudd_bddOr( dd, bTemp = p->bSum, bCube );  Cudd_Ref( p->bSum );
+        Cudd_RecursiveDeref( dd, bTemp );
+
+        // decrement the number of visits
+        p->nEdges--;
+
+        // if more visits to this node are expected, return
+        if ( p->nEdges ) 
+            return;
+        else // if ( p->nEdges == 0 )
+        { // this is the last visit - propagate the cube
+
+            // check where this node is
+            if ( cuddI(dd,aFunc->index) < s_CutLevel )
+            { // the node is above the cut
+                DdNode * bCube0, * bCube1;
+
+                // get the top-most variable
+                DdNode * bVarTop = dd->vars[aFunc->index];
+
+                // compute the propagated cubes
+                bCube0 = Cudd_bddAnd( dd, p->bSum, Cudd_Not( bVarTop ) );   Cudd_Ref( bCube0 );
+                bCube1 = Cudd_bddAnd( dd, p->bSum,           bVarTop   );   Cudd_Ref( bCube1 );
+
+                // call recursively
+                CollectNodesAndComputePaths_rec( dd, cuddE(aFunc), bCube0, Visited, CutNodes );
+                CollectNodesAndComputePaths_rec( dd, cuddT(aFunc), bCube1, Visited, CutNodes );
+
+                // dereference the cubes
+                Cudd_RecursiveDeref( dd, bCube0 );
+                Cudd_RecursiveDeref( dd, bCube1 );
+                return;
+            }
+            else
+            { // the node is below the cut
+                // add this node to the cut node table, if it is not yet there
+
+//                DdNode * bNode;
+//                bNode = Cudd_addBddPattern( dd, aFunc );  Cudd_Ref( bNode );
+                if ( st_find_or_add(CutNodes, (char*)aFunc, &slot) )
+                { // the node exists - should never happen
+                    assert( 0 );
+                }
+                *slot = (char*) p->bSum;   Cudd_Ref( p->bSum );
+                // the table takes the reference of bNode
+                return;
+            }
+        }
+    }
+
+    // the node does not exist in the visited table - should never happen
+    assert(0);
+
+} /* end of CollectNodesAndComputePaths_rec */
+
+
+
+////////////////////////////////////////////////////////////////////////
+///                           END OF FILE                            ///
+////////////////////////////////////////////////////////////////////////
diff --git a/src/misc/extra/extraBddKmap.c b/src/misc/extra/extraBddKmap.c
new file mode 100644
index 00000000..bb43db68
--- /dev/null
+++ b/src/misc/extra/extraBddKmap.c
@@ -0,0 +1,783 @@
+/**CFile****************************************************************
+
+  FileName    [extraBddKmap.c]
+
+  PackageName [extra]
+
+  Synopsis    [Visualizing the K-map.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 2.0. Started - September 1, 2003.]
+
+  Revision    [$Id: extraBddKmap.c,v 1.0 2003/05/21 18:03:50 alanmi Exp $]
+
+***********************************************************************/
+
+///      K-map visualization using pseudo graphics      ///
+///       Version 1.0. Started - August 20, 2000        ///
+///     Version 2.0. Added to EXTRA - July 17, 2001     ///
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+// the maximum number of variables in the Karnaugh Map
+#define MAXVARS 20
+
+/*
+// single line
+#define SINGLE_VERTICAL     (char)179
+#define SINGLE_HORIZONTAL   (char)196
+#define SINGLE_TOP_LEFT     (char)218
+#define SINGLE_TOP_RIGHT    (char)191
+#define SINGLE_BOT_LEFT     (char)192
+#define SINGLE_BOT_RIGHT    (char)217
+
+// double line
+#define DOUBLE_VERTICAL     (char)186
+#define DOUBLE_HORIZONTAL   (char)205
+#define DOUBLE_TOP_LEFT     (char)201
+#define DOUBLE_TOP_RIGHT    (char)187
+#define DOUBLE_BOT_LEFT     (char)200
+#define DOUBLE_BOT_RIGHT    (char)188
+
+// line intersections
+#define SINGLES_CROSS       (char)197
+#define DOUBLES_CROSS       (char)206
+#define S_HOR_CROSS_D_VER   (char)215
+#define S_VER_CROSS_D_HOR   (char)216
+
+// single line joining
+#define S_JOINS_S_VER_LEFT  (char)180
+#define S_JOINS_S_VER_RIGHT (char)195
+#define S_JOINS_S_HOR_TOP   (char)193
+#define S_JOINS_S_HOR_BOT   (char)194
+
+// double line joining
+#define D_JOINS_D_VER_LEFT  (char)185
+#define D_JOINS_D_VER_RIGHT (char)204
+#define D_JOINS_D_HOR_TOP   (char)202
+#define D_JOINS_D_HOR_BOT   (char)203
+
+// single line joining double line
+#define S_JOINS_D_VER_LEFT  (char)182
+#define S_JOINS_D_VER_RIGHT (char)199
+#define S_JOINS_D_HOR_TOP   (char)207
+#define S_JOINS_D_HOR_BOT   (char)209
+*/
+
+// single line
+#define SINGLE_VERTICAL     (char)'|'
+#define SINGLE_HORIZONTAL   (char)'-'
+#define SINGLE_TOP_LEFT     (char)'+'
+#define SINGLE_TOP_RIGHT    (char)'+'
+#define SINGLE_BOT_LEFT     (char)'+'
+#define SINGLE_BOT_RIGHT    (char)'+'
+
+// double line
+#define DOUBLE_VERTICAL     (char)'|'
+#define DOUBLE_HORIZONTAL   (char)'-'
+#define DOUBLE_TOP_LEFT     (char)'+'
+#define DOUBLE_TOP_RIGHT    (char)'+'
+#define DOUBLE_BOT_LEFT     (char)'+'
+#define DOUBLE_BOT_RIGHT    (char)'+'
+
+// line intersections
+#define SINGLES_CROSS       (char)'+'
+#define DOUBLES_CROSS       (char)'+'
+#define S_HOR_CROSS_D_VER   (char)'+'
+#define S_VER_CROSS_D_HOR   (char)'+'
+
+// single line joining
+#define S_JOINS_S_VER_LEFT  (char)'+'
+#define S_JOINS_S_VER_RIGHT (char)'+'
+#define S_JOINS_S_HOR_TOP   (char)'+'
+#define S_JOINS_S_HOR_BOT   (char)'+'
+
+// double line joining
+#define D_JOINS_D_VER_LEFT  (char)'+'
+#define D_JOINS_D_VER_RIGHT (char)'+'
+#define D_JOINS_D_HOR_TOP   (char)'+'
+#define D_JOINS_D_HOR_BOT   (char)'+'
+
+// single line joining double line
+#define S_JOINS_D_VER_LEFT  (char)'+'
+#define S_JOINS_D_VER_RIGHT (char)'+'
+#define S_JOINS_D_HOR_TOP   (char)'+'
+#define S_JOINS_D_HOR_BOT   (char)'+'
+
+
+// other symbols
+#define UNDERSCORE          (char)95
+//#define SYMBOL_ZERO       (char)248   // degree sign
+//#define SYMBOL_ZERO         (char)'o'
+#define SYMBOL_ZERO         (char)' '
+#define SYMBOL_ONE          (char)'1'
+#define SYMBOL_DC           (char)'-'
+#define SYMBOL_OVERLAP      (char)'?'
+
+// full cells and half cells
+#define CELL_FREE           (char)32
+#define CELL_FULL           (char)219
+#define HALF_UPPER          (char)223
+#define HALF_LOWER          (char)220
+#define HALF_LEFT           (char)221
+#define HALF_RIGHT          (char)222
+
+
+/*---------------------------------------------------------------------------*/
+/* Structure declarations                                                    */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+// the array of BDD variables used internally
+static DdNode * s_XVars[MAXVARS];
+
+// flag which determines where the horizontal variable names are printed
+static int fHorizontalVarNamesPrintedAbove = 1;
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+// Oleg's way of generating the gray code
+static int GrayCode( int BinCode );
+static int BinCode ( int GrayCode );
+
+/**AutomaticEnd***************************************************************/
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+
+/**Function********************************************************************
+
+  Synopsis    [Prints the K-map of the function.]
+
+  Description [If the pointer to the array of variables XVars is NULL,
+               fSuppType determines how the support will be determined.
+               fSuppType == 0 -- takes the first nVars of the manager
+               fSuppType == 1 -- takes the topmost nVars of the manager
+               fSuppType == 2 -- determines support from the on-set and the offset
+               ]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_PrintKMap( 
+  FILE * Output,  /* the output stream */
+  DdManager * dd, 
+  DdNode * OnSet, 
+  DdNode * OffSet, 
+  int nVars, 
+  DdNode ** XVars, 
+  int fSuppType, /* the flag which determines how support is computed */
+  char ** pVarNames )
+{
+    int d, p, n, s, v, h, w;
+    int nVarsVer;
+    int nVarsHor;
+    int nCellsVer;
+    int nCellsHor;
+    int nSkipSpaces;
+
+    // make sure that on-set and off-set do not overlap
+    if ( !Cudd_bddLeq( dd, OnSet, Cudd_Not(OffSet) ) )
+    {
+        fprintf( Output, "PrintKMap(): The on-set and the off-set overlap\n" );
+        return;
+    }
+/*
+    if ( OnSet == b1 )
+    {
+        fprintf( Output, "PrintKMap(): Constant 1\n" );
+        return;
+    }
+    if ( OffSet == b1 )
+    {
+        fprintf( Output, "PrintKMap(): Constant 0\n" );
+        return;
+    }
+*/
+    if ( nVars < 0 || nVars > MAXVARS )
+    {
+        fprintf( Output, "PrintKMap(): The number of variables is less than zero or more than %d\n", MAXVARS );
+        return;
+    }
+
+    // determine the support if it is not given
+    if ( XVars == NULL )
+    {
+        if ( fSuppType == 0 )
+        {   // assume that the support includes the first nVars of the manager
+            assert( nVars );
+            for ( v = 0; v < nVars; v++ )
+                s_XVars[v] = Cudd_bddIthVar( dd, v );
+        }
+        else if ( fSuppType == 1 )
+        {   // assume that the support includes the topmost nVars of the manager
+            assert( nVars );
+            for ( v = 0; v < nVars; v++ )
+                s_XVars[v] = Cudd_bddIthVar( dd, dd->invperm[v] );
+        }
+        else // determine the support
+        {
+            DdNode * SuppOn, * SuppOff, * Supp;
+            int cVars = 0;
+            DdNode * TempSupp;
+
+            // determine support
+            SuppOn = Cudd_Support( dd, OnSet );         Cudd_Ref( SuppOn );
+            SuppOff = Cudd_Support( dd, OffSet );       Cudd_Ref( SuppOff );
+            Supp = Cudd_bddAnd( dd, SuppOn, SuppOff );  Cudd_Ref( Supp );
+            Cudd_RecursiveDeref( dd, SuppOn );
+            Cudd_RecursiveDeref( dd, SuppOff );
+
+            nVars = Cudd_SupportSize( dd, Supp );
+            if ( nVars > MAXVARS )
+            {
+                fprintf( Output, "PrintKMap(): The number of variables is more than %d\n", MAXVARS );
+                Cudd_RecursiveDeref( dd, Supp );
+                return;
+            }
+
+            // assign variables
+            for ( TempSupp = Supp; TempSupp != dd->one; TempSupp = Cudd_T(TempSupp), cVars++ )
+                s_XVars[cVars] = Cudd_bddIthVar( dd, TempSupp->index );
+
+            Cudd_RecursiveDeref( dd, TempSupp );
+        }
+    }
+    else
+    {
+        // copy variables
+        assert( XVars );
+        for ( v = 0; v < nVars; v++ )
+            s_XVars[v] = XVars[v];
+    }
+
+    ////////////////////////////////////////////////////////////////////
+    // determine the Karnaugh map parameters
+    nVarsVer = nVars/2;
+    nVarsHor = nVars - nVarsVer;
+    nCellsVer = (1<<nVarsVer);
+    nCellsHor = (1<<nVarsHor);
+    nSkipSpaces = nVarsVer + 1;
+
+    ////////////////////////////////////////////////////////////////////
+    // print variable names
+    fprintf( Output, "\n" );
+    for ( w = 0; w < nVarsVer; w++ )
+        if ( pVarNames == NULL )
+            fprintf( Output, "%c", 'a'+nVarsHor+w );
+        else
+            fprintf( Output, " %s", pVarNames[nVarsHor+w] );
+
+    if ( fHorizontalVarNamesPrintedAbove )
+    {
+        fprintf( Output, " \\ " );
+        for ( w = 0; w < nVarsHor; w++ )
+            if ( pVarNames == NULL )
+                fprintf( Output, "%c", 'a'+w );
+            else
+                fprintf( Output, "%s ", pVarNames[w] );
+    }
+    fprintf( Output, "\n" );
+
+    if ( fHorizontalVarNamesPrintedAbove )
+    {
+        ////////////////////////////////////////////////////////////////////
+        // print horizontal digits
+        for ( d = 0; d < nVarsHor; d++ )
+        {
+            for ( p = 0; p < nSkipSpaces + 2; p++, fprintf( Output, " " ) );
+            for ( n = 0; n < nCellsHor; n++ )
+                if ( GrayCode(n) & (1<<(nVarsHor-1-d)) )
+                    fprintf( Output, "1   " );
+                else
+                    fprintf( Output, "0   " );
+            fprintf( Output, "\n" );
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////
+    // print the upper line
+    for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+    fprintf( Output, "%c", DOUBLE_TOP_LEFT );
+    for ( s = 0; s < nCellsHor; s++ )
+    {
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        if ( s != nCellsHor-1 )
+            if ( s&1 )
+                fprintf( Output, "%c", D_JOINS_D_HOR_BOT );
+            else
+                fprintf( Output, "%c", S_JOINS_D_HOR_BOT );
+    }
+    fprintf( Output, "%c", DOUBLE_TOP_RIGHT );
+    fprintf( Output, "\n" );
+
+    ////////////////////////////////////////////////////////////////////
+    // print the map
+    for ( v = 0; v < nCellsVer; v++ )
+    {
+        DdNode * CubeVerBDD;
+
+        // print horizontal digits
+//      for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+        for ( n = 0; n < nVarsVer; n++ )
+            if ( GrayCode(v) & (1<<(nVarsVer-1-n)) )
+                fprintf( Output, "1" );
+            else
+                fprintf( Output, "0" );
+        fprintf( Output, " " );
+
+        // find vertical cube
+        CubeVerBDD = Extra_bddBitsToCube( dd, GrayCode(v), nVarsVer, s_XVars+nVarsHor, 1 );    Cudd_Ref( CubeVerBDD );
+
+        // print text line
+        fprintf( Output, "%c", DOUBLE_VERTICAL );
+        for ( h = 0; h < nCellsHor; h++ )
+        {
+            DdNode * CubeHorBDD, * Prod, * ValueOnSet, * ValueOffSet;
+
+            fprintf( Output, " " );
+//          fprintf( Output, "x" );
+            ///////////////////////////////////////////////////////////////
+            // determine what should be printed
+            CubeHorBDD  = Extra_bddBitsToCube( dd, GrayCode(h), nVarsHor, s_XVars, 1 );    Cudd_Ref( CubeHorBDD );
+            Prod = Cudd_bddAnd( dd, CubeHorBDD, CubeVerBDD );                   Cudd_Ref( Prod );
+            Cudd_RecursiveDeref( dd, CubeHorBDD );
+
+            ValueOnSet  = Cudd_Cofactor( dd, OnSet, Prod );                     Cudd_Ref( ValueOnSet );
+            ValueOffSet = Cudd_Cofactor( dd, OffSet, Prod );                    Cudd_Ref( ValueOffSet );
+            Cudd_RecursiveDeref( dd, Prod );
+
+            if ( ValueOnSet == b1 && ValueOffSet == b0 )
+                fprintf( Output, "%c", SYMBOL_ONE );
+            else if ( ValueOnSet == b0 && ValueOffSet == b1 )
+                fprintf( Output, "%c", SYMBOL_ZERO );
+            else if ( ValueOnSet == b0 && ValueOffSet == b0 ) 
+                fprintf( Output, "%c", SYMBOL_DC );
+            else if ( ValueOnSet == b1 && ValueOffSet == b1 ) 
+                fprintf( Output, "%c", SYMBOL_OVERLAP );
+            else
+                assert(0);
+
+            Cudd_RecursiveDeref( dd, ValueOnSet );
+            Cudd_RecursiveDeref( dd, ValueOffSet );
+            ///////////////////////////////////////////////////////////////
+            fprintf( Output, " " );
+
+            if ( h != nCellsHor-1 )
+                if ( h&1 )
+                    fprintf( Output, "%c", DOUBLE_VERTICAL );
+                else
+                    fprintf( Output, "%c", SINGLE_VERTICAL );
+        }
+        fprintf( Output, "%c", DOUBLE_VERTICAL );
+        fprintf( Output, "\n" );
+
+        Cudd_RecursiveDeref( dd, CubeVerBDD );
+
+        if ( v != nCellsVer-1 )
+        // print separator line
+        {
+            for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+            if ( v&1 )
+            {
+                fprintf( Output, "%c", D_JOINS_D_VER_RIGHT );
+                for ( s = 0; s < nCellsHor; s++ )
+                {
+                    fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+                    fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+                    fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+                    if ( s != nCellsHor-1 )
+                        if ( s&1 )
+                            fprintf( Output, "%c", DOUBLES_CROSS );
+                        else
+                            fprintf( Output, "%c", S_VER_CROSS_D_HOR );
+                }
+                fprintf( Output, "%c", D_JOINS_D_VER_LEFT );
+            }
+            else
+            {
+                fprintf( Output, "%c", S_JOINS_D_VER_RIGHT );
+                for ( s = 0; s < nCellsHor; s++ )
+                {
+                    fprintf( Output, "%c", SINGLE_HORIZONTAL );
+                    fprintf( Output, "%c", SINGLE_HORIZONTAL );
+                    fprintf( Output, "%c", SINGLE_HORIZONTAL );
+                    if ( s != nCellsHor-1 )
+                        if ( s&1 )
+                            fprintf( Output, "%c", S_HOR_CROSS_D_VER );
+                        else
+                            fprintf( Output, "%c", SINGLES_CROSS );
+                }
+                fprintf( Output, "%c", S_JOINS_D_VER_LEFT );
+            }
+            fprintf( Output, "\n" );
+        }
+    }
+    
+    ////////////////////////////////////////////////////////////////////
+    // print the lower line
+    for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+    fprintf( Output, "%c", DOUBLE_BOT_LEFT );
+    for ( s = 0; s < nCellsHor; s++ )
+    {
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        if ( s != nCellsHor-1 )
+            if ( s&1 )
+                fprintf( Output, "%c", D_JOINS_D_HOR_TOP );
+            else
+                fprintf( Output, "%c", S_JOINS_D_HOR_TOP );
+    }
+    fprintf( Output, "%c", DOUBLE_BOT_RIGHT );
+    fprintf( Output, "\n" );
+
+    if ( !fHorizontalVarNamesPrintedAbove )
+    {
+        ////////////////////////////////////////////////////////////////////
+        // print horizontal digits
+        for ( d = 0; d < nVarsHor; d++ )
+        {
+            for ( p = 0; p < nSkipSpaces + 2; p++, fprintf( Output, " " ) );
+            for ( n = 0; n < nCellsHor; n++ )
+                if ( GrayCode(n) & (1<<(nVarsHor-1-d)) )
+                    fprintf( Output, "1   " );
+                else
+                    fprintf( Output, "0   " );
+
+            /////////////////////////////////
+            fprintf( Output, "%c", (char)('a'+d) );
+            /////////////////////////////////
+            fprintf( Output, "\n" );
+        }
+    }
+}
+
+
+
+/**Function********************************************************************
+
+  Synopsis    [Prints the K-map of the relation.]
+
+  Description [Assumes that the relation depends the first nXVars of XVars and 
+  the first nYVars of YVars. Draws X and Y vars and vertical and horizontal vars.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_PrintKMapRelation( 
+  FILE * Output,  /* the output stream */
+  DdManager * dd, 
+  DdNode * OnSet, 
+  DdNode * OffSet, 
+  int nXVars, 
+  int nYVars, 
+  DdNode ** XVars, 
+  DdNode ** YVars ) /* the flag which determines how support is computed */
+{
+    int d, p, n, s, v, h, w;
+    int nVars;
+    int nVarsVer;
+    int nVarsHor;
+    int nCellsVer;
+    int nCellsHor;
+    int nSkipSpaces;
+
+    // make sure that on-set and off-set do not overlap
+    if ( !Cudd_bddLeq( dd, OnSet, Cudd_Not(OffSet) ) )
+    {
+        fprintf( Output, "PrintKMap(): The on-set and the off-set overlap\n" );
+        return;
+    }
+
+    if ( OnSet == b1 )
+    {
+        fprintf( Output, "PrintKMap(): Constant 1\n" );
+        return;
+    }
+    if ( OffSet == b1 )
+    {
+        fprintf( Output, "PrintKMap(): Constant 0\n" );
+        return;
+    }
+
+    nVars = nXVars + nYVars;
+    if ( nVars < 0 || nVars > MAXVARS )
+    {
+        fprintf( Output, "PrintKMap(): The number of variables is less than zero or more than %d\n", MAXVARS );
+        return;
+    }
+
+
+    ////////////////////////////////////////////////////////////////////
+    // determine the Karnaugh map parameters
+    nVarsVer = nXVars;
+    nVarsHor = nYVars;
+    nCellsVer = (1<<nVarsVer);
+    nCellsHor = (1<<nVarsHor);
+    nSkipSpaces = nVarsVer + 1;
+
+    ////////////////////////////////////////////////////////////////////
+    // print variable names
+    fprintf( Output, "\n" );
+    for ( w = 0; w < nVarsVer; w++ )
+        fprintf( Output, "%c", 'a'+nVarsHor+w );
+    if ( fHorizontalVarNamesPrintedAbove )
+    {
+        fprintf( Output, " \\ " );
+        for ( w = 0; w < nVarsHor; w++ )
+            fprintf( Output, "%c", 'a'+w );
+    }
+    fprintf( Output, "\n" );
+
+    if ( fHorizontalVarNamesPrintedAbove )
+    {
+        ////////////////////////////////////////////////////////////////////
+        // print horizontal digits
+        for ( d = 0; d < nVarsHor; d++ )
+        {
+            for ( p = 0; p < nSkipSpaces + 2; p++, fprintf( Output, " " ) );
+            for ( n = 0; n < nCellsHor; n++ )
+                if ( GrayCode(n) & (1<<(nVarsHor-1-d)) )
+                    fprintf( Output, "1   " );
+                else
+                    fprintf( Output, "0   " );
+            fprintf( Output, "\n" );
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////
+    // print the upper line
+    for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+    fprintf( Output, "%c", DOUBLE_TOP_LEFT );
+    for ( s = 0; s < nCellsHor; s++ )
+    {
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        if ( s != nCellsHor-1 )
+            if ( s&1 )
+                fprintf( Output, "%c", D_JOINS_D_HOR_BOT );
+            else
+                fprintf( Output, "%c", S_JOINS_D_HOR_BOT );
+    }
+    fprintf( Output, "%c", DOUBLE_TOP_RIGHT );
+    fprintf( Output, "\n" );
+
+    ////////////////////////////////////////////////////////////////////
+    // print the map
+    for ( v = 0; v < nCellsVer; v++ )
+    {
+        DdNode * CubeVerBDD;
+
+        // print horizontal digits
+//      for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+        for ( n = 0; n < nVarsVer; n++ )
+            if ( GrayCode(v) & (1<<(nVarsVer-1-n)) )
+                fprintf( Output, "1" );
+            else
+                fprintf( Output, "0" );
+        fprintf( Output, " " );
+
+        // find vertical cube
+//      CubeVerBDD = Extra_bddBitsToCube( dd, GrayCode(v), nVarsVer, s_XVars+nVarsHor );    Cudd_Ref( CubeVerBDD );
+        CubeVerBDD = Extra_bddBitsToCube( dd, GrayCode(v), nXVars, XVars, 1 );                 Cudd_Ref( CubeVerBDD );
+
+        // print text line
+        fprintf( Output, "%c", DOUBLE_VERTICAL );
+        for ( h = 0; h < nCellsHor; h++ )
+        {
+            DdNode * CubeHorBDD, * Prod, * ValueOnSet, * ValueOffSet;
+
+            fprintf( Output, " " );
+//          fprintf( Output, "x" );
+            ///////////////////////////////////////////////////////////////
+            // determine what should be printed
+//          CubeHorBDD  = Extra_bddBitsToCube( dd, GrayCode(h), nVarsHor, s_XVars );    Cudd_Ref( CubeHorBDD );
+            CubeHorBDD  = Extra_bddBitsToCube( dd, GrayCode(h), nYVars, YVars, 1 );        Cudd_Ref( CubeHorBDD );
+            Prod = Cudd_bddAnd( dd, CubeHorBDD, CubeVerBDD );                           Cudd_Ref( Prod );
+            Cudd_RecursiveDeref( dd, CubeHorBDD );
+
+            ValueOnSet  = Cudd_Cofactor( dd, OnSet, Prod );                     Cudd_Ref( ValueOnSet );
+            ValueOffSet = Cudd_Cofactor( dd, OffSet, Prod );                    Cudd_Ref( ValueOffSet );
+            Cudd_RecursiveDeref( dd, Prod );
+
+            if ( ValueOnSet == b1 && ValueOffSet == b0 )
+                fprintf( Output, "%c", SYMBOL_ONE );
+            else if ( ValueOnSet == b0 && ValueOffSet == b1 )
+                fprintf( Output, "%c", SYMBOL_ZERO );
+            else if ( ValueOnSet == b0 && ValueOffSet == b0 ) 
+                fprintf( Output, "%c", SYMBOL_DC );
+            else if ( ValueOnSet == b1 && ValueOffSet == b1 ) 
+                fprintf( Output, "%c", SYMBOL_OVERLAP );
+            else
+                assert(0);
+
+            Cudd_RecursiveDeref( dd, ValueOnSet );
+            Cudd_RecursiveDeref( dd, ValueOffSet );
+            ///////////////////////////////////////////////////////////////
+            fprintf( Output, " " );
+
+            if ( h != nCellsHor-1 )
+                if ( h&1 )
+                    fprintf( Output, "%c", DOUBLE_VERTICAL );
+                else
+                    fprintf( Output, "%c", SINGLE_VERTICAL );
+        }
+        fprintf( Output, "%c", DOUBLE_VERTICAL );
+        fprintf( Output, "\n" );
+
+        Cudd_RecursiveDeref( dd, CubeVerBDD );
+
+        if ( v != nCellsVer-1 )
+        // print separator line
+        {
+            for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+            if ( v&1 )
+            {
+                fprintf( Output, "%c", D_JOINS_D_VER_RIGHT );
+                for ( s = 0; s < nCellsHor; s++ )
+                {
+                    fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+                    fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+                    fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+                    if ( s != nCellsHor-1 )
+                        if ( s&1 )
+                            fprintf( Output, "%c", DOUBLES_CROSS );
+                        else
+                            fprintf( Output, "%c", S_VER_CROSS_D_HOR );
+                }
+                fprintf( Output, "%c", D_JOINS_D_VER_LEFT );
+            }
+            else
+            {
+                fprintf( Output, "%c", S_JOINS_D_VER_RIGHT );
+                for ( s = 0; s < nCellsHor; s++ )
+                {
+                    fprintf( Output, "%c", SINGLE_HORIZONTAL );
+                    fprintf( Output, "%c", SINGLE_HORIZONTAL );
+                    fprintf( Output, "%c", SINGLE_HORIZONTAL );
+                    if ( s != nCellsHor-1 )
+                        if ( s&1 )
+                            fprintf( Output, "%c", S_HOR_CROSS_D_VER );
+                        else
+                            fprintf( Output, "%c", SINGLES_CROSS );
+                }
+                fprintf( Output, "%c", S_JOINS_D_VER_LEFT );
+            }
+            fprintf( Output, "\n" );
+        }
+    }
+    
+    ////////////////////////////////////////////////////////////////////
+    // print the lower line
+    for ( p = 0; p < nSkipSpaces; p++, fprintf( Output, " " ) );
+    fprintf( Output, "%c", DOUBLE_BOT_LEFT );
+    for ( s = 0; s < nCellsHor; s++ )
+    {
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        fprintf( Output, "%c", DOUBLE_HORIZONTAL );
+        if ( s != nCellsHor-1 )
+            if ( s&1 )
+                fprintf( Output, "%c", D_JOINS_D_HOR_TOP );
+            else
+                fprintf( Output, "%c", S_JOINS_D_HOR_TOP );
+    }
+    fprintf( Output, "%c", DOUBLE_BOT_RIGHT );
+    fprintf( Output, "\n" );
+
+    if ( !fHorizontalVarNamesPrintedAbove )
+    {
+        ////////////////////////////////////////////////////////////////////
+        // print horizontal digits
+        for ( d = 0; d < nVarsHor; d++ )
+        {
+            for ( p = 0; p < nSkipSpaces + 2; p++, fprintf( Output, " " ) );
+            for ( n = 0; n < nCellsHor; n++ )
+                if ( GrayCode(n) & (1<<(nVarsHor-1-d)) )
+                    fprintf( Output, "1   " );
+                else
+                    fprintf( Output, "0   " );
+
+            /////////////////////////////////
+            fprintf( Output, "%c", (char)('a'+d) );
+            /////////////////////////////////
+            fprintf( Output, "\n" );
+        }
+    }
+}
+
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static functions                                            */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int GrayCode ( int BinCode )
+{
+  return BinCode ^ ( BinCode >> 1 );
+}
+
+/**Function********************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int BinCode ( int GrayCode )
+{
+  int bc = GrayCode;
+  while( GrayCode >>= 1 ) bc ^= GrayCode;
+  return bc;
+}
+
+
diff --git a/src/misc/extra/extraBddMisc.c b/src/misc/extra/extraBddMisc.c
new file mode 100644
index 00000000..a3320ad3
--- /dev/null
+++ b/src/misc/extra/extraBddMisc.c
@@ -0,0 +1,1614 @@
+/**CFile****************************************************************
+
+  FileName    [extraBddMisc.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [DD-based utilities.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraBddMisc.c,v 1.4 2005/10/04 00:19:54 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+// file "extraDdTransfer.c"
+static DdNode * extraTransferPermuteRecur( DdManager * ddS, DdManager * ddD, DdNode * f, st_table * table, int * Permute );
+static DdNode * extraTransferPermute( DdManager * ddS, DdManager * ddD, DdNode * f, int * Permute );
+static DdNode * cuddBddPermuteRecur ARGS( ( DdManager * manager, DdHashTable * table, DdNode * node, int *permut ) );
+
+// file "cuddUtils.c"
+static void ddSupportStep(DdNode *f, int *support);
+static void ddClearFlag(DdNode *f);
+
+static DdNode* extraZddPrimes( DdManager *dd, DdNode* F );
+
+/**AutomaticEnd***************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Convert a {A,B}DD from a manager to another with variable remapping.]
+
+  Description [Convert a {A,B}DD from a manager to another one. The orders of the
+  variables in the two managers may be different. Returns a
+  pointer to the {A,B}DD in the destination manager if successful; NULL
+  otherwise. The i-th entry in the array Permute tells what is the index
+  of the i-th variable from the old manager in the new manager.]
+
+  SideEffects [None]
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_TransferPermute( DdManager * ddSource, DdManager * ddDestination, DdNode * f, int * Permute )
+{
+    DdNode * bRes;
+    do
+    {
+        ddDestination->reordered = 0;
+        bRes = extraTransferPermute( ddSource, ddDestination, f, Permute );
+    }
+    while ( ddDestination->reordered == 1 );
+    return ( bRes );
+
+}                               /* end of Extra_TransferPermute */
+
+/**Function********************************************************************
+
+  Synopsis    [Transfers the BDD from one manager into another level by level.]
+
+  Description [Transfers the BDD from one manager into another while
+  preserving the correspondence between variables level by level.]
+
+  SideEffects [None]
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_TransferLevelByLevel( DdManager * ddSource, DdManager * ddDestination, DdNode * f )
+{
+    DdNode * bRes;
+    int * pPermute;
+    int nMin, nMax, i;
+
+    nMin = ddMin(ddSource->size, ddDestination->size);
+    nMax = ddMax(ddSource->size, ddDestination->size);
+    pPermute = ALLOC( int, nMax );
+    // set up the variable permutation
+    for ( i = 0; i < nMin; i++ )
+        pPermute[ ddSource->invperm[i] ] = ddDestination->invperm[i];
+    if ( ddSource->size > ddDestination->size )
+    {
+        for (      ; i < nMax; i++ )
+            pPermute[ ddSource->invperm[i] ] = -1;
+    }
+    bRes = Extra_TransferPermute( ddSource, ddDestination, f, pPermute );
+    FREE( pPermute );
+    return bRes;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Remaps the function to depend on the topmost variables on the manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddRemapUp(
+  DdManager * dd,
+  DdNode * bF )
+{
+    int * pPermute;
+    DdNode * bSupp, * bTemp, * bRes;
+    int Counter;
+
+    pPermute = ALLOC( int, dd->size );
+
+    // get support
+    bSupp = Cudd_Support( dd, bF );    Cudd_Ref( bSupp );
+
+    // create the variable map
+    // to remap the DD into the upper part of the manager
+    Counter = 0;
+    for ( bTemp = bSupp; bTemp != dd->one; bTemp = cuddT(bTemp) )
+        pPermute[bTemp->index] = dd->invperm[Counter++];
+
+    // transfer the BDD and remap it
+    bRes = Cudd_bddPermute( dd, bF, pPermute );  Cudd_Ref( bRes );
+
+    // remove support
+    Cudd_RecursiveDeref( dd, bSupp );
+
+    // return
+    Cudd_Deref( bRes );
+    free( pPermute );
+    return bRes;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Moves the BDD by the given number of variables up or down.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     [Extra_bddShift]
+
+******************************************************************************/
+DdNode * Extra_bddMove( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bF,
+  int nVars) 
+{
+    DdNode * res;
+    DdNode * bVars;
+    if ( nVars == 0 )
+        return bF;
+    if ( Cudd_IsConstant(bF) )
+        return bF;
+    assert( nVars <= dd->size );
+    if ( nVars > 0 )
+        bVars = dd->vars[nVars];
+    else
+        bVars = Cudd_Not(dd->vars[-nVars]);
+
+    do {
+        dd->reordered = 0;
+        res = extraBddMove( dd, bF, bVars );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_bddMove */
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_StopManager( DdManager * dd )
+{
+    int RetValue;
+    // check for remaining references in the package
+    RetValue = Cudd_CheckZeroRef( dd );
+    if ( RetValue > 0 )
+        printf( "\nThe number of referenced nodes = %d\n\n", RetValue );
+//  Cudd_PrintInfo( dd, stdout );
+    Cudd_Quit( dd );
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Outputs the BDD in a readable format.]
+
+  Description []
+
+  SideEffects [None]
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_bddPrint( DdManager * dd, DdNode * F )
+{
+    DdGen * Gen;
+    int * Cube;
+    CUDD_VALUE_TYPE Value;
+    int nVars = dd->size;
+    int fFirstCube = 1;
+    int i;
+
+    if ( F == NULL )
+    {
+        printf("NULL");
+        return;
+    }
+    if ( F == b0 )
+    {
+        printf("Constant 0");
+        return;
+    }
+    if ( F == b1 )
+    {
+        printf("Constant 1");
+        return;
+    }
+
+    Cudd_ForeachCube( dd, F, Gen, Cube, Value )
+    {
+        if ( fFirstCube )
+            fFirstCube = 0;
+        else
+//          Output << " + ";
+            printf( " + " );
+
+        for ( i = 0; i < nVars; i++ )
+            if ( Cube[i] == 0 )
+                printf( "[%d]'", i );
+//              printf( "%c'", (char)('a'+i) );
+            else if ( Cube[i] == 1 )
+                printf( "[%d]", i );
+//              printf( "%c", (char)('a'+i) );
+    }
+
+//  printf("\n");
+}
+/**Function********************************************************************
+
+  Synopsis    [Returns the size of the support.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddSuppSize( DdManager * dd, DdNode * bSupp )
+{
+    int Counter = 0;
+    while ( bSupp != b1 )
+    {
+        assert( !Cudd_IsComplement(bSupp) );
+        assert( cuddE(bSupp) == b0 );
+
+        bSupp = cuddT(bSupp);
+        Counter++;
+    }
+    return Counter;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Returns 1 if the support contains the given BDD variable.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddSuppContainVar( DdManager * dd, DdNode * bS, DdNode * bVar )   
+{ 
+    for( ; bS != b1; bS = cuddT(bS) )
+        if ( bS->index == bVar->index )
+            return 1;
+    return 0;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Returns 1 if two supports represented as BDD cubes are overlapping.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddSuppOverlapping( DdManager * dd, DdNode * S1, DdNode * S2 )
+{
+    while ( S1->index != CUDD_CONST_INDEX && S2->index != CUDD_CONST_INDEX )
+    {
+        // if the top vars are the same, they intersect
+        if ( S1->index == S2->index )
+            return 1;
+        // if the top vars are different, skip the one, which is higher
+        if ( dd->perm[S1->index] < dd->perm[S2->index] )
+            S1 = cuddT(S1);
+        else
+            S2 = cuddT(S2);
+    }
+    return 0;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Returns the number of different vars in two supports.]
+
+  Description [Counts the number of variables that appear in one support and 
+  does not appear in other support. If the number exceeds DiffMax, returns DiffMax.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddSuppDifferentVars( DdManager * dd, DdNode * S1, DdNode * S2, int DiffMax )
+{
+    int Result = 0;
+    while ( S1->index != CUDD_CONST_INDEX && S2->index != CUDD_CONST_INDEX )
+    {
+        // if the top vars are the same, this var is the same
+        if ( S1->index == S2->index )
+        {
+            S1 = cuddT(S1);
+            S2 = cuddT(S2);
+            continue;
+        }
+        // the top var is different
+        Result++;
+
+        if ( Result >= DiffMax )
+            return DiffMax;
+
+        // if the top vars are different, skip the one, which is higher
+        if ( dd->perm[S1->index] < dd->perm[S2->index] )
+            S1 = cuddT(S1);
+        else
+            S2 = cuddT(S2);
+    }
+
+    // consider the remaining variables
+    if ( S1->index != CUDD_CONST_INDEX )
+        Result += Extra_bddSuppSize(dd,S1);
+    else if ( S2->index != CUDD_CONST_INDEX )
+        Result += Extra_bddSuppSize(dd,S2);
+
+    if ( Result >= DiffMax )
+        return DiffMax;
+    return Result;
+}
+
+
+/**Function********************************************************************
+
+  Synopsis    [Checks the support containment.]
+
+  Description [This function returns 1 if one support is contained in another.
+  In this case, bLarge (bSmall) is assigned to point to the larger (smaller) support.
+  If the supports are identical, return 0 and does not assign the supports!]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddSuppCheckContainment( DdManager * dd, DdNode * bL, DdNode * bH, DdNode ** bLarge, DdNode ** bSmall )
+{
+    DdNode * bSL = bL;
+    DdNode * bSH = bH;
+    int fLcontainsH = 1;
+    int fHcontainsL = 1;
+    int TopVar;
+    
+    if ( bSL == bSH )
+        return 0;
+
+    while ( bSL != b1 || bSH != b1 )
+    {
+        if ( bSL == b1 )
+        { // Low component has no vars; High components has some vars
+            fLcontainsH = 0;
+            if ( fHcontainsL == 0 )
+                return 0;
+            else
+                break;
+        }
+
+        if ( bSH == b1 )
+        { // similarly
+            fHcontainsL = 0;
+            if ( fLcontainsH == 0 )
+                return 0;
+            else
+                break;
+        }
+
+        // determine the topmost var of the supports by comparing their levels
+        if ( dd->perm[bSL->index] < dd->perm[bSH->index] )
+            TopVar = bSL->index;
+        else
+            TopVar = bSH->index;
+
+        if ( TopVar == bSL->index && TopVar == bSH->index ) 
+        { // they are on the same level
+            // it does not tell us anything about their containment
+            // skip this var
+            bSL = cuddT(bSL);
+            bSH = cuddT(bSH);
+        }
+        else if ( TopVar == bSL->index ) // and TopVar != bSH->index
+        { // Low components is higher and contains more vars
+            // it is not possible that High component contains Low
+            fHcontainsL = 0;
+            // skip this var
+            bSL = cuddT(bSL);
+        }
+        else // if ( TopVar == bSH->index ) // and TopVar != bSL->index
+        { // similarly
+            fLcontainsH = 0;
+            // skip this var
+            bSH = cuddT(bSH);
+        }
+
+        // check the stopping condition
+        if ( !fHcontainsL && !fLcontainsH )
+            return 0;
+    }
+    // only one of them can be true at the same time
+    assert( !fHcontainsL || !fLcontainsH );
+    if ( fHcontainsL )
+    {
+        *bLarge = bH;
+        *bSmall = bL;
+    }
+    else // fLcontainsH
+    {
+        *bLarge = bL;
+        *bSmall = bH;
+    }
+    return 1;
+}
+
+
+/**Function********************************************************************
+
+  Synopsis    [Finds variables on which the DD depends and returns them as am array.]
+
+  Description [Finds the variables on which the DD depends. Returns an array 
+  with entries set to 1 for those variables that belong to the support; 
+  NULL otherwise. The array is allocated by the user and should have at least
+  as many entries as the maximum number of variables in BDD and ZDD parts of 
+  the manager.]
+
+  SideEffects [None]
+
+  SeeAlso     [Cudd_Support Cudd_VectorSupport Cudd_ClassifySupport]
+
+******************************************************************************/
+int * 
+Extra_SupportArray(
+  DdManager * dd, /* manager */
+  DdNode * f,     /* DD whose support is sought */
+  int * support ) /* array allocated by the user */
+{
+    int i, size;
+
+    /* Initialize support array for ddSupportStep. */
+    size = ddMax(dd->size, dd->sizeZ);
+    for (i = 0; i < size; i++) 
+        support[i] = 0;
+    
+    /* Compute support and clean up markers. */
+    ddSupportStep(Cudd_Regular(f),support);
+    ddClearFlag(Cudd_Regular(f));
+
+    return(support);
+
+} /* end of Extra_SupportArray */
+
+/**Function********************************************************************
+
+  Synopsis    [Finds the variables on which a set of DDs depends.]
+
+  Description [Finds the variables on which a set of DDs depends.
+  The set must contain either BDDs and ADDs, or ZDDs.
+  Returns a BDD consisting of the product of the variables if
+  successful; NULL otherwise.]
+
+  SideEffects [None]
+
+  SeeAlso     [Cudd_Support Cudd_ClassifySupport]
+
+******************************************************************************/
+int *
+Extra_VectorSupportArray( 
+  DdManager * dd, /* manager */ 
+  DdNode ** F, /* array of DDs whose support is sought */ 
+  int n, /* size of the array */  
+  int * support ) /* array allocated by the user */
+{
+    int i, size;
+
+    /* Allocate and initialize support array for ddSupportStep. */
+    size = ddMax( dd->size, dd->sizeZ );
+    for ( i = 0; i < size; i++ )
+        support[i] = 0;
+
+    /* Compute support and clean up markers. */
+    for ( i = 0; i < n; i++ )
+        ddSupportStep( Cudd_Regular(F[i]), support );
+    for ( i = 0; i < n; i++ )
+        ddClearFlag( Cudd_Regular(F[i]) );
+
+    return support;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Find any cube belonging to the on-set of the function.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode *  Extra_bddFindOneCube( DdManager * dd, DdNode * bF )
+{
+    char * s_Temp;
+    DdNode * bCube, * bTemp;
+    int v;
+
+    // get the vector of variables in the cube
+    s_Temp = ALLOC( char, dd->size );
+    Cudd_bddPickOneCube( dd, bF, s_Temp );
+
+    // start the cube
+    bCube = b1; Cudd_Ref( bCube );
+    for ( v = 0; v < dd->size; v++ )
+        if ( s_Temp[v] == 0 )
+        {
+//          Cube &= !s_XVars[v];
+            bCube = Cudd_bddAnd( dd, bTemp = bCube, Cudd_Not(dd->vars[v]) ); Cudd_Ref( bCube );
+            Cudd_RecursiveDeref( dd, bTemp );
+        }
+        else if ( s_Temp[v] == 1 )
+        {
+//          Cube &=  s_XVars[v];
+            bCube = Cudd_bddAnd( dd, bTemp = bCube,          dd->vars[v]  ); Cudd_Ref( bCube );
+            Cudd_RecursiveDeref( dd, bTemp );
+        }
+    Cudd_Deref(bCube);
+    free( s_Temp );
+    return bCube;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Returns one cube contained in the given BDD.]
+
+  Description [This function returns the cube with the smallest 
+  bits-to-integer value.]
+
+  SideEffects []
+
+******************************************************************************/
+DdNode * Extra_bddGetOneCube( DdManager * dd, DdNode * bFunc )
+{
+    DdNode * bFuncR, * bFunc0, * bFunc1;
+    DdNode * bRes0,  * bRes1,  * bRes;
+
+    bFuncR = Cudd_Regular(bFunc);
+    if ( cuddIsConstant(bFuncR) )
+        return bFunc;
+
+    // cofactor
+    if ( Cudd_IsComplement(bFunc) )
+    {
+        bFunc0 = Cudd_Not( cuddE(bFuncR) );
+        bFunc1 = Cudd_Not( cuddT(bFuncR) );
+    }
+    else
+    {
+        bFunc0 = cuddE(bFuncR);
+        bFunc1 = cuddT(bFuncR);
+    }
+
+    // try to find the cube with the negative literal
+    bRes0 = Extra_bddGetOneCube( dd, bFunc0 );  Cudd_Ref( bRes0 );
+
+    if ( bRes0 != b0 )
+    {
+        bRes = Cudd_bddAnd( dd, bRes0, Cudd_Not(dd->vars[bFuncR->index]) ); Cudd_Ref( bRes );
+        Cudd_RecursiveDeref( dd, bRes0 );
+    }
+    else
+    {
+        Cudd_RecursiveDeref( dd, bRes0 );
+        // try to find the cube with the positive literal
+        bRes1 = Extra_bddGetOneCube( dd, bFunc1 );  Cudd_Ref( bRes1 );
+        assert( bRes1 != b0 );
+        bRes = Cudd_bddAnd( dd, bRes1, dd->vars[bFuncR->index] ); Cudd_Ref( bRes );
+        Cudd_RecursiveDeref( dd, bRes1 );
+    }
+
+    Cudd_Deref( bRes );
+    return bRes;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the reordering-sensitive step of Extra_bddMove().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddComputeRangeCube( DdManager * dd, int iStart, int iStop )
+{
+    DdNode * bTemp, * bProd;
+    int i;
+    assert( iStart <= iStop );
+    assert( iStart >= 0 && iStart <= dd->size );
+    assert( iStop >= 0  && iStop  <= dd->size );
+    bProd = b1;         Cudd_Ref( bProd );
+    for ( i = iStart; i < iStop; i++ )
+    {
+        bProd = Cudd_bddAnd( dd, bTemp = bProd, dd->vars[i] );      Cudd_Ref( bProd );
+        Cudd_RecursiveDeref( dd, bTemp ); 
+    }
+    Cudd_Deref( bProd );
+    return bProd;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the cube of BDD variables corresponding to bits it the bit-code]
+
+  Description [Returns a bdd composed of elementary bdds found in array BddVars[] such 
+  that the bdd vars encode the number Value of bit length CodeWidth (if fMsbFirst is 1, 
+  the most significant bit is encoded with the first bdd variable). If the variables 
+  BddVars are not specified, takes the first CodeWidth variables of the manager]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddBitsToCube( DdManager * dd, int Code, int CodeWidth, DdNode ** pbVars, int fMsbFirst )
+{
+    int z;
+    DdNode * bTemp, * bVar, * bVarBdd, * bResult;
+
+    bResult = b1;   Cudd_Ref( bResult );
+    for ( z = 0; z < CodeWidth; z++ )
+    {
+        bVarBdd = (pbVars)? pbVars[z]: dd->vars[z];
+        if ( fMsbFirst )
+            bVar = Cudd_NotCond( bVarBdd, (Code & (1 << (CodeWidth-1-z)))==0 );
+        else
+            bVar = Cudd_NotCond( bVarBdd, (Code & (1 << (z)))==0 );
+        bResult = Cudd_bddAnd( dd, bTemp = bResult, bVar );     Cudd_Ref( bResult );
+        Cudd_RecursiveDeref( dd, bTemp );
+    }
+    Cudd_Deref( bResult );
+
+    return bResult;
+}  /* end of Extra_bddBitsToCube */
+
+/**Function********************************************************************
+
+  Synopsis    [Finds the support as a negative polarity cube.]
+
+  Description [Finds the variables on which a DD depends. Returns a BDD 
+  consisting of the product of the variables in the negative polarity 
+  if successful; NULL otherwise.]
+
+  SideEffects [None]
+
+  SeeAlso     [Cudd_VectorSupport Cudd_Support]
+
+******************************************************************************/
+DdNode * Extra_bddSupportNegativeCube( DdManager * dd, DdNode * f )
+{
+    int *support;
+    DdNode *res, *tmp, *var;
+    int i, j;
+    int size;
+
+    /* Allocate and initialize support array for ddSupportStep. */
+    size = ddMax( dd->size, dd->sizeZ );
+    support = ALLOC( int, size );
+    if ( support == NULL )
+    {
+        dd->errorCode = CUDD_MEMORY_OUT;
+        return ( NULL );
+    }
+    for ( i = 0; i < size; i++ )
+    {
+        support[i] = 0;
+    }
+
+    /* Compute support and clean up markers. */
+    ddSupportStep( Cudd_Regular( f ), support );
+    ddClearFlag( Cudd_Regular( f ) );
+
+    /* Transform support from array to cube. */
+    do
+    {
+        dd->reordered = 0;
+        res = DD_ONE( dd );
+        cuddRef( res );
+        for ( j = size - 1; j >= 0; j-- )
+        {                        /* for each level bottom-up */
+            i = ( j >= dd->size ) ? j : dd->invperm[j];
+            if ( support[i] == 1 )
+            {
+                var = cuddUniqueInter( dd, i, dd->one, Cudd_Not( dd->one ) );
+                //////////////////////////////////////////////////////////////////
+                var = Cudd_Not(var);
+                //////////////////////////////////////////////////////////////////
+                cuddRef( var );
+                tmp = cuddBddAndRecur( dd, res, var );
+                if ( tmp == NULL )
+                {
+                    Cudd_RecursiveDeref( dd, res );
+                    Cudd_RecursiveDeref( dd, var );
+                    res = NULL;
+                    break;
+                }
+                cuddRef( tmp );
+                Cudd_RecursiveDeref( dd, res );
+                Cudd_RecursiveDeref( dd, var );
+                res = tmp;
+            }
+        }
+    }
+    while ( dd->reordered == 1 );
+
+    FREE( support );
+    if ( res != NULL )
+        cuddDeref( res );
+    return ( res );
+
+}                                /* end of Extra_SupportNeg */
+
+/**Function********************************************************************
+
+  Synopsis    [Returns 1 if the BDD is the BDD of elementary variable.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddIsVar( DdNode * bFunc )
+{
+    bFunc = Cudd_Regular( bFunc );
+    if ( cuddIsConstant(bFunc) )
+        return 0;
+    return cuddIsConstant( cuddT(bFunc) ) && cuddIsConstant( Cudd_Regular(cuddE(bFunc)) );
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Creates AND composed of the first nVars of the manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddCreateAnd( DdManager * dd, int nVars )
+{
+    DdNode * bFunc, * bTemp;
+    int i;
+    bFunc = Cudd_ReadOne(dd); Cudd_Ref( bFunc );
+    for ( i = 0; i < nVars; i++ )
+    {
+        bFunc = Cudd_bddAnd( dd, bTemp = bFunc, Cudd_bddIthVar(dd,i) );  Cudd_Ref( bFunc );
+        Cudd_RecursiveDeref( dd, bTemp );
+    }
+    Cudd_Deref( bFunc );
+    return bFunc;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Creates OR composed of the first nVars of the manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddCreateOr( DdManager * dd, int nVars )
+{
+    DdNode * bFunc, * bTemp;
+    int i;
+    bFunc = Cudd_ReadLogicZero(dd); Cudd_Ref( bFunc );
+    for ( i = 0; i < nVars; i++ )
+    {
+        bFunc = Cudd_bddOr( dd, bTemp = bFunc, Cudd_bddIthVar(dd,i) );  Cudd_Ref( bFunc );
+        Cudd_RecursiveDeref( dd, bTemp );
+    }
+    Cudd_Deref( bFunc );
+    return bFunc;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Creates EXOR composed of the first nVars of the manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddCreateExor( DdManager * dd, int nVars )
+{
+    DdNode * bFunc, * bTemp;
+    int i;
+    bFunc = Cudd_ReadLogicZero(dd); Cudd_Ref( bFunc );
+    for ( i = 0; i < nVars; i++ )
+    {
+        bFunc = Cudd_bddXor( dd, bTemp = bFunc, Cudd_bddIthVar(dd,i) );  Cudd_Ref( bFunc );
+        Cudd_RecursiveDeref( dd, bTemp );
+    }
+    Cudd_Deref( bFunc );
+    return bFunc;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the set of primes as a ZDD.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_zddPrimes( DdManager * dd, DdNode * F )
+{
+    DdNode    *res;
+    do {
+        dd->reordered = 0;
+        res = extraZddPrimes(dd, F);
+        if ( dd->reordered == 1 )
+            printf("\nReordering in Extra_zddPrimes()\n");
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_zddPrimes */
+
+/**Function********************************************************************
+
+  Synopsis    [Permutes the variables of the array of BDDs.]
+
+  Description [Given a permutation in array permut, creates a new BDD
+  with permuted variables. There should be an entry in array permut
+  for each variable in the manager. The i-th entry of permut holds the
+  index of the variable that is to substitute the i-th variable.
+  The DDs in the resulting array are already referenced.]
+
+  SideEffects [None]
+
+  SeeAlso     [Cudd_addPermute Cudd_bddSwapVariables]
+
+******************************************************************************/
+void Extra_bddPermuteArray( DdManager * manager, DdNode ** bNodesIn, DdNode ** bNodesOut, int nNodes, int *permut )
+{
+    DdHashTable *table;
+    int i, k;
+    do
+    {
+        manager->reordered = 0;
+        table = cuddHashTableInit( manager, 1, 2 );
+
+        /* permute the output functions one-by-one */
+        for ( i = 0; i < nNodes; i++ )
+        {
+            bNodesOut[i] = cuddBddPermuteRecur( manager, table, bNodesIn[i], permut );
+            if ( bNodesOut[i] == NULL )
+            {
+                /* deref the array of the already computed outputs */
+                for ( k = 0; k < i; k++ )
+                    Cudd_RecursiveDeref( manager, bNodesOut[k] );
+                break;
+            }
+            cuddRef( bNodesOut[i] );
+        }
+        /* Dispose of local cache. */
+        cuddHashTableQuit( table );
+    }
+    while ( manager->reordered == 1 );
+}    /* end of Extra_bddPermuteArray */
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the reordering-sensitive step of Extra_bddMove().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraBddMove( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bF,
+  DdNode * bDist) 
+{
+    DdNode * bRes;
+
+    if ( Cudd_IsConstant(bF) )
+        return bF;
+
+    if ( bRes = cuddCacheLookup2(dd, extraBddMove, bF, bDist) )
+        return bRes;
+    else
+    {
+        DdNode * bRes0, * bRes1;             
+        DdNode * bF0, * bF1;             
+        DdNode * bFR = Cudd_Regular(bF); 
+        int VarNew;
+        
+        if ( Cudd_IsComplement(bDist) )
+            VarNew = bFR->index - Cudd_Not(bDist)->index;
+        else
+            VarNew = bFR->index + bDist->index;
+        assert( VarNew < dd->size );
+
+        // cofactor the functions
+        if ( bFR != bF ) // bFunc is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+        bRes0 = extraBddMove( dd, bF0, bDist );
+        if ( bRes0 == NULL ) 
+            return NULL;
+        cuddRef( bRes0 );
+
+        bRes1 = extraBddMove( dd, bF1, bDist );
+        if ( bRes1 == NULL ) 
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            return NULL;
+        }
+        cuddRef( bRes1 );
+
+        /* only bRes0 and bRes1 are referenced at this point */
+        bRes = cuddBddIteRecur( dd, dd->vars[VarNew], bRes1, bRes0 );
+        if ( bRes == NULL ) 
+        {
+            Cudd_RecursiveDeref( dd, bRes0 );
+            Cudd_RecursiveDeref( dd, bRes1 );
+            return NULL;
+        }
+        cuddRef( bRes );
+        Cudd_RecursiveDeref( dd, bRes0 );
+        Cudd_RecursiveDeref( dd, bRes1 );
+
+        /* insert the result into cache */
+        cuddCacheInsert2( dd, extraBddMove, bF, bDist, bRes );
+        cuddDeref( bRes );
+        return bRes;
+    }
+} /* end of extraBddMove */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Finds three cofactors of the cover w.r.t. to the topmost variable.]
+
+  Description [Finds three cofactors of the cover w.r.t. to the topmost variable.
+  Does not check the cover for being a constant. Assumes that ZDD variables encoding 
+  positive and negative polarities are adjacent in the variable order. Is different 
+  from cuddZddGetCofactors3() in that it does not compute the cofactors w.r.t. the 
+  given variable but takes the cofactors with respent to the topmost variable. 
+  This function is more efficient when used in recursive procedures because it does 
+  not require referencing of the resulting cofactors (compare cuddZddProduct() 
+  and extraZddPrimeProduct()).]
+
+  SideEffects [None]
+
+  SeeAlso     [cuddZddGetCofactors3]
+
+******************************************************************************/
+void 
+extraDecomposeCover( 
+  DdManager* dd,    /* the manager */
+  DdNode*  zC,      /* the cover */
+  DdNode** zC0,     /* the pointer to the negative var cofactor */ 
+  DdNode** zC1,     /* the pointer to the positive var cofactor */ 
+  DdNode** zC2 )    /* the pointer to the cofactor without var */ 
+{
+    if ( (zC->index & 1) == 0 ) 
+    { /* the top variable is present in positive polarity and maybe in negative */
+
+        DdNode *Temp = cuddE( zC );
+        *zC1  = cuddT( zC );
+        if ( cuddIZ(dd,Temp->index) == cuddIZ(dd,zC->index) + 1 )
+        {   /* Temp is not a terminal node 
+             * top var is present in negative polarity */
+            *zC2 = cuddE( Temp );
+            *zC0 = cuddT( Temp );
+        }
+        else
+        {   /* top var is not present in negative polarity */
+            *zC2 = Temp;
+            *zC0 = dd->zero;
+        }
+    }
+    else 
+    { /* the top variable is present only in negative */
+        *zC1 = dd->zero;
+        *zC2 = cuddE( zC );
+        *zC0 = cuddT( zC );
+    }
+} /* extraDecomposeCover */
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static Functions                                            */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Convert a BDD from a manager to another one.]
+
+  Description [Convert a BDD from a manager to another one. Returns a
+  pointer to the BDD in the destination manager if successful; NULL
+  otherwise.]
+
+  SideEffects [None]
+
+  SeeAlso     [Extra_TransferPermute]
+
+******************************************************************************/
+DdNode * extraTransferPermute( DdManager * ddS, DdManager * ddD, DdNode * f, int * Permute )
+{
+    DdNode *res;
+    st_table *table = NULL;
+    st_generator *gen = NULL;
+    DdNode *key, *value;
+
+    table = st_init_table( st_ptrcmp, st_ptrhash );
+    if ( table == NULL )
+        goto failure;
+    res = extraTransferPermuteRecur( ddS, ddD, f, table, Permute );
+    if ( res != NULL )
+        cuddRef( res );
+
+    /* Dereference all elements in the table and dispose of the table.
+       ** This must be done also if res is NULL to avoid leaks in case of
+       ** reordering. */
+    gen = st_init_gen( table );
+    if ( gen == NULL )
+        goto failure;
+    while ( st_gen( gen, ( char ** ) &key, ( char ** ) &value ) )
+    {
+        Cudd_RecursiveDeref( ddD, value );
+    }
+    st_free_gen( gen );
+    gen = NULL;
+    st_free_table( table );
+    table = NULL;
+
+    if ( res != NULL )
+        cuddDeref( res );
+    return ( res );
+
+  failure:
+    if ( table != NULL )
+        st_free_table( table );
+    if ( gen != NULL )
+        st_free_gen( gen );
+    return ( NULL );
+
+}                               /* end of extraTransferPermute */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_TransferPermute.]
+
+  Description [Performs the recursive step of Extra_TransferPermute.
+  Returns a pointer to the result if successful; NULL otherwise.]
+
+  SideEffects [None]
+
+  SeeAlso     [extraTransferPermute]
+
+******************************************************************************/
+static DdNode * 
+extraTransferPermuteRecur( 
+  DdManager * ddS, 
+  DdManager * ddD, 
+  DdNode * f, 
+  st_table * table, 
+  int * Permute )
+{
+    DdNode *ft, *fe, *t, *e, *var, *res;
+    DdNode *one, *zero;
+    int index;
+    int comple = 0;
+
+    statLine( ddD );
+    one = DD_ONE( ddD );
+    comple = Cudd_IsComplement( f );
+
+    /* Trivial cases. */
+    if ( Cudd_IsConstant( f ) )
+        return ( Cudd_NotCond( one, comple ) );
+
+
+    /* Make canonical to increase the utilization of the cache. */
+    f = Cudd_NotCond( f, comple );
+    /* Now f is a regular pointer to a non-constant node. */
+
+    /* Check the cache. */
+    if ( st_lookup( table, ( char * ) f, ( char ** ) &res ) )
+        return ( Cudd_NotCond( res, comple ) );
+
+    /* Recursive step. */
+    if ( Permute )
+        index = Permute[f->index];
+    else
+        index = f->index;
+
+    ft = cuddT( f );
+    fe = cuddE( f );
+
+    t = extraTransferPermuteRecur( ddS, ddD, ft, table, Permute );
+    if ( t == NULL )
+    {
+        return ( NULL );
+    }
+    cuddRef( t );
+
+    e = extraTransferPermuteRecur( ddS, ddD, fe, table, Permute );
+    if ( e == NULL )
+    {
+        Cudd_RecursiveDeref( ddD, t );
+        return ( NULL );
+    }
+    cuddRef( e );
+
+    zero = Cudd_Not(ddD->one);
+    var = cuddUniqueInter( ddD, index, one, zero );
+    if ( var == NULL )
+    {
+        Cudd_RecursiveDeref( ddD, t );
+        Cudd_RecursiveDeref( ddD, e );
+        return ( NULL );
+    }
+    res = cuddBddIteRecur( ddD, var, t, e );
+
+    if ( res == NULL )
+    {
+        Cudd_RecursiveDeref( ddD, t );
+        Cudd_RecursiveDeref( ddD, e );
+        return ( NULL );
+    }
+    cuddRef( res );
+    Cudd_RecursiveDeref( ddD, t );
+    Cudd_RecursiveDeref( ddD, e );
+
+    if ( st_add_direct( table, ( char * ) f, ( char * ) res ) ==
+         ST_OUT_OF_MEM )
+    {
+        Cudd_RecursiveDeref( ddD, res );
+        return ( NULL );
+    }
+    return ( Cudd_NotCond( res, comple ) );
+
+}                               /* end of extraTransferPermuteRecur */
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the recursive step of Cudd_Support.]
+
+  Description [Performs the recursive step of Cudd_Support. Performs a
+  DFS from f. The support is accumulated in supp as a side effect. Uses
+  the LSB of the then pointer as visited flag.]
+
+  SideEffects [None]
+
+  SeeAlso     [ddClearFlag]
+
+******************************************************************************/
+static void
+ddSupportStep(
+  DdNode * f,
+  int * support)
+{
+    if (cuddIsConstant(f) || Cudd_IsComplement(f->next)) {
+    return;
+    }
+
+    support[f->index] = 1;
+    ddSupportStep(cuddT(f),support);
+    ddSupportStep(Cudd_Regular(cuddE(f)),support);
+    /* Mark as visited. */
+    f->next = Cudd_Not(f->next);
+    return;
+
+} /* end of ddSupportStep */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Performs a DFS from f, clearing the LSB of the next
+  pointers.]
+
+  Description []
+
+  SideEffects [None]
+
+  SeeAlso     [ddSupportStep ddDagInt]
+
+******************************************************************************/
+static void
+ddClearFlag(
+  DdNode * f)
+{
+    if (!Cudd_IsComplement(f->next)) {
+    return;
+    }
+    /* Clear visited flag. */
+    f->next = Cudd_Regular(f->next);
+    if (cuddIsConstant(f)) {
+    return;
+    }
+    ddClearFlag(cuddT(f));
+    ddClearFlag(Cudd_Regular(cuddE(f)));
+    return;
+
+} /* end of ddClearFlag */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Composed three subcovers into one ZDD.]
+
+  Description []
+
+  SideEffects [None]
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode *
+extraComposeCover( 
+  DdManager* dd,    /* the manager */
+  DdNode* zC0,     /* the pointer to the negative var cofactor */ 
+  DdNode* zC1,     /* the pointer to the positive var cofactor */ 
+  DdNode* zC2,     /* the pointer to the cofactor without var */ 
+  int TopVar)    /* the index of the positive ZDD var */
+{
+    DdNode * zRes, * zTemp;
+    /* compose with-neg-var and without-var using the neg ZDD var */
+    zTemp = cuddZddGetNode( dd, 2*TopVar + 1, zC0, zC2 );
+    if ( zTemp == NULL ) 
+    {
+        Cudd_RecursiveDerefZdd(dd, zC0);
+        Cudd_RecursiveDerefZdd(dd, zC1);
+        Cudd_RecursiveDerefZdd(dd, zC2);
+        return NULL;
+    }
+    cuddRef( zTemp );
+    cuddDeref( zC0 );
+    cuddDeref( zC2 );
+
+    /* compose with-pos-var and previous result using the pos ZDD var */
+    zRes = cuddZddGetNode( dd, 2*TopVar, zC1, zTemp );
+    if ( zRes == NULL ) 
+    {
+        Cudd_RecursiveDerefZdd(dd, zC1);
+        Cudd_RecursiveDerefZdd(dd, zTemp);
+        return NULL;
+    }
+    cuddDeref( zC1 );
+    cuddDeref( zTemp );
+    return zRes;
+} /* extraComposeCover */
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the recursive step of prime computation.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode* extraZddPrimes( DdManager *dd, DdNode* F )
+{
+    DdNode *zRes;
+
+    if ( F == Cudd_Not( dd->one ) )
+        return dd->zero;
+    if ( F == dd->one )
+        return dd->one;
+
+    /* check cache */
+    zRes = cuddCacheLookup1Zdd(dd, extraZddPrimes, F);
+    if (zRes)
+        return(zRes);
+    {
+        /* temporary variables */
+        DdNode *bF01, *zP0, *zP1;
+        /* three components of the prime set */
+        DdNode *zResE, *zResP, *zResN;
+        int fIsComp = Cudd_IsComplement( F );
+
+        /* find cofactors of F */
+        DdNode * bF0 = Cudd_NotCond( Cudd_E( F ), fIsComp );
+        DdNode * bF1 = Cudd_NotCond( Cudd_T( F ), fIsComp );
+
+        /* find the intersection of cofactors */
+        bF01 = cuddBddAndRecur( dd, bF0, bF1 );
+        if ( bF01 == NULL ) return NULL;
+        cuddRef( bF01 );
+
+        /* solve the problems for cofactors */
+        zP0 = extraZddPrimes( dd, bF0 );
+        if ( zP0 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bF01 );
+            return NULL;
+        }
+        cuddRef( zP0 );
+
+        zP1 = extraZddPrimes( dd, bF1 );
+        if ( zP1 == NULL )
+        {
+            Cudd_RecursiveDeref( dd, bF01 );
+            Cudd_RecursiveDerefZdd( dd, zP0 );
+            return NULL;
+        }
+        cuddRef( zP1 );
+
+        /* check for local unateness */
+        if ( bF01 == bF0 )       /* unate increasing */
+        {
+            /* intersection is useless */
+            cuddDeref( bF01 );
+            /* the primes of intersection are the primes of F0 */
+            zResE = zP0;
+            /* there are no primes with negative var */
+            zResN = dd->zero;
+            cuddRef( zResN );
+            /* primes with positive var are primes of F1 that are not primes of F01 */
+            zResP = cuddZddDiff( dd, zP1, zP0 );
+            if ( zResP == NULL )  
+            {
+                Cudd_RecursiveDerefZdd( dd, zResE );
+                Cudd_RecursiveDerefZdd( dd, zResN );
+                Cudd_RecursiveDerefZdd( dd, zP1 );
+                return NULL;
+            }
+            cuddRef( zResP );
+            Cudd_RecursiveDerefZdd( dd, zP1 );
+        }
+        else if ( bF01 == bF1 ) /* unate decreasing */
+        {
+            /* intersection is useless */
+            cuddDeref( bF01 );
+            /* the primes of intersection are the primes of F1 */
+            zResE = zP1;
+            /* there are no primes with positive var */
+            zResP = dd->zero;
+            cuddRef( zResP );
+            /* primes with negative var are primes of F0 that are not primes of F01 */
+            zResN = cuddZddDiff( dd, zP0, zP1 );
+            if ( zResN == NULL )  
+            {
+                Cudd_RecursiveDerefZdd( dd, zResE );
+                Cudd_RecursiveDerefZdd( dd, zResP );
+                Cudd_RecursiveDerefZdd( dd, zP0 );
+                return NULL;
+            }
+            cuddRef( zResN );
+            Cudd_RecursiveDerefZdd( dd, zP0 );
+        }
+        else /* not unate */
+        {
+            /* primes without the top var are primes of F10 */
+            zResE = extraZddPrimes( dd, bF01 );
+            if ( zResE == NULL )  
+            {
+                Cudd_RecursiveDerefZdd( dd, bF01 );
+                Cudd_RecursiveDerefZdd( dd, zP0 );
+                Cudd_RecursiveDerefZdd( dd, zP1 );
+                return NULL;
+            }
+            cuddRef( zResE );
+            Cudd_RecursiveDeref( dd, bF01 );
+
+            /* primes with the negative top var are those of P0 that are not in F10 */
+            zResN = cuddZddDiff( dd, zP0, zResE );
+            if ( zResN == NULL )  
+            {
+                Cudd_RecursiveDerefZdd( dd, zResE );
+                Cudd_RecursiveDerefZdd( dd, zP0 );
+                Cudd_RecursiveDerefZdd( dd, zP1 );
+                return NULL;
+            }
+            cuddRef( zResN );
+            Cudd_RecursiveDerefZdd( dd, zP0 );
+
+            /* primes with the positive top var are those of P1 that are not in F10 */
+            zResP = cuddZddDiff( dd, zP1, zResE );
+            if ( zResP == NULL )  
+            {
+                Cudd_RecursiveDerefZdd( dd, zResE );
+                Cudd_RecursiveDerefZdd( dd, zResN );
+                Cudd_RecursiveDerefZdd( dd, zP1 );
+                return NULL;
+            }
+            cuddRef( zResP );
+            Cudd_RecursiveDerefZdd( dd, zP1 );
+        }
+
+        zRes = extraComposeCover( dd, zResN, zResP, zResE, Cudd_Regular(F)->index );
+        if ( zRes == NULL ) return NULL;
+
+        /* insert the result into cache */
+        cuddCacheInsert1(dd, extraZddPrimes, F, zRes);
+        return zRes;
+    }
+} /* end of extraZddPrimes */
+
+/**Function********************************************************************
+
+  Synopsis    [Implements the recursive step of Cudd_bddPermute.]
+
+  Description [ Recursively puts the BDD in the order given in the array permut.
+  Checks for trivial cases to terminate recursion, then splits on the
+  children of this node.  Once the solutions for the children are
+  obtained, it puts into the current position the node from the rest of
+  the BDD that should be here. Then returns this BDD.
+  The key here is that the node being visited is NOT put in its proper
+  place by this instance, but rather is switched when its proper position
+  is reached in the recursion tree.<p>
+  The DdNode * that is returned is the same BDD as passed in as node,
+  but in the new order.]
+
+  SideEffects [None]
+
+  SeeAlso     [Cudd_bddPermute cuddAddPermuteRecur]
+
+******************************************************************************/
+static DdNode *
+cuddBddPermuteRecur( DdManager * manager /* DD manager */ ,
+                     DdHashTable * table /* computed table */ ,
+                     DdNode * node /* BDD to be reordered */ ,
+                     int *permut /* permutation array */  )
+{
+    DdNode *N, *T, *E;
+    DdNode *res;
+    int index;
+
+    statLine( manager );
+    N = Cudd_Regular( node );
+
+    /* Check for terminal case of constant node. */
+    if ( cuddIsConstant( N ) )
+    {
+        return ( node );
+    }
+
+    /* If problem already solved, look up answer and return. */
+    if ( N->ref != 1 && ( res = cuddHashTableLookup1( table, N ) ) != NULL )
+    {
+#ifdef DD_DEBUG
+        bddPermuteRecurHits++;
+#endif
+        return ( Cudd_NotCond( res, N != node ) );
+    }
+
+    /* Split and recur on children of this node. */
+    T = cuddBddPermuteRecur( manager, table, cuddT( N ), permut );
+    if ( T == NULL )
+        return ( NULL );
+    cuddRef( T );
+    E = cuddBddPermuteRecur( manager, table, cuddE( N ), permut );
+    if ( E == NULL )
+    {
+        Cudd_IterDerefBdd( manager, T );
+        return ( NULL );
+    }
+    cuddRef( E );
+
+    /* Move variable that should be in this position to this position
+       ** by retrieving the single var BDD for that variable, and calling
+       ** cuddBddIteRecur with the T and E we just created.
+     */
+    index = permut[N->index];
+    res = cuddBddIteRecur( manager, manager->vars[index], T, E );
+    if ( res == NULL )
+    {
+        Cudd_IterDerefBdd( manager, T );
+        Cudd_IterDerefBdd( manager, E );
+        return ( NULL );
+    }
+    cuddRef( res );
+    Cudd_IterDerefBdd( manager, T );
+    Cudd_IterDerefBdd( manager, E );
+
+    /* Do not keep the result if the reference count is only 1, since
+       ** it will not be visited again.
+     */
+    if ( N->ref != 1 )
+    {
+        ptrint fanout = ( ptrint ) N->ref;
+        cuddSatDec( fanout );
+        if ( !cuddHashTableInsert1( table, N, res, fanout ) )
+        {
+            Cudd_IterDerefBdd( manager, res );
+            return ( NULL );
+        }
+    }
+    cuddDeref( res );
+    return ( Cudd_NotCond( res, N != node ) );
+
+}                                /* end of cuddBddPermuteRecur */
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraBddSymm.c b/src/misc/extra/extraBddSymm.c
new file mode 100644
index 00000000..358402b0
--- /dev/null
+++ b/src/misc/extra/extraBddSymm.c
@@ -0,0 +1,1469 @@
+/**CFile****************************************************************
+
+  FileName    [extraBddSymm.c]
+
+  PackageName [extra]
+
+  Synopsis    [Efficient methods to compute the information about
+  symmetric variables using the algorithm presented in the paper:
+  A. Mishchenko. Fast Computation of Symmetries in Boolean Functions. 
+  Transactions on CAD, Nov. 2003.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 2.0. Started - September 1, 2003.]
+
+  Revision    [$Id: extraBddSymm.c,v 1.0 2003/09/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+#define DD_GET_SYMM_VARS_TAG          0x0a /* former DD_BDD_XOR_EXIST_ABSTRACT_TAG */
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the classical symmetry information for the function.]
+
+  Description [Returns the symmetry information in the form of Extra_SymmInfo_t structure.]
+
+  SideEffects [If the ZDD variables are not derived from BDD variables with
+  multiplicity 2, this function may derive them in a wrong way.]
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_SymmInfo_t * Extra_SymmPairsCompute( 
+  DdManager * dd,   /* the manager */
+  DdNode * bFunc)   /* the function whose symmetries are computed */
+{
+    DdNode * bSupp;
+    DdNode * zRes;
+    Extra_SymmInfo_t * p;
+
+    bSupp = Cudd_Support( dd, bFunc );                      Cudd_Ref( bSupp );
+    zRes  = Extra_zddSymmPairsCompute( dd, bFunc, bSupp );  Cudd_Ref( zRes );
+
+    p = Extra_SymmPairsCreateFromZdd( dd, zRes, bSupp );
+
+    Cudd_RecursiveDeref( dd, bSupp );
+    Cudd_RecursiveDerefZdd( dd, zRes );
+
+    return p;
+
+} /* end of Extra_SymmPairsCompute */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the classical symmetry information as a ZDD.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_zddSymmPairsCompute( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bF,
+  DdNode * bVars) 
+{
+    DdNode * res;
+    do {
+        dd->reordered = 0;
+        res = extraZddSymmPairsCompute( dd, bF, bVars );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_zddSymmPairsCompute */
+
+/**Function********************************************************************
+
+  Synopsis    [Returns a singleton-set ZDD containing all variables that are symmetric with the given one.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_zddGetSymmetricVars( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bF,       /* the first function  - originally, the positive cofactor */
+  DdNode * bG,       /* the second fucntion - originally, the negative cofactor */
+  DdNode * bVars)    /* the set of variables, on which F and G depend */
+{
+    DdNode * res;
+    do {
+        dd->reordered = 0;
+        res = extraZddGetSymmetricVars( dd, bF, bG, bVars );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_zddGetSymmetricVars */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Converts a set of variables into a set of singleton subsets.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_zddGetSingletons( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bVars)    /* the set of variables */
+{
+    DdNode * res;
+    do {
+        dd->reordered = 0;
+        res = extraZddGetSingletons( dd, bVars );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_zddGetSingletons */
+
+/**Function********************************************************************
+
+  Synopsis    [Filters the set of variables using the support of the function.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddReduceVarSet( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bVars,    /* the set of variables to be reduced */
+  DdNode * bF)       /* the function whose support is used for reduction */
+{
+    DdNode * res;
+    do {
+        dd->reordered = 0;
+        res = extraBddReduceVarSet( dd, bVars, bF );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_bddReduceVarSet */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Allocates symmetry information structure.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_SymmInfo_t * Extra_SymmPairsAllocate( int nVars )
+{
+    int i;
+    Extra_SymmInfo_t * p;
+
+    // allocate and clean the storage for symmetry info
+    p = ALLOC( Extra_SymmInfo_t, 1 );
+    memset( p, 0, sizeof(Extra_SymmInfo_t) );
+    p->nVars     = nVars;
+    p->pVars     = ALLOC( int, nVars );  
+    p->pSymms    = ALLOC( char *, nVars );  
+    p->pSymms[0] = ALLOC( char  , nVars * nVars );
+    memset( p->pSymms[0], 0, nVars * nVars * sizeof(char) );
+
+    for ( i = 1; i < nVars; i++ )
+        p->pSymms[i] = p->pSymms[i-1] + nVars;
+
+    return p;
+} /* end of Extra_SymmPairsAllocate */
+
+/**Function********************************************************************
+
+  Synopsis    [Deallocates symmetry information structure.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_SymmPairsDissolve( Extra_SymmInfo_t * p )
+{
+    free( p->pVars );
+    free( p->pSymms[0] );
+    free( p->pSymms    );
+    free( p );
+} /* end of Extra_SymmPairsDissolve */
+
+/**Function********************************************************************
+
+  Synopsis    [Allocates symmetry information structure.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_SymmPairsPrint( Extra_SymmInfo_t * p )
+{
+    int i, k;
+    printf( "\n" );
+    for ( i = 0; i < p->nVars; i++ )
+    {
+        for ( k = 0; k <= i; k++ )
+            printf( " " );
+        for ( k = i+1; k < p->nVars; k++ )
+            if ( p->pSymms[i][k] )
+                printf( "1" );
+            else
+                printf( "." );
+        printf( "\n" );
+    }
+} /* end of Extra_SymmPairsPrint */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Creates the symmetry information structure from ZDD.]
+
+  Description [ZDD representation of symmetries is the set of cubes, each
+  of which has two variables in the positive polarity. These variables correspond
+  to the symmetric variable pair.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_SymmInfo_t * Extra_SymmPairsCreateFromZdd( DdManager * dd, DdNode * zPairs, DdNode * bSupp )
+{
+    int i;
+    int nSuppSize;
+    Extra_SymmInfo_t * p;
+    int * pMapVars2Nums;
+    DdNode * bTemp;
+    DdNode * zSet, * zCube, * zTemp;
+    int iVar1, iVar2;
+
+    nSuppSize = Extra_bddSuppSize( dd, bSupp );
+
+    // allocate and clean the storage for symmetry info
+    p = Extra_SymmPairsAllocate( nSuppSize );
+
+    // allocate the storage for the temporary map
+    pMapVars2Nums = ALLOC( int, dd->size );
+    memset( pMapVars2Nums, 0, dd->size * sizeof(int) );
+
+    // assign the variables
+    p->nVarsMax = dd->size;
+//  p->nNodes   = Cudd_DagSize( zPairs );
+    p->nNodes   = 0;
+    for ( i = 0, bTemp = bSupp; bTemp != b1; bTemp = cuddT(bTemp), i++ )
+    {
+        p->pVars[i] = bTemp->index;
+        pMapVars2Nums[bTemp->index] = i;
+    }
+
+    // write the symmetry info into the structure
+    zSet = zPairs;   Cudd_Ref( zSet );
+    while ( zSet != z0 )
+    {
+        // get the next cube
+        zCube  = Extra_zddSelectOneSubset( dd, zSet );    Cudd_Ref( zCube );
+
+        // add these two variables to the data structure
+        assert( cuddT( cuddT(zCube) ) == z1 );
+        iVar1 = zCube->index/2;
+        iVar2 = cuddT(zCube)->index/2;
+        if ( pMapVars2Nums[iVar1] < pMapVars2Nums[iVar2] )
+            p->pSymms[ pMapVars2Nums[iVar1] ][ pMapVars2Nums[iVar2] ] = 1;
+        else
+            p->pSymms[ pMapVars2Nums[iVar2] ][ pMapVars2Nums[iVar1] ] = 1;
+        // count the symmetric pairs
+        p->nSymms ++;
+
+        // update the cuver and deref the cube
+        zSet = Cudd_zddDiff( dd, zTemp = zSet, zCube );     Cudd_Ref( zSet );
+        Cudd_RecursiveDerefZdd( dd, zTemp );
+        Cudd_RecursiveDerefZdd( dd, zCube );
+
+    } // for each cube 
+    Cudd_RecursiveDerefZdd( dd, zSet );
+
+    FREE( pMapVars2Nums );
+    return p;
+
+} /* end of Extra_SymmPairsCreateFromZdd */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Checks the possibility of two variables being symmetric.]
+
+  Description [Returns 0 if vars are not symmetric. Return 1 if vars can be symmetric.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddCheckVarsSymmetric( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bF,
+  int iVar1,
+  int iVar2) 
+{
+    DdNode * bVars;
+    int Res;
+
+//  return 1;
+
+    assert( iVar1 != iVar2 );
+    assert( iVar1 < dd->size );
+    assert( iVar2 < dd->size );
+
+    bVars = Cudd_bddAnd( dd, dd->vars[iVar1], dd->vars[iVar2] );   Cudd_Ref( bVars );
+
+    Res = (int)( extraBddCheckVarsSymmetric( dd, bF, bVars ) == b1 );
+
+    Cudd_RecursiveDeref( dd, bVars );
+
+    return Res;
+} /* end of Extra_bddCheckVarsSymmetric */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the classical symmetry information for the function.]
+
+  Description [Uses the naive way of comparing cofactors.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_SymmInfo_t * Extra_SymmPairsComputeNaive( DdManager * dd, DdNode * bFunc )
+{
+    DdNode * bSupp, * bTemp;
+    int nSuppSize;
+    Extra_SymmInfo_t * p;
+    int i, k;
+
+    // compute the support
+    bSupp = Cudd_Support( dd, bFunc );   Cudd_Ref( bSupp );
+    nSuppSize = Extra_bddSuppSize( dd, bSupp );
+//printf( "Support = %d. ", nSuppSize );
+//Extra_bddPrint( dd, bSupp );
+//printf( "%d ", nSuppSize );
+
+    // allocate the storage for symmetry info
+    p = Extra_SymmPairsAllocate( nSuppSize );
+
+    // assign the variables
+    p->nVarsMax = dd->size;
+    for ( i = 0, bTemp = bSupp; bTemp != b1; bTemp = cuddT(bTemp), i++ )
+        p->pVars[i] = bTemp->index;
+
+    // go through the candidate pairs and check using Idea1
+    for ( i = 0; i < nSuppSize; i++ )
+    for ( k = i+1; k < nSuppSize; k++ )
+    {
+        p->pSymms[k][i] = p->pSymms[i][k] = Extra_bddCheckVarsSymmetricNaive( dd, bFunc, p->pVars[i], p->pVars[k] );
+        if ( p->pSymms[i][k] )
+             p->nSymms++;
+    }
+
+    Cudd_RecursiveDeref( dd, bSupp );
+    return p;
+
+} /* end of Extra_SymmPairsComputeNaive */
+
+/**Function********************************************************************
+
+  Synopsis    [Checks if the two variables are symmetric.]
+
+  Description [Returns 0 if vars are not symmetric. Return 1 if vars are symmetric.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddCheckVarsSymmetricNaive( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bF,
+  int iVar1,
+  int iVar2) 
+{
+    DdNode * bCube1, * bCube2;
+    DdNode * bCof01, * bCof10;
+    int Res;
+
+    assert( iVar1 != iVar2 );
+    assert( iVar1 < dd->size );
+    assert( iVar2 < dd->size );
+
+    bCube1 = Cudd_bddAnd( dd, Cudd_Not( dd->vars[iVar1] ), dd->vars[iVar2] );   Cudd_Ref( bCube1 );
+    bCube2 = Cudd_bddAnd( dd, Cudd_Not( dd->vars[iVar2] ), dd->vars[iVar1] );   Cudd_Ref( bCube2 );
+
+    bCof01 = Cudd_Cofactor( dd, bF, bCube1 );  Cudd_Ref( bCof01 );
+    bCof10 = Cudd_Cofactor( dd, bF, bCube2 );  Cudd_Ref( bCof10 );
+
+    Res = (int)( bCof10 == bCof01 );
+
+    Cudd_RecursiveDeref( dd, bCof01 );
+    Cudd_RecursiveDeref( dd, bCof10 );
+    Cudd_RecursiveDeref( dd, bCube1 );
+    Cudd_RecursiveDeref( dd, bCube2 );
+
+    return Res;
+} /* end of Extra_bddCheckVarsSymmetricNaive */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Builds ZDD representing the set of fixed-size variable tuples.]
+
+  Description [Creates ZDD of all combinations of variables in Support that
+  is represented by a BDD.]
+
+  SideEffects [New ZDD variables are created if indices of the variables
+               present in the combination are larger than the currently
+               allocated number of ZDD variables.]
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode* Extra_zddTuplesFromBdd( 
+  DdManager * dd,   /* the DD manager */
+  int K,            /* the number of variables in tuples */
+  DdNode * bVarsN)   /* the set of all variables represented as a BDD */
+{
+    DdNode  *zRes;
+    int     autoDynZ;
+
+    autoDynZ = dd->autoDynZ;
+    dd->autoDynZ = 0;
+
+    do {
+        /* transform the numeric arguments (K) into a DdNode* argument;
+         * this allows us to use the standard internal CUDD cache */
+        DdNode *bVarSet = bVarsN, *bVarsK = bVarsN;
+        int     nVars = 0, i;
+
+        /* determine the number of variables in VarSet */
+        while ( bVarSet != b1 )
+        {
+            nVars++;
+            /* make sure that the VarSet is a cube */
+            if ( cuddE( bVarSet ) != b0 )
+                return NULL;
+            bVarSet = cuddT( bVarSet );
+        }
+        /* make sure that the number of variables in VarSet is less or equal 
+           that the number of variables that should be present in the tuples
+        */
+        if ( K > nVars )
+            return NULL;
+
+        /* the second argument in the recursive call stannds for <n>;
+        /* reate the first argument, which stands for <k> 
+         * as when we are talking about the tuple of <k> out of <n> */
+        for ( i = 0; i < nVars-K; i++ )
+            bVarsK = cuddT( bVarsK );
+
+        dd->reordered = 0;
+        zRes = extraZddTuplesFromBdd(dd, bVarsK, bVarsN );
+
+    } while (dd->reordered == 1);
+    dd->autoDynZ = autoDynZ;
+    return zRes;
+
+} /* end of Extra_zddTuplesFromBdd */
+
+/**Function********************************************************************
+
+  Synopsis    [Selects one subset from the set of subsets represented by a ZDD.]
+
+  Description []
+
+  SideEffects [None]
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode* Extra_zddSelectOneSubset( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * zS)      /* the ZDD */
+{
+    DdNode  *res;
+    do {
+        dd->reordered = 0;
+        res = extraZddSelectOneSubset(dd, zS);
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_zddSelectOneSubset */
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Performs a recursive step of Extra_SymmPairsCompute.]
+
+  Description [Returns the set of symmetric variable pairs represented as a set 
+  of two-literal ZDD cubes. Both variables always appear in the positive polarity
+  in the cubes. This function works without building new BDD nodes. Some relatively 
+  small number of ZDD nodes may be built to ensure proper bookkeeping of the 
+  symmetry information.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * 
+extraZddSymmPairsCompute( 
+  DdManager * dd,   /* the manager */
+  DdNode * bFunc,   /* the function whose symmetries are computed */
+  DdNode * bVars )  /* the set of variables on which this function depends */
+{
+    DdNode * zRes;
+    DdNode * bFR = Cudd_Regular(bFunc); 
+
+    if ( cuddIsConstant(bFR) )
+    {
+        int nVars, i;
+
+        // determine how many vars are in the bVars
+        nVars = Extra_bddSuppSize( dd, bVars );
+        if ( nVars < 2 )
+            return z0;
+        else
+        {
+            DdNode * bVarsK;
+
+            // create the BDD bVarsK corresponding to K = 2;
+            bVarsK = bVars;
+            for ( i = 0; i < nVars-2; i++ )
+                bVarsK = cuddT( bVarsK );
+            return extraZddTuplesFromBdd( dd, bVarsK, bVars );
+        }
+    }
+    assert( bVars != b1 );
+
+    if ( zRes = cuddCacheLookup2Zdd(dd, extraZddSymmPairsCompute, bFunc, bVars) )
+        return zRes;
+    else
+    {
+        DdNode * zRes0, * zRes1;
+        DdNode * zTemp, * zPlus, * zSymmVars;             
+        DdNode * bF0, * bF1;             
+        DdNode * bVarsNew;
+        int nVarsExtra;
+        int LevelF;
+
+        // every variable in bF should be also in bVars, therefore LevelF cannot be above LevelV
+        // if LevelF is below LevelV, scroll through the vars in bVars to the same level as F
+        // count how many extra vars are there in bVars
+        nVarsExtra = 0;
+        LevelF = dd->perm[bFR->index];
+        for ( bVarsNew = bVars; LevelF > dd->perm[bVarsNew->index]; bVarsNew = cuddT(bVarsNew) )
+            nVarsExtra++; 
+        // the indexes (level) of variables should be synchronized now
+        assert( bFR->index == bVarsNew->index );
+
+        // cofactor the function
+        if ( bFR != bFunc ) // bFunc is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+        // solve subproblems
+        zRes0 = extraZddSymmPairsCompute( dd, bF0, cuddT(bVarsNew) );
+        if ( zRes0 == NULL )
+            return NULL;
+        cuddRef( zRes0 );
+
+        // if there is no symmetries in the negative cofactor
+        // there is no need to test the positive cofactor
+        if ( zRes0 == z0 )
+            zRes = zRes0;  // zRes takes reference
+        else
+        {
+            zRes1 = extraZddSymmPairsCompute( dd, bF1, cuddT(bVarsNew) );
+            if ( zRes1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes0 );
+                return NULL;
+            }
+            cuddRef( zRes1 );
+
+            // only those variables are pair-wise symmetric 
+            // that are pair-wise symmetric in both cofactors
+            // therefore, intersect the solutions
+            zRes = cuddZddIntersect( dd, zRes0, zRes1 );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes0 );
+                Cudd_RecursiveDerefZdd( dd, zRes1 );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zRes0 );
+            Cudd_RecursiveDerefZdd( dd, zRes1 );
+        }
+
+        // consider the current top-most variable and find all the vars
+        // that are pairwise symmetric with it
+        // these variables are returned as a set of ZDD singletons
+        zSymmVars = extraZddGetSymmetricVars( dd, bF1, bF0, cuddT(bVarsNew) );
+        if ( zSymmVars == NULL )
+        {
+            Cudd_RecursiveDerefZdd( dd, zRes );
+            return NULL;
+        }
+        cuddRef( zSymmVars );
+
+        // attach the topmost variable to the set, to get the variable pairs
+        // use the positive polarity ZDD variable for the purpose
+
+        // there is no need to do so, if zSymmVars is empty
+        if ( zSymmVars == z0 )
+            Cudd_RecursiveDerefZdd( dd, zSymmVars );
+        else
+        {
+            zPlus = cuddZddGetNode( dd, 2*bFR->index, zSymmVars, z0 );
+            if ( zPlus == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                Cudd_RecursiveDerefZdd( dd, zSymmVars );
+                return NULL;
+            }
+            cuddRef( zPlus );
+            cuddDeref( zSymmVars );
+
+            // add these variable pairs to the result
+            zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                Cudd_RecursiveDerefZdd( dd, zPlus );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+        }
+
+        // only zRes is referenced at this point
+
+        // if we skipped some variables, these variables cannot be symmetric with
+        // any variables that are currently in the support of bF, but they can be 
+        // symmetric with the variables that are in bVars but not in the support of bF
+        if ( nVarsExtra )
+        {
+            // it is possible to improve this step:
+            // (1) there is no need to enter here, if nVarsExtra < 2
+
+            // create the set of topmost nVarsExtra in bVars
+            DdNode * bVarsExtra;
+            int nVars;
+
+            // remove from bVars all the variable that are in the support of bFunc
+            bVarsExtra = extraBddReduceVarSet( dd, bVars, bFunc );  
+            if ( bVarsExtra == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                return NULL;
+            }
+            cuddRef( bVarsExtra );
+
+            // determine how many vars are in the bVarsExtra
+            nVars = Extra_bddSuppSize( dd, bVarsExtra );
+            if ( nVars < 2 )
+            {
+                Cudd_RecursiveDeref( dd, bVarsExtra );
+            }
+            else
+            {
+                int i;
+                DdNode * bVarsK;
+
+                // create the BDD bVarsK corresponding to K = 2;
+                bVarsK = bVarsExtra;
+                for ( i = 0; i < nVars-2; i++ )
+                    bVarsK = cuddT( bVarsK );
+
+                // create the 2 variable tuples
+                zPlus = extraZddTuplesFromBdd( dd, bVarsK, bVarsExtra );
+                if ( zPlus == NULL )
+                {
+                    Cudd_RecursiveDeref( dd, bVarsExtra );
+                    Cudd_RecursiveDerefZdd( dd, zRes );
+                    return NULL;
+                }
+                cuddRef( zPlus );
+                Cudd_RecursiveDeref( dd, bVarsExtra );
+
+                // add these to the result
+                zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+                if ( zRes == NULL )
+                {
+                    Cudd_RecursiveDerefZdd( dd, zTemp );
+                    Cudd_RecursiveDerefZdd( dd, zPlus );
+                    return NULL;
+                }
+                cuddRef( zRes );
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                Cudd_RecursiveDerefZdd( dd, zPlus );
+            }
+        }
+        cuddDeref( zRes );
+
+
+        /* insert the result into cache */
+        cuddCacheInsert2(dd, extraZddSymmPairsCompute, bFunc, bVars, zRes);
+        return zRes;
+    }
+} /* end of extraZddSymmPairsCompute */
+
+/**Function********************************************************************
+
+  Synopsis    [Performs a recursive step of Extra_zddGetSymmetricVars.]
+
+  Description [Returns the set of ZDD singletons, containing those positive
+  ZDD variables that correspond to BDD variables x, for which it is true 
+  that bF(x=0) == bG(x=1).]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraZddGetSymmetricVars( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bF,       /* the first function  - originally, the positive cofactor */
+  DdNode * bG,       /* the second function - originally, the negative cofactor */
+  DdNode * bVars)    /* the set of variables, on which F and G depend */
+{
+    DdNode * zRes;
+    DdNode * bFR = Cudd_Regular(bF); 
+    DdNode * bGR = Cudd_Regular(bG); 
+
+    if ( cuddIsConstant(bFR) && cuddIsConstant(bGR) )
+    {
+        if ( bF == bG )
+            return extraZddGetSingletons( dd, bVars );
+        else 
+            return z0;
+    }
+    assert( bVars != b1 );
+
+    if ( zRes = cuddCacheLookupZdd(dd, DD_GET_SYMM_VARS_TAG, bF, bG, bVars) )
+        return zRes;
+    else
+    {
+        DdNode * zRes0, * zRes1;             
+        DdNode * zPlus, * zTemp;
+        DdNode * bF0, * bF1;             
+        DdNode * bG0, * bG1;             
+        DdNode * bVarsNew;
+    
+        int LevelF = cuddI(dd,bFR->index);
+        int LevelG = cuddI(dd,bGR->index);
+        int LevelFG;
+
+        if ( LevelF < LevelG )
+            LevelFG = LevelF;
+        else
+            LevelFG = LevelG;
+
+        // at least one of the arguments is not a constant
+        assert( LevelFG < dd->size );
+
+        // every variable in bF and bG should be also in bVars, therefore LevelFG cannot be above LevelV
+        // if LevelFG is below LevelV, scroll through the vars in bVars to the same level as LevelFG
+        for ( bVarsNew = bVars; LevelFG > dd->perm[bVarsNew->index]; bVarsNew = cuddT(bVarsNew) );
+        assert( LevelFG == dd->perm[bVarsNew->index] );
+
+        // cofactor the functions
+        if ( LevelF == LevelFG )
+        {
+            if ( bFR != bF ) // bF is complemented 
+            {
+                bF0 = Cudd_Not( cuddE(bFR) );
+                bF1 = Cudd_Not( cuddT(bFR) );
+            }
+            else
+            {
+                bF0 = cuddE(bFR);
+                bF1 = cuddT(bFR);
+            }
+        }
+        else 
+            bF0 = bF1 = bF;
+
+        if ( LevelG == LevelFG )
+        {
+            if ( bGR != bG ) // bG is complemented 
+            {
+                bG0 = Cudd_Not( cuddE(bGR) );
+                bG1 = Cudd_Not( cuddT(bGR) );
+            }
+            else
+            {
+                bG0 = cuddE(bGR);
+                bG1 = cuddT(bGR);
+            }
+        }
+        else 
+            bG0 = bG1 = bG;
+
+        // solve subproblems
+        zRes0 = extraZddGetSymmetricVars( dd, bF0, bG0, cuddT(bVarsNew) );
+        if ( zRes0 == NULL ) 
+            return NULL;
+        cuddRef( zRes0 );
+
+        // if there is not symmetries in the negative cofactor
+        // there is no need to test the positive cofactor
+        if ( zRes0 == z0 )
+            zRes = zRes0;  // zRes takes reference
+        else
+        {
+            zRes1 = extraZddGetSymmetricVars( dd, bF1, bG1, cuddT(bVarsNew) );
+            if ( zRes1 == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes0 );
+                return NULL;
+            }
+            cuddRef( zRes1 );
+
+            // only those variables should belong to the resulting set 
+            // for which the property is true for both cofactors
+            zRes = cuddZddIntersect( dd, zRes0, zRes1 );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes0 );
+                Cudd_RecursiveDerefZdd( dd, zRes1 );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zRes0 );
+            Cudd_RecursiveDerefZdd( dd, zRes1 );
+        }
+
+        // add one more singleton if the property is true for this variable
+        if ( bF0 == bG1 )
+        {
+            zPlus = cuddZddGetNode( dd, 2*bVarsNew->index, z1, z0 );
+            if ( zPlus == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                return NULL;
+            }
+            cuddRef( zPlus );
+
+            // add these variable pairs to the result
+            zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                Cudd_RecursiveDerefZdd( dd, zPlus );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+        }
+
+        if ( bF == bG && bVars != bVarsNew )
+        { 
+            // if the functions are equal, so are their cofactors
+            // add those variables from V that are above F and G 
+
+            DdNode * bVarsExtra;
+
+            assert( LevelFG > dd->perm[bVars->index] );
+
+            // create the BDD of the extra variables
+            bVarsExtra = cuddBddExistAbstractRecur( dd, bVars, bVarsNew );
+            if ( bVarsExtra == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                return NULL;
+            }
+            cuddRef( bVarsExtra );
+
+            zPlus = extraZddGetSingletons( dd, bVarsExtra );
+            if ( zPlus == NULL )
+            {
+                Cudd_RecursiveDeref( dd, bVarsExtra );
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                return NULL;
+            }
+            cuddRef( zPlus );
+            Cudd_RecursiveDeref( dd, bVarsExtra );
+
+            // add these to the result
+            zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                Cudd_RecursiveDerefZdd( dd, zPlus );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+        }
+        cuddDeref( zRes );
+
+        cuddCacheInsert( dd, DD_GET_SYMM_VARS_TAG, bF, bG, bVars, zRes );
+        return zRes;
+    }
+}   /* end of extraZddGetSymmetricVars */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Performs a recursive step of Extra_zddGetSingletons.]
+
+  Description [Returns the set of ZDD singletons, containing those positive 
+  polarity ZDD variables that correspond to the BDD variables in bVars.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraZddGetSingletons( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bVars)    /* the set of variables */
+{
+    DdNode * zRes;
+
+    if ( bVars == b1 )
+//    if ( bVars == b0 )  // bug fixed by Jin Zhang, Jan 23, 2004
+        return z1;
+
+    if ( zRes = cuddCacheLookup1Zdd(dd, extraZddGetSingletons, bVars) )
+        return zRes;
+    else
+    {
+        DdNode * zTemp, * zPlus;          
+
+        // solve subproblem
+        zRes = extraZddGetSingletons( dd, cuddT(bVars) );
+        if ( zRes == NULL ) 
+            return NULL;
+        cuddRef( zRes );
+        
+        zPlus = cuddZddGetNode( dd, 2*bVars->index, z1, z0 );
+        if ( zPlus == NULL ) 
+        {
+            Cudd_RecursiveDerefZdd( dd, zRes );
+            return NULL;
+        }
+        cuddRef( zPlus );
+
+        // add these to the result
+        zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+        if ( zRes == NULL )
+        {
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+            return NULL;
+        }
+        cuddRef( zRes );
+        Cudd_RecursiveDerefZdd( dd, zTemp );
+        Cudd_RecursiveDerefZdd( dd, zPlus );
+        cuddDeref( zRes );
+
+        cuddCacheInsert1( dd, extraZddGetSingletons, bVars, zRes );
+        return zRes;
+    }
+}   /* end of extraZddGetSingletons */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Performs a recursive step of Extra_bddReduceVarSet.]
+
+  Description [Returns the set of all variables in the given set that are not in the 
+  support of the given function.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraBddReduceVarSet( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bVars,    /* the set of variables to be reduced */
+  DdNode * bF)       /* the function whose support is used for reduction */
+{
+    DdNode * bRes;
+    DdNode * bFR = Cudd_Regular(bF);
+
+    if ( cuddIsConstant(bFR) || bVars == b1 )
+        return bVars;
+
+    if ( bRes = cuddCacheLookup2(dd, extraBddReduceVarSet, bVars, bF) )
+        return bRes;
+    else
+    {
+        DdNode * bF0, * bF1;             
+        DdNode * bVarsThis, * bVarsLower, * bTemp;
+        int LevelF;
+
+        // if LevelF is below LevelV, scroll through the vars in bVars 
+        LevelF = dd->perm[bFR->index];
+        for ( bVarsThis = bVars; LevelF > cuddI(dd,bVarsThis->index); bVarsThis = cuddT(bVarsThis) );
+        // scroll also through the current var, because it should be not be added
+        if ( LevelF == cuddI(dd,bVarsThis->index) )
+            bVarsLower = cuddT(bVarsThis);
+        else
+            bVarsLower = bVarsThis;
+
+        // cofactor the function
+        if ( bFR != bF ) // bFunc is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+        // solve subproblems
+        bRes = extraBddReduceVarSet( dd, bVarsLower, bF0 );
+        if ( bRes == NULL ) 
+            return NULL;
+        cuddRef( bRes );
+
+        bRes = extraBddReduceVarSet( dd, bTemp = bRes, bF1 );
+        if ( bRes == NULL ) 
+        {
+            Cudd_RecursiveDeref( dd, bTemp );
+            return NULL;
+        }
+        cuddRef( bRes );
+        Cudd_RecursiveDeref( dd, bTemp );
+
+        // the current var should not be added
+        // add the skipped vars
+        if ( bVarsThis != bVars )
+        {
+            DdNode * bVarsExtra;
+
+            // extract the skipped variables
+            bVarsExtra = cuddBddExistAbstractRecur( dd, bVars, bVarsThis );
+            if ( bVarsExtra == NULL )
+            {
+                Cudd_RecursiveDeref( dd, bRes );
+                return NULL;
+            }
+            cuddRef( bVarsExtra );
+
+            // add these variables
+            bRes = cuddBddAndRecur( dd, bTemp = bRes, bVarsExtra );
+            if ( bRes == NULL ) 
+            {
+                Cudd_RecursiveDeref( dd, bTemp );
+                Cudd_RecursiveDeref( dd, bVarsExtra );
+                return NULL;
+            }
+            cuddRef( bRes );
+            Cudd_RecursiveDeref( dd, bTemp );
+            Cudd_RecursiveDeref( dd, bVarsExtra );
+        }
+        cuddDeref( bRes );
+
+        cuddCacheInsert2( dd, extraBddReduceVarSet, bVars, bF, bRes );
+        return bRes;
+    }
+}   /* end of extraBddReduceVarSet */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_bddCheckVarsSymmetric().]
+
+  Description [Returns b0 if the variables are not symmetric. Returns b1 if the
+  variables can be symmetric. The variables are represented in the form of a 
+  two-variable cube. In case the cube contains one variable (below Var1 level),
+  the cube's pointer is complemented if the variable Var1 occurred on the 
+  current path; otherwise, the cube's pointer is regular. Uses additional 
+  complemented bit (Hash_Not) to mark the result if in the BDD rooted that this
+  node there is a branch passing though the node labeled with Var2.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraBddCheckVarsSymmetric( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bF,
+  DdNode * bVars) 
+{
+    DdNode * bRes;
+
+    if ( bF == b0 )
+        return b1;
+
+    assert( bVars != b1 );
+    
+    if ( bRes = cuddCacheLookup2(dd, extraBddCheckVarsSymmetric, bF, bVars) )
+        return bRes;
+    else
+    {
+        DdNode * bRes0, * bRes1;
+        DdNode * bF0, * bF1;             
+        DdNode * bFR = Cudd_Regular(bF);
+        int LevelF = cuddI(dd,bFR->index);
+
+        DdNode * bVarsR = Cudd_Regular(bVars);
+        int fVar1Pres;
+        int iLev1;
+        int iLev2;
+
+        if ( bVarsR != bVars ) // cube's pointer is complemented
+        {
+            assert( cuddT(bVarsR) == b1 );
+            fVar1Pres = 1;                    // the first var is present on the path
+            iLev1 = -1;                       // we are already below the first var level
+            iLev2 = dd->perm[bVarsR->index];  // the level of the second var
+        }
+        else  // cube's pointer is NOT complemented
+        {
+            fVar1Pres = 0;                    // the first var is absent on the path
+            if ( cuddT(bVars) == b1 )
+            {
+                iLev1 = -1;                             // we are already below the first var level 
+                iLev2 = dd->perm[bVars->index];         // the level of the second var
+            }
+            else
+            {
+                assert( cuddT(cuddT(bVars)) == b1 );
+                iLev1 = dd->perm[bVars->index];         // the level of the first var 
+                iLev2 = dd->perm[cuddT(bVars)->index];  // the level of the second var
+            }
+        }
+
+        // cofactor the function
+        // the cofactors are needed only if we are above the second level
+        if ( LevelF < iLev2 )
+        {
+            if ( bFR != bF ) // bFunc is complemented 
+            {
+                bF0 = Cudd_Not( cuddE(bFR) );
+                bF1 = Cudd_Not( cuddT(bFR) );
+            }
+            else
+            {
+                bF0 = cuddE(bFR);
+                bF1 = cuddT(bFR);
+            }
+        }
+        else
+            bF0 = bF1 = NULL;
+
+        // consider five cases:
+        // (1) F is above iLev1
+        // (2) F is on the level iLev1
+        // (3) F is between iLev1 and iLev2
+        // (4) F is on the level iLev2
+        // (5) F is below iLev2
+
+        // (1) F is above iLev1
+        if ( LevelF < iLev1 )
+        {
+            // the returned result cannot have the hash attribute
+            // because we still did not reach the level of Var1;
+            // the attribute never travels above the level of Var1
+            bRes0 = extraBddCheckVarsSymmetric( dd, bF0, bVars );
+//          assert( !Hash_IsComplement( bRes0 ) );
+            assert( bRes0 != z0 );
+            if ( bRes0 == b0 )
+                bRes = b0;
+            else
+                bRes = extraBddCheckVarsSymmetric( dd, bF1, bVars );
+//          assert( !Hash_IsComplement( bRes ) );
+            assert( bRes != z0 );
+        }
+        // (2) F is on the level iLev1
+        else if ( LevelF == iLev1 )
+        {
+            bRes0 = extraBddCheckVarsSymmetric( dd, bF0, Cudd_Not( cuddT(bVars) ) );
+            if ( bRes0 == b0 )
+                bRes = b0;
+            else
+            {
+                bRes1 = extraBddCheckVarsSymmetric( dd, bF1, Cudd_Not( cuddT(bVars) ) );
+                if ( bRes1 == b0 )
+                    bRes = b0;
+                else
+                {
+//                  if ( Hash_IsComplement( bRes0 ) || Hash_IsComplement( bRes1 ) )
+                    if ( bRes0 == z0 || bRes1 == z0 )
+                        bRes = b1;
+                    else
+                        bRes = b0;
+                }
+            }
+        }
+        // (3) F is between iLev1 and iLev2
+        else if ( LevelF < iLev2 )
+        {
+            bRes0 = extraBddCheckVarsSymmetric( dd, bF0, bVars );
+            if ( bRes0 == b0 )
+                bRes = b0;
+            else
+            {
+                bRes1 = extraBddCheckVarsSymmetric( dd, bF1, bVars );
+                if ( bRes1 == b0 )
+                    bRes = b0;
+                else
+                {
+//                  if ( Hash_IsComplement( bRes0 ) || Hash_IsComplement( bRes1 ) )
+//                      bRes = Hash_Not( b1 );
+                    if ( bRes0 == z0 || bRes1 == z0 )
+                        bRes = z0;
+                    else
+                        bRes = b1;
+                }
+            }
+        }
+        // (4) F is on the level iLev2
+        else if ( LevelF == iLev2 )
+        {
+            // this is the only place where the hash attribute (Hash_Not) can be added 
+            // to the result; it can be added only if the path came through the node
+            // lebeled with Var1; therefore, the hash attribute cannot be returned
+            // to the caller function
+            if ( fVar1Pres )
+//              bRes = Hash_Not( b1 );
+                bRes = z0;
+            else 
+                bRes = b0;
+        }
+        // (5) F is below iLev2
+        else // if ( LevelF > iLev2 )
+        {
+            // it is possible that the path goes through the node labeled by Var1
+            // and still everything is okay; we do not label with Hash_Not here
+            // because the path does not go through node labeled by Var2
+            bRes = b1;
+        }
+
+        cuddCacheInsert2(dd, extraBddCheckVarsSymmetric, bF, bVars, bRes);
+        return bRes;
+    }
+} /* end of extraBddCheckVarsSymmetric */
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the reordering-sensitive step of Extra_zddTupleFromBdd().]
+
+  Description [Generates in a bottom-up fashion ZDD for all combinations
+               composed of k variables out of variables belonging to Support.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode* extraZddTuplesFromBdd( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bVarsK,   /* the number of variables in tuples */
+  DdNode * bVarsN)   /* the set of all variables */
+{
+    DdNode *zRes, *zRes0, *zRes1;
+    statLine(dd); 
+
+    /* terminal cases */
+/*  if ( k < 0 || k > n )
+ *      return dd->zero;
+ *  if ( n == 0 )
+ *      return dd->one; 
+ */
+    if ( cuddI( dd, bVarsK->index ) < cuddI( dd, bVarsN->index ) )
+        return z0;
+    if ( bVarsN == b1 )
+        return z1;
+
+    /* check cache */
+    zRes = cuddCacheLookup2Zdd(dd, extraZddTuplesFromBdd, bVarsK, bVarsN);
+    if (zRes)
+        return(zRes);
+
+    /* ZDD in which this variable is 0 */
+/*  zRes0 = extraZddTuplesFromBdd( dd, k,     n-1 ); */
+    zRes0 = extraZddTuplesFromBdd( dd, bVarsK, cuddT(bVarsN) );
+    if ( zRes0 == NULL ) 
+        return NULL;
+    cuddRef( zRes0 );
+
+    /* ZDD in which this variable is 1 */
+/*  zRes1 = extraZddTuplesFromBdd( dd, k-1,          n-1 ); */
+    if ( bVarsK == b1 )
+    {
+        zRes1 = z0;
+        cuddRef( zRes1 );
+    }
+    else
+    {
+        zRes1 = extraZddTuplesFromBdd( dd, cuddT(bVarsK), cuddT(bVarsN) );
+        if ( zRes1 == NULL ) 
+        {
+            Cudd_RecursiveDerefZdd( dd, zRes0 );
+            return NULL;
+        }
+        cuddRef( zRes1 );
+    }
+
+    /* compose Res0 and Res1 with the given ZDD variable */
+    zRes = cuddZddGetNode( dd, 2*bVarsN->index, zRes1, zRes0 );
+    if ( zRes == NULL ) 
+    {
+        Cudd_RecursiveDerefZdd( dd, zRes0 );
+        Cudd_RecursiveDerefZdd( dd, zRes1 );
+        return NULL;
+    }
+    cuddDeref( zRes0 );
+    cuddDeref( zRes1 );
+
+    /* insert the result into cache */
+    cuddCacheInsert2(dd, extraZddTuplesFromBdd, bVarsK, bVarsN, zRes);
+    return zRes;
+
+} /* end of extraZddTuplesFromBdd */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Performs the recursive step of Extra_zddSelectOneSubset.]
+
+  Description []
+
+  SideEffects [None]
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraZddSelectOneSubset( 
+  DdManager * dd, 
+  DdNode * zS )
+// selects one subset from the ZDD zS
+// returns z0 if and only if zS is an empty set of cubes
+{
+    DdNode * zRes;
+
+    if ( zS == z0 )    return z0;
+    if ( zS == z1 )    return z1;
+    
+    // check cache
+    if ( zRes = cuddCacheLookup1Zdd( dd, extraZddSelectOneSubset, zS ) )
+        return zRes;
+    else
+    {
+        DdNode * zS0, * zS1, * zTemp; 
+
+        zS0 = cuddE(zS);
+        zS1 = cuddT(zS);
+
+        if ( zS0 != z0 )
+        {
+            zRes = extraZddSelectOneSubset( dd, zS0 );
+            if ( zRes == NULL )
+                return NULL;
+        }
+        else // if ( zS0 == z0 )
+        {
+            assert( zS1 != z0 );
+            zRes = extraZddSelectOneSubset( dd, zS1 );
+            if ( zRes == NULL )
+                return NULL;
+            cuddRef( zRes );
+
+            zRes = cuddZddGetNode( dd, zS->index, zTemp = zRes, z0 );
+            if ( zRes == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                return NULL;
+            }
+            cuddDeref( zTemp );
+        }
+
+        // insert the result into cache
+        cuddCacheInsert1( dd, extraZddSelectOneSubset, zS, zRes );
+        return zRes;
+    }       
+} /* end of extraZddSelectOneSubset */
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static Functions                                            */
+/*---------------------------------------------------------------------------*/
diff --git a/src/misc/extra/extraBddUnate.c b/src/misc/extra/extraBddUnate.c
new file mode 100644
index 00000000..b0297c77
--- /dev/null
+++ b/src/misc/extra/extraBddUnate.c
@@ -0,0 +1,641 @@
+/**CFile****************************************************************
+
+  FileName    [extraBddUnate.c]
+
+  PackageName [extra]
+
+  Synopsis    [Efficient methods to compute the information about
+  unate variables using an algorithm that is conceptually similar to
+  the algorithm for two-variable symmetry computation presented in:
+  A. Mishchenko. Fast Computation of Symmetries in Boolean Functions. 
+  Transactions on CAD, Nov. 2003.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 2.0. Started - September 1, 2003.]
+
+  Revision    [$Id: extraBddUnate.c,v 1.0 2003/09/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the classical symmetry information for the function.]
+
+  Description [Returns the symmetry information in the form of Extra_UnateInfo_t structure.]
+
+  SideEffects [If the ZDD variables are not derived from BDD variables with
+  multiplicity 2, this function may derive them in a wrong way.]
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_UnateInfo_t * Extra_UnateComputeFast( 
+  DdManager * dd,   /* the manager */
+  DdNode * bFunc)   /* the function whose symmetries are computed */
+{
+    DdNode * bSupp;
+    DdNode * zRes;
+    Extra_UnateInfo_t * p;
+
+    bSupp = Cudd_Support( dd, bFunc );                      Cudd_Ref( bSupp );
+    zRes  = Extra_zddUnateInfoCompute( dd, bFunc, bSupp );  Cudd_Ref( zRes );
+
+    p = Extra_UnateInfoCreateFromZdd( dd, zRes, bSupp );
+
+    Cudd_RecursiveDeref( dd, bSupp );
+    Cudd_RecursiveDerefZdd( dd, zRes );
+
+    return p;
+
+} /* end of Extra_UnateInfoCompute */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the classical symmetry information as a ZDD.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_zddUnateInfoCompute( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bF,
+  DdNode * bVars) 
+{
+    DdNode * res;
+    do {
+        dd->reordered = 0;
+        res = extraZddUnateInfoCompute( dd, bF, bVars );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_zddUnateInfoCompute */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Converts a set of variables into a set of singleton subsets.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_zddGetSingletonsBoth( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bVars)    /* the set of variables */
+{
+    DdNode * res;
+    do {
+        dd->reordered = 0;
+        res = extraZddGetSingletonsBoth( dd, bVars );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_zddGetSingletonsBoth */
+
+/**Function********************************************************************
+
+  Synopsis    [Allocates unateness information structure.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_UnateInfo_t *  Extra_UnateInfoAllocate( int nVars )
+{
+    Extra_UnateInfo_t * p;
+    // allocate and clean the storage for unateness info
+    p = ALLOC( Extra_UnateInfo_t, 1 );
+    memset( p, 0, sizeof(Extra_UnateInfo_t) );
+    p->nVars     = nVars;
+    p->pVars     = ALLOC( Extra_UnateVar_t, nVars );  
+    memset( p->pVars, 0, nVars * sizeof(Extra_UnateVar_t) );
+    return p;
+} /* end of Extra_UnateInfoAllocate */
+
+/**Function********************************************************************
+
+  Synopsis    [Deallocates symmetry information structure.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_UnateInfoDissolve( Extra_UnateInfo_t * p )
+{
+    free( p->pVars );
+    free( p );
+} /* end of Extra_UnateInfoDissolve */
+
+/**Function********************************************************************
+
+  Synopsis    [Allocates symmetry information structure.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_UnateInfoPrint( Extra_UnateInfo_t * p )
+{
+    char * pBuffer;
+    int i;
+    pBuffer = ALLOC( char, p->nVarsMax+1 );
+    memset( pBuffer, ' ', p->nVarsMax );
+    pBuffer[p->nVarsMax] = 0;
+    for ( i = 0; i < p->nVars; i++ )
+        if ( p->pVars[i].Neg )
+            pBuffer[ p->pVars[i].iVar ] = 'n';
+        else if ( p->pVars[i].Pos )
+            pBuffer[ p->pVars[i].iVar ] = 'p';
+        else
+            pBuffer[ p->pVars[i].iVar ] = '.';
+    printf( "%s\n", pBuffer );
+    free( pBuffer );
+} /* end of Extra_UnateInfoPrint */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Creates the symmetry information structure from ZDD.]
+
+  Description [ZDD representation of symmetries is the set of cubes, each
+  of which has two variables in the positive polarity. These variables correspond
+  to the symmetric variable pair.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_UnateInfo_t * Extra_UnateInfoCreateFromZdd( DdManager * dd, DdNode * zPairs, DdNode * bSupp )
+{
+    Extra_UnateInfo_t * p;
+    DdNode * bTemp, * zSet, * zCube, * zTemp;
+    int * pMapVars2Nums;
+    int i, nSuppSize;
+
+    nSuppSize = Extra_bddSuppSize( dd, bSupp );
+
+    // allocate and clean the storage for symmetry info
+    p = Extra_UnateInfoAllocate( nSuppSize );
+
+    // allocate the storage for the temporary map
+    pMapVars2Nums = ALLOC( int, dd->size );
+    memset( pMapVars2Nums, 0, dd->size * sizeof(int) );
+
+    // assign the variables
+    p->nVarsMax = dd->size;
+    for ( i = 0, bTemp = bSupp; bTemp != b1; bTemp = cuddT(bTemp), i++ )
+    {
+        p->pVars[i].iVar = bTemp->index;
+        pMapVars2Nums[bTemp->index] = i;
+    }
+
+    // write the symmetry info into the structure
+    zSet = zPairs;   Cudd_Ref( zSet );
+//    Cudd_zddPrintCover( dd, zPairs );    printf( "\n" );
+    while ( zSet != z0 )
+    {
+        // get the next cube
+        zCube  = Extra_zddSelectOneSubset( dd, zSet );    Cudd_Ref( zCube );
+
+        // add this var to the data structure
+        assert( cuddT(zCube) == z1 && cuddE(zCube) == z0 );
+        if ( zCube->index & 1 ) // neg
+            p->pVars[ pMapVars2Nums[zCube->index/2] ].Neg = 1;
+        else
+            p->pVars[ pMapVars2Nums[zCube->index/2] ].Pos = 1;
+        // count the unate vars
+        p->nUnate++;
+
+        // update the cuver and deref the cube
+        zSet = Cudd_zddDiff( dd, zTemp = zSet, zCube );     Cudd_Ref( zSet );
+        Cudd_RecursiveDerefZdd( dd, zTemp );
+        Cudd_RecursiveDerefZdd( dd, zCube );
+
+    } // for each cube 
+    Cudd_RecursiveDerefZdd( dd, zSet );
+    FREE( pMapVars2Nums );
+    return p;
+
+} /* end of Extra_UnateInfoCreateFromZdd */
+
+
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the classical unateness information for the function.]
+
+  Description [Uses the naive way of comparing cofactors.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+Extra_UnateInfo_t * Extra_UnateComputeSlow( DdManager * dd, DdNode * bFunc )
+{
+    int nSuppSize;
+    DdNode * bSupp, * bTemp;
+    Extra_UnateInfo_t * p;
+    int i, Res;
+
+    // compute the support
+    bSupp = Cudd_Support( dd, bFunc );   Cudd_Ref( bSupp );
+    nSuppSize = Extra_bddSuppSize( dd, bSupp );
+//printf( "Support = %d. ", nSuppSize );
+//Extra_bddPrint( dd, bSupp );
+//printf( "%d ", nSuppSize );
+
+    // allocate the storage for symmetry info
+    p = Extra_UnateInfoAllocate( nSuppSize );
+
+    // assign the variables
+    p->nVarsMax = dd->size;
+    for ( i = 0, bTemp = bSupp; bTemp != b1; bTemp = cuddT(bTemp), i++ )
+    {
+        Res = Extra_bddCheckUnateNaive( dd, bFunc, bTemp->index );
+        p->pVars[i].iVar = bTemp->index;
+        if ( Res == -1 )
+            p->pVars[i].Neg = 1;
+        else if ( Res == 1 )
+            p->pVars[i].Pos = 1;
+        p->nUnate += (Res != 0);
+    }
+    Cudd_RecursiveDeref( dd, bSupp );
+    return p;
+
+} /* end of Extra_UnateComputeSlow */
+
+/**Function********************************************************************
+
+  Synopsis    [Checks if the two variables are symmetric.]
+
+  Description [Returns 0 if vars are not unate. Return -1/+1 if the var is neg/pos unate.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_bddCheckUnateNaive( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bF,
+  int iVar) 
+{
+    DdNode * bCof0, * bCof1;
+    int Res;
+
+    assert( iVar < dd->size );
+
+    bCof0 = Cudd_Cofactor( dd, bF, Cudd_Not(Cudd_bddIthVar(dd,iVar)) );  Cudd_Ref( bCof0 );
+    bCof1 = Cudd_Cofactor( dd, bF, Cudd_bddIthVar(dd,iVar) );            Cudd_Ref( bCof1 );
+
+    if ( Cudd_bddLeq( dd, bCof0, bCof1 ) )
+        Res = 1;
+    else if ( Cudd_bddLeq( dd, bCof1, bCof0 ) )
+        Res =-1;
+    else
+        Res = 0;
+
+    Cudd_RecursiveDeref( dd, bCof0 );
+    Cudd_RecursiveDeref( dd, bCof1 );
+    return Res;
+} /* end of Extra_bddCheckUnateNaive */
+
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Performs a recursive step of Extra_UnateInfoCompute.]
+
+  Description [Returns the set of symmetric variable pairs represented as a set 
+  of two-literal ZDD cubes. Both variables always appear in the positive polarity
+  in the cubes. This function works without building new BDD nodes. Some relatively 
+  small number of ZDD nodes may be built to ensure proper bookkeeping of the 
+  symmetry information.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * 
+extraZddUnateInfoCompute( 
+  DdManager * dd,   /* the manager */
+  DdNode * bFunc,   /* the function whose symmetries are computed */
+  DdNode * bVars )  /* the set of variables on which this function depends */
+{
+    DdNode * zRes;
+    DdNode * bFR = Cudd_Regular(bFunc); 
+
+    if ( cuddIsConstant(bFR) )
+    {
+        if ( cuddIsConstant(bVars) )
+            return z0;
+        return extraZddGetSingletonsBoth( dd, bVars );
+    }
+    assert( bVars != b1 );
+
+    if ( zRes = cuddCacheLookup2Zdd(dd, extraZddUnateInfoCompute, bFunc, bVars) )
+        return zRes;
+    else
+    {
+        DdNode * zRes0, * zRes1;
+        DdNode * zTemp, * zPlus;             
+        DdNode * bF0, * bF1;             
+        DdNode * bVarsNew;
+        int nVarsExtra;
+        int LevelF;
+        int AddVar;
+
+        // every variable in bF should be also in bVars, therefore LevelF cannot be above LevelV
+        // if LevelF is below LevelV, scroll through the vars in bVars to the same level as F
+        // count how many extra vars are there in bVars
+        nVarsExtra = 0;
+        LevelF = dd->perm[bFR->index];
+        for ( bVarsNew = bVars; LevelF > dd->perm[bVarsNew->index]; bVarsNew = cuddT(bVarsNew) )
+            nVarsExtra++; 
+        // the indexes (level) of variables should be synchronized now
+        assert( bFR->index == bVarsNew->index );
+
+        // cofactor the function
+        if ( bFR != bFunc ) // bFunc is complemented 
+        {
+            bF0 = Cudd_Not( cuddE(bFR) );
+            bF1 = Cudd_Not( cuddT(bFR) );
+        }
+        else
+        {
+            bF0 = cuddE(bFR);
+            bF1 = cuddT(bFR);
+        }
+
+        // solve subproblems
+        zRes0 = extraZddUnateInfoCompute( dd, bF0, cuddT(bVarsNew) );
+        if ( zRes0 == NULL )
+            return NULL;
+        cuddRef( zRes0 );
+
+        // if there is no symmetries in the negative cofactor
+        // there is no need to test the positive cofactor
+        if ( zRes0 == z0 )
+            zRes = zRes0;  // zRes takes reference
+        else
+        {
+            zRes1 = extraZddUnateInfoCompute( dd, bF1, cuddT(bVarsNew) );
+            if ( zRes1 == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes0 );
+                return NULL;
+            }
+            cuddRef( zRes1 );
+
+            // only those variables are pair-wise symmetric 
+            // that are pair-wise symmetric in both cofactors
+            // therefore, intersect the solutions
+            zRes = cuddZddIntersect( dd, zRes0, zRes1 );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes0 );
+                Cudd_RecursiveDerefZdd( dd, zRes1 );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zRes0 );
+            Cudd_RecursiveDerefZdd( dd, zRes1 );
+        }
+
+        // consider the current top-most variable
+        AddVar = -1;
+        if ( Cudd_bddLeq( dd, bF0, bF1 ) ) // pos
+            AddVar = 0;
+        else if ( Cudd_bddLeq( dd, bF1, bF0 ) ) // neg
+            AddVar = 1;
+        if ( AddVar >= 0 )
+        {
+            // create the singleton
+            zPlus = cuddZddGetNode( dd, 2*bFR->index + AddVar, z1, z0 );
+            if ( zPlus == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                return NULL;
+            }
+            cuddRef( zPlus );
+
+            // add these to the result
+            zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                Cudd_RecursiveDerefZdd( dd, zPlus );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+        }
+        // only zRes is referenced at this point
+
+        // if we skipped some variables, these variables cannot be symmetric with
+        // any variables that are currently in the support of bF, but they can be 
+        // symmetric with the variables that are in bVars but not in the support of bF
+        for ( bVarsNew = bVars; LevelF > dd->perm[bVarsNew->index]; bVarsNew = cuddT(bVarsNew) )
+        {
+            // create the negative singleton
+            zPlus = cuddZddGetNode( dd, 2*bVarsNew->index+1, z1, z0 );
+            if ( zPlus == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                return NULL;
+            }
+            cuddRef( zPlus );
+
+            // add these to the result
+            zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                Cudd_RecursiveDerefZdd( dd, zPlus );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+        
+
+            // create the positive singleton
+            zPlus = cuddZddGetNode( dd, 2*bVarsNew->index, z1, z0 );
+            if ( zPlus == NULL ) 
+            {
+                Cudd_RecursiveDerefZdd( dd, zRes );
+                return NULL;
+            }
+            cuddRef( zPlus );
+
+            // add these to the result
+            zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+            if ( zRes == NULL )
+            {
+                Cudd_RecursiveDerefZdd( dd, zTemp );
+                Cudd_RecursiveDerefZdd( dd, zPlus );
+                return NULL;
+            }
+            cuddRef( zRes );
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+        }
+        cuddDeref( zRes );
+
+        /* insert the result into cache */
+        cuddCacheInsert2(dd, extraZddUnateInfoCompute, bFunc, bVars, zRes);
+        return zRes;
+    }
+} /* end of extraZddUnateInfoCompute */
+
+
+/**Function********************************************************************
+
+  Synopsis    [Performs a recursive step of Extra_zddGetSingletons.]
+
+  Description [Returns the set of ZDD singletons, containing those pos/neg 
+  polarity ZDD variables that correspond to the BDD variables in bVars.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraZddGetSingletonsBoth( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bVars)    /* the set of variables */
+{
+    DdNode * zRes;
+
+    if ( bVars == b1 )
+        return z1;
+
+    if ( zRes = cuddCacheLookup1Zdd(dd, extraZddGetSingletonsBoth, bVars) )
+        return zRes;
+    else
+    {
+        DdNode * zTemp, * zPlus;          
+
+        // solve subproblem
+        zRes = extraZddGetSingletonsBoth( dd, cuddT(bVars) );
+        if ( zRes == NULL ) 
+            return NULL;
+        cuddRef( zRes );
+
+        
+        // create the negative singleton
+        zPlus = cuddZddGetNode( dd, 2*bVars->index+1, z1, z0 );
+        if ( zPlus == NULL ) 
+        {
+            Cudd_RecursiveDerefZdd( dd, zRes );
+            return NULL;
+        }
+        cuddRef( zPlus );
+
+        // add these to the result
+        zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+        if ( zRes == NULL )
+        {
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+            return NULL;
+        }
+        cuddRef( zRes );
+        Cudd_RecursiveDerefZdd( dd, zTemp );
+        Cudd_RecursiveDerefZdd( dd, zPlus );
+        
+
+        // create the positive singleton
+        zPlus = cuddZddGetNode( dd, 2*bVars->index, z1, z0 );
+        if ( zPlus == NULL ) 
+        {
+            Cudd_RecursiveDerefZdd( dd, zRes );
+            return NULL;
+        }
+        cuddRef( zPlus );
+
+        // add these to the result
+        zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
+        if ( zRes == NULL )
+        {
+            Cudd_RecursiveDerefZdd( dd, zTemp );
+            Cudd_RecursiveDerefZdd( dd, zPlus );
+            return NULL;
+        }
+        cuddRef( zRes );
+        Cudd_RecursiveDerefZdd( dd, zTemp );
+        Cudd_RecursiveDerefZdd( dd, zPlus );
+
+        cuddDeref( zRes );
+        cuddCacheInsert1( dd, extraZddGetSingletonsBoth, bVars, zRes );
+        return zRes;
+    }
+}   /* end of extraZddGetSingletonsBoth */
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static Functions                                            */
+/*---------------------------------------------------------------------------*/
diff --git a/src/misc/extra/extraUtilBitMatrix.c b/src/misc/extra/extraUtilBitMatrix.c
new file mode 100644
index 00000000..b860a538
--- /dev/null
+++ b/src/misc/extra/extraUtilBitMatrix.c
@@ -0,0 +1,415 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilBitMatrix.c]
+
+  PackageName [extra]
+
+  Synopsis    [Various reusable software utilities.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - September 1, 2003.]
+
+  Revision    [$Id: extraUtilBitMatrix.c,v 1.0 2003/09/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+struct Extra_BitMat_t_
+{
+    unsigned ** ppData;      // bit data
+    int         nSize;       // the number of bits in one dimension
+    int         nWords;      // the number of words in one dimension
+    int         nBitShift;   // the number of bits to shift to get words
+    unsigned    uMask;       // the mask to get the number of bits in the word
+    int         nLookups;    // the number of lookups  
+    int         nInserts;    // the number of inserts
+    int         nDeletes;    // the number of deletions
+};
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function*************************************************************
+
+  Synopsis    [Starts the bit matrix.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Extra_BitMat_t * Extra_BitMatrixStart( int nSize )
+{
+    Extra_BitMat_t * p;
+    int i;
+    p = ALLOC( Extra_BitMat_t, 1 );
+    memset( p, 0, sizeof(Extra_BitMat_t) );
+    p->nSize     = nSize;
+    p->nBitShift = (sizeof(unsigned) == 4) ?  5:  6;
+    p->uMask     = (sizeof(unsigned) == 4) ? 31: 63;
+    p->nWords    = nSize / (8 * sizeof(unsigned)) + ((nSize % (8 * sizeof(unsigned))) > 0);
+    p->ppData    = ALLOC( unsigned *, nSize );
+    p->ppData[0] = ALLOC( unsigned, nSize * p->nWords );
+    memset( p->ppData[0], 0, sizeof(unsigned) * nSize * p->nWords );
+    for ( i = 1; i < nSize; i++ )
+        p->ppData[i] = p->ppData[i-1] + p->nWords;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Stops the bit matrix.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixClean( Extra_BitMat_t * p )
+{
+    memset( p->ppData[0], 0, sizeof(unsigned) * p->nSize * p->nWords );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Stops the bit matrix.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixStop( Extra_BitMat_t * p )
+{
+    FREE( p->ppData[0] );
+    FREE( p->ppData );
+    FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the bit-matrix.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixPrint( Extra_BitMat_t * pMat )
+{
+    int i, k, nVars;
+    printf( "\n" );
+    nVars = Extra_BitMatrixReadSize( pMat );
+    for ( i = 0; i < nVars; i++ )
+    {
+        for ( k = 0; k <= i; k++ )
+            printf( " " );
+        for ( k = i+1; k < nVars; k++ )
+            if ( Extra_BitMatrixLookup1( pMat, i, k ) )
+                printf( "1" );
+            else
+                printf( "." );
+        printf( "\n" );
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Reads the matrix size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_BitMatrixReadSize( Extra_BitMat_t * p )
+{
+    return p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixInsert1( Extra_BitMat_t * p, int i, int k )
+{
+    p->nInserts++;
+    if ( i < k )
+        p->ppData[i][k>>p->nBitShift] |= (1<<(k & p->uMask));
+    else
+        p->ppData[k][i>>p->nBitShift] |= (1<<(i & p->uMask));
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_BitMatrixLookup1( Extra_BitMat_t * p, int i, int k )
+{
+    p->nLookups++;
+    if ( i < k )
+        return ((p->ppData[i][k>>p->nBitShift] & (1<<(k & p->uMask))) > 0);
+    else
+        return ((p->ppData[k][i>>p->nBitShift] & (1<<(i & p->uMask))) > 0);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixDelete1( Extra_BitMat_t * p, int i, int k )
+{
+    p->nDeletes++;
+    if ( i < k )
+        p->ppData[i][k>>p->nBitShift] &= ~(1<<(k & p->uMask));
+    else
+        p->ppData[k][i>>p->nBitShift] &= ~(1<<(i & p->uMask));
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixInsert2( Extra_BitMat_t * p, int i, int k )
+{
+    p->nInserts++;
+    if ( i > k )
+        p->ppData[i][k>>p->nBitShift] |= (1<<(k & p->uMask));
+    else
+        p->ppData[k][i>>p->nBitShift] |= (1<<(i & p->uMask));
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_BitMatrixLookup2( Extra_BitMat_t * p, int i, int k )
+{
+    p->nLookups++;
+    if ( i > k )
+        return ((p->ppData[i][k>>p->nBitShift] & (1<<(k & p->uMask))) > 0);
+    else
+        return ((p->ppData[k][i>>p->nBitShift] & (1<<(i & p->uMask))) > 0);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixDelete2( Extra_BitMat_t * p, int i, int k )
+{
+    p->nDeletes++;
+    if ( i > k )
+        p->ppData[i][k>>p->nBitShift] &= ~(1<<(k & p->uMask));
+    else
+        p->ppData[k][i>>p->nBitShift] &= ~(1<<(i & p->uMask));
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixOr( Extra_BitMat_t * p, int i, unsigned * pInfo )
+{
+    int w;
+    for ( w = 0; w < p->nWords; w++ )
+        p->ppData[i][w] |= pInfo[w];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the element into the upper part.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BitMatrixOrTwo( Extra_BitMat_t * p, int i, int j )
+{
+    int w;
+    for ( w = 0; w < p->nWords; w++ )
+        p->ppData[i][w] = p->ppData[j][w] = (p->ppData[i][w] | p->ppData[j][w]);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of 1's in the upper rectangle.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_BitMatrixCountOnesUpper( Extra_BitMat_t * p )
+{
+    int i, k, nTotal = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        for ( k = i + 1; k < p->nSize; k++ )
+            nTotal += ( (p->ppData[i][k>>5] & (1 << (k&31))) > 0 );
+    return nTotal;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns 1 if the matrices have no entries in common.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_BitMatrixIsDisjoint( Extra_BitMat_t * p1, Extra_BitMat_t * p2 )
+{
+    int i, w;
+    assert( p1->nSize == p2->nSize );
+    for ( i = 0; i < p1->nSize; i++ )
+        for ( w = 0; w < p1->nWords; w++ )
+            if ( p1->ppData[i][w] & p2->ppData[i][w] )
+                return 0;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns 1 if the matrix is a set of cliques.]
+
+  Description [For example pairwise symmetry info should satisfy this property.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_BitMatrixIsClique( Extra_BitMat_t * pMat )
+{
+    int v, u, i;
+    for ( v = 0; v < pMat->nSize; v++ )
+    for ( u = v+1; u < pMat->nSize; u++ )
+    {
+        if ( !Extra_BitMatrixLookup1( pMat, v, u ) )
+            continue;
+        // v and u are symmetric
+        for ( i = 0; i < pMat->nSize; i++ )
+        {
+            if ( i == v || i == u )
+                continue;
+            // i is neither v nor u
+            // the symmetry status of i is the same w.r.t. to v and u
+            if ( Extra_BitMatrixLookup1( pMat, i, v ) != Extra_BitMatrixLookup1( pMat, i, u ) )
+                return 0;
+        }
+    }
+    return 1;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraUtilCanon.c b/src/misc/extra/extraUtilCanon.c
new file mode 100644
index 00000000..fcc7d84d
--- /dev/null
+++ b/src/misc/extra/extraUtilCanon.c
@@ -0,0 +1,701 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilMisc.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [Computing canonical forms of Boolean functions using truth tables.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilMisc.c,v 1.0 2003/09/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+static unsigned s_Truths3[256];
+static char s_Phases3[256][9];
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+static int Extra_TruthCanonN_rec( int nVars, unsigned char * pt, unsigned ** pptRes, char ** ppfRes, int Flag );
+
+/**AutomaticEnd***************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the N-canonical form of the Boolean function up to 6 inputs.]
+
+  Description [The N-canonical form is defined as the truth table with 
+  the minimum integer value. This function exhaustively enumerates 
+  through the complete set of 2^N phase assignments.
+  Returns pointers to the static storage to the truth table and phases. 
+  This data should be used before the function is called again.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_TruthCanonFastN( int nVarsMax, int nVarsReal, unsigned * pt, unsigned ** pptRes, char ** ppfRes )
+{
+    static unsigned uTruthStore6[2];
+    int RetValue;
+    assert( nVarsMax <= 6 );
+    assert( nVarsReal <= nVarsMax );
+    RetValue = Extra_TruthCanonN_rec( nVarsReal <= 3? 3: nVarsReal, (unsigned char *)pt, pptRes, ppfRes, 0 );
+    if ( nVarsMax == 6 && nVarsReal < nVarsMax )
+    {
+        uTruthStore6[0] = **pptRes;
+        uTruthStore6[1] = **pptRes;
+        *pptRes = uTruthStore6;
+    }
+    return RetValue;
+}
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function*************************************************************
+
+  Synopsis    [Recursive implementation of the above.]
+
+  Description []
+               
+  SideEffects [This procedure has a bug, which shows on Solaris.
+  Most likely has something to do with the casts, i.g *((unsigned *)pt0)]
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_TruthCanonN_rec( int nVars, unsigned char * pt, unsigned ** pptRes, char ** ppfRes, int Flag )
+{
+    static unsigned uTruthStore[7][2][2];
+    static char uPhaseStore[7][2][64];
+
+    unsigned char * pt0, * pt1;
+    unsigned * ptRes0, * ptRes1, * ptRes;
+    unsigned uInit0, uInit1, uTruth0, uTruth1, uTemp;
+    char * pfRes0, * pfRes1, * pfRes;
+    int nf0, nf1, nfRes, i, nVarsN;
+
+    // table lookup for three vars
+    if ( nVars == 3 )
+    {
+        *pptRes = &s_Truths3[*pt];
+        *ppfRes = s_Phases3[*pt]+1;
+        return s_Phases3[*pt][0];
+    }
+
+    // number of vars for the next call
+    nVarsN = nVars-1;
+    // truth table for the next call
+    pt0 = pt;
+    pt1 = pt + (1 << nVarsN) / 8;
+    // 5-var truth tables for this call
+//    uInit0 = *((unsigned *)pt0);
+//    uInit1 = *((unsigned *)pt1);
+    if ( nVarsN == 3 )
+    {
+        uInit0 = (pt0[0] << 24) | (pt0[0] << 16) | (pt0[0] << 8) | pt0[0];
+        uInit1 = (pt1[0] << 24) | (pt1[0] << 16) | (pt1[0] << 8) | pt1[0];
+    }
+    else if ( nVarsN == 4 )
+    {
+        uInit0 = (pt0[1] << 24) | (pt0[0] << 16) | (pt0[1] << 8) | pt0[0];
+        uInit1 = (pt1[1] << 24) | (pt1[0] << 16) | (pt1[1] << 8) | pt1[0];
+    }
+    else
+    {
+        uInit0 = (pt0[3] << 24) | (pt0[2] << 16) | (pt0[1] << 8) | pt0[0];
+        uInit1 = (pt1[3] << 24) | (pt1[2] << 16) | (pt1[1] << 8) | pt1[0];
+    }
+
+    // storage for truth tables and phases
+    ptRes  = uTruthStore[nVars][Flag];
+    pfRes  = uPhaseStore[nVars][Flag];
+
+    // solve trivial cases
+    if ( uInit1 == 0 )
+    {
+        nf0 = Extra_TruthCanonN_rec( nVarsN, pt0, &ptRes0, &pfRes0, 0 );
+        uTruth1 = uInit1;
+        uTruth0 = *ptRes0;
+        nfRes   = 0;
+        for ( i = 0; i < nf0; i++ )
+            pfRes[nfRes++] = pfRes0[i];
+        goto finish;
+    }
+    if ( uInit0 == 0 )
+    {
+        nf1 = Extra_TruthCanonN_rec( nVarsN, pt1, &ptRes1, &pfRes1, 1 );
+        uTruth1 = uInit0;
+        uTruth0 = *ptRes1;
+        nfRes   = 0;
+        for ( i = 0; i < nf1; i++ )
+            pfRes[nfRes++] = pfRes1[i] | (1<<nVarsN);
+        goto finish;
+    }
+
+    if ( uInit1 == 0xFFFFFFFF )
+    {
+        nf0 = Extra_TruthCanonN_rec( nVarsN, pt0, &ptRes0, &pfRes0, 0 );
+        uTruth1 = *ptRes0;
+        uTruth0 = uInit1;
+        nfRes   = 0;
+        for ( i = 0; i < nf0; i++ )
+            pfRes[nfRes++] = pfRes0[i] | (1<<nVarsN);
+        goto finish;
+    }
+    if ( uInit0 == 0xFFFFFFFF )
+    {
+        nf1 = Extra_TruthCanonN_rec( nVarsN, pt1, &ptRes1, &pfRes1, 1 );
+        uTruth1 = *ptRes1;
+        uTruth0 = uInit0;
+        nfRes   = 0;
+        for ( i = 0; i < nf1; i++ )
+            pfRes[nfRes++] = pfRes1[i];
+        goto finish;
+    }
+
+    // solve the problem for cofactors
+    nf0 = Extra_TruthCanonN_rec( nVarsN, pt0, &ptRes0, &pfRes0, 0 );
+    nf1 = Extra_TruthCanonN_rec( nVarsN, pt1, &ptRes1, &pfRes1, 1 );
+
+    // combine the result
+    if ( *ptRes1 < *ptRes0 )
+    {
+        uTruth0 = 0xFFFFFFFF;
+        nfRes   = 0;
+        for ( i = 0; i < nf1; i++ )
+        {
+            uTemp = Extra_TruthPolarize( uInit0, pfRes1[i], nVarsN );
+            if ( uTruth0 > uTemp )
+            {
+                nfRes          = 0;
+                uTruth0        = uTemp;
+                pfRes[nfRes++] = pfRes1[i];
+            }
+            else if ( uTruth0 == uTemp ) 
+                pfRes[nfRes++] = pfRes1[i];
+        }
+        uTruth1 = *ptRes1;
+    }
+    else if ( *ptRes1 > *ptRes0 )
+    {
+        uTruth0 = 0xFFFFFFFF;
+        nfRes   = 0;
+        for ( i = 0; i < nf0; i++ )
+        {
+            uTemp = Extra_TruthPolarize( uInit1, pfRes0[i], nVarsN );
+            if ( uTruth0 > uTemp )
+            {
+                nfRes          = 0;
+                uTruth0        = uTemp;
+                pfRes[nfRes++] = pfRes0[i] | (1<<nVarsN);
+            }
+            else if ( uTruth0 == uTemp ) 
+                pfRes[nfRes++] = pfRes0[i] | (1<<nVarsN);
+        }
+        uTruth1 = *ptRes0;
+    }
+    else 
+    {
+        assert( nf0 == nf1 );
+        nfRes = 0; 
+        for ( i = 0; i < nf1; i++ )
+            pfRes[nfRes++] = pfRes1[i];
+        for ( i = 0; i < nf0; i++ )
+            pfRes[nfRes++] = pfRes0[i] | (1<<nVarsN);
+        uTruth0 = Extra_TruthPolarize( uInit0, pfRes1[0], nVarsN );
+        uTruth1 = *ptRes0;
+    }
+
+finish :
+    if ( nVarsN == 3 )
+    {
+        uTruth0 &= 0xFF;
+        uTruth1 &= 0xFF;
+        uTemp = (uTruth1 << 8) | uTruth0;
+        *ptRes = (uTemp << 16) | uTemp;
+    }
+    else if ( nVarsN == 4 )
+    {
+        uTruth0 &= 0xFFFF;
+        uTruth1 &= 0xFFFF;
+        *ptRes = (uTruth1 << 16) | uTruth0;
+    }
+    else if ( nVarsN == 5 )
+    {
+        *(ptRes+0) = uTruth0;
+        *(ptRes+1) = uTruth1;
+    }
+
+    *pptRes = ptRes;
+    *ppfRes = pfRes;
+    return nfRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Map_Var3Print()
+{
+    extern void Extra_Truth3VarN( unsigned ** puCanons, char *** puPhases, char ** ppCounters );
+
+    unsigned * uCanons;
+    char ** uPhases;
+    char * pCounters;
+    int i, k;
+
+    Extra_Truth3VarN( &uCanons, &uPhases, &pCounters );
+
+    for ( i = 0; i < 256; i++ )
+    {
+        if ( i % 8 == 0 )
+            printf( "\n" );
+        Extra_PrintHex( stdout, uCanons[i], 5 ); 
+        printf( ", " );
+    }
+    printf( "\n" );
+
+    for ( i = 0; i < 256; i++ )
+    {
+        printf( "%3d */  { %2d,   ", i, pCounters[i] );
+        for ( k = 0; k < pCounters[i]; k++ )            
+            printf( "%s%d", k? ", ":"", uPhases[i][k] );
+        printf( " }\n" );
+    }
+    printf( "\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Map_Var3Test()
+{
+    extern void Extra_Truth3VarN( unsigned ** puCanons, char *** puPhases, char ** ppCounters );
+
+    unsigned * uCanons;
+    char ** uPhases;
+    char * pCounters;
+    int i;
+    unsigned * ptRes;
+    char * pfRes;
+    unsigned uTruth;
+    int Count;
+
+    Extra_Truth3VarN( &uCanons, &uPhases, &pCounters );
+
+    for ( i = 0; i < 256; i++ )
+    {
+        uTruth = i;
+        Count =  Extra_TruthCanonFastN( 5, 3, &uTruth, &ptRes, &pfRes );
+        if ( *ptRes != uCanons[i] || Count != pCounters[i] )
+        {
+            int k = 0;
+        }
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Map_Var4Test()
+{
+    extern void Extra_Truth4VarN( unsigned short ** puCanons, char *** puPhases, char ** ppCounters, int PhaseMax );
+
+    unsigned short * uCanons;
+    char ** uPhases;
+    char * pCounters;
+    int i, k;
+    unsigned * ptRes;
+    char * pfRes;
+    unsigned uTruth;
+    int Count;
+
+    Extra_Truth4VarN( &uCanons, &uPhases, &pCounters, 16 );
+
+    for ( i = 0; i < 256*256; i++ )
+    {
+        uTruth = i;
+        Count =  Extra_TruthCanonFastN( 5, 4, &uTruth, &ptRes, &pfRes );
+        if ( (*ptRes & 0xFFFF) != uCanons[i] || Count != pCounters[i] )
+        {
+            int k = 0;
+        }
+        for ( k = 0; k < Count; k++ )
+            if ( uPhases[i][k] != pfRes[k] )
+            {
+                int v = 0;
+            }
+    }
+}
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static Functions                                            */
+/*---------------------------------------------------------------------------*/
+
+static unsigned s_Truths3[256] = 
+{
+    0x00000000, 0x01010101, 0x01010101, 0x03030303, 0x01010101, 0x05050505, 0x06060606, 0x07070707,
+    0x01010101, 0x06060606, 0x05050505, 0x07070707, 0x03030303, 0x07070707, 0x07070707, 0x0f0f0f0f,
+    0x01010101, 0x11111111, 0x12121212, 0x13131313, 0x14141414, 0x15151515, 0x16161616, 0x17171717,
+    0x18181818, 0x19191919, 0x1a1a1a1a, 0x1b1b1b1b, 0x1c1c1c1c, 0x1d1d1d1d, 0x1e1e1e1e, 0x1f1f1f1f,
+    0x01010101, 0x12121212, 0x11111111, 0x13131313, 0x18181818, 0x1a1a1a1a, 0x19191919, 0x1b1b1b1b,
+    0x14141414, 0x16161616, 0x15151515, 0x17171717, 0x1c1c1c1c, 0x1e1e1e1e, 0x1d1d1d1d, 0x1f1f1f1f,
+    0x03030303, 0x13131313, 0x13131313, 0x33333333, 0x1c1c1c1c, 0x35353535, 0x36363636, 0x37373737,
+    0x1c1c1c1c, 0x36363636, 0x35353535, 0x37373737, 0x3c3c3c3c, 0x3d3d3d3d, 0x3d3d3d3d, 0x3f3f3f3f,
+    0x01010101, 0x14141414, 0x18181818, 0x1c1c1c1c, 0x11111111, 0x15151515, 0x19191919, 0x1d1d1d1d,
+    0x12121212, 0x16161616, 0x1a1a1a1a, 0x1e1e1e1e, 0x13131313, 0x17171717, 0x1b1b1b1b, 0x1f1f1f1f,
+    0x05050505, 0x15151515, 0x1a1a1a1a, 0x35353535, 0x15151515, 0x55555555, 0x56565656, 0x57575757,
+    0x1a1a1a1a, 0x56565656, 0x5a5a5a5a, 0x5b5b5b5b, 0x35353535, 0x57575757, 0x5b5b5b5b, 0x5f5f5f5f,
+    0x06060606, 0x16161616, 0x19191919, 0x36363636, 0x19191919, 0x56565656, 0x66666666, 0x67676767,
+    0x16161616, 0x69696969, 0x56565656, 0x6b6b6b6b, 0x36363636, 0x6b6b6b6b, 0x67676767, 0x6f6f6f6f,
+    0x07070707, 0x17171717, 0x1b1b1b1b, 0x37373737, 0x1d1d1d1d, 0x57575757, 0x67676767, 0x77777777,
+    0x1e1e1e1e, 0x6b6b6b6b, 0x5b5b5b5b, 0x7b7b7b7b, 0x3d3d3d3d, 0x7d7d7d7d, 0x7e7e7e7e, 0x7f7f7f7f,
+    0x01010101, 0x18181818, 0x14141414, 0x1c1c1c1c, 0x12121212, 0x1a1a1a1a, 0x16161616, 0x1e1e1e1e,
+    0x11111111, 0x19191919, 0x15151515, 0x1d1d1d1d, 0x13131313, 0x1b1b1b1b, 0x17171717, 0x1f1f1f1f,
+    0x06060606, 0x19191919, 0x16161616, 0x36363636, 0x16161616, 0x56565656, 0x69696969, 0x6b6b6b6b,
+    0x19191919, 0x66666666, 0x56565656, 0x67676767, 0x36363636, 0x67676767, 0x6b6b6b6b, 0x6f6f6f6f,
+    0x05050505, 0x1a1a1a1a, 0x15151515, 0x35353535, 0x1a1a1a1a, 0x5a5a5a5a, 0x56565656, 0x5b5b5b5b,
+    0x15151515, 0x56565656, 0x55555555, 0x57575757, 0x35353535, 0x5b5b5b5b, 0x57575757, 0x5f5f5f5f,
+    0x07070707, 0x1b1b1b1b, 0x17171717, 0x37373737, 0x1e1e1e1e, 0x5b5b5b5b, 0x6b6b6b6b, 0x7b7b7b7b,
+    0x1d1d1d1d, 0x67676767, 0x57575757, 0x77777777, 0x3d3d3d3d, 0x7e7e7e7e, 0x7d7d7d7d, 0x7f7f7f7f,
+    0x03030303, 0x1c1c1c1c, 0x1c1c1c1c, 0x3c3c3c3c, 0x13131313, 0x35353535, 0x36363636, 0x3d3d3d3d,
+    0x13131313, 0x36363636, 0x35353535, 0x3d3d3d3d, 0x33333333, 0x37373737, 0x37373737, 0x3f3f3f3f,
+    0x07070707, 0x1d1d1d1d, 0x1e1e1e1e, 0x3d3d3d3d, 0x17171717, 0x57575757, 0x6b6b6b6b, 0x7d7d7d7d,
+    0x1b1b1b1b, 0x67676767, 0x5b5b5b5b, 0x7e7e7e7e, 0x37373737, 0x77777777, 0x7b7b7b7b, 0x7f7f7f7f,
+    0x07070707, 0x1e1e1e1e, 0x1d1d1d1d, 0x3d3d3d3d, 0x1b1b1b1b, 0x5b5b5b5b, 0x67676767, 0x7e7e7e7e,
+    0x17171717, 0x6b6b6b6b, 0x57575757, 0x7d7d7d7d, 0x37373737, 0x7b7b7b7b, 0x77777777, 0x7f7f7f7f,
+    0x0f0f0f0f, 0x1f1f1f1f, 0x1f1f1f1f, 0x3f3f3f3f, 0x1f1f1f1f, 0x5f5f5f5f, 0x6f6f6f6f, 0x7f7f7f7f,
+    0x1f1f1f1f, 0x6f6f6f6f, 0x5f5f5f5f, 0x7f7f7f7f, 0x3f3f3f3f, 0x7f7f7f7f, 0x7f7f7f7f, 0xffffffff
+};
+
+static char s_Phases3[256][9] = 
+{
+/*   0 */  {  8,   0, 1, 2, 3, 4, 5, 6, 7 }, 
+/*   1 */  {  1,   0 }, 
+/*   2 */  {  1,   1 }, 
+/*   3 */  {  2,   0, 1 }, 
+/*   4 */  {  1,   2 }, 
+/*   5 */  {  2,   0, 2 }, 
+/*   6 */  {  2,   0, 3 }, 
+/*   7 */  {  1,   0 }, 
+/*   8 */  {  1,   3 }, 
+/*   9 */  {  2,   1, 2 }, 
+/*  10 */  {  2,   1, 3 }, 
+/*  11 */  {  1,   1 }, 
+/*  12 */  {  2,   2, 3 }, 
+/*  13 */  {  1,   2 }, 
+/*  14 */  {  1,   3 }, 
+/*  15 */  {  4,   0, 1, 2, 3 }, 
+/*  16 */  {  1,   4 }, 
+/*  17 */  {  2,   0, 4 }, 
+/*  18 */  {  2,   0, 5 }, 
+/*  19 */  {  1,   0 }, 
+/*  20 */  {  2,   0, 6 }, 
+/*  21 */  {  1,   0 }, 
+/*  22 */  {  1,   0 }, 
+/*  23 */  {  1,   0 }, 
+/*  24 */  {  2,   0, 7 }, 
+/*  25 */  {  1,   0 }, 
+/*  26 */  {  1,   0 }, 
+/*  27 */  {  1,   0 }, 
+/*  28 */  {  1,   0 }, 
+/*  29 */  {  1,   0 }, 
+/*  30 */  {  1,   0 }, 
+/*  31 */  {  1,   0 }, 
+/*  32 */  {  1,   5 }, 
+/*  33 */  {  2,   1, 4 }, 
+/*  34 */  {  2,   1, 5 }, 
+/*  35 */  {  1,   1 }, 
+/*  36 */  {  2,   1, 6 }, 
+/*  37 */  {  1,   1 }, 
+/*  38 */  {  1,   1 }, 
+/*  39 */  {  1,   1 }, 
+/*  40 */  {  2,   1, 7 }, 
+/*  41 */  {  1,   1 }, 
+/*  42 */  {  1,   1 }, 
+/*  43 */  {  1,   1 }, 
+/*  44 */  {  1,   1 }, 
+/*  45 */  {  1,   1 }, 
+/*  46 */  {  1,   1 }, 
+/*  47 */  {  1,   1 }, 
+/*  48 */  {  2,   4, 5 }, 
+/*  49 */  {  1,   4 }, 
+/*  50 */  {  1,   5 }, 
+/*  51 */  {  4,   0, 1, 4, 5 }, 
+/*  52 */  {  1,   6 }, 
+/*  53 */  {  1,   0 }, 
+/*  54 */  {  1,   0 }, 
+/*  55 */  {  1,   0 }, 
+/*  56 */  {  1,   7 }, 
+/*  57 */  {  1,   1 }, 
+/*  58 */  {  1,   1 }, 
+/*  59 */  {  1,   1 }, 
+/*  60 */  {  4,   0, 1, 6, 7 }, 
+/*  61 */  {  1,   0 }, 
+/*  62 */  {  1,   1 }, 
+/*  63 */  {  2,   0, 1 }, 
+/*  64 */  {  1,   6 }, 
+/*  65 */  {  2,   2, 4 }, 
+/*  66 */  {  2,   2, 5 }, 
+/*  67 */  {  1,   2 }, 
+/*  68 */  {  2,   2, 6 }, 
+/*  69 */  {  1,   2 }, 
+/*  70 */  {  1,   2 }, 
+/*  71 */  {  1,   2 }, 
+/*  72 */  {  2,   2, 7 }, 
+/*  73 */  {  1,   2 }, 
+/*  74 */  {  1,   2 }, 
+/*  75 */  {  1,   2 }, 
+/*  76 */  {  1,   2 }, 
+/*  77 */  {  1,   2 }, 
+/*  78 */  {  1,   2 }, 
+/*  79 */  {  1,   2 }, 
+/*  80 */  {  2,   4, 6 }, 
+/*  81 */  {  1,   4 }, 
+/*  82 */  {  1,   5 }, 
+/*  83 */  {  1,   4 }, 
+/*  84 */  {  1,   6 }, 
+/*  85 */  {  4,   0, 2, 4, 6 }, 
+/*  86 */  {  1,   0 }, 
+/*  87 */  {  1,   0 }, 
+/*  88 */  {  1,   7 }, 
+/*  89 */  {  1,   2 }, 
+/*  90 */  {  4,   0, 2, 5, 7 }, 
+/*  91 */  {  1,   0 }, 
+/*  92 */  {  1,   6 }, 
+/*  93 */  {  1,   2 }, 
+/*  94 */  {  1,   2 }, 
+/*  95 */  {  2,   0, 2 }, 
+/*  96 */  {  2,   4, 7 }, 
+/*  97 */  {  1,   4 }, 
+/*  98 */  {  1,   5 }, 
+/*  99 */  {  1,   4 }, 
+/* 100 */  {  1,   6 }, 
+/* 101 */  {  1,   4 }, 
+/* 102 */  {  4,   0, 3, 4, 7 }, 
+/* 103 */  {  1,   0 }, 
+/* 104 */  {  1,   7 }, 
+/* 105 */  {  4,   0, 3, 5, 6 }, 
+/* 106 */  {  1,   7 }, 
+/* 107 */  {  1,   0 }, 
+/* 108 */  {  1,   7 }, 
+/* 109 */  {  1,   3 }, 
+/* 110 */  {  1,   3 }, 
+/* 111 */  {  2,   0, 3 }, 
+/* 112 */  {  1,   4 }, 
+/* 113 */  {  1,   4 }, 
+/* 114 */  {  1,   5 }, 
+/* 115 */  {  1,   4 }, 
+/* 116 */  {  1,   6 }, 
+/* 117 */  {  1,   4 }, 
+/* 118 */  {  1,   4 }, 
+/* 119 */  {  2,   0, 4 }, 
+/* 120 */  {  1,   7 }, 
+/* 121 */  {  1,   5 }, 
+/* 122 */  {  1,   5 }, 
+/* 123 */  {  2,   0, 5 }, 
+/* 124 */  {  1,   6 }, 
+/* 125 */  {  2,   0, 6 }, 
+/* 126 */  {  2,   0, 7 }, 
+/* 127 */  {  1,   0 }, 
+/* 128 */  {  1,   7 }, 
+/* 129 */  {  2,   3, 4 }, 
+/* 130 */  {  2,   3, 5 }, 
+/* 131 */  {  1,   3 }, 
+/* 132 */  {  2,   3, 6 }, 
+/* 133 */  {  1,   3 }, 
+/* 134 */  {  1,   3 }, 
+/* 135 */  {  1,   3 }, 
+/* 136 */  {  2,   3, 7 }, 
+/* 137 */  {  1,   3 }, 
+/* 138 */  {  1,   3 }, 
+/* 139 */  {  1,   3 }, 
+/* 140 */  {  1,   3 }, 
+/* 141 */  {  1,   3 }, 
+/* 142 */  {  1,   3 }, 
+/* 143 */  {  1,   3 }, 
+/* 144 */  {  2,   5, 6 }, 
+/* 145 */  {  1,   4 }, 
+/* 146 */  {  1,   5 }, 
+/* 147 */  {  1,   5 }, 
+/* 148 */  {  1,   6 }, 
+/* 149 */  {  1,   6 }, 
+/* 150 */  {  4,   1, 2, 4, 7 }, 
+/* 151 */  {  1,   1 }, 
+/* 152 */  {  1,   7 }, 
+/* 153 */  {  4,   1, 2, 5, 6 }, 
+/* 154 */  {  1,   5 }, 
+/* 155 */  {  1,   1 }, 
+/* 156 */  {  1,   6 }, 
+/* 157 */  {  1,   2 }, 
+/* 158 */  {  1,   2 }, 
+/* 159 */  {  2,   1, 2 }, 
+/* 160 */  {  2,   5, 7 }, 
+/* 161 */  {  1,   4 }, 
+/* 162 */  {  1,   5 }, 
+/* 163 */  {  1,   5 }, 
+/* 164 */  {  1,   6 }, 
+/* 165 */  {  4,   1, 3, 4, 6 }, 
+/* 166 */  {  1,   3 }, 
+/* 167 */  {  1,   1 }, 
+/* 168 */  {  1,   7 }, 
+/* 169 */  {  1,   1 }, 
+/* 170 */  {  4,   1, 3, 5, 7 }, 
+/* 171 */  {  1,   1 }, 
+/* 172 */  {  1,   7 }, 
+/* 173 */  {  1,   3 }, 
+/* 174 */  {  1,   3 }, 
+/* 175 */  {  2,   1, 3 }, 
+/* 176 */  {  1,   5 }, 
+/* 177 */  {  1,   4 }, 
+/* 178 */  {  1,   5 }, 
+/* 179 */  {  1,   5 }, 
+/* 180 */  {  1,   6 }, 
+/* 181 */  {  1,   4 }, 
+/* 182 */  {  1,   4 }, 
+/* 183 */  {  2,   1, 4 }, 
+/* 184 */  {  1,   7 }, 
+/* 185 */  {  1,   5 }, 
+/* 186 */  {  1,   5 }, 
+/* 187 */  {  2,   1, 5 }, 
+/* 188 */  {  1,   7 }, 
+/* 189 */  {  2,   1, 6 }, 
+/* 190 */  {  2,   1, 7 }, 
+/* 191 */  {  1,   1 }, 
+/* 192 */  {  2,   6, 7 }, 
+/* 193 */  {  1,   4 }, 
+/* 194 */  {  1,   5 }, 
+/* 195 */  {  4,   2, 3, 4, 5 }, 
+/* 196 */  {  1,   6 }, 
+/* 197 */  {  1,   2 }, 
+/* 198 */  {  1,   3 }, 
+/* 199 */  {  1,   2 }, 
+/* 200 */  {  1,   7 }, 
+/* 201 */  {  1,   2 }, 
+/* 202 */  {  1,   3 }, 
+/* 203 */  {  1,   3 }, 
+/* 204 */  {  4,   2, 3, 6, 7 }, 
+/* 205 */  {  1,   2 }, 
+/* 206 */  {  1,   3 }, 
+/* 207 */  {  2,   2, 3 }, 
+/* 208 */  {  1,   6 }, 
+/* 209 */  {  1,   4 }, 
+/* 210 */  {  1,   5 }, 
+/* 211 */  {  1,   4 }, 
+/* 212 */  {  1,   6 }, 
+/* 213 */  {  1,   6 }, 
+/* 214 */  {  1,   7 }, 
+/* 215 */  {  2,   2, 4 }, 
+/* 216 */  {  1,   7 }, 
+/* 217 */  {  1,   6 }, 
+/* 218 */  {  1,   7 }, 
+/* 219 */  {  2,   2, 5 }, 
+/* 220 */  {  1,   6 }, 
+/* 221 */  {  2,   2, 6 }, 
+/* 222 */  {  2,   2, 7 }, 
+/* 223 */  {  1,   2 }, 
+/* 224 */  {  1,   7 }, 
+/* 225 */  {  1,   4 }, 
+/* 226 */  {  1,   5 }, 
+/* 227 */  {  1,   5 }, 
+/* 228 */  {  1,   6 }, 
+/* 229 */  {  1,   6 }, 
+/* 230 */  {  1,   7 }, 
+/* 231 */  {  2,   3, 4 }, 
+/* 232 */  {  1,   7 }, 
+/* 233 */  {  1,   6 }, 
+/* 234 */  {  1,   7 }, 
+/* 235 */  {  2,   3, 5 }, 
+/* 236 */  {  1,   7 }, 
+/* 237 */  {  2,   3, 6 }, 
+/* 238 */  {  2,   3, 7 }, 
+/* 239 */  {  1,   3 }, 
+/* 240 */  {  4,   4, 5, 6, 7 }, 
+/* 241 */  {  1,   4 }, 
+/* 242 */  {  1,   5 }, 
+/* 243 */  {  2,   4, 5 }, 
+/* 244 */  {  1,   6 }, 
+/* 245 */  {  2,   4, 6 }, 
+/* 246 */  {  2,   4, 7 }, 
+/* 247 */  {  1,   4 }, 
+/* 248 */  {  1,   7 }, 
+/* 249 */  {  2,   5, 6 }, 
+/* 250 */  {  2,   5, 7 }, 
+/* 251 */  {  1,   5 }, 
+/* 252 */  {  2,   6, 7 }, 
+/* 253 */  {  1,   6 }, 
+/* 254 */  {  1,   7 }, 
+/* 255 */  {  8,   0, 1, 2, 3, 4, 5, 6, 7 }
+};
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraUtilFile.c b/src/misc/extra/extraUtilFile.c
new file mode 100644
index 00000000..4c51b8b5
--- /dev/null
+++ b/src/misc/extra/extraUtilFile.c
@@ -0,0 +1,495 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilFile.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [File management utilities.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilFile.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function*************************************************************
+
+  Synopsis    [Tries to find a file name with a different extension.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_FileGetSimilarName( char * pFileNameWrong, char * pS1, char * pS2, char * pS3, char * pS4, char * pS5 )
+{
+    FILE * pFile;
+    char * pFileNameOther;
+    char * pFileGen;
+
+    if ( pS1 == NULL )
+        return NULL;
+
+    // get the generic file name
+    pFileGen = Extra_FileNameGeneric( pFileNameWrong );
+    pFileNameOther = Extra_FileNameAppend( pFileGen, pS1 );
+    pFile = fopen( pFileNameOther, "r" );
+    if ( pFile == NULL && pS2 )
+    { // try one more
+        pFileNameOther = Extra_FileNameAppend( pFileGen, pS2 );
+        pFile = fopen( pFileNameOther, "r" );
+        if ( pFile == NULL && pS3 )
+        { // try one more
+            pFileNameOther = Extra_FileNameAppend( pFileGen, pS3 );
+            pFile = fopen( pFileNameOther, "r" );
+            if ( pFile == NULL && pS4 )
+            { // try one more
+                pFileNameOther = Extra_FileNameAppend( pFileGen, pS4 );
+                pFile = fopen( pFileNameOther, "r" );
+                if ( pFile == NULL && pS5 )
+                { // try one more
+                    pFileNameOther = Extra_FileNameAppend( pFileGen, pS5 );
+                    pFile = fopen( pFileNameOther, "r" );
+                }
+            }
+        }
+    }
+    FREE( pFileGen );
+    if ( pFile )
+    {
+        fclose( pFile );
+        return pFileNameOther;
+    }
+    // did not find :(
+    return NULL;            
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the pointer to the file extension.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_FileNameExtension( char * FileName )
+{
+    char * pDot;
+    // find the last "dot" in the file name, if it is present
+    for ( pDot = FileName + strlen(FileName)-1; pDot >= FileName; pDot-- )
+        if ( *pDot == '.' )
+            return pDot + 1;
+   return NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the composite name of the file.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_FileNameAppend( char * pBase, char * pSuffix )
+{
+    static char Buffer[500];
+    sprintf( Buffer, "%s%s", pBase, pSuffix );
+    return Buffer;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_FileNameGeneric( char * FileName )
+{
+    char * pDot;
+    char * pUnd;
+    char * pRes;
+    
+    // find the generic name of the file
+    pRes = Extra_UtilStrsav( FileName );
+    // find the pointer to the "." symbol in the file name
+//  pUnd = strstr( FileName, "_" );
+    pUnd = NULL;
+    pDot = strstr( FileName, "." );
+    if ( pUnd )
+        pRes[pUnd - FileName] = 0;
+    else if ( pDot )
+        pRes[pDot - FileName] = 0;
+    return pRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the file size.]
+
+  Description [The file should be closed.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_FileSize( char * pFileName )
+{
+    FILE * pFile;
+    int nFileSize;
+    pFile = fopen( pFileName, "r" );
+    if ( pFile == NULL )
+    {
+        printf( "Extra_FileSize(): The file is unavailable (absent or open).\n" );
+        return 0;
+    }
+    fseek( pFile, 0, SEEK_END );  
+    nFileSize = ftell( pFile ); 
+    fclose( pFile );
+    return nFileSize;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Read the file into the internal buffer.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_FileRead( FILE * pFile )
+{
+    int nFileSize;
+    char * pBuffer;
+    // get the file size, in bytes
+    fseek( pFile, 0, SEEK_END );  
+    nFileSize = ftell( pFile );  
+    // move the file current reading position to the beginning
+    rewind( pFile ); 
+    // load the contents of the file into memory
+    pBuffer = ALLOC( char, nFileSize + 3 );
+    fread( pBuffer, nFileSize, 1, pFile );
+    // terminate the string with '\0'
+    pBuffer[ nFileSize + 0] = '\n';
+    pBuffer[ nFileSize + 1] = '\0';
+    return pBuffer;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the time stamp.]
+
+  Description [The file should be closed.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_TimeStamp()
+{
+    static char Buffer[100];
+    char * TimeStamp;
+    time_t ltime;
+    // get the current time
+    time( &ltime );
+    TimeStamp = asctime( localtime( &ltime ) );
+    TimeStamp[ strlen(TimeStamp) - 1 ] = 0;
+    strcpy( Buffer, TimeStamp );
+    return Buffer;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_ReadBinary( char * Buffer )
+{
+    unsigned Result;
+    int i;
+
+    Result = 0;
+    for ( i = 0; Buffer[i]; i++ )
+        if ( Buffer[i] == '0' || Buffer[i] == '1' )
+            Result = Result * 2 + Buffer[i] - '0';
+        else
+        {
+            assert( 0 );
+        }
+    return Result;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the bit string.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_PrintBinary( FILE * pFile, unsigned Sign[], int nBits )
+{
+    int Remainder, nWords;
+    int w, i;
+
+    Remainder = (nBits%(sizeof(unsigned)*8));
+    nWords    = (nBits/(sizeof(unsigned)*8)) + (Remainder>0);
+
+    for ( w = nWords-1; w >= 0; w-- )
+        for ( i = ((w == nWords-1 && Remainder)? Remainder-1: 31); i >= 0; i-- )
+            fprintf( pFile, "%c", '0' + (int)((Sign[w] & (1<<i)) > 0) );
+
+//  fprintf( pFile, "\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reads the hex unsigned into the bit-string.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_ReadHexadecimal( unsigned Sign[], char * pString, int nVars )
+{
+    int nWords, nDigits, Digit, k, c;
+    nWords = Extra_TruthWordNum( nVars );
+    for ( k = 0; k < nWords; k++ )
+        Sign[k] = 0;
+    // read the number from the string
+    nDigits = (1 << nVars) / 4;
+    if ( nDigits == 0 )
+        nDigits = 1;
+    for ( k = 0; k < nDigits; k++ )
+    {
+        c = nDigits-1-k;
+        if ( pString[c] >= '0' && pString[c] <= '9' )
+            Digit = pString[c] - '0';
+        else if ( pString[c] >= 'A' && pString[c] <= 'F' )
+            Digit = pString[c] - 'A' + 10;
+        else if ( pString[c] >= 'a' && pString[c] <= 'f' )
+            Digit = pString[c] - 'a' + 10;
+        else { assert( 0 ); return 0; }
+        Sign[k/8] |= ( (Digit & 15) << ((k%8) * 4) );
+    }
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the hex unsigned into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_PrintHexadecimal( FILE * pFile, unsigned Sign[], int nVars )
+{
+    int nDigits, Digit, k;
+    // write the number into the file
+    nDigits = (1 << nVars) / 4;
+    for ( k = nDigits - 1; k >= 0; k-- )
+    {
+        Digit = ((Sign[k/8] >> ((k%8) * 4)) & 15);
+        if ( Digit < 10 )
+            fprintf( pFile, "%d", Digit );
+        else
+            fprintf( pFile, "%c", 'a' + Digit-10 );
+    }
+//    fprintf( pFile, "\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the hex unsigned into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_PrintHexadecimalString( char * pString, unsigned Sign[], int nVars )
+{
+    int nDigits, Digit, k;
+    // write the number into the file
+    nDigits = (1 << nVars) / 4;
+    for ( k = nDigits - 1; k >= 0; k-- )
+    {
+        Digit = ((Sign[k/8] >> ((k%8) * 4)) & 15);
+        if ( Digit < 10 )
+            *pString++ = '0' + Digit;
+        else
+            *pString++ = 'a' + Digit-10;
+    }
+//    fprintf( pFile, "\n" );
+    *pString = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the hex unsigned into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_PrintHex( FILE * pFile, unsigned uTruth, int nVars )
+{
+    int nMints, nDigits, Digit, k;
+
+    // write the number into the file
+    fprintf( pFile, "0x" );
+    nMints  = (1 << nVars);
+    nDigits = nMints / 4;
+    for ( k = nDigits - 1; k >= 0; k-- )
+    {
+        Digit = ((uTruth >> (k * 4)) & 15);
+        if ( Digit < 10 )
+            fprintf( pFile, "%d", Digit );
+        else
+            fprintf( pFile, "%c", 'a' + Digit-10 );
+    }
+//    fprintf( pFile, "\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the composite name of the file.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_PrintSymbols( FILE * pFile, char Char, int nTimes, int fPrintNewLine )
+{
+    int i;
+    for ( i = 0; i < nTimes; i++ )
+        printf( "%c", Char );
+    if ( fPrintNewLine )
+        printf( "\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Appends the string.]
+
+  Description [Assumes that the given string (pStrGiven) has been allocated
+  before using malloc(). The additional string has not been allocated.
+  Allocs more root, appends the additional part, frees the old given string.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_StringAppend( char * pStrGiven, char * pStrAdd )
+{
+    char * pTemp;
+    if ( pStrGiven )
+    {
+        pTemp = ALLOC( char, strlen(pStrGiven) + strlen(pStrAdd) + 2 );
+        sprintf( pTemp, "%s%s", pStrGiven, pStrAdd );
+        free( pStrGiven );
+    }
+    else
+        pTemp = Extra_UtilStrsav( pStrAdd );
+    return pTemp;
+}
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static Functions                                            */
+/*---------------------------------------------------------------------------*/
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraUtilMemory.c b/src/misc/extra/extraUtilMemory.c
new file mode 100644
index 00000000..6eccf015
--- /dev/null
+++ b/src/misc/extra/extraUtilMemory.c
@@ -0,0 +1,625 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilMemory.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [Memory managers.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilMemory.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+struct Extra_MmFixed_t_
+{
+    // information about individual entries
+    int           nEntrySize;    // the size of one entry
+    int           nEntriesAlloc; // the total number of entries allocated
+    int           nEntriesUsed;  // the number of entries in use
+    int           nEntriesMax;   // the max number of entries in use
+    char *        pEntriesFree;  // the linked list of free entries
+
+    // this is where the memory is stored
+    int           nChunkSize;    // the size of one chunk
+    int           nChunksAlloc;  // the maximum number of memory chunks 
+    int           nChunks;       // the current number of memory chunks 
+    char **       pChunks;       // the allocated memory
+
+    // statistics
+    int           nMemoryUsed;   // memory used in the allocated entries
+    int           nMemoryAlloc;  // memory allocated
+};
+
+struct Extra_MmFlex_t_
+{
+    // information about individual entries
+    int           nEntriesUsed;  // the number of entries allocated
+    char *        pCurrent;      // the current pointer to free memory
+    char *        pEnd;          // the first entry outside the free memory
+
+    // this is where the memory is stored
+    int           nChunkSize;    // the size of one chunk
+    int           nChunksAlloc;  // the maximum number of memory chunks 
+    int           nChunks;       // the current number of memory chunks 
+    char **       pChunks;       // the allocated memory
+
+    // statistics
+    int           nMemoryUsed;   // memory used in the allocated entries
+    int           nMemoryAlloc;  // memory allocated
+};
+
+
+struct Extra_MmStep_t_
+{
+    int                nMems;    // the number of fixed memory managers employed
+    Extra_MmFixed_t ** pMems;    // memory managers: 2^1 words, 2^2 words, etc
+    int                nMapSize; // the size of the memory array
+    Extra_MmFixed_t ** pMap;     // maps the number of bytes into its memory manager
+    int                nLargeChunksAlloc;  // the maximum number of large memory chunks 
+    int                nLargeChunks;       // the current number of large memory chunks 
+    void **            pLargeChunks;       // the allocated large memory chunks
+};
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates memory pieces of fixed size.]
+
+  Description [The size of the chunk is computed as the minimum of
+  1024 entries and 64K. Can only work with entry size at least 4 byte long.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Extra_MmFixed_t * Extra_MmFixedStart( int nEntrySize )
+{
+    Extra_MmFixed_t * p;
+
+    p = ALLOC( Extra_MmFixed_t, 1 );
+    memset( p, 0, sizeof(Extra_MmFixed_t) );
+
+    p->nEntrySize    = nEntrySize;
+    p->nEntriesAlloc = 0;
+    p->nEntriesUsed  = 0;
+    p->pEntriesFree  = NULL;
+
+    if ( nEntrySize * (1 << 10) < (1<<16) )
+        p->nChunkSize = (1 << 10);
+    else
+        p->nChunkSize = (1<<16) / nEntrySize;
+    if ( p->nChunkSize < 8 )
+        p->nChunkSize = 8;
+
+    p->nChunksAlloc  = 64;
+    p->nChunks       = 0;
+    p->pChunks       = ALLOC( char *, p->nChunksAlloc );
+
+    p->nMemoryUsed   = 0;
+    p->nMemoryAlloc  = 0;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmFixedPrint( Extra_MmFixed_t * p )
+{
+    printf( "Fixed memory manager: Entry = %5d. Chunk = %5d. Chunks used = %5d.\n",
+        p->nEntrySize, p->nChunkSize, p->nChunks );
+    printf( "   Entries used = %8d. Entries peak = %8d. Memory used = %8d. Memory alloc = %8d.\n",
+        p->nEntriesUsed, p->nEntriesMax, p->nEntrySize * p->nEntriesUsed, p->nMemoryAlloc );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmFixedStop( Extra_MmFixed_t * p )
+{
+    int i;
+    if ( p == NULL )
+        return;
+    for ( i = 0; i < p->nChunks; i++ )
+        free( p->pChunks[i] );
+    free( p->pChunks );
+    free( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_MmFixedEntryFetch( Extra_MmFixed_t * p )
+{
+    char * pTemp;
+    int i;
+
+    // check if there are still free entries
+    if ( p->nEntriesUsed == p->nEntriesAlloc )
+    { // need to allocate more entries
+        assert( p->pEntriesFree == NULL );
+        if ( p->nChunks == p->nChunksAlloc )
+        {
+            p->nChunksAlloc *= 2;
+            p->pChunks = REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
+        }
+        p->pEntriesFree = ALLOC( char, p->nEntrySize * p->nChunkSize );
+        p->nMemoryAlloc += p->nEntrySize * p->nChunkSize;
+        // transform these entries into a linked list
+        pTemp = p->pEntriesFree;
+        for ( i = 1; i < p->nChunkSize; i++ )
+        {
+            *((char **)pTemp) = pTemp + p->nEntrySize;
+            pTemp += p->nEntrySize;
+        }
+        // set the last link
+        *((char **)pTemp) = NULL;
+        // add the chunk to the chunk storage
+        p->pChunks[ p->nChunks++ ] = p->pEntriesFree;
+        // add to the number of entries allocated
+        p->nEntriesAlloc += p->nChunkSize;
+    }
+    // incrememt the counter of used entries
+    p->nEntriesUsed++;
+    if ( p->nEntriesMax < p->nEntriesUsed )
+        p->nEntriesMax = p->nEntriesUsed;
+    // return the first entry in the free entry list
+    pTemp = p->pEntriesFree;
+    p->pEntriesFree = *((char **)pTemp);
+    return pTemp;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmFixedEntryRecycle( Extra_MmFixed_t * p, char * pEntry )
+{
+    // decrement the counter of used entries
+    p->nEntriesUsed--;
+    // add the entry to the linked list of free entries
+    *((char **)pEntry) = p->pEntriesFree;
+    p->pEntriesFree = pEntry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description [Relocates all the memory except the first chunk.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmFixedRestart( Extra_MmFixed_t * p )
+{
+    int i;
+    char * pTemp;
+
+    // deallocate all chunks except the first one
+    for ( i = 1; i < p->nChunks; i++ )
+        free( p->pChunks[i] );
+    p->nChunks = 1;
+    // transform these entries into a linked list
+    pTemp = p->pChunks[0];
+    for ( i = 1; i < p->nChunkSize; i++ )
+    {
+        *((char **)pTemp) = pTemp + p->nEntrySize;
+        pTemp += p->nEntrySize;
+    }
+    // set the last link
+    *((char **)pTemp) = NULL;
+    // set the free entry list
+    p->pEntriesFree  = p->pChunks[0];
+    // set the correct statistics
+    p->nMemoryAlloc  = p->nEntrySize * p->nChunkSize;
+    p->nMemoryUsed   = 0;
+    p->nEntriesAlloc = p->nChunkSize;
+    p->nEntriesUsed  = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_MmFixedReadMemUsage( Extra_MmFixed_t * p )
+{
+    return p->nMemoryAlloc;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_MmFixedReadMaxEntriesUsed( Extra_MmFixed_t * p )
+{
+    return p->nEntriesMax;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates entries of flexible size.]
+
+  Description [Can only work with entry size at least 4 byte long.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Extra_MmFlex_t * Extra_MmFlexStart()
+{
+    Extra_MmFlex_t * p;
+//printf( "allocing flex\n" );
+    p = ALLOC( Extra_MmFlex_t, 1 );
+    memset( p, 0, sizeof(Extra_MmFlex_t) );
+
+    p->nEntriesUsed  = 0;
+    p->pCurrent      = NULL;
+    p->pEnd          = NULL;
+
+    p->nChunkSize    = (1 << 10);
+    p->nChunksAlloc  = 64;
+    p->nChunks       = 0;
+    p->pChunks       = ALLOC( char *, p->nChunksAlloc );
+
+    p->nMemoryUsed   = 0;
+    p->nMemoryAlloc  = 0;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmFlexPrint( Extra_MmFlex_t * p )
+{
+    printf( "Flexible memory manager: Chunk size = %d. Chunks used = %d.\n",
+        p->nChunkSize, p->nChunks );
+    printf( "   Entries used = %d. Memory used = %d. Memory alloc = %d.\n",
+        p->nEntriesUsed, p->nMemoryUsed, p->nMemoryAlloc );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmFlexStop( Extra_MmFlex_t * p )
+{
+    int i;
+    if ( p == NULL )
+        return;
+//printf( "deleting flex\n" );
+    for ( i = 0; i < p->nChunks; i++ )
+        free( p->pChunks[i] );
+    free( p->pChunks );
+    free( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_MmFlexEntryFetch( Extra_MmFlex_t * p, int nBytes )
+{
+    char * pTemp;
+    // check if there are still free entries
+    if ( p->pCurrent == NULL || p->pCurrent + nBytes > p->pEnd )
+    { // need to allocate more entries
+        if ( p->nChunks == p->nChunksAlloc )
+        {
+            p->nChunksAlloc *= 2;
+            p->pChunks = REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
+        }
+        if ( nBytes > p->nChunkSize )
+        {
+            // resize the chunk size if more memory is requested than it can give
+            // (ideally, this should never happen)
+            p->nChunkSize = 2 * nBytes;
+        }
+        p->pCurrent = ALLOC( char, p->nChunkSize );
+        p->pEnd     = p->pCurrent + p->nChunkSize;
+        p->nMemoryAlloc += p->nChunkSize;
+        // add the chunk to the chunk storage
+        p->pChunks[ p->nChunks++ ] = p->pCurrent;
+    }
+    assert( p->pCurrent + nBytes <= p->pEnd );
+    // increment the counter of used entries
+    p->nEntriesUsed++;
+    // keep track of the memory used
+    p->nMemoryUsed += nBytes;
+    // return the next entry
+    pTemp = p->pCurrent;
+    p->pCurrent += nBytes;
+    return pTemp;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_MmFlexReadMemUsage( Extra_MmFlex_t * p )
+{
+    return p->nMemoryAlloc;
+}
+
+
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Starts the hierarchical memory manager.]
+
+  Description [This manager can allocate entries of any size.
+  Iternally they are mapped into the entries with the number of bytes
+  equal to the power of 2. The smallest entry size is 8 bytes. The
+  next one is 16 bytes etc. So, if the user requests 6 bytes, he gets 
+  8 byte entry. If we asks for 25 bytes, he gets 32 byte entry etc.
+  The input parameters "nSteps" says how many fixed memory managers
+  are employed internally. Calling this procedure with nSteps equal
+  to 10 results in 10 hierarchically arranged internal memory managers, 
+  which can allocate up to 4096 (1Kb) entries. Requests for larger 
+  entries are handed over to malloc() and then free()ed.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Extra_MmStep_t * Extra_MmStepStart( int nSteps )
+{
+    Extra_MmStep_t * p;
+    int i, k;
+    p = ALLOC( Extra_MmStep_t, 1 );
+    memset( p, 0, sizeof(Extra_MmStep_t) );
+    p->nMems = nSteps;
+    // start the fixed memory managers
+    p->pMems = ALLOC( Extra_MmFixed_t *, p->nMems );
+    for ( i = 0; i < p->nMems; i++ )
+        p->pMems[i] = Extra_MmFixedStart( (8<<i) );
+    // set up the mapping of the required memory size into the corresponding manager
+    p->nMapSize = (4<<p->nMems);
+    p->pMap = ALLOC( Extra_MmFixed_t *, p->nMapSize+1 );
+    p->pMap[0] = NULL;
+    for ( k = 1; k <= 4; k++ )
+        p->pMap[k] = p->pMems[0];
+    for ( i = 0; i < p->nMems; i++ )
+        for ( k = (4<<i)+1; k <= (8<<i); k++ )
+            p->pMap[k] = p->pMems[i];
+//for ( i = 1; i < 100; i ++ )
+//printf( "%10d: size = %10d\n", i, p->pMap[i]->nEntrySize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Stops the memory manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmStepStop( Extra_MmStep_t * p )
+{
+    int i;
+    for ( i = 0; i < p->nMems; i++ )
+        Extra_MmFixedStop( p->pMems[i] );
+//    if ( p->pLargeChunks ) 
+//    {
+//      for ( i = 0; i < p->nLargeChunks; i++ )
+//          free( p->pLargeChunks[i] );
+//      free( p->pLargeChunks );
+//    }
+    free( p->pMems );
+    free( p->pMap );
+    free( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_MmStepEntryFetch( Extra_MmStep_t * p, int nBytes )
+{
+    if ( nBytes == 0 )
+        return NULL;
+    if ( nBytes > p->nMapSize )
+    {
+//        printf( "Allocating %d bytes.\n", nBytes );
+/*
+        if ( p->nLargeChunks == p->nLargeChunksAlloc )
+        {
+            if ( p->nLargeChunksAlloc == 0 )
+                p->nLargeChunksAlloc = 5;
+            p->nLargeChunksAlloc *= 2;
+            p->pLargeChunks = REALLOC( char *, p->pLargeChunks, p->nLargeChunksAlloc ); 
+        }
+        p->pLargeChunks[ p->nLargeChunks++ ] = ALLOC( char, nBytes );
+        return p->pLargeChunks[ p->nLargeChunks - 1 ];
+*/
+        return ALLOC( char, nBytes );
+    }
+    return Extra_MmFixedEntryFetch( p->pMap[nBytes] );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Recycles the entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_MmStepEntryRecycle( Extra_MmStep_t * p, char * pEntry, int nBytes )
+{
+    if ( nBytes == 0 )
+        return;
+    if ( nBytes > p->nMapSize )
+    {
+        free( pEntry );
+        return;
+    }
+    Extra_MmFixedEntryRecycle( p->pMap[nBytes], pEntry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_MmStepReadMemUsage( Extra_MmStep_t * p )
+{
+    int i, nMemTotal = 0;
+    for ( i = 0; i < p->nMems; i++ )
+        nMemTotal += p->pMems[i]->nMemoryAlloc;
+    return nMemTotal;
+}
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static functions                                            */
+/*---------------------------------------------------------------------------*/
+
diff --git a/src/misc/extra/extraUtilMisc.c b/src/misc/extra/extraUtilMisc.c
new file mode 100644
index 00000000..dff774bc
--- /dev/null
+++ b/src/misc/extra/extraUtilMisc.c
@@ -0,0 +1,2235 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilMisc.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [Misc procedures.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilMisc.c,v 1.0 2003/09/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+static void Extra_Permutations_rec( char ** pRes, int nFact, int n, char Array[] );
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+
+/**Function********************************************************************
+
+  Synopsis    [Finds the smallest integer larger of equal than the logarithm.]
+
+  Description [Returns [Log2(Num)].]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_Base2Log( unsigned Num )
+{
+    int Res;
+    assert( Num >= 0 );
+    if ( Num == 0 ) return 0;
+    if ( Num == 1 ) return 1;
+    for ( Res = 0, Num--; Num; Num >>= 1, Res++ );
+    return Res;
+} /* end of Extra_Base2Log */
+
+/**Function********************************************************************
+
+  Synopsis    [Finds the smallest integer larger of equal than the logarithm.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_Base2LogDouble( double Num )
+{
+    double Res;
+    int ResInt;
+
+    Res    = log(Num)/log(2.0);
+    ResInt = (int)Res;
+    if ( ResInt == Res )
+        return ResInt;
+    else 
+        return ResInt+1;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Finds the smallest integer larger of equal than the logarithm.]
+
+  Description [Returns [Log10(Num)].]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_Base10Log( unsigned Num )
+{
+    int Res;
+    assert( Num >= 0 );
+    if ( Num == 0 ) return 0;
+    if ( Num == 1 ) return 1;
+    for ( Res = 0, Num--;  Num;  Num /= 10,  Res++ );
+    return Res;
+} /* end of Extra_Base2Log */
+
+/**Function********************************************************************
+
+  Synopsis    [Returns the power of two as a double.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+double Extra_Power2( int Degree )
+{
+    double Res;
+    assert( Degree >= 0 );
+    if ( Degree < 32 )
+        return (double)(01<<Degree); 
+    for ( Res = 1.0; Degree; Res *= 2.0, Degree-- );
+    return Res;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_Power3( int Num )
+{
+    int i;
+    int Res;
+    Res = 1;
+    for ( i = 0; i < Num; i++ )
+        Res *= 3;
+    return Res;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Finds the number of combinations of k elements out of n.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_NumCombinations( int k, int n )
+{
+    int i, Res = 1;
+    for ( i = 1; i <= k; i++ )
+            Res = Res * (n-i+1) / i;
+    return Res;
+} /* end of Extra_NumCombinations */
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int * Extra_DeriveRadixCode( int Number, int Radix, int nDigits )
+{
+    static int Code[100];
+    int i;
+    assert( nDigits < 100 );
+    for ( i = 0; i < nDigits; i++ )
+    {
+        Code[i] = Number % Radix;
+        Number  = Number / Radix;
+    }
+    assert( Number == 0 );
+    return Code;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of ones in the bitstring.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_CountOnes( unsigned char * pBytes, int nBytes )
+{
+    static int bit_count[256] = {
+      0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+      1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+      1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+      2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+      1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+      2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+      2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+      3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
+    };
+
+    int i, Counter;
+    Counter = 0;
+    for ( i = 0; i < nBytes; i++ )
+        Counter += bit_count[ *(pBytes+i) ];
+    return Counter;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the factorial.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+int Extra_Factorial( int n )
+{
+    int i, Res = 1;
+    for ( i = 1; i <= n; i++ )
+        Res *= i;
+    return Res;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Computes the set of all permutations.]
+
+  Description [The number of permutations in the array is n!. The number of
+  entries in each permutation is n. Therefore, the resulting array is a 
+  two-dimentional array of the size: n! x n. To free the resulting array,
+  call free() on the pointer returned by this procedure.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+char ** Extra_Permutations( int n )
+{
+    char Array[50];
+    char ** pRes;
+    int nFact, i;
+    // allocate memory
+    nFact = Extra_Factorial( n );
+    pRes  = (char **)Extra_ArrayAlloc( nFact, n, sizeof(char) );
+    // fill in the permutations
+    for ( i = 0; i < n; i++ )
+        Array[i] = i;
+    Extra_Permutations_rec( pRes, nFact, n, Array );
+    // print the permutations
+/*
+    {
+    int i, k;
+    for ( i = 0; i < nFact; i++ )
+    {
+        printf( "{" );
+        for ( k = 0; k < n; k++ )
+            printf( " %d", pRes[i][k] );
+        printf( " }\n" );
+    }
+    }
+*/
+    return pRes;
+}
+
+/**Function********************************************************************
+
+  Synopsis    [Fills in the array of permutations.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+void Extra_Permutations_rec( char ** pRes, int nFact, int n, char Array[] )
+{
+    char ** pNext;
+    int nFactNext;
+    int iTemp, iCur, iLast, k;
+
+    if ( n == 1 )
+    {
+        pRes[0][0] = Array[0];
+        return;
+    }
+
+    // get the next factorial
+    nFactNext = nFact / n;
+    // get the last entry
+    iLast = n - 1;
+
+    for ( iCur = 0; iCur < n; iCur++ )
+    {
+        // swap Cur and Last
+        iTemp        = Array[iCur];
+        Array[iCur]  = Array[iLast];
+        Array[iLast] = iTemp;
+
+        // get the pointer to the current section
+        pNext = pRes + (n - 1 - iCur) * nFactNext;
+
+        // set the last entry 
+        for ( k = 0; k < nFactNext; k++ )
+            pNext[k][iLast] = Array[iLast];
+
+        // call recursively for this part
+        Extra_Permutations_rec( pNext, nFactNext, n - 1, Array );
+
+        // swap them back
+        iTemp        = Array[iCur];
+        Array[iCur]  = Array[iLast];
+        Array[iLast] = iTemp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Permutes the given vector of minterms.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthPermute_int( int * pMints, int nMints, char * pPerm, int nVars, int * pMintsP )
+{
+    int m, v;
+    // clean the storage for minterms
+    memset( pMintsP, 0, sizeof(int) * nMints );
+    // go through minterms and add the variables
+    for ( m = 0; m < nMints; m++ )
+        for ( v = 0; v < nVars; v++ )
+            if ( pMints[m] & (1 << v) )
+                pMintsP[m] |= (1 << pPerm[v]);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Permutes the function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthPermute( unsigned Truth, char * pPerms, int nVars, int fReverse )
+{
+    unsigned Result;
+    int * pMints;
+    int * pMintsP;
+    int nMints;
+    int i, m;
+
+    assert( nVars < 6 );
+    nMints  = (1 << nVars);
+    pMints  = ALLOC( int, nMints );
+    pMintsP = ALLOC( int, nMints );
+    for ( i = 0; i < nMints; i++ )
+        pMints[i] = i;
+
+    Extra_TruthPermute_int( pMints, nMints, pPerms, nVars, pMintsP );
+
+    Result = 0;
+    if ( fReverse )
+    {
+        for ( m = 0; m < nMints; m++ )
+            if ( Truth & (1 << pMintsP[m]) )
+                Result |= (1 << m);
+    }
+    else
+    {
+        for ( m = 0; m < nMints; m++ )
+            if ( Truth & (1 << m) )
+                Result |= (1 << pMintsP[m]);
+    }
+
+    free( pMints );
+    free( pMintsP );
+
+    return Result;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Changes the phase of the function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthPolarize( unsigned uTruth, int Polarity, int nVars )
+{
+    // elementary truth tables
+    static unsigned Signs[5] = {
+        0xAAAAAAAA,    // 1010 1010 1010 1010 1010 1010 1010 1010
+        0xCCCCCCCC,    // 1010 1010 1010 1010 1010 1010 1010 1010
+        0xF0F0F0F0,    // 1111 0000 1111 0000 1111 0000 1111 0000
+        0xFF00FF00,    // 1111 1111 0000 0000 1111 1111 0000 0000
+        0xFFFF0000     // 1111 1111 1111 1111 0000 0000 0000 0000
+    };
+    unsigned uTruthRes, uCof0, uCof1;
+    int nMints, Shift, v;
+    assert( nVars < 6 );
+    nMints = (1 << nVars);
+    uTruthRes = uTruth;
+    for ( v = 0; v < nVars; v++ )
+        if ( Polarity & (1 << v) )
+        {
+            uCof0  = uTruth & ~Signs[v];
+            uCof1  = uTruth &  Signs[v];
+            Shift  = (1 << v);
+            uCof0 <<= Shift;
+            uCof1 >>= Shift;
+            uTruth = uCof0 | uCof1;
+        }
+    return uTruth;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes N-canonical form using brute-force methods.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthCanonN( unsigned uTruth, int nVars )
+{
+    unsigned uTruthMin, uPhase;
+    int nMints, i;
+    nMints    = (1 << nVars);
+    uTruthMin = 0xFFFFFFFF;
+    for ( i = 0; i < nMints; i++ )
+    {
+        uPhase = Extra_TruthPolarize( uTruth, i, nVars ); 
+        if ( uTruthMin > uPhase )
+            uTruthMin = uPhase;
+    }
+    return uTruthMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes NN-canonical form using brute-force methods.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthCanonNN( unsigned uTruth, int nVars )
+{
+    unsigned uTruthMin, uTruthC, uPhase;
+    int nMints, i;
+    nMints    = (1 << nVars);
+    uTruthC   = (unsigned)( (~uTruth) & ((~((unsigned)0)) >> (32-nMints)) );
+    uTruthMin = 0xFFFFFFFF;
+    for ( i = 0; i < nMints; i++ )
+    {
+        uPhase = Extra_TruthPolarize( uTruth, i, nVars ); 
+        if ( uTruthMin > uPhase )
+            uTruthMin = uPhase;
+        uPhase = Extra_TruthPolarize( uTruthC, i, nVars ); 
+        if ( uTruthMin > uPhase )
+            uTruthMin = uPhase;
+    }
+    return uTruthMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes P-canonical form using brute-force methods.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthCanonP( unsigned uTruth, int nVars )
+{
+    static int nVarsOld, nPerms;
+    static char ** pPerms = NULL;
+
+    unsigned uTruthMin, uPerm;
+    int k;
+
+    if ( pPerms == NULL )
+    {
+        nPerms = Extra_Factorial( nVars );   
+        pPerms = Extra_Permutations( nVars );
+        nVarsOld = nVars;
+    }
+    else if ( nVarsOld != nVars )
+    {
+        free( pPerms );
+        nPerms = Extra_Factorial( nVars );   
+        pPerms = Extra_Permutations( nVars );
+        nVarsOld = nVars;
+    }
+
+    uTruthMin = 0xFFFFFFFF;
+    for ( k = 0; k < nPerms; k++ )
+    {
+        uPerm = Extra_TruthPermute( uTruth, pPerms[k], nVars, 0 );
+        if ( uTruthMin > uPerm )
+            uTruthMin = uPerm;
+    }
+    return uTruthMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes NP-canonical form using brute-force methods.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthCanonNP( unsigned uTruth, int nVars )
+{
+    static int nVarsOld, nPerms;
+    static char ** pPerms = NULL;
+
+    unsigned uTruthMin, uPhase, uPerm;
+    int nMints, k, i;
+
+    if ( pPerms == NULL )
+    {
+        nPerms = Extra_Factorial( nVars );   
+        pPerms = Extra_Permutations( nVars );
+        nVarsOld = nVars;
+    }
+    else if ( nVarsOld != nVars )
+    {
+        free( pPerms );
+        nPerms = Extra_Factorial( nVars );   
+        pPerms = Extra_Permutations( nVars );
+        nVarsOld = nVars;
+    }
+
+    nMints    = (1 << nVars);
+    uTruthMin = 0xFFFFFFFF;
+    for ( i = 0; i < nMints; i++ )
+    {
+        uPhase = Extra_TruthPolarize( uTruth, i, nVars ); 
+        for ( k = 0; k < nPerms; k++ )
+        {
+            uPerm = Extra_TruthPermute( uPhase, pPerms[k], nVars, 0 );
+            if ( uTruthMin > uPerm )
+                uTruthMin = uPerm;
+        }
+    }
+    return uTruthMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes NPN-canonical form using brute-force methods.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthCanonNPN( unsigned uTruth, int nVars )
+{
+    static int nVarsOld, nPerms;
+    static char ** pPerms = NULL;
+
+    unsigned uTruthMin, uTruthC, uPhase, uPerm;
+    int nMints, k, i;
+
+    if ( pPerms == NULL )
+    {
+        nPerms = Extra_Factorial( nVars );   
+        pPerms = Extra_Permutations( nVars );
+        nVarsOld = nVars;
+    }
+    else if ( nVarsOld != nVars )
+    {
+        free( pPerms );
+        nPerms = Extra_Factorial( nVars );   
+        pPerms = Extra_Permutations( nVars );
+        nVarsOld = nVars;
+    }
+
+    nMints    = (1 << nVars);
+    uTruthC   = (unsigned)( (~uTruth) & ((~((unsigned)0)) >> (32-nMints)) );
+    uTruthMin = 0xFFFFFFFF;
+    for ( i = 0; i < nMints; i++ )
+    {
+        uPhase = Extra_TruthPolarize( uTruth, i, nVars ); 
+        for ( k = 0; k < nPerms; k++ )
+        {
+            uPerm = Extra_TruthPermute( uPhase, pPerms[k], nVars, 0 );
+            if ( uTruthMin > uPerm )
+                uTruthMin = uPerm;
+        }
+        uPhase = Extra_TruthPolarize( uTruthC, i, nVars ); 
+        for ( k = 0; k < nPerms; k++ )
+        {
+            uPerm = Extra_TruthPermute( uPhase, pPerms[k], nVars, 0 );
+            if ( uTruthMin > uPerm )
+                uTruthMin = uPerm;
+        }
+    }
+    return uTruthMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes NPN canonical forms for 4-variable functions.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_Truth4VarNPN( unsigned short ** puCanons, char ** puPhases, char ** puPerms, unsigned char ** puMap )
+{
+    unsigned short * uCanons;
+    unsigned char * uMap;
+    unsigned uTruth, uPhase, uPerm;
+    char ** pPerms4, * uPhases, * uPerms;
+    int nFuncs, nClasses;
+    int i, k;
+
+    nFuncs  = (1 << 16);
+    uCanons = ALLOC( unsigned short, nFuncs );
+    uPhases = ALLOC( char, nFuncs );
+    uPerms  = ALLOC( char, nFuncs );
+    uMap    = ALLOC( unsigned char, nFuncs );
+    memset( uCanons, 0, sizeof(unsigned short) * nFuncs );
+    memset( uPhases, 0, sizeof(char) * nFuncs );
+    memset( uPerms,  0, sizeof(char) * nFuncs );
+    memset( uMap,    0, sizeof(unsigned char) * nFuncs );
+    pPerms4 = Extra_Permutations( 4 );
+
+    nClasses = 1;
+    nFuncs = (1 << 15);
+    for ( uTruth = 1; uTruth < (unsigned)nFuncs; uTruth++ )
+    {
+        // skip already assigned
+        if ( uCanons[uTruth] )
+        {
+            assert( uTruth > uCanons[uTruth] );
+            uMap[~uTruth & 0xFFFF] = uMap[uTruth] = uMap[uCanons[uTruth]];
+            continue;
+        }
+        uMap[uTruth] = nClasses++;
+        for ( i = 0; i < 16; i++ )
+        {
+            uPhase = Extra_TruthPolarize( uTruth, i, 4 );
+            for ( k = 0; k < 24; k++ )
+            {
+                uPerm = Extra_TruthPermute( uPhase, pPerms4[k], 4, 0 );
+                if ( uCanons[uPerm] == 0 )
+                {
+                    uCanons[uPerm] = uTruth;
+                    uPhases[uPerm] = i;
+                    uPerms[uPerm]  = k;
+
+                    uPerm = ~uPerm & 0xFFFF;
+                    uCanons[uPerm] = uTruth;
+                    uPhases[uPerm] = i | 16;
+                    uPerms[uPerm]  = k;
+                }
+                else
+                    assert( uCanons[uPerm] == uTruth );
+            }
+            uPhase = Extra_TruthPolarize( ~uTruth & 0xFFFF, i, 4 ); 
+            for ( k = 0; k < 24; k++ )
+            {
+                uPerm = Extra_TruthPermute( uPhase, pPerms4[k], 4, 0 );
+                if ( uCanons[uPerm] == 0 )
+                {
+                    uCanons[uPerm] = uTruth;
+                    uPhases[uPerm] = i;
+                    uPerms[uPerm]  = k;
+
+                    uPerm = ~uPerm & 0xFFFF;
+                    uCanons[uPerm] = uTruth;
+                    uPhases[uPerm] = i | 16;
+                    uPerms[uPerm]  = k;
+                }
+                else
+                    assert( uCanons[uPerm] == uTruth );
+            }
+        }
+    }
+    uPhases[(1<<16)-1] = 16;
+    assert( nClasses == 222 );
+    free( pPerms4 );
+    if ( puCanons ) 
+        *puCanons = uCanons;
+    else
+        free( uCanons );
+    if ( puPhases ) 
+        *puPhases = uPhases;
+    else
+        free( uPhases );
+    if ( puPerms ) 
+        *puPerms = uPerms;
+    else
+        free( uPerms );
+    if ( puMap ) 
+        *puMap = uMap;
+    else
+        free( uMap );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes NPN canonical forms for 4-variable functions.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_Truth3VarN( unsigned ** puCanons, char *** puPhases, char ** ppCounters )
+{
+    int nPhasesMax = 8;
+    unsigned * uCanons;
+    unsigned uTruth, uPhase, uTruth32;
+    char ** uPhases, * pCounters;
+    int nFuncs, nClasses, i;
+
+    nFuncs  = (1 << 8);
+    uCanons = ALLOC( unsigned, nFuncs );
+    memset( uCanons, 0, sizeof(unsigned) * nFuncs );
+    pCounters = ALLOC( char, nFuncs );
+    memset( pCounters, 0, sizeof(char) * nFuncs );
+    uPhases = (char **)Extra_ArrayAlloc( nFuncs, nPhasesMax, sizeof(char) );
+    nClasses = 0;
+    for ( uTruth = 0; uTruth < (unsigned)nFuncs; uTruth++ )
+    {
+        // skip already assigned
+        uTruth32 = ((uTruth << 24) | (uTruth << 16) | (uTruth << 8) | uTruth);
+        if ( uCanons[uTruth] )
+        {
+            assert( uTruth32 > uCanons[uTruth] );
+            continue;
+        }
+        nClasses++;
+        for ( i = 0; i < 8; i++ )
+        {
+            uPhase = Extra_TruthPolarize( uTruth, i, 3 );
+            if ( uCanons[uPhase] == 0 && (uTruth || i==0) )
+            {
+                uCanons[uPhase]    = uTruth32;
+                uPhases[uPhase][0] = i;
+                pCounters[uPhase]  = 1;
+            }
+            else
+            {
+                assert( uCanons[uPhase] == uTruth32 );
+                if ( pCounters[uPhase] < nPhasesMax )
+                    uPhases[uPhase][ pCounters[uPhase]++ ] = i;
+            }
+        }
+    }
+    if ( puCanons ) 
+        *puCanons = uCanons;
+    else
+        free( uCanons );
+    if ( puPhases ) 
+        *puPhases = uPhases;
+    else
+        free( uPhases );
+    if ( ppCounters ) 
+        *ppCounters = pCounters;
+    else
+        free( pCounters );
+//    printf( "The number of 3N-classes = %d.\n", nClasses );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes NPN canonical forms for 4-variable functions.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_Truth4VarN( unsigned short ** puCanons, char *** puPhases, char ** ppCounters, int nPhasesMax )
+{
+    unsigned short * uCanons;
+    unsigned uTruth, uPhase;
+    char ** uPhases, * pCounters;
+    int nFuncs, nClasses, i;
+
+    nFuncs  = (1 << 16);
+    uCanons = ALLOC( unsigned short, nFuncs );
+    memset( uCanons, 0, sizeof(unsigned short) * nFuncs );
+    pCounters = ALLOC( char, nFuncs );
+    memset( pCounters, 0, sizeof(char) * nFuncs );
+    uPhases = (char **)Extra_ArrayAlloc( nFuncs, nPhasesMax, sizeof(char) );
+    nClasses = 0;
+    for ( uTruth = 0; uTruth < (unsigned)nFuncs; uTruth++ )
+    {
+        // skip already assigned
+        if ( uCanons[uTruth] )
+        {
+            assert( uTruth > uCanons[uTruth] );
+            continue;
+        }
+        nClasses++;
+        for ( i = 0; i < 16; i++ )
+        {
+            uPhase = Extra_TruthPolarize( uTruth, i, 4 );
+            if ( uCanons[uPhase] == 0 && (uTruth || i==0) )
+            {
+                uCanons[uPhase]    = uTruth;
+                uPhases[uPhase][0] = i;
+                pCounters[uPhase]  = 1;
+            }
+            else
+            {
+                assert( uCanons[uPhase] == uTruth );
+                if ( pCounters[uPhase] < nPhasesMax )
+                    uPhases[uPhase][ pCounters[uPhase]++ ] = i;
+            }
+        }
+    }
+    if ( puCanons ) 
+        *puCanons = uCanons;
+    else
+        free( uCanons );
+    if ( puPhases ) 
+        *puPhases = uPhases;
+    else
+        free( uPhases );
+    if ( ppCounters ) 
+        *ppCounters = pCounters;
+    else
+        free( pCounters );
+//    printf( "The number of 4N-classes = %d.\n", nClasses );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocated one-memory-chunk array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void ** Extra_ArrayAlloc( int nCols, int nRows, int Size )
+{
+    char ** pRes;
+    char * pBuffer;
+    int i;
+    assert( nCols > 0 && nRows > 0 && Size > 0 );
+    pBuffer = ALLOC( char, nCols * (sizeof(void *) + nRows * Size) );
+    pRes = (char **)pBuffer;
+    pRes[0] = pBuffer + nCols * sizeof(void *);
+    for ( i = 1; i < nCols; i++ )
+        pRes[i] = pRes[0] + i * nRows * Size;
+    return pRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes a phase of the 3-var function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned short Extra_TruthPerm4One( unsigned uTruth, int Phase )
+{
+    // cases
+    static unsigned short Cases[16] = {
+        0,      // 0000  - skip
+        0,      // 0001  - skip
+        0xCCCC, // 0010  - single var
+        0,      // 0011  - skip
+        0xF0F0, // 0100  - single var
+        1,      // 0101
+        1,      // 0110
+        0,      // 0111  - skip
+        0xFF00, // 1000  - single var
+        1,      // 1001
+        1,      // 1010
+        1,      // 1011
+        1,      // 1100
+        1,      // 1101
+        1,      // 1110
+        0       // 1111  - skip
+    };
+    // permutations
+    static int Perms[16][4] = {
+        { 0, 0, 0, 0 }, // 0000  - skip
+        { 0, 0, 0, 0 }, // 0001  - skip
+        { 0, 0, 0, 0 }, // 0010  - single var
+        { 0, 0, 0, 0 }, // 0011  - skip
+        { 0, 0, 0, 0 }, // 0100  - single var
+        { 0, 2, 1, 3 }, // 0101
+        { 2, 0, 1, 3 }, // 0110
+        { 0, 0, 0, 0 }, // 0111  - skip
+        { 0, 0, 0, 0 }, // 1000  - single var
+        { 0, 2, 3, 1 }, // 1001
+        { 2, 0, 3, 1 }, // 1010
+        { 0, 1, 3, 2 }, // 1011
+        { 2, 3, 0, 1 }, // 1100
+        { 0, 3, 1, 2 }, // 1101
+        { 3, 0, 1, 2 }, // 1110
+        { 0, 0, 0, 0 }  // 1111  - skip
+    };
+    int i, k, iRes;
+    unsigned uTruthRes;
+    assert( Phase >= 0 && Phase < 16 );
+    if ( Cases[Phase] == 0 )
+        return uTruth;
+    if ( Cases[Phase] > 1 )
+        return Cases[Phase];
+    uTruthRes = 0;
+    for ( i = 0; i < 16; i++ )
+        if ( uTruth & (1 << i) )
+        {
+            for ( iRes = 0, k = 0; k < 4; k++ )
+                if ( i & (1 << Perms[Phase][k]) )
+                    iRes |= (1 << k);
+            uTruthRes |= (1 << iRes);
+        }
+    return uTruthRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes a phase of the 3-var function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthPerm5One( unsigned uTruth, int Phase )
+{
+    // cases
+    static unsigned Cases[32] = {
+        0,          // 00000  - skip
+        0,          // 00001  - skip
+        0xCCCCCCCC, // 00010  - single var
+        0,          // 00011  - skip
+        0xF0F0F0F0, // 00100  - single var
+        1,          // 00101
+        1,          // 00110
+        0,          // 00111  - skip
+        0xFF00FF00, // 01000  - single var
+        1,          // 01001
+        1,          // 01010
+        1,          // 01011
+        1,          // 01100
+        1,          // 01101
+        1,          // 01110
+        0,          // 01111  - skip
+        0xFFFF0000, // 10000  - skip
+        1,          // 10001
+        1,          // 10010
+        1,          // 10011
+        1,          // 10100
+        1,          // 10101
+        1,          // 10110
+        1,          // 10111  - four var
+        1,          // 11000
+        1,          // 11001
+        1,          // 11010
+        1,          // 11011  - four var
+        1,          // 11100
+        1,          // 11101  - four var
+        1,          // 11110  - four var
+        0           // 11111  - skip
+    };
+    // permutations
+    static int Perms[32][5] = {
+        { 0, 0, 0, 0, 0 }, // 00000  - skip
+        { 0, 0, 0, 0, 0 }, // 00001  - skip
+        { 0, 0, 0, 0, 0 }, // 00010  - single var
+        { 0, 0, 0, 0, 0 }, // 00011  - skip
+        { 0, 0, 0, 0, 0 }, // 00100  - single var
+        { 0, 2, 1, 3, 4 }, // 00101
+        { 2, 0, 1, 3, 4 }, // 00110
+        { 0, 0, 0, 0, 0 }, // 00111  - skip
+        { 0, 0, 0, 0, 0 }, // 01000  - single var
+        { 0, 2, 3, 1, 4 }, // 01001
+        { 2, 0, 3, 1, 4 }, // 01010
+        { 0, 1, 3, 2, 4 }, // 01011
+        { 2, 3, 0, 1, 4 }, // 01100
+        { 0, 3, 1, 2, 4 }, // 01101
+        { 3, 0, 1, 2, 4 }, // 01110
+        { 0, 0, 0, 0, 0 }, // 01111  - skip
+        { 0, 0, 0, 0, 0 }, // 10000  - single var
+        { 0, 4, 2, 3, 1 }, // 10001
+        { 4, 0, 2, 3, 1 }, // 10010
+        { 0, 1, 3, 4, 2 }, // 10011
+        { 2, 3, 0, 4, 1 }, // 10100
+        { 0, 3, 1, 4, 2 }, // 10101
+        { 3, 0, 1, 4, 2 }, // 10110
+        { 0, 1, 2, 4, 3 }, // 10111  - four var
+        { 2, 3, 4, 0, 1 }, // 11000
+        { 0, 3, 4, 1, 2 }, // 11001
+        { 3, 0, 4, 1, 2 }, // 11010
+        { 0, 1, 4, 2, 3 }, // 11011  - four var
+        { 3, 4, 0, 1, 2 }, // 11100
+        { 0, 4, 1, 2, 3 }, // 11101  - four var
+        { 4, 0, 1, 2, 3 }, // 11110  - four var
+        { 0, 0, 0, 0, 0 }  // 11111  - skip
+    };
+    int i, k, iRes;
+    unsigned uTruthRes;
+    assert( Phase >= 0 && Phase < 32 );
+    if ( Cases[Phase] == 0 )
+        return uTruth;
+    if ( Cases[Phase] > 1 )
+        return Cases[Phase];
+    uTruthRes = 0;
+    for ( i = 0; i < 32; i++ )
+        if ( uTruth & (1 << i) )
+        {
+            for ( iRes = 0, k = 0; k < 5; k++ )
+                if ( i & (1 << Perms[Phase][k]) )
+                    iRes |= (1 << k);
+            uTruthRes |= (1 << iRes);
+        }
+    return uTruthRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes a phase of the 3-var function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthPerm6One( unsigned * uTruth, int Phase, unsigned * uTruthRes )
+{
+    // cases
+    static unsigned Cases[64] = {
+        0,          // 000000  - skip
+        0,          // 000001  - skip
+        0xCCCCCCCC, // 000010  - single var
+        0,          // 000011  - skip
+        0xF0F0F0F0, // 000100  - single var
+        1,          // 000101
+        1,          // 000110
+        0,          // 000111  - skip
+        0xFF00FF00, // 001000  - single var
+        1,          // 001001
+        1,          // 001010
+        1,          // 001011
+        1,          // 001100
+        1,          // 001101
+        1,          // 001110
+        0,          // 001111  - skip
+        0xFFFF0000, // 010000  - skip
+        1,          // 010001
+        1,          // 010010
+        1,          // 010011
+        1,          // 010100
+        1,          // 010101
+        1,          // 010110
+        1,          // 010111  - four var
+        1,          // 011000
+        1,          // 011001
+        1,          // 011010
+        1,          // 011011  - four var
+        1,          // 011100
+        1,          // 011101  - four var
+        1,          // 011110  - four var
+        0,          // 011111  - skip
+        0xFFFFFFFF, // 100000  - single var
+        1,          // 100001 
+        1,          // 100010  
+        1,          // 100011  
+        1,          // 100100  
+        1,          // 100101
+        1,          // 100110
+        1,          // 100111  
+        1,          // 101000  
+        1,          // 101001
+        1,          // 101010
+        1,          // 101011
+        1,          // 101100
+        1,          // 101101
+        1,          // 101110
+        1,          // 101111  
+        1,          // 110000  
+        1,          // 110001
+        1,          // 110010
+        1,          // 110011
+        1,          // 110100
+        1,          // 110101
+        1,          // 110110
+        1,          // 110111  
+        1,          // 111000
+        1,          // 111001
+        1,          // 111010
+        1,          // 111011  
+        1,          // 111100
+        1,          // 111101  
+        1,          // 111110  
+        0           // 111111  - skip
+    };
+    // permutations
+    static int Perms[64][6] = {
+        { 0, 0, 0, 0, 0, 0 }, // 000000  - skip
+        { 0, 0, 0, 0, 0, 0 }, // 000001  - skip
+        { 0, 0, 0, 0, 0, 0 }, // 000010  - single var
+        { 0, 0, 0, 0, 0, 0 }, // 000011  - skip
+        { 0, 0, 0, 0, 0, 0 }, // 000100  - single var
+        { 0, 2, 1, 3, 4, 5 }, // 000101
+        { 2, 0, 1, 3, 4, 5 }, // 000110
+        { 0, 0, 0, 0, 0, 0 }, // 000111  - skip
+        { 0, 0, 0, 0, 0, 0 }, // 001000  - single var
+        { 0, 2, 3, 1, 4, 5 }, // 001001
+        { 2, 0, 3, 1, 4, 5 }, // 001010
+        { 0, 1, 3, 2, 4, 5 }, // 001011
+        { 2, 3, 0, 1, 4, 5 }, // 001100
+        { 0, 3, 1, 2, 4, 5 }, // 001101
+        { 3, 0, 1, 2, 4, 5 }, // 001110
+        { 0, 0, 0, 0, 0, 0 }, // 001111  - skip
+        { 0, 0, 0, 0, 0, 0 }, // 010000  - skip
+        { 0, 4, 2, 3, 1, 5 }, // 010001
+        { 4, 0, 2, 3, 1, 5 }, // 010010
+        { 0, 1, 3, 4, 2, 5 }, // 010011
+        { 2, 3, 0, 4, 1, 5 }, // 010100
+        { 0, 3, 1, 4, 2, 5 }, // 010101
+        { 3, 0, 1, 4, 2, 5 }, // 010110
+        { 0, 1, 2, 4, 3, 5 }, // 010111  - four var
+        { 2, 3, 4, 0, 1, 5 }, // 011000
+        { 0, 3, 4, 1, 2, 5 }, // 011001
+        { 3, 0, 4, 1, 2, 5 }, // 011010
+        { 0, 1, 4, 2, 3, 5 }, // 011011  - four var
+        { 3, 4, 0, 1, 2, 5 }, // 011100
+        { 0, 4, 1, 2, 3, 5 }, // 011101  - four var
+        { 4, 0, 1, 2, 3, 5 }, // 011110  - four var
+        { 0, 0, 0, 0, 0, 0 }, // 011111  - skip
+        { 0, 0, 0, 0, 0, 0 }, // 100000  - single var
+        { 0, 2, 3, 4, 5, 1 }, // 100001 
+        { 2, 0, 3, 4, 5, 1 }, // 100010  
+        { 0, 1, 3, 4, 5, 2 }, // 100011  
+        { 2, 3, 0, 4, 5, 1 }, // 100100  
+        { 0, 3, 1, 4, 5, 2 }, // 100101
+        { 3, 0, 1, 4, 5, 2 }, // 100110
+        { 0, 1, 2, 4, 5, 3 }, // 100111  
+        { 2, 3, 4, 0, 5, 1 }, // 101000  
+        { 0, 3, 4, 1, 5, 2 }, // 101001
+        { 3, 0, 4, 1, 5, 2 }, // 101010
+        { 0, 1, 4, 2, 5, 3 }, // 101011
+        { 3, 4, 0, 1, 5, 2 }, // 101100
+        { 0, 4, 1, 2, 5, 3 }, // 101101
+        { 4, 0, 1, 2, 5, 3 }, // 101110
+        { 0, 1, 2, 3, 5, 4 }, // 101111  
+        { 2, 3, 4, 5, 0, 1 }, // 110000  
+        { 0, 3, 4, 5, 1, 2 }, // 110001
+        { 3, 0, 4, 5, 1, 2 }, // 110010
+        { 0, 1, 4, 5, 2, 3 }, // 110011
+        { 3, 4, 0, 5, 1, 2 }, // 110100
+        { 0, 4, 1, 5, 2, 3 }, // 110101
+        { 4, 0, 1, 5, 2, 3 }, // 110110
+        { 0, 1, 2, 5, 3, 4 }, // 110111  
+        { 3, 4, 5, 0, 1, 2 }, // 111000
+        { 0, 4, 5, 1, 2, 3 }, // 111001
+        { 4, 0, 5, 1, 2, 3 }, // 111010
+        { 0, 1, 5, 2, 3, 4 }, // 111011  
+        { 4, 5, 0, 1, 2, 3 }, // 111100
+        { 0, 5, 1, 2, 3, 4 }, // 111101  
+        { 5, 0, 1, 2, 3, 4 }, // 111110  
+        { 0, 0, 0, 0, 0, 0 }  // 111111  - skip
+    };
+    int i, k, iRes;
+    assert( Phase >= 0 && Phase < 64 );
+    if ( Cases[Phase] == 0 )
+    {
+        uTruthRes[0] = uTruth[0];
+        uTruthRes[1] = uTruth[1];
+        return;
+    }
+    if ( Cases[Phase] > 1 )
+    {
+        if ( Phase == 32 )
+        {
+            uTruthRes[0] = 0x00000000;
+            uTruthRes[1] = 0xFFFFFFFF;
+        }
+        else
+        {
+            uTruthRes[0] = Cases[Phase];
+            uTruthRes[1] = Cases[Phase];
+        }
+        return;
+    }
+    uTruthRes[0] = 0;
+    uTruthRes[1] = 0;
+    for ( i = 0; i < 64; i++ )
+    {
+        if ( i < 32 )
+        {
+            if ( uTruth[0] & (1 << i) )
+            {
+                for ( iRes = 0, k = 0; k < 6; k++ )
+                    if ( i & (1 << Perms[Phase][k]) )
+                        iRes |= (1 << k);
+                if ( iRes < 32 )
+                    uTruthRes[0] |= (1 << iRes);
+                else
+                    uTruthRes[1] |= (1 << (iRes-32));
+            }
+        }
+        else
+        {
+            if ( uTruth[1] & (1 << (i-32)) )
+            {
+                for ( iRes = 0, k = 0; k < 6; k++ )
+                    if ( i & (1 << Perms[Phase][k]) )
+                        iRes |= (1 << k);
+                if ( iRes < 32 )
+                    uTruthRes[0] |= (1 << iRes);
+                else
+                    uTruthRes[1] |= (1 << (iRes-32));
+            }
+        }
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes a phase of the 8-var function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthExpand( int nVars, int nWords, unsigned * puTruth, unsigned uPhase, unsigned * puTruthR )
+{
+    // elementary truth tables
+    static unsigned uTruths[8][8] = {
+        { 0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA },
+        { 0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC },
+        { 0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0 },
+        { 0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00 },
+        { 0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000 }, 
+        { 0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF }, 
+        { 0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF }, 
+        { 0x00000000,0x00000000,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF } 
+    };
+    static char Cases[256] = {
+         0, // 00000000
+         0, // 00000001
+         1, // 00000010
+         0, // 00000011
+         2, // 00000100
+        -1, // 00000101
+        -1, // 00000110
+         0, // 00000111
+         3, // 00001000
+        -1, // 00001001
+        -1, // 00001010
+        -1, // 00001011
+        -1, // 00001100
+        -1, // 00001101
+        -1, // 00001110
+         0, // 00001111
+         4, // 00010000
+        -1, // 00010001
+        -1, // 00010010
+        -1, // 00010011
+        -1, // 00010100
+        -1, // 00010101
+        -1, // 00010110
+        -1, // 00010111
+        -1, // 00011000
+        -1, // 00011001
+        -1, // 00011010
+        -1, // 00011011
+        -1, // 00011100
+        -1, // 00011101
+        -1, // 00011110
+         0, // 00011111
+         5, // 00100000
+        -1, // 00100001
+        -1, // 00100010
+        -1, // 00100011
+        -1, // 00100100
+        -1, // 00100101
+        -1, // 00100110
+        -1, // 00100111
+        -1, // 00101000
+        -1, // 00101001
+        -1, // 00101010
+        -1, // 00101011
+        -1, // 00101100
+        -1, // 00101101
+        -1, // 00101110
+        -1, // 00101111
+        -1, // 00110000
+        -1, // 00110001
+        -1, // 00110010
+        -1, // 00110011
+        -1, // 00110100
+        -1, // 00110101
+        -1, // 00110110
+        -1, // 00110111
+        -1, // 00111000
+        -1, // 00111001
+        -1, // 00111010
+        -1, // 00111011
+        -1, // 00111100
+        -1, // 00111101
+        -1, // 00111110
+         0, // 00111111
+         6, // 01000000
+        -1, // 01000001
+        -1, // 01000010
+        -1, // 01000011
+        -1, // 01000100
+        -1, // 01000101
+        -1, // 01000110
+        -1, // 01000111
+        -1, // 01001000
+        -1, // 01001001
+        -1, // 01001010
+        -1, // 01001011
+        -1, // 01001100
+        -1, // 01001101
+        -1, // 01001110
+        -1, // 01001111
+        -1, // 01010000
+        -1, // 01010001
+        -1, // 01010010
+        -1, // 01010011
+        -1, // 01010100
+        -1, // 01010101
+        -1, // 01010110
+        -1, // 01010111
+        -1, // 01011000
+        -1, // 01011001
+        -1, // 01011010
+        -1, // 01011011
+        -1, // 01011100
+        -1, // 01011101
+        -1, // 01011110
+        -1, // 01011111
+        -1, // 01100000
+        -1, // 01100001
+        -1, // 01100010
+        -1, // 01100011
+        -1, // 01100100
+        -1, // 01100101
+        -1, // 01100110
+        -1, // 01100111
+        -1, // 01101000
+        -1, // 01101001
+        -1, // 01101010
+        -1, // 01101011
+        -1, // 01101100
+        -1, // 01101101
+        -1, // 01101110
+        -1, // 01101111
+        -1, // 01110000
+        -1, // 01110001
+        -1, // 01110010
+        -1, // 01110011
+        -1, // 01110100
+        -1, // 01110101
+        -1, // 01110110
+        -1, // 01110111
+        -1, // 01111000
+        -1, // 01111001
+        -1, // 01111010
+        -1, // 01111011
+        -1, // 01111100
+        -1, // 01111101
+        -1, // 01111110
+         0, // 01111111
+         7, // 10000000
+        -1, // 10000001
+        -1, // 10000010
+        -1, // 10000011
+        -1, // 10000100
+        -1, // 10000101
+        -1, // 10000110
+        -1, // 10000111
+        -1, // 10001000
+        -1, // 10001001
+        -1, // 10001010
+        -1, // 10001011
+        -1, // 10001100
+        -1, // 10001101
+        -1, // 10001110
+        -1, // 10001111
+        -1, // 10010000
+        -1, // 10010001
+        -1, // 10010010
+        -1, // 10010011
+        -1, // 10010100
+        -1, // 10010101
+        -1, // 10010110
+        -1, // 10010111
+        -1, // 10011000
+        -1, // 10011001
+        -1, // 10011010
+        -1, // 10011011
+        -1, // 10011100
+        -1, // 10011101
+        -1, // 10011110
+        -1, // 10011111
+        -1, // 10100000
+        -1, // 10100001
+        -1, // 10100010
+        -1, // 10100011
+        -1, // 10100100
+        -1, // 10100101
+        -1, // 10100110
+        -1, // 10100111
+        -1, // 10101000
+        -1, // 10101001
+        -1, // 10101010
+        -1, // 10101011
+        -1, // 10101100
+        -1, // 10101101
+        -1, // 10101110
+        -1, // 10101111
+        -1, // 10110000
+        -1, // 10110001
+        -1, // 10110010
+        -1, // 10110011
+        -1, // 10110100
+        -1, // 10110101
+        -1, // 10110110
+        -1, // 10110111
+        -1, // 10111000
+        -1, // 10111001
+        -1, // 10111010
+        -1, // 10111011
+        -1, // 10111100
+        -1, // 10111101
+        -1, // 10111110
+        -1, // 10111111
+        -1, // 11000000
+        -1, // 11000001
+        -1, // 11000010
+        -1, // 11000011
+        -1, // 11000100
+        -1, // 11000101
+        -1, // 11000110
+        -1, // 11000111
+        -1, // 11001000
+        -1, // 11001001
+        -1, // 11001010
+        -1, // 11001011
+        -1, // 11001100
+        -1, // 11001101
+        -1, // 11001110
+        -1, // 11001111
+        -1, // 11010000
+        -1, // 11010001
+        -1, // 11010010
+        -1, // 11010011
+        -1, // 11010100
+        -1, // 11010101
+        -1, // 11010110
+        -1, // 11010111
+        -1, // 11011000
+        -1, // 11011001
+        -1, // 11011010
+        -1, // 11011011
+        -1, // 11011100
+        -1, // 11011101
+        -1, // 11011110
+        -1, // 11011111
+        -1, // 11100000
+        -1, // 11100001
+        -1, // 11100010
+        -1, // 11100011
+        -1, // 11100100
+        -1, // 11100101
+        -1, // 11100110
+        -1, // 11100111
+        -1, // 11101000
+        -1, // 11101001
+        -1, // 11101010
+        -1, // 11101011
+        -1, // 11101100
+        -1, // 11101101
+        -1, // 11101110
+        -1, // 11101111
+        -1, // 11110000
+        -1, // 11110001
+        -1, // 11110010
+        -1, // 11110011
+        -1, // 11110100
+        -1, // 11110101
+        -1, // 11110110
+        -1, // 11110111
+        -1, // 11111000
+        -1, // 11111001
+        -1, // 11111010
+        -1, // 11111011
+        -1, // 11111100
+        -1, // 11111101
+        -1, // 11111110
+         0  // 11111111
+    };
+    static char Perms[256][8] = {
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 00000000
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 00000001
+        { 1, 0, 2, 3, 4, 5, 6, 7 }, // 00000010
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 00000011
+        { 1, 2, 0, 3, 4, 5, 6, 7 }, // 00000100
+        { 0, 2, 1, 3, 4, 5, 6, 7 }, // 00000101
+        { 2, 0, 1, 3, 4, 5, 6, 7 }, // 00000110
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 00000111
+        { 1, 2, 3, 0, 4, 5, 6, 7 }, // 00001000
+        { 0, 2, 3, 1, 4, 5, 6, 7 }, // 00001001
+        { 2, 0, 3, 1, 4, 5, 6, 7 }, // 00001010
+        { 0, 1, 3, 2, 4, 5, 6, 7 }, // 00001011
+        { 2, 3, 0, 1, 4, 5, 6, 7 }, // 00001100
+        { 0, 3, 1, 2, 4, 5, 6, 7 }, // 00001101
+        { 3, 0, 1, 2, 4, 5, 6, 7 }, // 00001110
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 00001111
+        { 1, 2, 3, 4, 0, 5, 6, 7 }, // 00010000
+        { 0, 2, 3, 4, 1, 5, 6, 7 }, // 00010001
+        { 2, 0, 3, 4, 1, 5, 6, 7 }, // 00010010
+        { 0, 1, 3, 4, 2, 5, 6, 7 }, // 00010011
+        { 2, 3, 0, 4, 1, 5, 6, 7 }, // 00010100
+        { 0, 3, 1, 4, 2, 5, 6, 7 }, // 00010101
+        { 3, 0, 1, 4, 2, 5, 6, 7 }, // 00010110
+        { 0, 1, 2, 4, 3, 5, 6, 7 }, // 00010111
+        { 2, 3, 4, 0, 1, 5, 6, 7 }, // 00011000
+        { 0, 3, 4, 1, 2, 5, 6, 7 }, // 00011001
+        { 3, 0, 4, 1, 2, 5, 6, 7 }, // 00011010
+        { 0, 1, 4, 2, 3, 5, 6, 7 }, // 00011011
+        { 3, 4, 0, 1, 2, 5, 6, 7 }, // 00011100
+        { 0, 4, 1, 2, 3, 5, 6, 7 }, // 00011101
+        { 4, 0, 1, 2, 3, 5, 6, 7 }, // 00011110
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 00011111
+        { 1, 2, 3, 4, 5, 0, 6, 7 }, // 00100000
+        { 0, 2, 3, 4, 5, 1, 6, 7 }, // 00100001
+        { 2, 0, 3, 4, 5, 1, 6, 7 }, // 00100010
+        { 0, 1, 3, 4, 5, 2, 6, 7 }, // 00100011
+        { 2, 3, 0, 4, 5, 1, 6, 7 }, // 00100100
+        { 0, 3, 1, 4, 5, 2, 6, 7 }, // 00100101
+        { 3, 0, 1, 4, 5, 2, 6, 7 }, // 00100110
+        { 0, 1, 2, 4, 5, 3, 6, 7 }, // 00100111
+        { 2, 3, 4, 0, 5, 1, 6, 7 }, // 00101000
+        { 0, 3, 4, 1, 5, 2, 6, 7 }, // 00101001
+        { 3, 0, 4, 1, 5, 2, 6, 7 }, // 00101010
+        { 0, 1, 4, 2, 5, 3, 6, 7 }, // 00101011
+        { 3, 4, 0, 1, 5, 2, 6, 7 }, // 00101100
+        { 0, 4, 1, 2, 5, 3, 6, 7 }, // 00101101
+        { 4, 0, 1, 2, 5, 3, 6, 7 }, // 00101110
+        { 0, 1, 2, 3, 5, 4, 6, 7 }, // 00101111
+        { 2, 3, 4, 5, 0, 1, 6, 7 }, // 00110000
+        { 0, 3, 4, 5, 1, 2, 6, 7 }, // 00110001
+        { 3, 0, 4, 5, 1, 2, 6, 7 }, // 00110010
+        { 0, 1, 4, 5, 2, 3, 6, 7 }, // 00110011
+        { 3, 4, 0, 5, 1, 2, 6, 7 }, // 00110100
+        { 0, 4, 1, 5, 2, 3, 6, 7 }, // 00110101
+        { 4, 0, 1, 5, 2, 3, 6, 7 }, // 00110110
+        { 0, 1, 2, 5, 3, 4, 6, 7 }, // 00110111
+        { 3, 4, 5, 0, 1, 2, 6, 7 }, // 00111000
+        { 0, 4, 5, 1, 2, 3, 6, 7 }, // 00111001
+        { 4, 0, 5, 1, 2, 3, 6, 7 }, // 00111010
+        { 0, 1, 5, 2, 3, 4, 6, 7 }, // 00111011
+        { 4, 5, 0, 1, 2, 3, 6, 7 }, // 00111100
+        { 0, 5, 1, 2, 3, 4, 6, 7 }, // 00111101
+        { 5, 0, 1, 2, 3, 4, 6, 7 }, // 00111110
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 00111111
+        { 1, 2, 3, 4, 5, 6, 0, 7 }, // 01000000
+        { 0, 2, 3, 4, 5, 6, 1, 7 }, // 01000001
+        { 2, 0, 3, 4, 5, 6, 1, 7 }, // 01000010
+        { 0, 1, 3, 4, 5, 6, 2, 7 }, // 01000011
+        { 2, 3, 0, 4, 5, 6, 1, 7 }, // 01000100
+        { 0, 3, 1, 4, 5, 6, 2, 7 }, // 01000101
+        { 3, 0, 1, 4, 5, 6, 2, 7 }, // 01000110
+        { 0, 1, 2, 4, 5, 6, 3, 7 }, // 01000111
+        { 2, 3, 4, 0, 5, 6, 1, 7 }, // 01001000
+        { 0, 3, 4, 1, 5, 6, 2, 7 }, // 01001001
+        { 3, 0, 4, 1, 5, 6, 2, 7 }, // 01001010
+        { 0, 1, 4, 2, 5, 6, 3, 7 }, // 01001011
+        { 3, 4, 0, 1, 5, 6, 2, 7 }, // 01001100
+        { 0, 4, 1, 2, 5, 6, 3, 7 }, // 01001101
+        { 4, 0, 1, 2, 5, 6, 3, 7 }, // 01001110
+        { 0, 1, 2, 3, 5, 6, 4, 7 }, // 01001111
+        { 2, 3, 4, 5, 0, 6, 1, 7 }, // 01010000
+        { 0, 3, 4, 5, 1, 6, 2, 7 }, // 01010001
+        { 3, 0, 4, 5, 1, 6, 2, 7 }, // 01010010
+        { 0, 1, 4, 5, 2, 6, 3, 7 }, // 01010011
+        { 3, 4, 0, 5, 1, 6, 2, 7 }, // 01010100
+        { 0, 4, 1, 5, 2, 6, 3, 7 }, // 01010101
+        { 4, 0, 1, 5, 2, 6, 3, 7 }, // 01010110
+        { 0, 1, 2, 5, 3, 6, 4, 7 }, // 01010111
+        { 3, 4, 5, 0, 1, 6, 2, 7 }, // 01011000
+        { 0, 4, 5, 1, 2, 6, 3, 7 }, // 01011001
+        { 4, 0, 5, 1, 2, 6, 3, 7 }, // 01011010
+        { 0, 1, 5, 2, 3, 6, 4, 7 }, // 01011011
+        { 4, 5, 0, 1, 2, 6, 3, 7 }, // 01011100
+        { 0, 5, 1, 2, 3, 6, 4, 7 }, // 01011101
+        { 5, 0, 1, 2, 3, 6, 4, 7 }, // 01011110
+        { 0, 1, 2, 3, 4, 6, 5, 7 }, // 01011111
+        { 2, 3, 4, 5, 6, 0, 1, 7 }, // 01100000
+        { 0, 3, 4, 5, 6, 1, 2, 7 }, // 01100001
+        { 3, 0, 4, 5, 6, 1, 2, 7 }, // 01100010
+        { 0, 1, 4, 5, 6, 2, 3, 7 }, // 01100011
+        { 3, 4, 0, 5, 6, 1, 2, 7 }, // 01100100
+        { 0, 4, 1, 5, 6, 2, 3, 7 }, // 01100101
+        { 4, 0, 1, 5, 6, 2, 3, 7 }, // 01100110
+        { 0, 1, 2, 5, 6, 3, 4, 7 }, // 01100111
+        { 3, 4, 5, 0, 6, 1, 2, 7 }, // 01101000
+        { 0, 4, 5, 1, 6, 2, 3, 7 }, // 01101001
+        { 4, 0, 5, 1, 6, 2, 3, 7 }, // 01101010
+        { 0, 1, 5, 2, 6, 3, 4, 7 }, // 01101011
+        { 4, 5, 0, 1, 6, 2, 3, 7 }, // 01101100
+        { 0, 5, 1, 2, 6, 3, 4, 7 }, // 01101101
+        { 5, 0, 1, 2, 6, 3, 4, 7 }, // 01101110
+        { 0, 1, 2, 3, 6, 4, 5, 7 }, // 01101111
+        { 3, 4, 5, 6, 0, 1, 2, 7 }, // 01110000
+        { 0, 4, 5, 6, 1, 2, 3, 7 }, // 01110001
+        { 4, 0, 5, 6, 1, 2, 3, 7 }, // 01110010
+        { 0, 1, 5, 6, 2, 3, 4, 7 }, // 01110011
+        { 4, 5, 0, 6, 1, 2, 3, 7 }, // 01110100
+        { 0, 5, 1, 6, 2, 3, 4, 7 }, // 01110101
+        { 5, 0, 1, 6, 2, 3, 4, 7 }, // 01110110
+        { 0, 1, 2, 6, 3, 4, 5, 7 }, // 01110111
+        { 4, 5, 6, 0, 1, 2, 3, 7 }, // 01111000
+        { 0, 5, 6, 1, 2, 3, 4, 7 }, // 01111001
+        { 5, 0, 6, 1, 2, 3, 4, 7 }, // 01111010
+        { 0, 1, 6, 2, 3, 4, 5, 7 }, // 01111011
+        { 5, 6, 0, 1, 2, 3, 4, 7 }, // 01111100
+        { 0, 6, 1, 2, 3, 4, 5, 7 }, // 01111101
+        { 6, 0, 1, 2, 3, 4, 5, 7 }, // 01111110
+        { 0, 1, 2, 3, 4, 5, 6, 7 }, // 01111111
+        { 1, 2, 3, 4, 5, 6, 7, 0 }, // 10000000
+        { 0, 2, 3, 4, 5, 6, 7, 1 }, // 10000001
+        { 2, 0, 3, 4, 5, 6, 7, 1 }, // 10000010
+        { 0, 1, 3, 4, 5, 6, 7, 2 }, // 10000011
+        { 2, 3, 0, 4, 5, 6, 7, 1 }, // 10000100
+        { 0, 3, 1, 4, 5, 6, 7, 2 }, // 10000101
+        { 3, 0, 1, 4, 5, 6, 7, 2 }, // 10000110
+        { 0, 1, 2, 4, 5, 6, 7, 3 }, // 10000111
+        { 2, 3, 4, 0, 5, 6, 7, 1 }, // 10001000
+        { 0, 3, 4, 1, 5, 6, 7, 2 }, // 10001001
+        { 3, 0, 4, 1, 5, 6, 7, 2 }, // 10001010
+        { 0, 1, 4, 2, 5, 6, 7, 3 }, // 10001011
+        { 3, 4, 0, 1, 5, 6, 7, 2 }, // 10001100
+        { 0, 4, 1, 2, 5, 6, 7, 3 }, // 10001101
+        { 4, 0, 1, 2, 5, 6, 7, 3 }, // 10001110
+        { 0, 1, 2, 3, 5, 6, 7, 4 }, // 10001111
+        { 2, 3, 4, 5, 0, 6, 7, 1 }, // 10010000
+        { 0, 3, 4, 5, 1, 6, 7, 2 }, // 10010001
+        { 3, 0, 4, 5, 1, 6, 7, 2 }, // 10010010
+        { 0, 1, 4, 5, 2, 6, 7, 3 }, // 10010011
+        { 3, 4, 0, 5, 1, 6, 7, 2 }, // 10010100
+        { 0, 4, 1, 5, 2, 6, 7, 3 }, // 10010101
+        { 4, 0, 1, 5, 2, 6, 7, 3 }, // 10010110
+        { 0, 1, 2, 5, 3, 6, 7, 4 }, // 10010111
+        { 3, 4, 5, 0, 1, 6, 7, 2 }, // 10011000
+        { 0, 4, 5, 1, 2, 6, 7, 3 }, // 10011001
+        { 4, 0, 5, 1, 2, 6, 7, 3 }, // 10011010
+        { 0, 1, 5, 2, 3, 6, 7, 4 }, // 10011011
+        { 4, 5, 0, 1, 2, 6, 7, 3 }, // 10011100
+        { 0, 5, 1, 2, 3, 6, 7, 4 }, // 10011101
+        { 5, 0, 1, 2, 3, 6, 7, 4 }, // 10011110
+        { 0, 1, 2, 3, 4, 6, 7, 5 }, // 10011111
+        { 2, 3, 4, 5, 6, 0, 7, 1 }, // 10100000
+        { 0, 3, 4, 5, 6, 1, 7, 2 }, // 10100001
+        { 3, 0, 4, 5, 6, 1, 7, 2 }, // 10100010
+        { 0, 1, 4, 5, 6, 2, 7, 3 }, // 10100011
+        { 3, 4, 0, 5, 6, 1, 7, 2 }, // 10100100
+        { 0, 4, 1, 5, 6, 2, 7, 3 }, // 10100101
+        { 4, 0, 1, 5, 6, 2, 7, 3 }, // 10100110
+        { 0, 1, 2, 5, 6, 3, 7, 4 }, // 10100111
+        { 3, 4, 5, 0, 6, 1, 7, 2 }, // 10101000
+        { 0, 4, 5, 1, 6, 2, 7, 3 }, // 10101001
+        { 4, 0, 5, 1, 6, 2, 7, 3 }, // 10101010
+        { 0, 1, 5, 2, 6, 3, 7, 4 }, // 10101011
+        { 4, 5, 0, 1, 6, 2, 7, 3 }, // 10101100
+        { 0, 5, 1, 2, 6, 3, 7, 4 }, // 10101101
+        { 5, 0, 1, 2, 6, 3, 7, 4 }, // 10101110
+        { 0, 1, 2, 3, 6, 4, 7, 5 }, // 10101111
+        { 3, 4, 5, 6, 0, 1, 7, 2 }, // 10110000
+        { 0, 4, 5, 6, 1, 2, 7, 3 }, // 10110001
+        { 4, 0, 5, 6, 1, 2, 7, 3 }, // 10110010
+        { 0, 1, 5, 6, 2, 3, 7, 4 }, // 10110011
+        { 4, 5, 0, 6, 1, 2, 7, 3 }, // 10110100
+        { 0, 5, 1, 6, 2, 3, 7, 4 }, // 10110101
+        { 5, 0, 1, 6, 2, 3, 7, 4 }, // 10110110
+        { 0, 1, 2, 6, 3, 4, 7, 5 }, // 10110111
+        { 4, 5, 6, 0, 1, 2, 7, 3 }, // 10111000
+        { 0, 5, 6, 1, 2, 3, 7, 4 }, // 10111001
+        { 5, 0, 6, 1, 2, 3, 7, 4 }, // 10111010
+        { 0, 1, 6, 2, 3, 4, 7, 5 }, // 10111011
+        { 5, 6, 0, 1, 2, 3, 7, 4 }, // 10111100
+        { 0, 6, 1, 2, 3, 4, 7, 5 }, // 10111101
+        { 6, 0, 1, 2, 3, 4, 7, 5 }, // 10111110
+        { 0, 1, 2, 3, 4, 5, 7, 6 }, // 10111111
+        { 2, 3, 4, 5, 6, 7, 0, 1 }, // 11000000
+        { 0, 3, 4, 5, 6, 7, 1, 2 }, // 11000001
+        { 3, 0, 4, 5, 6, 7, 1, 2 }, // 11000010
+        { 0, 1, 4, 5, 6, 7, 2, 3 }, // 11000011
+        { 3, 4, 0, 5, 6, 7, 1, 2 }, // 11000100
+        { 0, 4, 1, 5, 6, 7, 2, 3 }, // 11000101
+        { 4, 0, 1, 5, 6, 7, 2, 3 }, // 11000110
+        { 0, 1, 2, 5, 6, 7, 3, 4 }, // 11000111
+        { 3, 4, 5, 0, 6, 7, 1, 2 }, // 11001000
+        { 0, 4, 5, 1, 6, 7, 2, 3 }, // 11001001
+        { 4, 0, 5, 1, 6, 7, 2, 3 }, // 11001010
+        { 0, 1, 5, 2, 6, 7, 3, 4 }, // 11001011
+        { 4, 5, 0, 1, 6, 7, 2, 3 }, // 11001100
+        { 0, 5, 1, 2, 6, 7, 3, 4 }, // 11001101
+        { 5, 0, 1, 2, 6, 7, 3, 4 }, // 11001110
+        { 0, 1, 2, 3, 6, 7, 4, 5 }, // 11001111
+        { 3, 4, 5, 6, 0, 7, 1, 2 }, // 11010000
+        { 0, 4, 5, 6, 1, 7, 2, 3 }, // 11010001
+        { 4, 0, 5, 6, 1, 7, 2, 3 }, // 11010010
+        { 0, 1, 5, 6, 2, 7, 3, 4 }, // 11010011
+        { 4, 5, 0, 6, 1, 7, 2, 3 }, // 11010100
+        { 0, 5, 1, 6, 2, 7, 3, 4 }, // 11010101
+        { 5, 0, 1, 6, 2, 7, 3, 4 }, // 11010110
+        { 0, 1, 2, 6, 3, 7, 4, 5 }, // 11010111
+        { 4, 5, 6, 0, 1, 7, 2, 3 }, // 11011000
+        { 0, 5, 6, 1, 2, 7, 3, 4 }, // 11011001
+        { 5, 0, 6, 1, 2, 7, 3, 4 }, // 11011010
+        { 0, 1, 6, 2, 3, 7, 4, 5 }, // 11011011
+        { 5, 6, 0, 1, 2, 7, 3, 4 }, // 11011100
+        { 0, 6, 1, 2, 3, 7, 4, 5 }, // 11011101
+        { 6, 0, 1, 2, 3, 7, 4, 5 }, // 11011110
+        { 0, 1, 2, 3, 4, 7, 5, 6 }, // 11011111
+        { 3, 4, 5, 6, 7, 0, 1, 2 }, // 11100000
+        { 0, 4, 5, 6, 7, 1, 2, 3 }, // 11100001
+        { 4, 0, 5, 6, 7, 1, 2, 3 }, // 11100010
+        { 0, 1, 5, 6, 7, 2, 3, 4 }, // 11100011
+        { 4, 5, 0, 6, 7, 1, 2, 3 }, // 11100100
+        { 0, 5, 1, 6, 7, 2, 3, 4 }, // 11100101
+        { 5, 0, 1, 6, 7, 2, 3, 4 }, // 11100110
+        { 0, 1, 2, 6, 7, 3, 4, 5 }, // 11100111
+        { 4, 5, 6, 0, 7, 1, 2, 3 }, // 11101000
+        { 0, 5, 6, 1, 7, 2, 3, 4 }, // 11101001
+        { 5, 0, 6, 1, 7, 2, 3, 4 }, // 11101010
+        { 0, 1, 6, 2, 7, 3, 4, 5 }, // 11101011
+        { 5, 6, 0, 1, 7, 2, 3, 4 }, // 11101100
+        { 0, 6, 1, 2, 7, 3, 4, 5 }, // 11101101
+        { 6, 0, 1, 2, 7, 3, 4, 5 }, // 11101110
+        { 0, 1, 2, 3, 7, 4, 5, 6 }, // 11101111
+        { 4, 5, 6, 7, 0, 1, 2, 3 }, // 11110000
+        { 0, 5, 6, 7, 1, 2, 3, 4 }, // 11110001
+        { 5, 0, 6, 7, 1, 2, 3, 4 }, // 11110010
+        { 0, 1, 6, 7, 2, 3, 4, 5 }, // 11110011
+        { 5, 6, 0, 7, 1, 2, 3, 4 }, // 11110100
+        { 0, 6, 1, 7, 2, 3, 4, 5 }, // 11110101
+        { 6, 0, 1, 7, 2, 3, 4, 5 }, // 11110110
+        { 0, 1, 2, 7, 3, 4, 5, 6 }, // 11110111
+        { 5, 6, 7, 0, 1, 2, 3, 4 }, // 11111000
+        { 0, 6, 7, 1, 2, 3, 4, 5 }, // 11111001
+        { 6, 0, 7, 1, 2, 3, 4, 5 }, // 11111010
+        { 0, 1, 7, 2, 3, 4, 5, 6 }, // 11111011
+        { 6, 7, 0, 1, 2, 3, 4, 5 }, // 11111100
+        { 0, 7, 1, 2, 3, 4, 5, 6 }, // 11111101
+        { 7, 0, 1, 2, 3, 4, 5, 6 }, // 11111110
+        { 0, 1, 2, 3, 4, 5, 6, 7 }  // 11111111
+    };
+
+    assert( uPhase > 0 && uPhase < (unsigned)(1 << nVars) );
+
+    // the same function
+    if ( Cases[uPhase] == 0 )
+    {
+        int i;
+        for ( i = 0; i < nWords; i++ )
+            puTruthR[i] = puTruth[i];
+        return;
+    }
+
+    // an elementary variable
+    if ( Cases[uPhase] > 0 )
+    {
+        int i;
+        for ( i = 0; i < nWords; i++ )
+            puTruthR[i] = uTruths[Cases[uPhase]][i];
+        return;
+    }
+
+    // truth table takes one word
+    if ( nWords == 1 )
+    {
+        int i, k, nMints, iRes;
+        char * pPerm = Perms[uPhase];
+        puTruthR[0] = 0;
+        nMints = (1 << nVars);
+        for ( i = 0; i < nMints; i++ )
+            if ( puTruth[0] & (1 << i) )
+            {
+                for ( iRes = 0, k = 0; k < nVars; k++ )
+                    if ( i & (1 << pPerm[k]) )
+                        iRes |= (1 << k);
+                puTruthR[0] |= (1 << iRes);
+            }
+        return;
+    }
+    else if ( nWords == 2 )
+    {
+        int i, k, iRes;
+        char * pPerm = Perms[uPhase];
+        puTruthR[0] = puTruthR[1] = 0;
+        for ( i = 0; i < 32; i++ )
+        {
+            if ( puTruth[0] & (1 << i) )
+            {
+                for ( iRes = 0, k = 0; k < 6; k++ )
+                    if ( i & (1 << pPerm[k]) )
+                        iRes |= (1 << k);
+                if ( iRes < 32 )
+                    puTruthR[0] |= (1 << iRes);
+                else
+                    puTruthR[1] |= (1 << (iRes-32));
+            }
+        }
+        for ( ; i < 64; i++ )
+        {
+            if ( puTruth[1] & (1 << (i-32)) )
+            {
+                for ( iRes = 0, k = 0; k < 6; k++ )
+                    if ( i & (1 << pPerm[k]) )
+                        iRes |= (1 << k);
+                if ( iRes < 32 )
+                    puTruthR[0] |= (1 << iRes);
+                else
+                    puTruthR[1] |= (1 << (iRes-32));
+            }
+        }
+    }
+    // truth table takes more than one word
+    else
+    {
+        int i, k, nMints, iRes;
+        char * pPerm = Perms[uPhase];
+        for ( i = 0; i < nWords; i++ )
+            puTruthR[i] = 0;
+        nMints = (1 << nVars);
+        for ( i = 0; i < nMints; i++ )
+            if ( puTruth[i>>5] & (1 << (i&31)) )
+            {
+                for ( iRes = 0, k = 0; k < 5; k++ )
+                    if ( i & (1 << pPerm[k]) )
+                        iRes |= (1 << k);
+                puTruthR[iRes>>5] |= (1 << (iRes&31));
+            }
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocated lookup table for truth table permutation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned short ** Extra_TruthPerm43()
+{
+    unsigned short ** pTable;
+    unsigned uTruth;
+    int i, k;
+    pTable = (unsigned short **)Extra_ArrayAlloc( 256, 16, 2 );
+    for ( i = 0; i < 256; i++ )
+    {
+        uTruth = (i << 8) | i;
+        for ( k = 0; k < 16; k++ )
+            pTable[i][k] = Extra_TruthPerm4One( uTruth, k );
+    }
+    return pTable;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocated lookup table for truth table permutation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned ** Extra_TruthPerm53()
+{
+    unsigned ** pTable;
+    unsigned uTruth;
+    int i, k;
+    pTable = (unsigned **)Extra_ArrayAlloc( 256, 32, 4 );
+    for ( i = 0; i < 256; i++ )
+    {
+        uTruth = (i << 24) | (i << 16) | (i << 8) | i;
+        for ( k = 0; k < 32; k++ )
+            pTable[i][k] = Extra_TruthPerm5One( uTruth, k );
+    }
+    return pTable;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocated lookup table for truth table permutation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned ** Extra_TruthPerm54()
+{
+    unsigned ** pTable;
+    unsigned uTruth;
+    int i;
+    pTable = (unsigned **)Extra_ArrayAlloc( 256*256, 4, 4 );
+    for ( i = 0; i < 256*256; i++ )
+    {
+        uTruth = (i << 16) | i;
+        pTable[i][0] = Extra_TruthPerm5One( uTruth, 31-8 );
+        pTable[i][1] = Extra_TruthPerm5One( uTruth, 31-4 );
+        pTable[i][2] = Extra_TruthPerm5One( uTruth, 31-2 );
+        pTable[i][3] = Extra_TruthPerm5One( uTruth, 31-1 );
+    }
+    return pTable;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocated lookup table for truth table permutation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned ** Extra_TruthPerm63()
+{
+    unsigned ** pTable;
+    unsigned uTruth[2];
+    int i, k;
+    pTable = (unsigned **)Extra_ArrayAlloc( 256, 64, 8 );
+    for ( i = 0; i < 256; i++ )
+    {
+        uTruth[0] = (i << 24) | (i << 16) | (i << 8) | i;
+        uTruth[1] = uTruth[0];
+        for ( k = 0; k < 64; k++ )
+            Extra_TruthPerm6One( uTruth, k, &pTable[i][k] );
+    }
+    return pTable;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the pointer to the elementary truth tables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned ** Extra_Truths8()
+{
+    static unsigned uTruths[8][8] = {
+        { 0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA },
+        { 0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC },
+        { 0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0 },
+        { 0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00 },
+        { 0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000 }, 
+        { 0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF }, 
+        { 0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF }, 
+        { 0x00000000,0x00000000,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF } 
+    };
+    static unsigned * puResult[8] = {
+        uTruths[0], uTruths[1], uTruths[2], uTruths[3], uTruths[4], uTruths[5], uTruths[6], uTruths[7] 
+    };
+    return (unsigned **)puResult;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Bubble-sorts components by scores in increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_BubbleSort( int Order[], int Costs[], int nSize, int fIncreasing )
+{
+    int i, Temp, fChanges;
+    assert( nSize < 1000 );
+    for ( i = 0; i < nSize; i++ )
+        Order[i] = i;
+    if ( fIncreasing )
+    {
+        do {
+            fChanges = 0;
+            for ( i = 0; i < nSize - 1; i++ )
+            {
+                if ( Costs[Order[i]] <= Costs[Order[i+1]] )
+                    continue;
+                Temp = Order[i];
+                Order[i] = Order[i+1];
+                Order[i+1] = Temp;
+                fChanges = 1;
+            }
+        } while ( fChanges );
+    }
+    else
+    {
+        do {
+            fChanges = 0;
+            for ( i = 0; i < nSize - 1; i++ )
+            {
+                if ( Costs[Order[i]] >= Costs[Order[i+1]] )
+                    continue;
+                Temp = Order[i];
+                Order[i] = Order[i+1];
+                Order[i+1] = Temp;
+                fChanges = 1;
+            }
+        } while ( fChanges );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the smallest prime larger than the number.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned int Cudd_PrimeCopy( unsigned int  p)
+{
+    int i,pn;
+
+    p--;
+    do {
+        p++;
+        if (p&1) {
+        pn = 1;
+        i = 3;
+        while ((unsigned) (i * i) <= p) {
+        if (p % i == 0) {
+            pn = 0;
+            break;
+        }
+        i += 2;
+        }
+    } else {
+        pn = 0;
+    }
+    } while (!pn);
+    return(p);
+
+} /* end of Cudd_Prime */
+
+/*---------------------------------------------------------------------------*/
+/* Definition of internal functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of static Functions                                            */
+/*---------------------------------------------------------------------------*/
+
+
+/**Function*************************************************************
+
+  Synopsis    [Computes the permutation table for 8 variables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthExpandGeneratePermTable()
+{
+    int i, k, nOnes, Last1, First0;
+    int iOne, iZero;
+
+    printf( "\nstatic char Cases[256] = {\n" );
+    for ( i = 0; i < 256; i++ )
+    {
+        nOnes = 0;
+        Last1 = First0 = -1;
+        for ( k = 0; k < 8; k++ )
+        {
+            if ( i & (1 << k) )
+            {
+                nOnes++;
+                Last1 = k;
+            }
+            else if ( First0 == -1 )
+                First0 = k;
+        }
+        if ( Last1 + 1 == First0 || i == 255 )
+            printf( "     %d%s", 0, (i==255? " ":",") );
+        else if ( nOnes == 1 )
+            printf( "     %d,", Last1 );
+        else
+            printf( "    -%d,", 1 );
+        printf( " // " );
+        Extra_PrintBinary( stdout, (unsigned*)&i, 8 );
+        printf( "\n" );
+    }
+    printf( "};\n" );
+
+    printf( "\nstatic char Perms[256][8] = {\n" );
+    for ( i = 0; i < 256; i++ )
+    {
+        printf( "    {" );
+        nOnes = 0;
+        for ( k = 0; k < 8; k++ )
+            if ( i & (1 << k) )
+                nOnes++;
+        iOne = 0;
+        iZero = nOnes;
+        for ( k = 0; k < 8; k++ )
+            if ( i & (1 << k) )
+                printf( "%s %d", (k==0? "":","), iOne++ );
+            else
+                printf( "%s %d", (k==0? "":","), iZero++ );
+        assert( iOne + iZero == 8 );
+        printf( " }%s // ", (i==255? " ":",") );
+        Extra_PrintBinary( stdout, (unsigned*)&i, 8 );
+        printf( "\n" );
+    }
+    printf( "};\n" );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraUtilProgress.c b/src/misc/extra/extraUtilProgress.c
new file mode 100644
index 00000000..6b6d5132
--- /dev/null
+++ b/src/misc/extra/extraUtilProgress.c
@@ -0,0 +1,176 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilProgress.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [Progress bar.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilProgress.c,v 1.0 2003/02/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include "extra.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+struct ProgressBarStruct
+{
+    int              nItemsNext;   // the number of items for the next update of the progress bar
+    int              nItemsTotal;  // the total number of items
+    int              posTotal;     // the total number of positions
+    int              posCur;       // the current position
+    FILE *           pFile;        // the output stream 
+};
+
+static void Extra_ProgressBarShow( ProgressBar * p, char * pString );
+static void Extra_ProgressBarClean( ProgressBar * p );
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Starts the progress bar.]
+
+  Description [The first parameter is the output stream (pFile), where
+  the progress is printed. The current printing position should be the
+  first one on the given line. The second parameters is the total
+  number of items that correspond to 100% position of the progress bar.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+ProgressBar * Extra_ProgressBarStart( FILE * pFile, int nItemsTotal )
+{
+    ProgressBar * p;
+    extern int Abc_FrameShowProgress( void * p );
+    extern void * Abc_FrameGetGlobalFrame();
+
+    if ( !Abc_FrameShowProgress(Abc_FrameGetGlobalFrame()) ) return NULL;
+    p = ALLOC( ProgressBar, 1 );
+    memset( p, 0, sizeof(ProgressBar) );
+    p->pFile       = pFile;
+    p->nItemsTotal = nItemsTotal;
+    p->posTotal    = 78;
+    p->posCur      = 1;
+    p->nItemsNext  = (int)((7.0+p->posCur)*p->nItemsTotal/p->posTotal);
+    Extra_ProgressBarShow( p, NULL );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Updates the progress bar.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_ProgressBarUpdate_int( ProgressBar * p, int nItemsCur, char * pString )
+{
+    if ( p == NULL ) return;
+    if ( nItemsCur < p->nItemsNext )
+        return;
+    if ( nItemsCur >= p->nItemsTotal )
+    {
+        p->posCur = 78;
+        p->nItemsNext = 0x7FFFFFFF;
+    }
+    else
+    {
+        p->posCur += 7;
+        p->nItemsNext = (int)((7.0+p->posCur)*p->nItemsTotal/p->posTotal);
+    }
+    Extra_ProgressBarShow( p, pString );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Stops the progress bar.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_ProgressBarStop( ProgressBar * p )
+{
+    if ( p == NULL ) return;
+    Extra_ProgressBarClean( p );
+    FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the progress bar of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_ProgressBarShow( ProgressBar * p, char * pString )
+{
+    int i;
+    if ( p == NULL ) return;
+    if ( pString )
+        fprintf( p->pFile, "%s ", pString );
+    for ( i = (pString? strlen(pString) + 1 : 0); i < p->posCur; i++ )
+        fprintf( p->pFile, "-" );
+    if ( i == p->posCur )
+        fprintf( p->pFile, ">" );
+    for ( i++  ; i <= p->posTotal; i++ )
+        fprintf( p->pFile, " " );
+    fprintf( p->pFile, "\r" );
+    fflush( stdout );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Cleans the progress bar before quitting.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_ProgressBarClean( ProgressBar * p )
+{
+    int i;
+    if ( p == NULL ) return;
+    for ( i = 0; i <= p->posTotal; i++ )
+        fprintf( p->pFile, " " );
+    fprintf( p->pFile, "\r" );
+    fflush( stdout );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraUtilReader.c b/src/misc/extra/extraUtilReader.c
new file mode 100644
index 00000000..c165b989
--- /dev/null
+++ b/src/misc/extra/extraUtilReader.c
@@ -0,0 +1,383 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilReader.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [File reading utilities.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilReader.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include "extra.h"
+#include "vec.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+#define EXTRA_BUFFER_SIZE        4*1048576    // 1M   - size of the data chunk stored in memory
+#define EXTRA_OFFSET_SIZE           4096    // 4K   - load new data when less than this is left
+
+#define EXTRA_MINIMUM(a,b)       (((a) < (b))? (a) : (b))
+
+struct Extra_FileReader_t_
+{
+    // the input file
+    char *           pFileName;     // the input file name
+    FILE *           pFile;         // the input file pointer
+    int              nFileSize;     // the total number of bytes in the file
+    int              nFileRead;     // the number of bytes currently read from file
+    // info about processing different types of input chars
+    char             pCharMap[256]; // the character map
+    // temporary storage for data 
+    char *           pBuffer;       // the buffer
+    int              nBufferSize;   // the size of the buffer
+    char *           pBufferCur;    // the current reading position
+    char *           pBufferEnd;    // the first position not used by currently loaded data
+    char *           pBufferStop;   // the position where loading new data will be done
+    // tokens given to the user
+    Vec_Ptr_t *      vTokens;       // the vector of tokens returned to the user
+    Vec_Int_t *      vLines;        // the vector of line numbers for each token
+    int              nLineCounter;  // the counter of lines processed
+    // status of the parser
+    int              fStop;         // this flag goes high when the end of file is reached
+};
+
+// character types
+typedef enum { 
+    EXTRA_CHAR_COMMENT,  // a character that begins the comment
+    EXTRA_CHAR_NORMAL,   // a regular character
+    EXTRA_CHAR_STOP,     // a character that delimits a series of tokens
+    EXTRA_CHAR_CLEAN     // a character that should be cleaned
+} Extra_CharType_t;
+
+// the static functions
+static void * Extra_FileReaderGetTokens_int( Extra_FileReader_t * p );
+static void Extra_FileReaderReload( Extra_FileReader_t * p );
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Starts the file reader.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Extra_FileReader_t * Extra_FileReaderAlloc( char * pFileName, 
+    char * pCharsComment, char * pCharsStop, char * pCharsClean )
+{
+    Extra_FileReader_t * p;
+    FILE * pFile;
+    char * pChar;
+    int nCharsToRead;
+    // check if the file can be opened
+    pFile = fopen( pFileName, "rb" );
+    if ( pFile == NULL )
+    {
+        printf( "Extra_FileReaderAlloc(): Cannot open input file \"%s\".\n", pFileName );
+        return NULL;
+    }
+    // start the file reader    
+    p = ALLOC( Extra_FileReader_t, 1 );
+    memset( p, 0, sizeof(Extra_FileReader_t) );
+    p->pFileName   = pFileName;
+    p->pFile       = pFile;
+    // set the character map
+    memset( p->pCharMap, EXTRA_CHAR_NORMAL, 256 );
+    for ( pChar = pCharsComment; *pChar; pChar++ )
+        p->pCharMap[(unsigned char)*pChar] = EXTRA_CHAR_COMMENT;
+    for ( pChar = pCharsStop; *pChar; pChar++ )
+        p->pCharMap[(unsigned char)*pChar] = EXTRA_CHAR_STOP;
+    for ( pChar = pCharsClean; *pChar; pChar++ )
+        p->pCharMap[(unsigned char)*pChar] = EXTRA_CHAR_CLEAN;
+    // get the file size, in bytes
+    fseek( pFile, 0, SEEK_END );  
+    p->nFileSize = ftell( pFile );  
+    rewind( pFile ); 
+    // allocate the buffer
+    p->pBuffer = ALLOC( char, EXTRA_BUFFER_SIZE+1 );
+    p->nBufferSize = EXTRA_BUFFER_SIZE;
+    p->pBufferCur  = p->pBuffer;
+    // determine how many chars to read
+    nCharsToRead = EXTRA_MINIMUM(p->nFileSize, EXTRA_BUFFER_SIZE);
+    // load the first part into the buffer
+    fread( p->pBuffer, nCharsToRead, 1, p->pFile );
+    p->nFileRead = nCharsToRead;
+    // set the ponters to the end and the stopping point
+    p->pBufferEnd  = p->pBuffer + nCharsToRead;
+    p->pBufferStop = (p->nFileRead == p->nFileSize)? p->pBufferEnd : p->pBuffer + EXTRA_BUFFER_SIZE - EXTRA_OFFSET_SIZE;
+    // start the arrays
+    p->vTokens = Vec_PtrAlloc( 100 );
+    p->vLines = Vec_IntAlloc( 100 );
+    p->nLineCounter = 1; // 1-based line counting
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Stops the file reader.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_FileReaderFree( Extra_FileReader_t * p )
+{
+    if ( p->pFile )
+        fclose( p->pFile );
+    FREE( p->pBuffer );
+    Vec_PtrFree( p->vTokens );
+    Vec_IntFree( p->vLines );
+    free( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the file size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_FileReaderGetFileName( Extra_FileReader_t * p )
+{
+    return p->pFileName;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the file size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_FileReaderGetFileSize( Extra_FileReader_t * p )
+{
+    return p->nFileSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the current reading position.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_FileReaderGetCurPosition( Extra_FileReader_t * p )
+{
+    return p->nFileRead - (p->pBufferEnd - p->pBufferCur);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the line number for the given token.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_FileReaderGetLineNumber( Extra_FileReader_t * p, int iToken )
+{
+    assert( iToken >= 0 && iToken < p->vTokens->nSize );
+    return p->vLines->pArray[iToken];
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the next set of tokens.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void * Extra_FileReaderGetTokens( Extra_FileReader_t * p )
+{
+    Vec_Ptr_t * vTokens;
+    while ( vTokens = Extra_FileReaderGetTokens_int( p ) )
+        if ( vTokens->nSize > 0 )
+            break;
+    return vTokens;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the next set of tokens.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void * Extra_FileReaderGetTokens_int( Extra_FileReader_t * p )
+{
+    char * pChar;
+    int fTokenStarted, MapValue;
+    if ( p->fStop )
+        return NULL;
+    // reset the token info
+    p->vTokens->nSize = 0;
+    p->vLines->nSize = 0;
+    fTokenStarted = 0;
+    // check if the new data should to be loaded
+    if ( p->pBufferCur > p->pBufferStop )
+        Extra_FileReaderReload( p );
+
+//    printf( "%d\n", p->pBufferEnd - p->pBufferCur );
+
+    // process the string starting from the current position
+    for ( pChar = p->pBufferCur; pChar < p->pBufferEnd; pChar++ )
+    {
+        // count the lines
+        if ( *pChar == '\n' )
+            p->nLineCounter++;
+        // switch depending on the character
+        MapValue = p->pCharMap[*pChar];
+
+//        printf( "Char value = %d. Map value = %d.\n", *pChar, MapValue );
+
+
+        switch ( MapValue )
+        {
+            case EXTRA_CHAR_COMMENT:
+                if ( *pChar != '/' || *(pChar+1) == '/' ) 
+                { // dealing with the need to have // as a comment
+                    // if the token was being written, stop it
+                    if ( fTokenStarted )
+                        fTokenStarted = 0;
+                    // eraze the comment till the end of line
+                    while ( *pChar != '\n' )
+                    {
+                        *pChar++ = 0;
+                        if ( pChar == p->pBufferEnd )
+                        {   // this failure is due to the fact the comment continued 
+                            // through EXTRA_OFFSET_SIZE chars till the end of the buffer
+                            printf( "Extra_FileReader failed to parse the file \"%s\".\n", p->pFileName );
+                            return NULL;
+                        }
+                    }
+                    pChar--;
+                    break;
+                }
+                // otherwise it is a normal character
+            case EXTRA_CHAR_NORMAL:
+                if ( !fTokenStarted )
+                {
+                    Vec_PtrPush( p->vTokens, pChar );
+                    Vec_IntPush( p->vLines, p->nLineCounter );
+                    fTokenStarted = 1;
+                }
+                break;
+            case EXTRA_CHAR_STOP:
+                if ( fTokenStarted )
+                    fTokenStarted = 0;
+                *pChar = 0;
+                // prepare before leaving
+                p->pBufferCur = pChar + 1;
+                return p->vTokens;
+            case EXTRA_CHAR_CLEAN:
+                if ( fTokenStarted )
+                    fTokenStarted = 0;
+                *pChar = 0;
+                break;
+            default:
+                assert( 0 );
+        }
+    }
+    // the file is finished or the last part continued 
+    // through EXTRA_OFFSET_SIZE chars till the end of the buffer
+    if ( p->pBufferStop == p->pBufferEnd ) // end of file
+    {
+        *pChar = 0;
+        p->fStop = 1;
+        return p->vTokens;
+    }
+    printf( "Extra_FileReader failed to parse the file \"%s\".\n", p->pFileName );
+/*
+    {
+        int i;
+        for ( i = 0; i < p->vTokens->nSize; i++ )
+            printf( "%s ", p->vTokens->pArray[i] );
+        printf( "\n" );
+    }
+*/
+    return NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Loads new data into the file reader.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_FileReaderReload( Extra_FileReader_t * p )
+{
+    int nCharsUsed, nCharsToRead;
+    assert( !p->fStop );
+    assert( p->pBufferCur > p->pBufferStop );
+    assert( p->pBufferCur < p->pBufferEnd );
+    // figure out how many chars are still not processed
+    nCharsUsed = p->pBufferEnd - p->pBufferCur;
+    // move the remaining data to the beginning of the buffer
+    memmove( p->pBuffer, p->pBufferCur, nCharsUsed );
+    p->pBufferCur = p->pBuffer;
+    // determine how many chars we will read
+    nCharsToRead = EXTRA_MINIMUM( p->nBufferSize - nCharsUsed, p->nFileSize - p->nFileRead );
+    // read the chars
+    fread( p->pBuffer + nCharsUsed, nCharsToRead, 1, p->pFile );
+    p->nFileRead += nCharsToRead;
+    // set the ponters to the end and the stopping point
+    p->pBufferEnd  = p->pBuffer + nCharsUsed + nCharsToRead;
+    p->pBufferStop = (p->nFileRead == p->nFileSize)? p->pBufferEnd : p->pBuffer + EXTRA_BUFFER_SIZE - EXTRA_OFFSET_SIZE;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraUtilTruth.c b/src/misc/extra/extraUtilTruth.c
new file mode 100644
index 00000000..3b0b16eb
--- /dev/null
+++ b/src/misc/extra/extraUtilTruth.c
@@ -0,0 +1,1148 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilMisc.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [Various procedures for truth table manipulation.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilMisc.c,v 1.0 2003/09/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "extra.h"
+
+/*---------------------------------------------------------------------------*/
+/* Constant declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Stucture declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Type declarations                                                         */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Variable declarations                                                     */
+/*---------------------------------------------------------------------------*/
+
+static unsigned s_VarMasks[5][2] = {
+    { 0x33333333, 0xAAAAAAAA },
+    { 0x55555555, 0xCCCCCCCC },
+    { 0x0F0F0F0F, 0xF0F0F0F0 },
+    { 0x00FF00FF, 0xFF00FF00 },
+    { 0x0000FFFF, 0xFFFF0000 }
+};
+
+/*---------------------------------------------------------------------------*/
+/* Macro declarations                                                        */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticStart*************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Static function prototypes                                                */
+/*---------------------------------------------------------------------------*/
+
+/**AutomaticEnd***************************************************************/
+
+/*---------------------------------------------------------------------------*/
+/* Definition of exported functions                                          */
+/*---------------------------------------------------------------------------*/
+
+/**Function*************************************************************
+
+  Synopsis    [Derive elementary truth tables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned ** Extra_TruthElementary( int nVars )
+{
+    unsigned ** pRes;
+    int i, k, nWords;
+    nWords = Extra_TruthWordNum(nVars);
+    pRes = (unsigned **)Extra_ArrayAlloc( nVars, nWords, 4 );
+    for ( i = 0; i < nVars; i++ )
+    {
+        if ( i < 5 )
+        {
+            for ( k = 0; k < nWords; k++ )
+                pRes[i][k] = s_VarMasks[i][1];
+        }
+        else
+        {
+            for ( k = 0; k < nWords; k++ )
+                if ( k & (1 << (i-5)) )
+                    pRes[i][k] = ~(unsigned)0;
+                else
+                    pRes[i][k] = 0;
+        }
+    }
+    return pRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Swaps two adjacent variables in the truth table.]
+
+  Description [Swaps var number Start and var number Start+1 (0-based numbers).
+  The input truth table is pIn. The output truth table is pOut.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthSwapAdjacentVars( unsigned * pOut, unsigned * pIn, int nVars, int iVar )
+{
+    static unsigned PMasks[4][3] = {
+        { 0x99999999, 0x22222222, 0x44444444 },
+        { 0xC3C3C3C3, 0x0C0C0C0C, 0x30303030 },
+        { 0xF00FF00F, 0x00F000F0, 0x0F000F00 },
+        { 0xFF0000FF, 0x0000FF00, 0x00FF0000 }
+    };
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step, Shift;
+
+    assert( iVar < nVars - 1 );
+    if ( iVar < 4 )
+    {
+        Shift = (1 << iVar);
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pIn[i] & PMasks[iVar][0]) | ((pIn[i] & PMasks[iVar][1]) << Shift) | ((pIn[i] & PMasks[iVar][2]) >> Shift);
+    }
+    else if ( iVar > 4 )
+    {
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 4*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+                pOut[i] = pIn[i];
+            for ( i = 0; i < Step; i++ )
+                pOut[Step+i] = pIn[2*Step+i];
+            for ( i = 0; i < Step; i++ )
+                pOut[2*Step+i] = pIn[Step+i];
+            for ( i = 0; i < Step; i++ )
+                pOut[3*Step+i] = pIn[3*Step+i];
+            pIn  += 4*Step;
+            pOut += 4*Step;
+        }
+    }
+    else // if ( iVar == 4 )
+    {
+        for ( i = 0; i < nWords; i += 2 )
+        {
+            pOut[i]   = (pIn[i]   & 0x0000FFFF) | ((pIn[i+1] & 0x0000FFFF) << 16);
+            pOut[i+1] = (pIn[i+1] & 0xFFFF0000) | ((pIn[i]   & 0xFFFF0000) >> 16);
+        }
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Swaps two adjacent variables in the truth table.]
+
+  Description [Swaps var number Start and var number Start+1 (0-based numbers).
+  The input truth table is pIn. The output truth table is pOut.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthSwapAdjacentVars2( unsigned * pIn, unsigned * pOut, int nVars, int Start )
+{
+    int nWords = (nVars <= 5)? 1 : (1 << (nVars-5));
+    int i, k, Step;
+
+    assert( Start < nVars - 1 );
+    switch ( Start )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pIn[i] & 0x99999999) | ((pIn[i] & 0x22222222) << 1) | ((pIn[i] & 0x44444444) >> 1);
+        return;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pIn[i] & 0xC3C3C3C3) | ((pIn[i] & 0x0C0C0C0C) << 2) | ((pIn[i] & 0x30303030) >> 2);
+        return;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pIn[i] & 0xF00FF00F) | ((pIn[i] & 0x00F000F0) << 4) | ((pIn[i] & 0x0F000F00) >> 4);
+        return;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pIn[i] & 0xFF0000FF) | ((pIn[i] & 0x0000FF00) << 8) | ((pIn[i] & 0x00FF0000) >> 8);
+        return;
+    case 4:
+        for ( i = 0; i < nWords; i += 2 )
+        {
+            pOut[i]   = (pIn[i]   & 0x0000FFFF) | ((pIn[i+1] & 0x0000FFFF) << 16);
+            pOut[i+1] = (pIn[i+1] & 0xFFFF0000) | ((pIn[i]   & 0xFFFF0000) >> 16);
+        }
+        return;
+    default:
+        Step = (1 << (Start - 5));
+        for ( k = 0; k < nWords; k += 4*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+                pOut[i] = pIn[i];
+            for ( i = 0; i < Step; i++ )
+                pOut[Step+i] = pIn[2*Step+i];
+            for ( i = 0; i < Step; i++ )
+                pOut[2*Step+i] = pIn[Step+i];
+            for ( i = 0; i < Step; i++ )
+                pOut[3*Step+i] = pIn[3*Step+i];
+            pIn  += 4*Step;
+            pOut += 4*Step;
+        }
+        return;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Expands the truth table according to the phase.]
+
+  Description [The input and output truth tables are in pIn/pOut. The current number
+  of variables is nVars. The total number of variables in nVarsAll. The last argument
+  (Phase) contains shows where the variables should go.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthStretch( unsigned * pOut, unsigned * pIn, int nVars, int nVarsAll, unsigned Phase )
+{
+    unsigned * pTemp;
+    int i, k, Var = nVars - 1, Counter = 0;
+    for ( i = nVarsAll - 1; i >= 0; i-- )
+        if ( Phase & (1 << i) )
+        {
+            for ( k = Var; k < i; k++ )
+            {
+                Extra_TruthSwapAdjacentVars( pOut, pIn, nVarsAll, k );
+                pTemp = pIn; pIn = pOut; pOut = pTemp;
+                Counter++;
+            }
+            Var--;
+        }
+    assert( Var == -1 );
+    // swap if it was moved an even number of times
+    if ( !(Counter & 1) )
+        Extra_TruthCopy( pOut, pIn, nVarsAll );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Shrinks the truth table according to the phase.]
+
+  Description [The input and output truth tables are in pIn/pOut. The current number
+  of variables is nVars. The total number of variables in nVarsAll. The last argument
+  (Phase) contains shows what variables should remain.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthShrink( unsigned * pOut, unsigned * pIn, int nVars, int nVarsAll, unsigned Phase )
+{
+    unsigned * pTemp;
+    int i, k, Var = 0, Counter = 0;
+    for ( i = 0; i < nVarsAll; i++ )
+        if ( Phase & (1 << i) )
+        {
+            for ( k = i-1; k >= Var; k-- )
+            {
+                Extra_TruthSwapAdjacentVars( pOut, pIn, nVarsAll, k );
+                pTemp = pIn; pIn = pOut; pOut = pTemp;
+                Counter++;
+            }
+            Var++;
+        }
+    assert( Var == nVars );
+    // swap if it was moved an even number of times
+    if ( !(Counter & 1) )
+        Extra_TruthCopy( pOut, pIn, nVarsAll );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Returns 1 if TT depends on the given variable.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_TruthVarInSupport( unsigned * pTruth, int nVars, int iVar )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step;
+
+    assert( iVar < nVars );
+    switch ( iVar )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            if ( (pTruth[i] & 0x55555555) != ((pTruth[i] & 0xAAAAAAAA) >> 1) )
+                return 1;
+        return 0;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            if ( (pTruth[i] & 0x33333333) != ((pTruth[i] & 0xCCCCCCCC) >> 2) )
+                return 1;
+        return 0;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            if ( (pTruth[i] & 0x0F0F0F0F) != ((pTruth[i] & 0xF0F0F0F0) >> 4) )
+                return 1;
+        return 0;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            if ( (pTruth[i] & 0x00FF00FF) != ((pTruth[i] & 0xFF00FF00) >> 8) )
+                return 1;
+        return 0;
+    case 4:
+        for ( i = 0; i < nWords; i++ )
+            if ( (pTruth[i] & 0x0000FFFF) != ((pTruth[i] & 0xFFFF0000) >> 16) )
+                return 1;
+        return 0;
+    default:
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 2*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+                if ( pTruth[i] != pTruth[Step+i] )
+                    return 1;
+            pTruth += 2*Step;
+        }
+        return 0;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the number of support vars.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_TruthSupportSize( unsigned * pTruth, int nVars )
+{
+    int i, Counter = 0;
+    for ( i = 0; i < nVars; i++ )
+        Counter += Extra_TruthVarInSupport( pTruth, nVars, i );
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns support of the function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_TruthSupport( unsigned * pTruth, int nVars )
+{
+    int i, Support = 0;
+    for ( i = 0; i < nVars; i++ )
+        if ( Extra_TruthVarInSupport( pTruth, nVars, i ) )
+            Support |= (1 << i);
+    return Support;
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Computes positive cofactor of the function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthCofactor1( unsigned * pTruth, int nVars, int iVar )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step;
+
+    assert( iVar < nVars );
+    switch ( iVar )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0xAAAAAAAA) | ((pTruth[i] & 0xAAAAAAAA) >> 1);
+        return;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0xCCCCCCCC) | ((pTruth[i] & 0xCCCCCCCC) >> 2);
+        return;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0xF0F0F0F0) | ((pTruth[i] & 0xF0F0F0F0) >> 4);
+        return;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0xFF00FF00) | ((pTruth[i] & 0xFF00FF00) >> 8);
+        return;
+    case 4:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0xFFFF0000) | ((pTruth[i] & 0xFFFF0000) >> 16);
+        return;
+    default:
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 2*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+                pTruth[i] = pTruth[Step+i];
+            pTruth += 2*Step;
+        }
+        return;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes negative cofactor of the function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthCofactor0( unsigned * pTruth, int nVars, int iVar )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step;
+
+    assert( iVar < nVars );
+    switch ( iVar )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0x55555555) | ((pTruth[i] & 0x55555555) << 1);
+        return;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0x33333333) | ((pTruth[i] & 0x33333333) << 2);
+        return;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0x0F0F0F0F) | ((pTruth[i] & 0x0F0F0F0F) << 4);
+        return;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0x00FF00FF) | ((pTruth[i] & 0x00FF00FF) << 8);
+        return;
+    case 4:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = (pTruth[i] & 0x0000FFFF) | ((pTruth[i] & 0x0000FFFF) << 16);
+        return;
+    default:
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 2*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+                pTruth[Step+i] = pTruth[i];
+            pTruth += 2*Step;
+        }
+        return;
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Existentially quantifies the variable.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthExist( unsigned * pTruth, int nVars, int iVar )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step;
+
+    assert( iVar < nVars );
+    switch ( iVar )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] |=  ((pTruth[i] & 0xAAAAAAAA) >> 1) | ((pTruth[i] & 0x55555555) << 1);
+        return;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] |=  ((pTruth[i] & 0xCCCCCCCC) >> 2) | ((pTruth[i] & 0x33333333) << 2);
+        return;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] |=  ((pTruth[i] & 0xF0F0F0F0) >> 4) | ((pTruth[i] & 0x0F0F0F0F) << 4);
+        return;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] |=  ((pTruth[i] & 0xFF00FF00) >> 8) | ((pTruth[i] & 0x00FF00FF) << 8);
+        return;
+    case 4:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] |=  ((pTruth[i] & 0xFFFF0000) >> 16) | ((pTruth[i] & 0x0000FFFF) << 16);
+        return;
+    default:
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 2*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+            {
+                pTruth[i]     |= pTruth[Step+i];
+                pTruth[Step+i] = pTruth[i];
+            }
+            pTruth += 2*Step;
+        }
+        return;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Existentially quantifies the variable.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthForall( unsigned * pTruth, int nVars, int iVar )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step;
+
+    assert( iVar < nVars );
+    switch ( iVar )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] &=  ((pTruth[i] & 0xAAAAAAAA) >> 1) | ((pTruth[i] & 0x55555555) << 1);
+        return;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] &=  ((pTruth[i] & 0xCCCCCCCC) >> 2) | ((pTruth[i] & 0x33333333) << 2);
+        return;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] &=  ((pTruth[i] & 0xF0F0F0F0) >> 4) | ((pTruth[i] & 0x0F0F0F0F) << 4);
+        return;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] &=  ((pTruth[i] & 0xFF00FF00) >> 8) | ((pTruth[i] & 0x00FF00FF) << 8);
+        return;
+    case 4:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] &=  ((pTruth[i] & 0xFFFF0000) >> 16) | ((pTruth[i] & 0x0000FFFF) << 16);
+        return;
+    default:
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 2*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+            {
+                pTruth[i]     &= pTruth[Step+i];
+                pTruth[Step+i] = pTruth[i];
+            }
+            pTruth += 2*Step;
+        }
+        return;
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Computes negative cofactor of the function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthMux( unsigned * pOut, unsigned * pCof0, unsigned * pCof1, int nVars, int iVar )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step;
+
+    assert( iVar < nVars );
+    switch ( iVar )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pCof0[i] & 0x55555555) | (pCof1[i] & 0xAAAAAAAA);
+        return;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pCof0[i] & 0x33333333) | (pCof1[i] & 0xCCCCCCCC);
+        return;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pCof0[i] & 0x0F0F0F0F) | (pCof1[i] & 0xF0F0F0F0);
+        return;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pCof0[i] & 0x00FF00FF) | (pCof1[i] & 0xFF00FF00);
+        return;
+    case 4:
+        for ( i = 0; i < nWords; i++ )
+            pOut[i] = (pCof0[i] & 0x0000FFFF) | (pCof1[i] & 0xFFFF0000);
+        return;
+    default:
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 2*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+            {
+                pOut[i]      = pCof0[i];
+                pOut[Step+i] = pCof1[Step+i];
+            }
+            pOut += 2*Step;
+        }
+        return;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Checks symmetry of two variables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_TruthVarsSymm( unsigned * pTruth, int nVars, int iVar0, int iVar1 )
+{
+    static unsigned uTemp0[16], uTemp1[16];
+    assert( nVars <= 9 );
+    // compute Cof01
+    Extra_TruthCopy( uTemp0, pTruth, nVars );
+    Extra_TruthCofactor0( uTemp0, nVars, iVar0 );
+    Extra_TruthCofactor1( uTemp0, nVars, iVar1 );
+    // compute Cof10
+    Extra_TruthCopy( uTemp1, pTruth, nVars );
+    Extra_TruthCofactor1( uTemp1, nVars, iVar0 );
+    Extra_TruthCofactor0( uTemp1, nVars, iVar1 );
+    // compare
+    return Extra_TruthIsEqual( uTemp0, uTemp1, nVars );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Checks antisymmetry of two variables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_TruthVarsAntiSymm( unsigned * pTruth, int nVars, int iVar0, int iVar1 )
+{
+    static unsigned uTemp0[16], uTemp1[16];
+    assert( nVars <= 9 );
+    // compute Cof00
+    Extra_TruthCopy( uTemp0, pTruth, nVars );
+    Extra_TruthCofactor0( uTemp0, nVars, iVar0 );
+    Extra_TruthCofactor0( uTemp0, nVars, iVar1 );
+    // compute Cof11
+    Extra_TruthCopy( uTemp1, pTruth, nVars );
+    Extra_TruthCofactor1( uTemp1, nVars, iVar0 );
+    Extra_TruthCofactor1( uTemp1, nVars, iVar1 );
+    // compare
+    return Extra_TruthIsEqual( uTemp0, uTemp1, nVars );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Changes phase of the function w.r.t. one variable.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthChangePhase( unsigned * pTruth, int nVars, int iVar )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Step;
+    unsigned Temp;
+
+    assert( iVar < nVars );
+    switch ( iVar )
+    {
+    case 0:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = ((pTruth[i] & 0x55555555) << 1) | ((pTruth[i] & 0xAAAAAAAA) >> 1);
+        return;
+    case 1:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = ((pTruth[i] & 0x33333333) << 2) | ((pTruth[i] & 0xCCCCCCCC) >> 2);
+        return;
+    case 2:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = ((pTruth[i] & 0x0F0F0F0F) << 4) | ((pTruth[i] & 0xF0F0F0F0) >> 4);
+        return;
+    case 3:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = ((pTruth[i] & 0x00FF00FF) << 8) | ((pTruth[i] & 0xFF00FF00) >> 8);
+        return;
+    case 4:
+        for ( i = 0; i < nWords; i++ )
+            pTruth[i] = ((pTruth[i] & 0x0000FFFF) << 16) | ((pTruth[i] & 0xFFFF0000) >> 16);
+        return;
+    default:
+        Step = (1 << (iVar - 5));
+        for ( k = 0; k < nWords; k += 2*Step )
+        {
+            for ( i = 0; i < Step; i++ )
+            {
+                Temp = pTruth[i];
+                pTruth[i] = pTruth[Step+i];
+                pTruth[Step+i] = Temp;
+            }
+            pTruth += 2*Step;
+        }
+        return;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes minimum overlap in supports of cofactors.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_TruthMinCofSuppOverlap( unsigned * pTruth, int nVars, int * pVarMin )
+{
+    static unsigned uCofactor[16];
+    int i, ValueCur, ValueMin, VarMin;
+    unsigned uSupp0, uSupp1;
+    int nVars0, nVars1;
+    assert( nVars <= 9 );
+    ValueMin = 32;
+    VarMin   = -1;
+    for ( i = 0; i < nVars; i++ )
+    {
+        // get negative cofactor
+        Extra_TruthCopy( uCofactor, pTruth, nVars );
+        Extra_TruthCofactor0( uCofactor, nVars, i );
+        uSupp0 = Extra_TruthSupport( uCofactor, nVars );
+        nVars0 = Extra_WordCountOnes( uSupp0 );
+//Extra_PrintBinary( stdout, &uSupp0, 8 ); printf( "\n" );
+        // get positive cofactor
+        Extra_TruthCopy( uCofactor, pTruth, nVars );
+        Extra_TruthCofactor1( uCofactor, nVars, i );
+        uSupp1 = Extra_TruthSupport( uCofactor, nVars );
+        nVars1 = Extra_WordCountOnes( uSupp1 );
+//Extra_PrintBinary( stdout, &uSupp1, 8 ); printf( "\n" );
+        // get the number of common vars
+        ValueCur = Extra_WordCountOnes( uSupp0 & uSupp1 );
+        if ( ValueMin > ValueCur && nVars0 <= 5 && nVars1 <= 5 )
+        {
+            ValueMin = ValueCur;
+            VarMin = i;
+        }
+        if ( ValueMin == 0 )
+            break;
+    }
+    if ( pVarMin )
+        *pVarMin = VarMin;
+    return ValueMin;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of 1's in each cofactor.]
+
+  Description [The resulting numbers are stored in the array of shorts, 
+  whose length is 2*nVars. The number of 1's is counted in a different
+  space than the original function. For example, if the function depends 
+  on k variables, the cofactors are assumed to depend on k-1 variables.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_TruthCountOnesInCofs( unsigned * pTruth, int nVars, short * pStore )
+{
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, k, Counter;
+    memset( pStore, 0, sizeof(short) * 2 * nVars );
+    if ( nVars <= 5 )
+    {
+        if ( nVars > 0 )
+        {
+            pStore[2*0+0] = Extra_WordCountOnes( pTruth[0] & 0x55555555 );
+            pStore[2*0+1] = Extra_WordCountOnes( pTruth[0] & 0xAAAAAAAA );
+        }
+        if ( nVars > 1 )
+        {
+            pStore[2*1+0] = Extra_WordCountOnes( pTruth[0] & 0x33333333 );
+            pStore[2*1+1] = Extra_WordCountOnes( pTruth[0] & 0xCCCCCCCC );
+        }
+        if ( nVars > 2 )
+        {
+            pStore[2*2+0] = Extra_WordCountOnes( pTruth[0] & 0x0F0F0F0F );
+            pStore[2*2+1] = Extra_WordCountOnes( pTruth[0] & 0xF0F0F0F0 );
+        }
+        if ( nVars > 3 )
+        {
+            pStore[2*3+0] = Extra_WordCountOnes( pTruth[0] & 0x00FF00FF );
+            pStore[2*3+1] = Extra_WordCountOnes( pTruth[0] & 0xFF00FF00 );
+        }
+        if ( nVars > 4 )
+        {
+            pStore[2*4+0] = Extra_WordCountOnes( pTruth[0] & 0x0000FFFF );
+            pStore[2*4+1] = Extra_WordCountOnes( pTruth[0] & 0xFFFF0000 );
+        }
+        return;
+    }
+    // nVars >= 6
+    // count 1's for all other variables
+    for ( k = 0; k < nWords; k++ )
+    {
+        Counter = Extra_WordCountOnes( pTruth[k] );
+        for ( i = 5; i < nVars; i++ )
+            if ( k & (1 << (i-5)) )
+                pStore[2*i+1] += Counter;
+            else
+                pStore[2*i+0] += Counter;
+    }
+    // count 1's for the first five variables
+    for ( k = 0; k < nWords/2; k++ )
+    {
+        pStore[2*0+0] += Extra_WordCountOnes( (pTruth[0] & 0x55555555) | ((pTruth[1] & 0x55555555) <<  1) );
+        pStore[2*0+1] += Extra_WordCountOnes( (pTruth[0] & 0xAAAAAAAA) | ((pTruth[1] & 0xAAAAAAAA) >>  1) );
+        pStore[2*1+0] += Extra_WordCountOnes( (pTruth[0] & 0x33333333) | ((pTruth[1] & 0x33333333) <<  2) );
+        pStore[2*1+1] += Extra_WordCountOnes( (pTruth[0] & 0xCCCCCCCC) | ((pTruth[1] & 0xCCCCCCCC) >>  2) );
+        pStore[2*2+0] += Extra_WordCountOnes( (pTruth[0] & 0x0F0F0F0F) | ((pTruth[1] & 0x0F0F0F0F) <<  4) );
+        pStore[2*2+1] += Extra_WordCountOnes( (pTruth[0] & 0xF0F0F0F0) | ((pTruth[1] & 0xF0F0F0F0) >>  4) );
+        pStore[2*3+0] += Extra_WordCountOnes( (pTruth[0] & 0x00FF00FF) | ((pTruth[1] & 0x00FF00FF) <<  8) );
+        pStore[2*3+1] += Extra_WordCountOnes( (pTruth[0] & 0xFF00FF00) | ((pTruth[1] & 0xFF00FF00) >>  8) );
+        pStore[2*4+0] += Extra_WordCountOnes( (pTruth[0] & 0x0000FFFF) | ((pTruth[1] & 0x0000FFFF) << 16) );
+        pStore[2*4+1] += Extra_WordCountOnes( (pTruth[0] & 0xFFFF0000) | ((pTruth[1] & 0xFFFF0000) >> 16) );
+        pTruth += 2;
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Canonicize the truth table.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthHash( unsigned * pIn, int nWords )
+{
+    // The 1,024 smallest prime numbers used to compute the hash value
+    // http://www.math.utah.edu/~alfeld/math/primelist.html
+    static int HashPrimes[1024] = { 2, 3, 5, 
+    7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 
+    101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 
+    193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 
+    293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 
+    409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 
+    521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 
+    641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 
+    757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 
+    881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 
+    1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 
+    1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 
+    1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 
+    1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 
+    1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 
+    1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 
+    1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 
+    1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 
+    1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 
+    1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 
+    2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 
+    2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 
+    2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 
+    2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 
+    2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 
+    2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 
+    2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 
+    2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 
+    2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 
+    3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 
+    3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 
+    3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 
+    3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 
+    3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 
+    3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 
+    3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 
+    3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 
+    3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 
+    4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 
+    4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 
+    4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 
+    4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 
+    4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 
+    4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 
+    4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 
+    4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 
+    5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 
+    5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 
+    5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 
+    5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 
+    5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 
+    5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 
+    5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 
+    5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 
+    6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 
+    6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 
+    6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 
+    6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 
+    6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 
+    6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 
+    6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 
+    6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 
+    6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 
+    7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 
+    7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 
+    7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 
+    7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 
+    7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 
+    7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 
+    7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 
+    8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 
+    8147, 8161 };
+    int i;
+    unsigned uHashKey;
+    assert( nWords <= 1024 );
+    uHashKey = 0;
+    for ( i = 0; i < nWords; i++ )
+        uHashKey ^= HashPrimes[i] * pIn[i];
+    return uHashKey;
+}
+
+ 
+/**Function*************************************************************
+
+  Synopsis    [Canonicize the truth table.]
+
+  Description [Returns the phase. ]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+unsigned Extra_TruthSemiCanonicize( unsigned * pInOut, unsigned * pAux, int nVars, char * pCanonPerm, short * pStore )
+{
+    unsigned * pIn = pInOut, * pOut = pAux, * pTemp;
+    int nWords = Extra_TruthWordNum( nVars );
+    int i, Temp, fChange, Counter, nOnes;//, k, j, w, Limit;
+    unsigned uCanonPhase;
+
+    // canonicize output
+    uCanonPhase = 0;
+    nOnes = Extra_TruthCountOnes(pIn, nVars);
+    if ( (nOnes > nWords * 16) || ((nOnes == nWords * 16) && (pIn[0] & 1)) )
+    {
+        uCanonPhase |= (1 << nVars);
+        Extra_TruthNot( pIn, pIn, nVars );
+    }
+
+    // collect the minterm counts
+    Extra_TruthCountOnesInCofs( pIn, nVars, pStore );
+
+    // canonicize phase
+    for ( i = 0; i < nVars; i++ )
+    {
+        if ( pStore[2*i+0] <= pStore[2*i+1] )
+            continue;
+        uCanonPhase |= (1 << i);
+        Temp = pStore[2*i+0];
+        pStore[2*i+0] = pStore[2*i+1];
+        pStore[2*i+1] = Temp;
+        Extra_TruthChangePhase( pIn, nVars, i );
+    }
+
+//    Extra_PrintHexadecimal( stdout, pIn, nVars );
+//    printf( "\n" );
+
+    // permute
+    Counter = 0;
+    do {
+        fChange = 0;
+        for ( i = 0; i < nVars-1; i++ )
+        {
+            if ( pStore[2*i] <= pStore[2*(i+1)] )
+                continue;
+            Counter++;
+            fChange = 1;
+
+            Temp = pCanonPerm[i];
+            pCanonPerm[i] = pCanonPerm[i+1];
+            pCanonPerm[i+1] = Temp;
+
+            Temp = pStore[2*i];
+            pStore[2*i] = pStore[2*(i+1)];
+            pStore[2*(i+1)] = Temp;
+
+            Temp = pStore[2*i+1];
+            pStore[2*i+1] = pStore[2*(i+1)+1];
+            pStore[2*(i+1)+1] = Temp;
+
+            Extra_TruthSwapAdjacentVars( pOut, pIn, nVars, i );
+            pTemp = pIn; pIn = pOut; pOut = pTemp;
+        }
+    } while ( fChange );
+
+/*
+    Extra_PrintBinary( stdout, &uCanonPhase, nVars+1 ); printf( " : " );
+    for ( i = 0; i < nVars; i++ )
+        printf( "%d=%d/%d  ", pCanonPerm[i], pStore[2*i], pStore[2*i+1] );
+    printf( "  C = %d\n", Counter );
+    Extra_PrintHexadecimal( stdout, pIn, nVars );
+    printf( "\n" );
+*/
+
+/*
+    // process symmetric variable groups
+    uSymms = 0;
+    for ( i = 0; i < nVars-1; i++ )
+    {
+        if ( pStore[2*i] != pStore[2*(i+1)] ) // i and i+1 cannot be symmetric
+            continue;
+        if ( pStore[2*i] != pStore[2*i+1] )
+            continue;
+        if ( Extra_TruthVarsSymm( pIn, nVars, i, i+1 ) )
+            continue;
+        if ( Extra_TruthVarsAntiSymm( pIn, nVars, i, i+1 ) )
+            Extra_TruthChangePhase( pIn, nVars, i+1 );
+    }
+*/
+
+/*
+    // process symmetric variable groups
+    uSymms = 0;
+    for ( i = 0; i < nVars-1; i++ )
+    {
+        if ( pStore[2*i] != pStore[2*(i+1)] ) // i and i+1 cannot be symmetric
+            continue;
+        // i and i+1 can be symmetric
+        // find the end of this group
+        for ( k = i+1; k < nVars; k++ )
+            if ( pStore[2*i] != pStore[2*k] ) 
+                break;
+        Limit = k;
+        assert( i < Limit-1 );
+        // go through the variables in this group
+        for ( j = i + 1; j < Limit; j++ )
+        {
+            // check symmetry
+            if ( Extra_TruthVarsSymm( pIn, nVars, i, j ) )
+            {
+                uSymms |= (1 << j);
+                continue;
+            }
+            // they are phase-unknown
+            if ( pStore[2*i] == pStore[2*i+1] ) 
+            {
+                if ( Extra_TruthVarsAntiSymm( pIn, nVars, i, j ) )
+                {
+                    Extra_TruthChangePhase( pIn, nVars, j );
+                    uCanonPhase ^= (1 << j);
+                    uSymms |= (1 << j);
+                    continue;
+                }
+            }
+
+            // they are not symmetric - move j as far as it goes in the group
+            for ( k = j; k < Limit-1; k++ )
+            {
+                Counter++;
+
+                Temp = pCanonPerm[k];
+                pCanonPerm[k] = pCanonPerm[k+1];
+                pCanonPerm[k+1] = Temp;
+
+                assert( pStore[2*k] == pStore[2*(k+1)] );
+                Extra_TruthSwapAdjacentVars( pOut, pIn, nVars, k );
+                pTemp = pIn; pIn = pOut; pOut = pTemp;
+            }
+            Limit--;
+            j--;
+        }
+        i = Limit - 1;
+    }
+*/
+
+    // swap if it was moved an even number of times
+    if ( Counter & 1 )
+        Extra_TruthCopy( pOut, pIn, nVars );
+    return uCanonPhase;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/extraUtilUtil.c b/src/misc/extra/extraUtilUtil.c
new file mode 100644
index 00000000..ee0c400a
--- /dev/null
+++ b/src/misc/extra/extraUtilUtil.c
@@ -0,0 +1,330 @@
+/**CFile****************************************************************
+
+  FileName    [extraUtilUtil.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [extra]
+
+  Synopsis    [Old SIS utilities.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: extraUtilUtil.c,v 1.0 2003/02/01 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include "extra.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+#define EXTRA_RLIMIT_DATA_DEFAULT 67108864  // assume 64MB by default 
+
+/*  File   : getopt.c
+ *  Author : Henry Spencer, University of Toronto
+ *  Updated: 28 April 1984
+ *
+ *  Changes: (R Rudell)
+ *  changed index() to strchr();
+ *  added getopt_reset() to reset the getopt argument parsing
+ *
+ *  Purpose: get option letter from argv.
+ */
+
+char * globalUtilOptarg;        // Global argument pointer (util_optarg)
+int    globalUtilOptind = 0;    // Global argv index (util_optind)
+
+static char *pScanStr;
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [util_cpu_time()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+long Extra_CpuTime()
+{
+    return clock();
+}
+
+/**Function*************************************************************
+
+  Synopsis    [getSoftDataLimit()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_GetSoftDataLimit()
+{
+    return EXTRA_RLIMIT_DATA_DEFAULT;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [util_getopt_reset()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Extra_UtilGetoptReset()
+{
+    globalUtilOptarg = 0;
+    globalUtilOptind = 0;
+    pScanStr = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [util_getopt()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_UtilGetopt( int argc, char *argv[], char *optstring )
+{
+    register int c;
+    register char *place;
+
+    globalUtilOptarg = NULL;
+
+    if (pScanStr == NULL || *pScanStr == '\0') {
+    if (globalUtilOptind == 0) globalUtilOptind++;
+    if (globalUtilOptind >= argc) return EOF;
+    place = argv[globalUtilOptind];
+    if (place[0] != '-' || place[1] == '\0') return EOF;
+    globalUtilOptind++;
+    if (place[1] == '-' && place[2] == '\0') return EOF;
+    pScanStr = place+1;
+    }
+
+    c = *pScanStr++;
+    place = strchr(optstring, c);
+    if (place == NULL || c == ':') {
+    (void) fprintf(stderr, "%s: unknown option %c\n", argv[0], c);
+    return '?';
+    }
+    if (*++place == ':') {
+    if (*pScanStr != '\0') {
+        globalUtilOptarg = pScanStr;
+        pScanStr = NULL;
+    } else {
+        if (globalUtilOptind >= argc) {
+        (void) fprintf(stderr, "%s: %c requires an argument\n", 
+            argv[0], c);
+        return '?';
+        }
+        globalUtilOptarg = argv[globalUtilOptind];
+        globalUtilOptind++;
+    }
+    }
+    return c;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [util_print_time()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_UtilPrintTime( long t )
+{
+    static char s[40];
+
+    (void) sprintf(s, "%ld.%02ld sec", t/1000, (t%1000)/10);
+    return s;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Extra_UtilStrsav()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_UtilStrsav( char *s )
+{
+    if(s == NULL) {  /* added 7/95, for robustness */
+       return s;
+    }
+    else {
+       return strcpy(ALLOC(char, strlen(s)+1), s);
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [util_tilde_expand()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_UtilTildeExpand( char *fname )
+{
+    return Extra_UtilStrsav( fname );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [check_file()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Extra_UtilCheckFile(char *filename, char *mode)
+{
+    FILE *fp;
+    int got_file;
+
+    if (strcmp(mode, "x") == 0) {
+    mode = "r";
+    }
+    fp = fopen(filename, mode);
+    got_file = (fp != 0);
+    if (fp != 0) {
+    (void) fclose(fp);
+    }
+    return got_file;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [util_file_search()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Extra_UtilFileSearch(char *file, char *path, char *mode)
+//char *file;            // file we're looking for 
+//char *path;            // search path, colon separated 
+//char *mode;            // "r", "w", or "x" 
+{
+    int quit;
+    char *buffer, *filename, *save_path, *cp;
+
+    if (path == 0 || strcmp(path, "") == 0) {
+    path = ".";        /* just look in the current directory */
+    }
+
+    save_path = path = Extra_UtilStrsav(path);
+    quit = 0;
+    do {
+    cp = strchr(path, ':');
+    if (cp != 0) {
+        *cp = '\0';
+    } else {
+        quit = 1;
+    }
+
+    /* cons up the filename out of the path and file name */
+    if (strcmp(path, ".") == 0) {
+        buffer = Extra_UtilStrsav(file);
+    } else {
+        buffer = ALLOC(char, strlen(path) + strlen(file) + 4);
+        (void) sprintf(buffer, "%s/%s", path, file);
+    }
+    filename = Extra_UtilTildeExpand(buffer);
+    FREE(buffer);
+
+    /* see if we can access it */
+    if (Extra_UtilCheckFile(filename, mode)) {
+        FREE(save_path);
+        return filename;
+    }
+    FREE(filename);
+    path = ++cp;
+    } while (! quit); 
+
+    FREE(save_path);
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [MMout_of_memory()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+/* MMout_of_memory -- out of memory for lazy people, flush and exit */
+void Extra_UtilMMout_Of_Memory( long size )
+{
+    (void) fflush(stdout);
+    (void) fprintf(stderr, "\nout of memory allocating %u bytes\n",
+           (unsigned) size);
+    assert( 0 );
+    exit(1);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [MMoutOfMemory()]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void (*Extra_UtilMMoutOfMemory)() = Extra_UtilMMout_Of_Memory;
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/misc/extra/module.make b/src/misc/extra/module.make
new file mode 100644
index 00000000..ec8bca4d
--- /dev/null
+++ b/src/misc/extra/module.make
@@ -0,0 +1,15 @@
+SRC +=    src/misc/extra/extraBddAuto.c \
+    src/misc/extra/extraBddCas.c \
+    src/misc/extra/extraBddKmap.c \
+    src/misc/extra/extraBddMisc.c \
+    src/misc/extra/extraBddSymm.c \
+    src/misc/extra/extraBddUnate.c \
+    src/misc/extra/extraUtilBitMatrix.c \
+    src/misc/extra/extraUtilCanon.c \
+    src/misc/extra/extraUtilFile.c \
+    src/misc/extra/extraUtilMemory.c \
+    src/misc/extra/extraUtilMisc.c \
+    src/misc/extra/extraUtilProgress.c \
+    src/misc/extra/extraUtilReader.c \
+    src/misc/extra/extraUtilTruth.c \
+    src/misc/extra/extraUtilUtil.c