Version abc70930

10 files changed, 0 insertions, 2972 deletions

diff --git a/src/opt/rwr/module.make b/src/opt/rwr/module.make
deleted file mode 100644
index 077a3c01..00000000
--- a/src/opt/rwr/module.make
+++ /dev/null
@@ -1,7 +0,0 @@
-SRC +=  src/opt/rwr/rwrDec.c \
-    src/opt/rwr/rwrEva.c \
-    src/opt/rwr/rwrExp.c \
-    src/opt/rwr/rwrLib.c \
-    src/opt/rwr/rwrMan.c \
-    src/opt/rwr/rwrPrint.c \
-    src/opt/rwr/rwrUtil.c
diff --git a/src/opt/rwr/rwr.h b/src/opt/rwr/rwr.h
deleted file mode 100644
index f24f9535..00000000
--- a/src/opt/rwr/rwr.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwr.h]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [External declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
- 
-#ifndef __RWR_H__
-#define __RWR_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-#include "abc.h"
-#include "cut.h"
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                         BASIC TYPES                              ///
-////////////////////////////////////////////////////////////////////////
- 
-#define RWR_LIMIT  1048576/4  // ((1 << 20) 
-
-typedef struct Rwr_Man_t_   Rwr_Man_t;
-typedef struct Rwr_Node_t_  Rwr_Node_t;
-
-struct Rwr_Man_t_
-{
-    // internal lookups
-    int                nFuncs;           // number of four var functions
-    unsigned short *   puCanons;         // canonical forms
-    char *             pPhases;          // canonical phases
-    char *             pPerms;           // canonical permutations
-    unsigned char *    pMap;             // mapping of functions into class numbers
-    unsigned short *   pMapInv;          // mapping of classes into functions
-    char *             pPractical;       // practical NPN classes
-    char **            pPerms4;          // four-var permutations
-    // node space
-    Vec_Ptr_t *        vForest;          // all the nodes
-    Rwr_Node_t **      pTable;           // the hash table of nodes by their canonical form
-    Vec_Vec_t *        vClasses;         // the nodes of the equivalence classes
-    Extra_MmFixed_t *  pMmNode;          // memory for nodes and cuts
-    // statistical variables
-    int                nTravIds;         // the counter of traversal IDs
-    int                nConsidered;      // the number of nodes considered
-    int                nAdded;           // the number of nodes added to lists
-    int                nClasses;         // the number of NN classes
-    // the result of resynthesis
-    int                fCompl;           // indicates if the output of FF should be complemented
-    void *             pGraph;           // the decomposition tree (temporary)
-    Vec_Ptr_t *        vFanins;          // the fanins array (temporary)
-    Vec_Ptr_t *        vFaninsCur;       // the fanins array (temporary)
-    Vec_Int_t *        vLevNums;         // the array of levels (temporary)
-    Vec_Ptr_t *        vNodesTemp;       // the nodes in MFFC (temporary)
-    // node statistics
-    int                nNodesConsidered;
-    int                nNodesRewritten;
-    int                nNodesGained;
-    int                nNodesBeg;
-    int                nNodesEnd;
-    int                nScores[222];
-    int                nCutsGood;
-    int                nCutsBad;
-    int                nSubgraphs;
-    // runtime statistics
-    int                timeStart;
-    int                timeCut;
-    int                timeRes;
-    int                timeEval;
-    int                timeMffc;
-    int                timeUpdate;
-    int                timeTotal;
-};
-
-struct Rwr_Node_t_ // 24 bytes
-{
-    int                Id;               // ID 
-    int                TravId;           // traversal ID
-    short              nScore;
-    short              nGain;
-    short              nAdded;
-    unsigned           uTruth : 16;      // truth table
-    unsigned           Volume :  8;      // volume
-    unsigned           Level  :  6;      // level
-    unsigned           fUsed  :  1;      // mark
-    unsigned           fExor  :  1;      // mark
-    Rwr_Node_t *       p0;               // first child
-    Rwr_Node_t *       p1;               // second child
-    Rwr_Node_t *       pNext;            // next in the table
-};
-
-// manipulation of complemented attributes
-static inline bool         Rwr_IsComplement( Rwr_Node_t * p )    { return (bool)(((unsigned long)p) & 01);           }
-static inline Rwr_Node_t * Rwr_Regular( Rwr_Node_t * p )         { return (Rwr_Node_t *)((unsigned long)(p) & ~01);  }
-static inline Rwr_Node_t * Rwr_Not( Rwr_Node_t * p )             { return (Rwr_Node_t *)((unsigned long)(p) ^  01);  }
-static inline Rwr_Node_t * Rwr_NotCond( Rwr_Node_t * p, int c )  { return (Rwr_Node_t *)((unsigned long)(p) ^ (c));  }
-
-////////////////////////////////////////////////////////////////////////
-///                      MACRO DEFINITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DECLARATIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== rwrDec.c ========================================================*/
-extern void              Rwr_ManPreprocess( Rwr_Man_t * p );
-/*=== rwrEva.c ========================================================*/
-extern int               Rwr_NodeRewrite( Rwr_Man_t * p, Cut_Man_t * pManCut, Abc_Obj_t * pNode, int fUpdateLevel, int fUseZeros, int fPlaceEnable );
-extern void              Rwr_ScoresClean( Rwr_Man_t * p );
-extern void              Rwr_ScoresReport( Rwr_Man_t * p );
-/*=== rwrLib.c ========================================================*/
-extern void              Rwr_ManPrecompute( Rwr_Man_t * p );
-extern Rwr_Node_t *      Rwr_ManAddVar( Rwr_Man_t * p, unsigned uTruth, int fPrecompute );
-extern Rwr_Node_t *      Rwr_ManAddNode( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Node_t * p1, int fExor, int Level, int Volume );
-extern int               Rwr_ManNodeVolume( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Node_t * p1 );
-extern void              Rwr_ManIncTravId( Rwr_Man_t * p );
-/*=== rwrMan.c ========================================================*/
-extern Rwr_Man_t *       Rwr_ManStart( bool fPrecompute );
-extern void              Rwr_ManStop( Rwr_Man_t * p );
-extern void              Rwr_ManPrintStats( Rwr_Man_t * p );
-extern void              Rwr_ManPrintStatsFile( Rwr_Man_t * p );
-extern void *            Rwr_ManReadDecs( Rwr_Man_t * p );
-extern Vec_Ptr_t *       Rwr_ManReadLeaves( Rwr_Man_t * p );
-extern int               Rwr_ManReadCompl( Rwr_Man_t * p );
-extern void              Rwr_ManAddTimeCuts( Rwr_Man_t * p, int Time );
-extern void              Rwr_ManAddTimeUpdate( Rwr_Man_t * p, int Time );
-extern void              Rwr_ManAddTimeTotal( Rwr_Man_t * p, int Time );
-/*=== rwrPrint.c ========================================================*/
-extern void              Rwr_ManPrint( Rwr_Man_t * p );
-/*=== rwrUtil.c ========================================================*/
-extern void              Rwr_ManWriteToArray( Rwr_Man_t * p );
-extern void              Rwr_ManLoadFromArray( Rwr_Man_t * p, int fVerbose );
-extern void              Rwr_ManWriteToFile( Rwr_Man_t * p, char * pFileName );
-extern void              Rwr_ManLoadFromFile( Rwr_Man_t * p, char * pFileName );
-extern void              Rwr_ListAddToTail( Rwr_Node_t ** ppList, Rwr_Node_t * pNode );
-extern char *            Rwr_ManGetPractical( Rwr_Man_t * p );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/opt/rwr/rwrDec.c b/src/opt/rwr/rwrDec.c
deleted file mode 100644
index ef7af34f..00000000
--- a/src/opt/rwr/rwrDec.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrDec.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [Evaluation and decomposition procedures.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrDec.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-#include "dec.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static Dec_Graph_t * Rwr_NodePreprocess( Rwr_Man_t * p, Rwr_Node_t * pNode );
-static Dec_Edge_t    Rwr_TravCollect_rec( Rwr_Man_t * p, Rwr_Node_t * pNode, Dec_Graph_t * pGraph );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Preprocesses computed library of subgraphs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManPreprocess( Rwr_Man_t * p )
-{
-    Dec_Graph_t * pGraph;
-    Rwr_Node_t * pNode;
-    int i, k;
-    // put the nodes into the structure
-    p->pMapInv  = ALLOC( unsigned short, 222 );
-    memset( p->pMapInv, 0, sizeof(unsigned short) * 222 );
-    p->vClasses = Vec_VecStart( 222 );
-    for ( i = 0; i < p->nFuncs; i++ )
-    {
-        if ( p->pTable[i] == NULL )
-            continue;
-        // consider all implementations of this function
-        for ( pNode = p->pTable[i]; pNode; pNode = pNode->pNext )
-        {
-            assert( pNode->uTruth == p->pTable[i]->uTruth );
-            assert( p->pMap[pNode->uTruth] >= 0 && p->pMap[pNode->uTruth] < 222 );
-            Vec_VecPush( p->vClasses, p->pMap[pNode->uTruth], pNode );
-            p->pMapInv[ p->pMap[pNode->uTruth] ] = p->puCanons[pNode->uTruth];
-        }
-    }
-    // compute decomposition forms for each node and verify them
-    Vec_VecForEachEntry( p->vClasses, pNode, i, k )
-    {
-        pGraph = Rwr_NodePreprocess( p, pNode );
-        pNode->pNext = (Rwr_Node_t *)pGraph;
-        assert( pNode->uTruth == (Dec_GraphDeriveTruth(pGraph) & 0xFFFF) );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Preprocesses subgraphs rooted at this node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Dec_Graph_t * Rwr_NodePreprocess( Rwr_Man_t * p, Rwr_Node_t * pNode )
-{
-    Dec_Graph_t * pGraph;
-    Dec_Edge_t eRoot;
-    assert( !Rwr_IsComplement(pNode) );
-    // consider constant
-    if ( pNode->uTruth == 0 )
-        return Dec_GraphCreateConst0();
-    // consider the case of elementary var
-    if ( pNode->uTruth == 0x00FF )
-        return Dec_GraphCreateLeaf( 3, 4, 1 );
-    // start the subgraphs
-    pGraph = Dec_GraphCreate( 4 );
-    // collect the nodes
-    Rwr_ManIncTravId( p );
-    eRoot = Rwr_TravCollect_rec( p, pNode, pGraph );
-    Dec_GraphSetRoot( pGraph, eRoot );
-    return pGraph;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Dec_Edge_t Rwr_TravCollect_rec( Rwr_Man_t * p, Rwr_Node_t * pNode, Dec_Graph_t * pGraph )
-{
-    Dec_Edge_t eNode0, eNode1, eNode;
-    // elementary variable
-    if ( pNode->fUsed )
-        return Dec_EdgeCreate( pNode->Id - 1, 0 );
-    // previously visited node
-    if ( pNode->TravId == p->nTravIds )
-        return Dec_IntToEdge( pNode->Volume );
-    pNode->TravId = p->nTravIds;
-    // solve for children
-    eNode0 = Rwr_TravCollect_rec( p, Rwr_Regular(pNode->p0), pGraph );
-    if ( Rwr_IsComplement(pNode->p0) )    
-        eNode0.fCompl = !eNode0.fCompl;
-    eNode1 = Rwr_TravCollect_rec( p, Rwr_Regular(pNode->p1), pGraph );
-    if ( Rwr_IsComplement(pNode->p1) )    
-        eNode1.fCompl = !eNode1.fCompl;
-    // create the decomposition node(s)
-    if ( pNode->fExor )
-        eNode = Dec_GraphAddNodeXor( pGraph, eNode0, eNode1, 0 );
-    else
-        eNode = Dec_GraphAddNodeAnd( pGraph, eNode0, eNode1 );
-    // save the result
-    pNode->Volume = Dec_EdgeToInt( eNode );
-    return eNode;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/opt/rwr/rwrEva.c b/src/opt/rwr/rwrEva.c
deleted file mode 100644
index f46c16c0..00000000
--- a/src/opt/rwr/rwrEva.c
+++ /dev/null
@@ -1,587 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrDec.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [Evaluation and decomposition procedures.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrDec.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-#include "dec.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCut, Vec_Ptr_t * vFaninsCur, int nNodesSaved, int LevelMax, int * pGainBest, int fPlaceEnable );
-static int Rwr_CutIsBoolean( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves );
-static int Rwr_CutCountNumNodes( Abc_Obj_t * pObj, Cut_Cut_t * pCut );
-static int Rwr_NodeGetDepth_rec( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Performs rewriting for one node.]
-
-  Description [This procedure considers all the cuts computed for the node
-  and tries to rewrite each of them using the "forest" of different AIG
-  structures precomputed and stored in the RWR manager. 
-  Determines the best rewriting and computes the gain in the number of AIG
-  nodes in the final network. In the end, p->vFanins contains information 
-  about the best cut that can be used for rewriting, while p->pGraph gives 
-  the decomposition dag (represented using decomposition graph data structure).
-  Returns gain in the number of nodes or -1 if node cannot be rewritten.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_NodeRewrite( Rwr_Man_t * p, Cut_Man_t * pManCut, Abc_Obj_t * pNode, int fUpdateLevel, int fUseZeros, int fPlaceEnable )
-{
-    int fVeryVerbose = 0;
-    Dec_Graph_t * pGraph;
-    Cut_Cut_t * pCut;//, * pTemp;
-    Abc_Obj_t * pFanin;
-    unsigned uPhase, uTruthBest, uTruth;
-    char * pPerm;
-    int Required, nNodesSaved, nNodesSaveCur;
-    int i, GainCur, GainBest = -1;
-    int clk, clk2;//, Counter;
-
-    p->nNodesConsidered++;
-    // get the required times
-    Required = fUpdateLevel? Abc_ObjRequiredLevel(pNode) : ABC_INFINITY;
-
-    // get the node's cuts
-clk = clock();
-    pCut = (Cut_Cut_t *)Abc_NodeGetCutsRecursive( pManCut, pNode, 0, 0 );
-    assert( pCut != NULL );
-p->timeCut += clock() - clk;
-
-//printf( " %d", Rwr_CutCountNumNodes(pNode, pCut) );
-/*
-    Counter = 0;
-    for ( pTemp = pCut->pNext; pTemp; pTemp = pTemp->pNext )
-        Counter++;
-    printf( "%d ", Counter );
-*/
-    // go through the cuts
-clk = clock();
-    for ( pCut = pCut->pNext; pCut; pCut = pCut->pNext )
-    {
-        // consider only 4-input cuts
-        if ( pCut->nLeaves < 4 )
-            continue;
-//            Cut_CutPrint( pCut, 0 ), printf( "\n" );
-
-        // get the fanin permutation
-        uTruth = 0xFFFF & *Cut_CutReadTruth(pCut);
-        pPerm = p->pPerms4[ p->pPerms[uTruth] ];
-        uPhase = p->pPhases[uTruth];
-        // collect fanins with the corresponding permutation/phase
-        Vec_PtrClear( p->vFaninsCur );
-        Vec_PtrFill( p->vFaninsCur, (int)pCut->nLeaves, 0 );
-        for ( i = 0; i < (int)pCut->nLeaves; i++ )
-        {
-            pFanin = Abc_NtkObj( pNode->pNtk, pCut->pLeaves[pPerm[i]] );
-            if ( pFanin == NULL )
-                break;
-            pFanin = Abc_ObjNotCond(pFanin, ((uPhase & (1<<i)) > 0) );
-            Vec_PtrWriteEntry( p->vFaninsCur, i, pFanin );
-        }
-        if ( i != (int)pCut->nLeaves )
-        {
-            p->nCutsBad++;
-            continue;
-        }
-        p->nCutsGood++;
-
-        {
-            int Counter = 0;
-            Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
-                if ( Abc_ObjFanoutNum(Abc_ObjRegular(pFanin)) == 1 )
-                    Counter++;
-            if ( Counter > 2 )
-                continue;
-        }
-
-clk2 = clock();
-/*
-        printf( "Considering: (" );
-        Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
-            printf( "%d ", Abc_ObjFanoutNum(Abc_ObjRegular(pFanin)) );
-        printf( ")\n" );
-*/
-        // mark the fanin boundary 
-        Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
-            Abc_ObjRegular(pFanin)->vFanouts.nSize++;
-
-        // label MFFC with current ID
-        Abc_NtkIncrementTravId( pNode->pNtk );
-        nNodesSaved = Abc_NodeMffcLabelAig( pNode );
-        // unmark the fanin boundary
-        Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
-            Abc_ObjRegular(pFanin)->vFanouts.nSize--;
-p->timeMffc += clock() - clk2;
-
-        // evaluate the cut
-clk2 = clock();
-        pGraph = Rwr_CutEvaluate( p, pNode, pCut, p->vFaninsCur, nNodesSaved, Required, &GainCur, fPlaceEnable );
-p->timeEval += clock() - clk2;
-
-        // check if the cut is better than the current best one
-        if ( pGraph != NULL && GainBest < GainCur )
-        {
-            // save this form
-            nNodesSaveCur = nNodesSaved;
-            GainBest  = GainCur;
-            p->pGraph  = pGraph;
-            p->fCompl = ((uPhase & (1<<4)) > 0);
-            uTruthBest = 0xFFFF & *Cut_CutReadTruth(pCut);
-            // collect fanins in the
-            Vec_PtrClear( p->vFanins );
-            Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
-                Vec_PtrPush( p->vFanins, pFanin );
-        }
-    }
-p->timeRes += clock() - clk;
-
-    if ( GainBest == -1 )
-        return -1;
-/*
-    if ( GainBest > 0 )
-    {
-        printf( "Class %d  ", p->pMap[uTruthBest] );
-        printf( "Gain = %d. Node %d : ", GainBest, pNode->Id );
-        Vec_PtrForEachEntry( p->vFanins, pFanin, i )
-            printf( "%d ", Abc_ObjRegular(pFanin)->Id );
-        Dec_GraphPrint( stdout, p->pGraph, NULL, NULL );
-        printf( "\n" );
-    }
-*/
-
-//    printf( "%d", nNodesSaveCur - GainBest );
-/*
-    if ( GainBest > 0 )
-    {
-        if ( Rwr_CutIsBoolean( pNode, p->vFanins ) )
-            printf( "b" );
-        else
-        {
-            printf( "Node %d : ", pNode->Id );
-            Vec_PtrForEachEntry( p->vFanins, pFanin, i )
-                printf( "%d ", Abc_ObjRegular(pFanin)->Id );
-            printf( "a" );
-        }
-    }
-*/
-/*
-    if ( GainBest > 0 )
-        if ( p->fCompl )
-            printf( "c" );
-        else
-            printf( "." );
-*/
-
-    // copy the leaves
-    Vec_PtrForEachEntry( p->vFanins, pFanin, i )
-        Dec_GraphNode(p->pGraph, i)->pFunc = pFanin;
-/*
-    printf( "(" );
-    Vec_PtrForEachEntry( p->vFanins, pFanin, i )
-        printf( " %d", Abc_ObjRegular(pFanin)->vFanouts.nSize - 1 );
-    printf( " )  " );
-*/
-//    printf( "%d ", Rwr_NodeGetDepth_rec( pNode, p->vFanins ) );
-
-    p->nScores[p->pMap[uTruthBest]]++;
-    p->nNodesGained += GainBest;
-    if ( fUseZeros || GainBest > 0 )
-    {
-        p->nNodesRewritten++;
-    }
-
-    // report the progress
-    if ( fVeryVerbose && GainBest > 0 )
-    {
-        printf( "Node %6s :   ", Abc_ObjName(pNode) );
-        printf( "Fanins = %d. ", p->vFanins->nSize );
-        printf( "Save = %d.  ", nNodesSaveCur );
-        printf( "Add = %d.  ",  nNodesSaveCur-GainBest );
-        printf( "GAIN = %d.  ", GainBest );
-        printf( "Cone = %d.  ", p->pGraph? Dec_GraphNodeNum(p->pGraph) : 0 );
-        printf( "Class = %d.  ", p->pMap[uTruthBest] );
-        printf( "\n" );
-    }
-    return GainBest;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Evaluates the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCut, Vec_Ptr_t * vFaninsCur, int nNodesSaved, int LevelMax, int * pGainBest, int fPlaceEnable )
-{
-    Vec_Ptr_t * vSubgraphs;
-    Dec_Graph_t * pGraphBest, * pGraphCur;
-    Rwr_Node_t * pNode, * pFanin;
-    int nNodesAdded, GainBest, i, k;
-    unsigned uTruth;
-    float CostBest, CostCur;
-    // find the matching class of subgraphs
-    uTruth = 0xFFFF & *Cut_CutReadTruth(pCut);
-    vSubgraphs = Vec_VecEntry( p->vClasses, p->pMap[uTruth] );
-    p->nSubgraphs += vSubgraphs->nSize;
-    // determine the best subgraph
-    GainBest = -1;
-    CostBest = ABC_INFINITY;
-    Vec_PtrForEachEntry( vSubgraphs, pNode, i )
-    {
-        // get the current graph
-        pGraphCur = (Dec_Graph_t *)pNode->pNext;
-        // copy the leaves
-        Vec_PtrForEachEntry( vFaninsCur, pFanin, k )
-            Dec_GraphNode(pGraphCur, k)->pFunc = pFanin;
-        // detect how many unlabeled nodes will be reused
-        nNodesAdded = Dec_GraphToNetworkCount( pRoot, pGraphCur, nNodesSaved, LevelMax );
-        if ( nNodesAdded == -1 )
-            continue;
-        assert( nNodesSaved >= nNodesAdded );
-
-        // evaluate the cut
-        if ( fPlaceEnable )
-        {
-            extern float Abc_PlaceEvaluateCut( Abc_Obj_t * pRoot, Vec_Ptr_t * vFanins );
-
-            float Alpha = 0.5; // ???
-            float PlaceCost;
-
-            // get the placement cost of the cut
-            PlaceCost = Abc_PlaceEvaluateCut( pRoot, vFaninsCur );
-
-            // get the weigted cost of the cut
-            CostCur = nNodesSaved - nNodesAdded + Alpha * PlaceCost;
-
-            // do not allow uphill moves
-            if ( nNodesSaved - nNodesAdded < 0 )
-                continue;
-
-            // decide what cut to use
-            if ( CostBest > CostCur )
-            {
-                GainBest   = nNodesSaved - nNodesAdded; // pure node cost
-                CostBest   = CostCur;                   // cost with placement
-                pGraphBest = pGraphCur;                 // subgraph to be used for rewriting
-
-                // score the graph
-                if ( nNodesSaved - nNodesAdded > 0 )
-                {
-                    pNode->nScore++;
-                    pNode->nGain += GainBest;
-                    pNode->nAdded += nNodesAdded;
-                }
-            }
-        }
-        else
-        {
-            // count the gain at this node
-            if ( GainBest < nNodesSaved - nNodesAdded )
-            {
-                GainBest   = nNodesSaved - nNodesAdded;
-                pGraphBest = pGraphCur;
-
-                // score the graph
-                if ( nNodesSaved - nNodesAdded > 0 )
-                {
-                    pNode->nScore++;
-                    pNode->nGain += GainBest;
-                    pNode->nAdded += nNodesAdded;
-                }
-            }
-        }
-    }
-    if ( GainBest == -1 )
-        return NULL;
-    *pGainBest = GainBest;
-    return pGraphBest;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks the type of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_CutIsBoolean_rec( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves, int fMarkA )
-{
-    if ( Vec_PtrFind(vLeaves, pObj) >= 0 || Vec_PtrFind(vLeaves, Abc_ObjNot(pObj)) >= 0 )
-    {
-        if ( fMarkA )
-            pObj->fMarkA = 1;
-        else
-            pObj->fMarkB = 1;
-        return;
-    }
-    assert( !Abc_ObjIsCi(pObj) );
-    Rwr_CutIsBoolean_rec( Abc_ObjFanin0(pObj), vLeaves, fMarkA );
-    Rwr_CutIsBoolean_rec( Abc_ObjFanin1(pObj), vLeaves, fMarkA );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks the type of the cut.]
-
-  Description [Returns 1(0) if the cut is Boolean (algebraic).]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_CutIsBoolean( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves )
-{
-    Abc_Obj_t * pTemp;
-    int i, RetValue;
-    Vec_PtrForEachEntry( vLeaves, pTemp, i )
-    {
-        pTemp = Abc_ObjRegular(pTemp);
-        assert( !pTemp->fMarkA && !pTemp->fMarkB );
-    }
-    Rwr_CutIsBoolean_rec( Abc_ObjFanin0(pObj), vLeaves, 1 );
-    Rwr_CutIsBoolean_rec( Abc_ObjFanin1(pObj), vLeaves, 0 );
-    RetValue = 0;
-    Vec_PtrForEachEntry( vLeaves, pTemp, i )
-    {
-        pTemp = Abc_ObjRegular(pTemp);
-        RetValue |= pTemp->fMarkA && pTemp->fMarkB;
-        pTemp->fMarkA = pTemp->fMarkB = 0;
-    }
-    return RetValue;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Count the nodes in the cut space of a node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_CutCountNumNodes_rec( Abc_Obj_t * pObj, Cut_Cut_t * pCut, Vec_Ptr_t * vNodes )
-{
-    int i;
-    for ( i = 0; i < (int)pCut->nLeaves; i++ )
-        if ( pCut->pLeaves[i] == pObj->Id )
-        {
-            // check if the node is collected
-            if ( pObj->fMarkC == 0 )
-            {
-                pObj->fMarkC = 1;
-                Vec_PtrPush( vNodes, pObj );
-            }
-            return;
-        }
-    assert( Abc_ObjIsNode(pObj) );
-    // check if the node is collected
-    if ( pObj->fMarkC == 0 )
-    {
-        pObj->fMarkC = 1;
-        Vec_PtrPush( vNodes, pObj );
-    }
-    // traverse the fanins
-    Rwr_CutCountNumNodes_rec( Abc_ObjFanin0(pObj), pCut, vNodes );
-    Rwr_CutCountNumNodes_rec( Abc_ObjFanin1(pObj), pCut, vNodes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Count the nodes in the cut space of a node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_CutCountNumNodes( Abc_Obj_t * pObj, Cut_Cut_t * pCut )
-{
-    Vec_Ptr_t * vNodes;
-    int i, Counter;
-    // collect all nodes
-    vNodes = Vec_PtrAlloc( 100 );
-    for ( pCut = pCut->pNext; pCut; pCut = pCut->pNext )
-        Rwr_CutCountNumNodes_rec( pObj, pCut, vNodes );
-    // clean all nodes
-    Vec_PtrForEachEntry( vNodes, pObj, i )
-        pObj->fMarkC = 0;
-    // delete and return
-    Counter = Vec_PtrSize(vNodes);
-    Vec_PtrFree( vNodes );
-    return Counter;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns depth of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_NodeGetDepth_rec( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves )
-{
-    Abc_Obj_t * pLeaf;
-    int i, Depth0, Depth1;
-    if ( Abc_ObjIsCi(pObj) )
-        return 0;
-    Vec_PtrForEachEntry( vLeaves, pLeaf, i )
-        if ( pObj == Abc_ObjRegular(pLeaf) )
-            return 0;
-    Depth0 = Rwr_NodeGetDepth_rec( Abc_ObjFanin0(pObj), vLeaves );
-    Depth1 = Rwr_NodeGetDepth_rec( Abc_ObjFanin1(pObj), vLeaves );
-    return 1 + ABC_MAX( Depth0, Depth1 );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ScoresClean( Rwr_Man_t * p )
-{
-    Vec_Ptr_t * vSubgraphs;
-    Rwr_Node_t * pNode;
-    int i, k;
-    for ( i = 0; i < p->vClasses->nSize; i++ )
-    {
-        vSubgraphs = Vec_VecEntry( p->vClasses, i );
-        Vec_PtrForEachEntry( vSubgraphs, pNode, k )
-            pNode->nScore = pNode->nGain = pNode->nAdded = 0;
-    }
-}
-
-static int Gains[222];
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_ScoresCompare( int * pNum1, int * pNum2 )
-{
-    if ( Gains[*pNum1] > Gains[*pNum2] )
-        return -1;
-    if ( Gains[*pNum1] < Gains[*pNum2] )
-        return 1;
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ScoresReport( Rwr_Man_t * p )
-{
-    extern void Ivy_TruthDsdComputePrint( unsigned uTruth );
-    int Perm[222];
-    Vec_Ptr_t * vSubgraphs;
-    Rwr_Node_t * pNode;
-    int i, iNew, k;
-    unsigned uTruth;
-    // collect total gains
-    assert( p->vClasses->nSize == 222 );
-    for ( i = 0; i < p->vClasses->nSize; i++ )
-    {
-        Perm[i] = i;
-        Gains[i] = 0;
-        vSubgraphs = Vec_VecEntry( p->vClasses, i );
-        Vec_PtrForEachEntry( vSubgraphs, pNode, k )
-            Gains[i] += pNode->nGain;
-    }
-    // sort the gains
-    qsort( Perm, 222, sizeof(int), (int (*)(const void *, const void *))Rwr_ScoresCompare );
-
-    // print classes
-    for ( i = 0; i < p->vClasses->nSize; i++ )
-    {
-        iNew = Perm[i];
-        if ( Gains[iNew] == 0 )
-            break;
-        vSubgraphs = Vec_VecEntry( p->vClasses, iNew );
-        printf( "CLASS %3d: Subgr = %3d. Total gain = %6d.  ", iNew, Vec_PtrSize(vSubgraphs), Gains[iNew] );
-        uTruth = (unsigned)p->pMapInv[iNew];
-        Extra_PrintBinary( stdout, &uTruth, 16 );
-        printf( "  " );
-        Ivy_TruthDsdComputePrint( (unsigned)p->pMapInv[iNew] | ((unsigned)p->pMapInv[iNew] << 16) );
-        Vec_PtrForEachEntry( vSubgraphs, pNode, k )
-        {
-            if ( pNode->nScore == 0 )
-                continue;
-            printf( "    %2d: S=%5d. A=%5d. G=%6d. ", k, pNode->nScore, pNode->nAdded, pNode->nGain );
-            Dec_GraphPrint( stdout, (Dec_Graph_t *)pNode->pNext, NULL, NULL );
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/opt/rwr/rwrExp.c b/src/opt/rwr/rwrExp.c
deleted file mode 100644
index 2d00bb1c..00000000
--- a/src/opt/rwr/rwrExp.c
+++ /dev/null
@@ -1,333 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrExp.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [Computation of practically used NN-classes of 4-input cuts.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrExp.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Rwr_Man4_t_ Rwr_Man4_t;
-struct Rwr_Man4_t_
-{
-    // internal lookups
-    int                nFuncs;           // the number of four-var functions
-    unsigned short *   puCanons;         // canonical forms
-    int *              pnCounts;         // the counters of functions in each class
-    int                nConsidered;      // the number of nodes considered
-    int                nClasses;         // the number of NN classes
-};
-
-typedef struct Rwr_Man5_t_ Rwr_Man5_t;
-struct Rwr_Man5_t_
-{
-    // internal lookups
-    stmm_table *       tTableNN;         // the NN canonical forms
-    stmm_table *       tTableNPN;        // the NPN canonical forms
-};
-
-static Rwr_Man4_t * s_pManRwrExp4 = NULL;
-static Rwr_Man5_t * s_pManRwrExp5 = NULL;
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Collects stats about 4-var functions appearing in netlists.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwt_Man4ExploreStart()
-{
-    Rwr_Man4_t * p;
-    p = ALLOC( Rwr_Man4_t, 1 );
-    memset( p, 0, sizeof(Rwr_Man4_t) );
-    // canonical forms
-    p->nFuncs    = (1<<16);
-    // canonical forms, phases, perms
-    Extra_Truth4VarNPN( &p->puCanons, NULL, NULL, NULL );
-    // counters
-    p->pnCounts  = ALLOC( int, p->nFuncs );
-    memset( p->pnCounts, 0, sizeof(int) * p->nFuncs );
-    s_pManRwrExp4 = p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects stats about 4-var functions appearing in netlists.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwt_Man4ExploreCount( unsigned uTruth )
-{
-    assert( uTruth < (1<<16) );
-    s_pManRwrExp4->pnCounts[ s_pManRwrExp4->puCanons[uTruth] ]++;    
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects stats about 4-var functions appearing in netlists.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwt_Man4ExplorePrint()
-{
-    FILE * pFile;
-    int i, CountMax, CountWrite, nCuts, nClasses;
-    int * pDistrib;
-    int * pReprs;
-    // find the max number of occurences
-    nCuts = nClasses = 0;
-    CountMax = 0;
-    for ( i = 0; i < s_pManRwrExp4->nFuncs; i++ )
-    {
-        if ( CountMax < s_pManRwrExp4->pnCounts[i] )
-            CountMax = s_pManRwrExp4->pnCounts[i];
-        nCuts += s_pManRwrExp4->pnCounts[i];
-        if ( s_pManRwrExp4->pnCounts[i] > 0 )
-            nClasses++;
-    }
-    printf( "Number of cuts considered       = %8d.\n", nCuts );
-    printf( "Classes occurring at least once = %8d.\n", nClasses );
-    // print the distribution of classes
-    pDistrib = ALLOC( int, CountMax + 1 );
-    pReprs   = ALLOC( int, CountMax + 1 );
-    memset( pDistrib, 0, sizeof(int)*(CountMax + 1) );
-    for ( i = 0; i < s_pManRwrExp4->nFuncs; i++ )
-    {
-        pDistrib[ s_pManRwrExp4->pnCounts[i] ]++;
-        pReprs[ s_pManRwrExp4->pnCounts[i] ] = i;
-    }
-
-    printf( "Occurence = %6d.  Num classes = %4d.  \n", 0, 2288-nClasses );
-    for ( i = 1; i <= CountMax; i++ )
-        if ( pDistrib[i] )
-        {
-            printf( "Occurence = %6d.  Num classes = %4d.  Repr = ", i, pDistrib[i] );
-            Extra_PrintBinary( stdout, (unsigned*)&(pReprs[i]), 16 ); 
-            printf( "\n" );
-        }
-    free( pDistrib );
-    free( pReprs );
-    // write into a file all classes above limit (5)
-    CountWrite = 0;
-    pFile = fopen( "npnclass_stats4.txt", "w" );
-    for ( i = 0; i < s_pManRwrExp4->nFuncs; i++ )
-        if ( s_pManRwrExp4->pnCounts[i] > 0 )
-        {
-            Extra_PrintHex( pFile, i, 4 );
-            fprintf( pFile, " %10d\n", s_pManRwrExp4->pnCounts[i] );
-//            fprintf( pFile, "%d ", i );
-            CountWrite++;
-        }
-    fclose( pFile );
-    printf( "%d classes written into file \"%s\".\n", CountWrite, "npnclass_stats4.txt" );
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Collects stats about 4-var functions appearing in netlists.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwt_Man5ExploreStart()
-{
-    Rwr_Man5_t * p;
-    p = ALLOC( Rwr_Man5_t, 1 );
-    memset( p, 0, sizeof(Rwr_Man5_t) );
-    p->tTableNN  = stmm_init_table( st_numcmp, st_numhash );
-    p->tTableNPN = stmm_init_table( st_numcmp, st_numhash );
-    s_pManRwrExp5 = p;
-
-//Extra_PrintHex( stdout, Extra_TruthCanonNPN( 0x0000FFFF, 5 ), 5 );
-//printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects stats about 4-var functions appearing in netlists.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwt_Man5ExploreCount( unsigned uTruth )
-{
-    int * pCounter;
-    if ( !stmm_find_or_add( s_pManRwrExp5->tTableNN, (char *)uTruth, (char***)&pCounter ) )
-        *pCounter = 0;
-    (*pCounter)++;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects stats about 4-var functions appearing in netlists.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwt_Man5ExplorePrint()
-{
-    FILE * pFile;
-    stmm_generator * gen;
-    int i, CountMax, nCuts, Counter;
-    int * pDistrib;
-    unsigned * pReprs;
-    unsigned uTruth, uTruthC;
-    int clk = clock();
-    Vec_Int_t * vClassesNN, * vClassesNPN;
-
-    // find the max number of occurences
-    nCuts = 0;
-    CountMax = 0;
-    stmm_foreach_item( s_pManRwrExp5->tTableNN, gen, (char **)&uTruth, (char **)&Counter )
-    {
-        nCuts += Counter;
-        if ( CountMax < Counter )
-            CountMax = Counter;
-    }
-    printf( "Number of cuts considered       = %8d.\n", nCuts );
-    printf( "Classes occurring at least once = %8d.\n", stmm_count(s_pManRwrExp5->tTableNN) );
-    printf( "The largest number of occurence = %8d.\n", CountMax );
-
-    // print the distribution of classes
-    pDistrib = ALLOC( int, CountMax + 1 );
-    pReprs   = ALLOC( unsigned, CountMax + 1 );
-    memset( pDistrib, 0, sizeof(int)*(CountMax + 1) );
-    stmm_foreach_item( s_pManRwrExp5->tTableNN, gen, (char **)&uTruth, (char **)&Counter )
-    {
-        assert( Counter <= CountMax );
-        pDistrib[ Counter ]++;
-        pReprs[ Counter ] = uTruth;
-    }
-
-    for ( i = 1; i <= CountMax; i++ )
-        if ( pDistrib[i] )
-        {
-            printf( "Occurence = %6d.  Num classes = %4d.  Repr = ", i, pDistrib[i] );
-            Extra_PrintBinary( stdout, pReprs + i, 32 ); 
-            printf( "\n" );
-        }
-    free( pDistrib );
-    free( pReprs );
-
-
-    // put them into an array
-    vClassesNN = Vec_IntAlloc( stmm_count(s_pManRwrExp5->tTableNN) );
-    stmm_foreach_item( s_pManRwrExp5->tTableNN, gen, (char **)&uTruth, NULL )
-        Vec_IntPush( vClassesNN, (int)uTruth );
-    Vec_IntSortUnsigned( vClassesNN );
-
-    // write into a file all classes
-    pFile = fopen( "nnclass_stats5.txt", "w" );
-    Vec_IntForEachEntry( vClassesNN, uTruth, i )
-    {
-        if ( !stmm_lookup( s_pManRwrExp5->tTableNN, (char *)uTruth, (char **)&Counter ) )
-        {
-            assert( 0 );
-        }
-        Extra_PrintHex( pFile, uTruth, 5 );
-        fprintf( pFile, " %10d\n", Counter );
-    }
-    fclose( pFile );
-    printf( "%d classes written into file \"%s\".\n", vClassesNN->nSize, "nnclass_stats5.txt" );
-
-
-clk = clock();
-    // how many NPN classes exist?
-    Vec_IntForEachEntry( vClassesNN, uTruth, i )
-    {
-        int * pCounter;
-        uTruthC = Extra_TruthCanonNPN( uTruth, 5 );
-        if ( !stmm_find_or_add( s_pManRwrExp5->tTableNPN, (char *)uTruthC, (char***)&pCounter ) )
-            *pCounter = 0;
-        if ( !stmm_lookup( s_pManRwrExp5->tTableNN, (char *)uTruth, (char **)&Counter ) )
-        {
-            assert( 0 );
-        }
-        (*pCounter) += Counter;
-    }
-    printf( "The numbe of NPN classes = %d.\n", stmm_count(s_pManRwrExp5->tTableNPN) );
-PRT( "Computing NPN classes", clock() - clk );
-
-    // put them into an array
-    vClassesNPN = Vec_IntAlloc( stmm_count(s_pManRwrExp5->tTableNPN) );
-    stmm_foreach_item( s_pManRwrExp5->tTableNPN, gen, (char **)&uTruth, NULL )
-        Vec_IntPush( vClassesNPN, (int)uTruth );
-    Vec_IntSortUnsigned( vClassesNPN );
-
-    // write into a file all classes
-    pFile = fopen( "npnclass_stats5.txt", "w" );
-    Vec_IntForEachEntry( vClassesNPN, uTruth, i )
-    {
-        if ( !stmm_lookup( s_pManRwrExp5->tTableNPN, (char *)uTruth, (char **)&Counter ) )
-        {
-            assert( 0 );
-        }
-        Extra_PrintHex( pFile, uTruth, 5 );
-        fprintf( pFile, " %10d\n", Counter );
-    }
-    fclose( pFile );
-    printf( "%d classes written into file \"%s\".\n", vClassesNPN->nSize, "npnclass_stats5.txt" );
-
-
-    // can they be uniquely characterized?
-
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/opt/rwr/rwrLib.c b/src/opt/rwr/rwrLib.c
deleted file mode 100644
index 1cdf350e..00000000
--- a/src/opt/rwr/rwrLib.c
+++ /dev/null
@@ -1,362 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrLib.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    []
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrLib.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static Rwr_Node_t *        Rwr_ManTryNode( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Node_t * p1, int fExor, int Level, int Volume );
-static void                Rwr_MarkUsed_rec( Rwr_Man_t * p, Rwr_Node_t * pNode );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Precomputes the forest in the manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManPrecompute( Rwr_Man_t * p )
-{
-    Rwr_Node_t * p0, * p1;
-    int i, k, Level, Volume;
-    int LevelOld = -1;
-    int nNodes;
-
-    Vec_PtrForEachEntryStart( p->vForest, p0, i, 1 )
-    Vec_PtrForEachEntryStart( p->vForest, p1, k, 1 )
-    {
-        if ( LevelOld < (int)p0->Level )
-        {
-            LevelOld = p0->Level;
-            printf( "Starting level %d  (at %d nodes).\n", LevelOld+1, i );
-            printf( "Considered = %5d M.   Found = %8d.   Classes = %6d.   Trying %7d.\n", 
-                p->nConsidered/1000000, p->vForest->nSize, p->nClasses, i );
-        }
-
-        if ( k == i )
-            break;
-//        if ( p0->Level + p1->Level > 6 ) // hard
-//            break;
-
-        if ( p0->Level + p1->Level > 5 ) // easy 
-            break;
-
-//        if ( p0->Level + p1->Level > 6 || (p0->Level == 3 && p1->Level == 3) )
-//            break;
-
-        // compute the level and volume of the new nodes
-        Level  = 1 + ABC_MAX( p0->Level, p1->Level );
-        Volume = 1 + Rwr_ManNodeVolume( p, p0, p1 );
-        // try four different AND nodes
-        Rwr_ManTryNode( p,         p0 ,         p1 , 0, Level, Volume );
-        Rwr_ManTryNode( p, Rwr_Not(p0),         p1 , 0, Level, Volume );
-        Rwr_ManTryNode( p,         p0 , Rwr_Not(p1), 0, Level, Volume );
-        Rwr_ManTryNode( p, Rwr_Not(p0), Rwr_Not(p1), 0, Level, Volume );
-        // try EXOR
-        Rwr_ManTryNode( p,         p0 ,         p1 , 1, Level, Volume + 1 );
-        // report the progress
-        if ( p->nConsidered % 50000000 == 0 )
-            printf( "Considered = %5d M.   Found = %8d.   Classes = %6d.   Trying %7d.\n", 
-                p->nConsidered/1000000, p->vForest->nSize, p->nClasses, i );
-        // quit after some time
-        if ( p->vForest->nSize == RWR_LIMIT + 5 )
-        {
-            printf( "Considered = %5d M.   Found = %8d.   Classes = %6d.   Trying %7d.\n", 
-                p->nConsidered/1000000, p->vForest->nSize, p->nClasses, i );
-            goto save;
-        }
-    }
-save :
-
-    // mark the relevant ones
-    Rwr_ManIncTravId( p );
-    k = 5;
-    nNodes = 0;
-    Vec_PtrForEachEntryStart( p->vForest, p0, i, 5 )
-        if ( p0->uTruth == p->puCanons[p0->uTruth] )
-        {
-            Rwr_MarkUsed_rec( p, p0 );
-            nNodes++;
-        }
-
-    // compact the array by throwing away non-canonical
-    k = 5;
-    Vec_PtrForEachEntryStart( p->vForest, p0, i, 5 )
-        if ( p0->fUsed )
-        {
-            p->vForest->pArray[k] = p0;
-            p0->Id = k++;
-        }
-    p->vForest->nSize = k;
-    printf( "Total canonical = %4d. Total used = %5d.\n", nNodes, p->vForest->nSize );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Rwr_Node_t * Rwr_ManTryNode( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Node_t * p1, int fExor, int Level, int Volume )
-{
-    Rwr_Node_t * pOld, * pNew, ** ppPlace;
-    unsigned uTruth;
-    // compute truth table, level, volume
-    p->nConsidered++;
-    if ( fExor )
-    {
-//        printf( "Considering EXOR of %d and %d.\n", p0->Id, p1->Id );
-        uTruth = (p0->uTruth ^ p1->uTruth);
-    }
-    else
-        uTruth = (Rwr_IsComplement(p0)? ~Rwr_Regular(p0)->uTruth : Rwr_Regular(p0)->uTruth) & 
-                 (Rwr_IsComplement(p1)? ~Rwr_Regular(p1)->uTruth : Rwr_Regular(p1)->uTruth) & 0xFFFF;
-    // skip non-practical classes
-    if ( Level > 2 && !p->pPractical[p->puCanons[uTruth]] )
-        return NULL;
-    // enumerate through the nodes with the same canonical form
-    ppPlace = p->pTable + uTruth;
-    for ( pOld = *ppPlace; pOld; ppPlace = &pOld->pNext, pOld = pOld->pNext )
-    {
-        if ( pOld->Level <  (unsigned)Level && pOld->Volume < (unsigned)Volume )
-            return NULL;
-        if ( pOld->Level == (unsigned)Level && pOld->Volume < (unsigned)Volume )
-            return NULL;
-//        if ( pOld->Level <  (unsigned)Level && pOld->Volume == (unsigned)Volume )
-//            return NULL;
-    }
-/*
-    // enumerate through the nodes with the opposite polarity
-    for ( pOld = p->pTable[~uTruth & 0xFFFF]; pOld; pOld = pOld->pNext )
-    {
-        if ( pOld->Level <  (unsigned)Level && pOld->Volume < (unsigned)Volume )
-            return NULL;
-        if ( pOld->Level == (unsigned)Level && pOld->Volume < (unsigned)Volume )
-            return NULL;
-//        if ( pOld->Level <  (unsigned)Level && pOld->Volume == (unsigned)Volume )
-//            return NULL;
-    }
-*/
-    // count the classes
-    if ( p->pTable[uTruth] == NULL && p->puCanons[uTruth] == uTruth )
-        p->nClasses++;
-    // create the new node
-    pNew = (Rwr_Node_t *)Extra_MmFixedEntryFetch( p->pMmNode );
-    pNew->Id     = p->vForest->nSize;
-    pNew->TravId = 0;
-    pNew->uTruth = uTruth;
-    pNew->Level  = Level;
-    pNew->Volume = Volume;
-    pNew->fUsed  = 0;
-    pNew->fExor  = fExor;
-    pNew->p0     = p0;
-    pNew->p1     = p1;
-    pNew->pNext  = NULL;
-    Vec_PtrPush( p->vForest, pNew );
-    *ppPlace     = pNew;
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Rwr_Node_t * Rwr_ManAddNode( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Node_t * p1, int fExor, int Level, int Volume )
-{
-    Rwr_Node_t * pNew;
-    unsigned uTruth;
-    // compute truth table, leve, volume
-    p->nConsidered++;
-    if ( fExor )
-        uTruth = (p0->uTruth ^ p1->uTruth);
-    else
-        uTruth = (Rwr_IsComplement(p0)? ~Rwr_Regular(p0)->uTruth : Rwr_Regular(p0)->uTruth) & 
-                 (Rwr_IsComplement(p1)? ~Rwr_Regular(p1)->uTruth : Rwr_Regular(p1)->uTruth) & 0xFFFF;
-    // create the new node
-    pNew = (Rwr_Node_t *)Extra_MmFixedEntryFetch( p->pMmNode );
-    pNew->Id     = p->vForest->nSize;
-    pNew->TravId = 0;
-    pNew->uTruth = uTruth;
-    pNew->Level  = Level;
-    pNew->Volume = Volume;
-    pNew->fUsed  = 0;
-    pNew->fExor  = fExor;
-    pNew->p0     = p0;
-    pNew->p1     = p1;
-    pNew->pNext  = NULL;
-    Vec_PtrPush( p->vForest, pNew );
-    // do not add if the node is not essential
-    if ( uTruth != p->puCanons[uTruth] )
-        return pNew;
-
-    // add to the list
-    p->nAdded++;
-    if ( p->pTable[uTruth] == NULL )
-        p->nClasses++;
-    Rwr_ListAddToTail( p->pTable + uTruth, pNew );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Rwr_Node_t * Rwr_ManAddVar( Rwr_Man_t * p, unsigned uTruth, int fPrecompute )
-{
-    Rwr_Node_t * pNew;
-    pNew = (Rwr_Node_t *)Extra_MmFixedEntryFetch( p->pMmNode );
-    pNew->Id     = p->vForest->nSize;
-    pNew->TravId = 0;
-    pNew->uTruth = uTruth;
-    pNew->Level  = 0;
-    pNew->Volume = 0;
-    pNew->fUsed  = 1;
-    pNew->fExor  = 0;
-    pNew->p0     = NULL;
-    pNew->p1     = NULL;    
-    pNew->pNext  = NULL;
-    Vec_PtrPush( p->vForest, pNew );
-    if ( fPrecompute )
-        Rwr_ListAddToTail( p->pTable + uTruth, pNew );
-    return pNew;
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_MarkUsed_rec( Rwr_Man_t * p, Rwr_Node_t * pNode )
-{
-    if ( pNode->fUsed || pNode->TravId == p->nTravIds )
-        return;
-    pNode->TravId = p->nTravIds;
-    pNode->fUsed = 1;
-    Rwr_MarkUsed_rec( p, Rwr_Regular(pNode->p0) );
-    Rwr_MarkUsed_rec( p, Rwr_Regular(pNode->p1) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_Trav_rec( Rwr_Man_t * p, Rwr_Node_t * pNode, int * pVolume )
-{
-    if ( pNode->fUsed || pNode->TravId == p->nTravIds )
-        return;
-    pNode->TravId = p->nTravIds;
-    (*pVolume)++;
-    if ( pNode->fExor )
-        (*pVolume)++;
-    Rwr_Trav_rec( p, Rwr_Regular(pNode->p0), pVolume );
-    Rwr_Trav_rec( p, Rwr_Regular(pNode->p1), pVolume );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_ManNodeVolume( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Node_t * p1 )
-{
-    int Volume = 0;
-    Rwr_ManIncTravId( p );
-    Rwr_Trav_rec( p, p0, &Volume );
-    Rwr_Trav_rec( p, p1, &Volume );
-    return Volume;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManIncTravId( Rwr_Man_t * p )
-{
-    Rwr_Node_t * pNode;
-    int i;
-    if ( p->nTravIds++ < 0x8FFFFFFF )
-        return;
-    Vec_PtrForEachEntry( p->vForest, pNode, i )
-        pNode->TravId = 0;
-    p->nTravIds = 1;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/opt/rwr/rwrMan.c b/src/opt/rwr/rwrMan.c
deleted file mode 100644
index 87a080c7..00000000
--- a/src/opt/rwr/rwrMan.c
+++ /dev/null
@@ -1,318 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrMan.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [Rewriting manager.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrMan.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-#include "main.h"
-#include "dec.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Starts rewriting manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Rwr_Man_t * Rwr_ManStart( bool fPrecompute )
-{
-    Dec_Man_t * pManDec;
-    Rwr_Man_t * p;
-    int clk = clock();
-clk = clock();
-    p = ALLOC( Rwr_Man_t, 1 );
-    memset( p, 0, sizeof(Rwr_Man_t) );
-    p->nFuncs = (1<<16);
-    pManDec   = Abc_FrameReadManDec();
-    p->puCanons = pManDec->puCanons; 
-    p->pPhases  = pManDec->pPhases; 
-    p->pPerms   = pManDec->pPerms; 
-    p->pMap     = pManDec->pMap; 
-    // initialize practical NPN classes
-    p->pPractical  = Rwr_ManGetPractical( p );
-    // create the table
-    p->pTable = ALLOC( Rwr_Node_t *, p->nFuncs );
-    memset( p->pTable, 0, sizeof(Rwr_Node_t *) * p->nFuncs );
-    // create the elementary nodes
-    p->pMmNode  = Extra_MmFixedStart( sizeof(Rwr_Node_t) );
-    p->vForest  = Vec_PtrAlloc( 100 );
-    Rwr_ManAddVar( p, 0x0000, fPrecompute ); // constant 0
-    Rwr_ManAddVar( p, 0xAAAA, fPrecompute ); // var A
-    Rwr_ManAddVar( p, 0xCCCC, fPrecompute ); // var B
-    Rwr_ManAddVar( p, 0xF0F0, fPrecompute ); // var C
-    Rwr_ManAddVar( p, 0xFF00, fPrecompute ); // var D
-    p->nClasses = 5;
-    // other stuff
-    p->nTravIds   = 1;
-    p->pPerms4    = Extra_Permutations( 4 );
-    p->vLevNums   = Vec_IntAlloc( 50 );
-    p->vFanins    = Vec_PtrAlloc( 50 );
-    p->vFaninsCur = Vec_PtrAlloc( 50 );
-    p->vNodesTemp = Vec_PtrAlloc( 50 );
-    if ( fPrecompute )
-    {   // precompute subgraphs
-        Rwr_ManPrecompute( p );
-//        Rwr_ManPrint( p );
-        Rwr_ManWriteToArray( p );
-    }
-    else
-    {   // load saved subgraphs
-        Rwr_ManLoadFromArray( p, 0 );
-//        Rwr_ManPrint( p );
-        Rwr_ManPreprocess( p );
-    }
-p->timeStart = clock() - clk;
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops rewriting manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManStop( Rwr_Man_t * p )
-{
-    if ( p->vClasses )
-    {
-        Rwr_Node_t * pNode;
-        int i, k;
-        Vec_VecForEachEntry( p->vClasses, pNode, i, k )
-            Dec_GraphFree( (Dec_Graph_t *)pNode->pNext );
-    }
-    if ( p->vClasses )  Vec_VecFree( p->vClasses );
-    Vec_PtrFree( p->vNodesTemp );
-    Vec_PtrFree( p->vForest );
-    Vec_IntFree( p->vLevNums );
-    Vec_PtrFree( p->vFanins );
-    Vec_PtrFree( p->vFaninsCur );
-    Extra_MmFixedStop( p->pMmNode );
-    FREE( p->pMapInv );
-    free( p->pTable );
-    free( p->pPractical );
-    free( p->pPerms4 );
-    free( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManPrintStats( Rwr_Man_t * p )
-{
-    int i, Counter = 0;
-    for ( i = 0; i < 222; i++ )
-        Counter += (p->nScores[i] > 0);
-
-    printf( "Rewriting statistics:\n" );
-    printf( "Total cuts tries  = %8d.\n", p->nCutsGood );
-    printf( "Bad cuts found    = %8d.\n", p->nCutsBad );
-    printf( "Total subgraphs   = %8d.\n", p->nSubgraphs );
-    printf( "Used NPN classes  = %8d.\n", Counter );
-    printf( "Nodes considered  = %8d.\n", p->nNodesConsidered );
-    printf( "Nodes rewritten   = %8d.\n", p->nNodesRewritten );
-    printf( "Gain              = %8d. (%6.2f %%).\n", p->nNodesBeg-p->nNodesEnd, 100.0*(p->nNodesBeg-p->nNodesEnd)/p->nNodesBeg );
-    PRT( "Start       ", p->timeStart );
-    PRT( "Cuts        ", p->timeCut );
-    PRT( "Resynthesis ", p->timeRes );
-    PRT( "    Mffc    ", p->timeMffc );
-    PRT( "    Eval    ", p->timeEval );
-    PRT( "Update      ", p->timeUpdate );
-    PRT( "TOTAL       ", p->timeTotal );
-
-/*
-    printf( "The scores are:\n" );
-    for ( i = 0; i < 222; i++ )
-        if ( p->nScores[i] > 0 )
-        {
-            extern void Ivy_TruthDsdComputePrint( unsigned uTruth );
-            printf( "%3d = %8d  canon = %5d  ", i, p->nScores[i], p->pMapInv[i] );
-            Ivy_TruthDsdComputePrint( (unsigned)p->pMapInv[i] | ((unsigned)p->pMapInv[i] << 16) );
-        }
-*/
-    printf( "\n" );
-
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManPrintStatsFile( Rwr_Man_t * p )
-{
-    FILE * pTable;
-    pTable = fopen( "stats.txt", "a+" );
-    fprintf( pTable, "%d ", p->nCutsGood );
-    fprintf( pTable, "%d ", p->nSubgraphs );
-    fprintf( pTable, "%d ", p->nNodesRewritten );
-    fprintf( pTable, "%d", p->nNodesGained );
-    fprintf( pTable, "\n" );
-    fclose( pTable );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void * Rwr_ManReadDecs( Rwr_Man_t * p )
-{
-    return p->pGraph;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Rwr_ManReadLeaves( Rwr_Man_t * p )
-{
-    return p->vFanins;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_ManReadCompl( Rwr_Man_t * p )
-{
-    return p->fCompl;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManAddTimeCuts( Rwr_Man_t * p, int Time )
-{
-    p->timeCut += Time;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManAddTimeUpdate( Rwr_Man_t * p, int Time )
-{
-    p->timeUpdate += Time;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the resynthesis manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManAddTimeTotal( Rwr_Man_t * p, int Time )
-{
-    p->timeTotal += Time;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Precomputes AIG subgraphs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_Precompute()
-{
-    Rwr_Man_t * p;
-    p = Rwr_ManStart( 1 );
-    Rwr_ManStop( p );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/opt/rwr/rwrPrint.c b/src/opt/rwr/rwrPrint.c
deleted file mode 100644
index 82ad2a90..00000000
--- a/src/opt/rwr/rwrPrint.c
+++ /dev/null
@@ -1,266 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrCut.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [Cut computation.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrCut.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
- 
-/**Function*************************************************************
-
-  Synopsis    [Adds one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_Trav2_rec( Rwr_Man_t * p, Rwr_Node_t * pNode, int * pVolume )
-{
-    if ( pNode->fUsed || pNode->TravId == p->nTravIds )
-        return;
-    pNode->TravId = p->nTravIds;
-    (*pVolume)++;
-    Rwr_Trav2_rec( p, Rwr_Regular(pNode->p0), pVolume );
-    Rwr_Trav2_rec( p, Rwr_Regular(pNode->p1), pVolume );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds the node to the end of the list.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_GetBushVolume( Rwr_Man_t * p, int Entry, int * pVolume, int * pnFuncs )
-{
-    Rwr_Node_t * pNode;
-    int Volume = 0;
-    int nFuncs = 0;
-    Rwr_ManIncTravId( p );
-    for ( pNode = p->pTable[Entry]; pNode; pNode = pNode->pNext )
-    {
-        if ( pNode->uTruth != p->puCanons[pNode->uTruth] )
-            continue;
-        nFuncs++;
-        Rwr_Trav2_rec( p, pNode, &Volume );
-    }
-    *pVolume = Volume;
-    *pnFuncs = nFuncs;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds the node to the end of the list.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_GetBushSumOfVolumes( Rwr_Man_t * p, int Entry )
-{
-    Rwr_Node_t * pNode;
-    int Volume, VolumeTotal = 0;
-    for ( pNode = p->pTable[Entry]; pNode; pNode = pNode->pNext )
-    {
-        if ( pNode->uTruth != p->puCanons[pNode->uTruth] )
-            continue;
-        Volume = 0;
-        Rwr_ManIncTravId( p );
-        Rwr_Trav2_rec( p, pNode, &Volume );
-        VolumeTotal += Volume;
-    }
-    return VolumeTotal;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints one rwr node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_NodePrint_rec( FILE * pFile, Rwr_Node_t * pNode )
-{
-    assert( !Rwr_IsComplement(pNode) );
-
-    if ( pNode->Id == 0 )
-    {
-        fprintf( pFile, "Const1" );
-        return;
-    }
-
-    if ( pNode->Id < 5 )
-    {
-        fprintf( pFile, "%c", 'a' + pNode->Id - 1 );
-        return;
-    }
-
-    if ( Rwr_IsComplement(pNode->p0) )
-    {
-        if ( Rwr_Regular(pNode->p0)->Id < 5 )
-        {
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p0) );
-            fprintf( pFile, "\'" );
-        }
-        else
-        {
-            fprintf( pFile, "(" );
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p0) );
-            fprintf( pFile, ")\'" );
-        }
-    }
-    else
-    {
-        if ( Rwr_Regular(pNode->p0)->Id < 5 )
-        {
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p0) );
-        }
-        else
-        {
-            fprintf( pFile, "(" );
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p0) );
-            fprintf( pFile, ")" );
-        }
-    }
-
-    if ( pNode->fExor )
-        fprintf( pFile, "+" );
-
-    if ( Rwr_IsComplement(pNode->p1) )
-    {
-        if ( Rwr_Regular(pNode->p1)->Id < 5 )
-        {
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p1) );
-            fprintf( pFile, "\'" );
-        }
-        else
-        {
-            fprintf( pFile, "(" );
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p1) );
-            fprintf( pFile, ")\'" );
-        }
-    }
-    else
-    {
-        if ( Rwr_Regular(pNode->p1)->Id < 5 )
-        {
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p1) );
-        }
-        else
-        {
-            fprintf( pFile, "(" );
-            Rwr_NodePrint_rec( pFile, Rwr_Regular(pNode->p1) );
-            fprintf( pFile, ")" );
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints one rwr node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_NodePrint( FILE * pFile, Rwr_Man_t * p, Rwr_Node_t * pNode )
-{
-    unsigned uTruth;
-    fprintf( pFile, "%5d : ", pNode->Id );
-    Extra_PrintHex( pFile, pNode->uTruth, 4 );
-    fprintf( pFile, " tt=" );
-    uTruth = pNode->uTruth;
-    Extra_PrintBinary( pFile, &uTruth, 16 );
-//    fprintf( pFile, " cn=", pNode->Id );
-//    uTruth = p->puCanons[pNode->uTruth];
-//    Extra_PrintBinary( pFile, &uTruth, 16 );
-    fprintf( pFile, " lev=%d", pNode->Level );
-    fprintf( pFile, " vol=%d", pNode->Volume );
-    fprintf( pFile, "  " );
-    Rwr_NodePrint_rec( pFile, pNode );
-    fprintf( pFile, "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints one rwr node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManPrint( Rwr_Man_t * p )
-{
-    FILE * pFile;
-    Rwr_Node_t * pNode;
-    unsigned uTruth;
-    int Limit, Counter, Volume, nFuncs, i;
-    pFile = fopen( "graph_lib.txt", "w" );
-    Counter = 0;
-    Limit = (1 << 16);
-    for ( i = 0; i < Limit; i++ )
-    {
-        if ( p->pTable[i] == NULL )
-            continue;
-        if ( i != p->puCanons[i] )
-            continue;
-        fprintf( pFile, "\nClass %3d. Func %6d.  ", p->pMap[i], Counter++ );
-        Rwr_GetBushVolume( p, i, &Volume, &nFuncs );
-        fprintf( pFile, "Roots = %3d. Vol = %3d. Sum = %3d.  ", nFuncs, Volume, Rwr_GetBushSumOfVolumes(p, i) );
-        uTruth = i;
-        Extra_PrintBinary( pFile, &uTruth, 16 );
-        fprintf( pFile, "\n" );
-        for ( pNode = p->pTable[i]; pNode; pNode = pNode->pNext )
-            if ( pNode->uTruth == p->puCanons[pNode->uTruth] )
-                Rwr_NodePrint( pFile, p, pNode );
-    }
-    fclose( pFile );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/opt/rwr/rwrTemp.c b/src/opt/rwr/rwrTemp.c
deleted file mode 100644
index 3ffbd408..00000000
--- a/src/opt/rwr/rwrTemp.c
+++ /dev/null
@@ -1,121 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrCut.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [Cut computation.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrCut.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static int pTruths[13719];
-static int pFreqs[13719];
-static int pPerm[13719];
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
- 
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Rwr_TempCompare( int * pNum1, int * pNum2 )
-{
-    int Freq1 = pFreqs[*pNum1];
-    int Freq2 = pFreqs[*pNum2];
-    if ( Freq1 < Freq2 )
-        return 1;
-    if ( Freq1 > Freq2 )
-        return -1;
-    return 0; 
-}
- 
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_Temp()
-{
-    char Buffer[32];
-    int nFuncs = 13719;
-    int nEntries = 100;
-    unsigned uTruth;
-    int i, k;
-    FILE * pFile;
-
-    pFile = fopen( "nnclass_stats5.txt", "r" );
-    for ( i = 0; i < 13719; i++ )
-    {
-        fscanf( pFile, "%s%d", Buffer, &pFreqs[i] );
-        Extra_ReadHexadecimal( &uTruth, Buffer+2, 5 );
-        pTruths[i] = uTruth;
-    }
-    fclose( pFile );
-
-    for ( i = 0; i < 13719; i++ )
-        pPerm[i] = i;
-
-    qsort( (void *)pPerm, 13719, sizeof(int), 
-            (int (*)(const void *, const void *)) Rwr_TempCompare );
-
-
-    pFile = fopen( "5npn_100.blif", "w" );
-    fprintf( pFile, "# Most frequent NPN classes of 5 vars.\n" );
-    fprintf( pFile, ".model 5npn\n" );
-    fprintf( pFile, ".inputs a b c d e\n" );
-    fprintf( pFile, ".outputs" );
-    for ( i = 0; i < nEntries; i++ )
-        fprintf( pFile, " %02d", i );
-    fprintf( pFile, "\n" );
-
-    for ( i = 0; i < nEntries; i++ )
-    {
-        fprintf( pFile, ".names a b c d e %02d\n", i );
-        uTruth = pTruths[pPerm[i]];
-        for ( k = 0; k < 32; k++ )
-            if ( uTruth & (1 << k) )
-            {
-                Extra_PrintBinary( pFile, &k, 5 );
-                fprintf( pFile, " 1\n" );
-            }
-    }
-    fprintf( pFile, ".end\n" );
-    fclose( pFile );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/opt/rwr/rwrUtil.c b/src/opt/rwr/rwrUtil.c
deleted file mode 100644
index b2add2bf..00000000
--- a/src/opt/rwr/rwrUtil.c
+++ /dev/null
@@ -1,659 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [rwrUtil.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [DAG-aware AIG rewriting package.]
-
-  Synopsis    [Various utilities.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: rwrUtil.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "rwr.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-// precomputed data
-#ifdef _WIN32
-unsigned short s_RwrPracticalClasses[];
-unsigned short s_RwtAigSubgraphs[];
-#else
-static unsigned short s_RwrPracticalClasses[];
-static unsigned short s_RwtAigSubgraphs[];
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Writes data.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManWriteToArray( Rwr_Man_t * p )
-{
-    FILE * pFile;
-    Rwr_Node_t * pNode;
-    unsigned Entry0, Entry1;
-    int i, nEntries, clk = clock();
-    // prepare the buffer
-    nEntries = p->vForest->nSize - 5;
-    pFile = fopen( "npn4_aig_array.txt", "w" );
-    fprintf( pFile, "static unsigned short s_RwtAigSubgraphs[] = \n{" );
-    for ( i = 0; i < nEntries; i++ )
-    {
-        if ( i % 5 == 0 )
-            fprintf( pFile, "\n    " );
-        pNode = p->vForest->pArray[i+5];
-        Entry0 = (Rwr_Regular(pNode->p0)->Id << 1) | Rwr_IsComplement(pNode->p0);
-        Entry1 = (Rwr_Regular(pNode->p1)->Id << 1) | Rwr_IsComplement(pNode->p1);
-        Entry0 = (Entry0 << 1) | pNode->fExor;
-        Extra_PrintHex( pFile, Entry0, 4 );
-        fprintf( pFile, "," );
-        Extra_PrintHex( pFile, Entry1, 4 );
-        fprintf( pFile, ", " );
-    }
-    if ( i % 5 == 0 )
-        fprintf( pFile, "\n    " );
-    Extra_PrintHex( pFile, 0, 4 );
-    fprintf( pFile, "," );
-    Extra_PrintHex( pFile, 0, 4 );
-    fprintf( pFile, " \n};\n" );
-    fclose( pFile );
-    printf( "The number of nodes saved = %d.   ", nEntries );  PRT( "Saving", clock() - clk );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Loads data.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManLoadFromArray( Rwr_Man_t * p, int fVerbose )
-{
-    unsigned short * pArray = s_RwtAigSubgraphs;
-    Rwr_Node_t * p0, * p1;
-    unsigned Entry0, Entry1;
-    int Level, Volume, nEntries, fExor;
-    int i, clk = clock();
-
-    // reconstruct the forest
-    for ( i = 0; ; i++ )
-    {
-        Entry0 = pArray[2*i + 0];
-        Entry1 = pArray[2*i + 1];
-        if ( Entry0 == 0 && Entry1 == 0 )
-            break;
-        // get EXOR flag
-        fExor = (Entry0 & 1);
-        Entry0 >>= 1;
-        // get the nodes
-        p0 = p->vForest->pArray[Entry0 >> 1];
-        p1 = p->vForest->pArray[Entry1 >> 1];
-        // compute the level and volume of the new nodes
-        Level  = 1 + ABC_MAX( p0->Level, p1->Level );
-        Volume = 1 + Rwr_ManNodeVolume( p, p0, p1 );
-        // set the complemented attributes
-        p0 = Rwr_NotCond( p0, (Entry0 & 1) );
-        p1 = Rwr_NotCond( p1, (Entry1 & 1) );
-        // add the node
-//        Rwr_ManTryNode( p, p0, p1, Level, Volume );
-        Rwr_ManAddNode( p, p0, p1, fExor, Level, Volume + fExor );
-    }
-    nEntries = i - 1;
-    if ( fVerbose )
-    {
-        printf( "The number of classes = %d. Canonical nodes = %d.\n", p->nClasses, p->nAdded );
-        printf( "The number of nodes loaded = %d.  ", nEntries );  PRT( "Loading", clock() - clk );
-    }
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Writes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManWriteToFile( Rwr_Man_t * p, char * pFileName )
-{
-    FILE * pFile;
-    Rwr_Node_t * pNode;
-    unsigned * pBuffer;
-    int i, nEntries, clk = clock();
-    // prepare the buffer
-    nEntries = p->vForest->nSize - 5;
-    pBuffer = ALLOC( unsigned, nEntries * 2 );
-    for ( i = 0; i < nEntries; i++ )
-    {
-        pNode = p->vForest->pArray[i+5];
-        pBuffer[2*i + 0] = (Rwr_Regular(pNode->p0)->Id << 1) | Rwr_IsComplement(pNode->p0);
-        pBuffer[2*i + 1] = (Rwr_Regular(pNode->p1)->Id << 1) | Rwr_IsComplement(pNode->p1);
-        // save EXOR flag
-        pBuffer[2*i + 0] = (pBuffer[2*i + 0] << 1) | pNode->fExor;
-
-    }
-    pFile = fopen( pFileName, "wb" );
-    fwrite( &nEntries, sizeof(int), 1, pFile );
-    fwrite( pBuffer, sizeof(unsigned), nEntries * 2, pFile );
-    free( pBuffer );
-    fclose( pFile );
-    printf( "The number of nodes saved = %d.   ", nEntries );  PRT( "Saving", clock() - clk );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Loads data.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ManLoadFromFile( Rwr_Man_t * p, char * pFileName )
-{
-    FILE * pFile;
-    Rwr_Node_t * p0, * p1;
-    unsigned * pBuffer;
-    int Level, Volume, nEntries, fExor;
-    int i, clk = clock();
-
-    // load the data
-    pFile = fopen( pFileName, "rb" );
-    if ( pFile == NULL )
-    {
-        printf( "Rwr_ManLoadFromFile: Cannot open file \"%s\".\n", pFileName );
-        return;
-    }
-    fread( &nEntries, sizeof(int), 1, pFile );
-    pBuffer = ALLOC( unsigned, nEntries * 2 );
-    fread( pBuffer, sizeof(unsigned), nEntries * 2, pFile );
-    fclose( pFile );
-    // reconstruct the forest
-    for ( i = 0; i < nEntries; i++ )
-    {
-        // get EXOR flag
-        fExor = (pBuffer[2*i + 0] & 1);
-        pBuffer[2*i + 0] = (pBuffer[2*i + 0] >> 1);
-        // get the nodes
-        p0 = p->vForest->pArray[pBuffer[2*i + 0] >> 1];
-        p1 = p->vForest->pArray[pBuffer[2*i + 1] >> 1];
-        // compute the level and volume of the new nodes
-        Level  = 1 + ABC_MAX( p0->Level, p1->Level );
-        Volume = 1 + Rwr_ManNodeVolume( p, p0, p1 );
-        // set the complemented attributes
-        p0 = Rwr_NotCond( p0, (pBuffer[2*i + 0] & 1) );
-        p1 = Rwr_NotCond( p1, (pBuffer[2*i + 1] & 1) );
-        // add the node
-//        Rwr_ManTryNode( p, p0, p1, Level, Volume );
-        Rwr_ManAddNode( p, p0, p1, fExor, Level, Volume + fExor );
-    }
-    free( pBuffer );
-    printf( "The number of classes = %d. Canonical nodes = %d.\n", p->nClasses, p->nAdded );
-    printf( "The number of nodes loaded = %d.   ", nEntries );  PRT( "Loading", clock() - clk );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Adds the node to the end of the list.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Rwr_ListAddToTail( Rwr_Node_t ** ppList, Rwr_Node_t * pNode )
-{
-    Rwr_Node_t * pTemp;
-    // find the last one
-    for ( pTemp = *ppList; pTemp; pTemp = pTemp->pNext )
-        ppList = &pTemp->pNext;
-    // attach at the end
-    *ppList = pNode;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Create practical classes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char * Rwr_ManGetPractical( Rwr_Man_t * p )
-{
-    char * pPractical;
-    int i;
-    pPractical = ALLOC( char, p->nFuncs );
-    memset( pPractical, 0, sizeof(char) * p->nFuncs );
-    pPractical[0] = 1;
-    for ( i = 1; ; i++ )
-    {
-        if ( s_RwrPracticalClasses[i] == 0 )
-            break;
-        pPractical[ s_RwrPracticalClasses[i] ] = 1;
-    }
-    return pPractical;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-// the following 135 practical NPN classes of 4-variable functions were computed
-// by considering all 4-input cuts appearing in IWLS, MCNC, and ISCAS benchmarks
-static unsigned short s_RwrPracticalClasses[] = 
-{
-    0x0000, 0x0001, 0x0003, 0x0006, 0x0007, 0x000f, 0x0016, 0x0017, 0x0018, 0x0019, 0x001b, 
-    0x001e, 0x001f, 0x003c, 0x003d, 0x003f, 0x0069, 0x006b, 0x006f, 0x007e, 0x007f, 0x00ff, 
-    0x0116, 0x0118, 0x0119, 0x011a, 0x011b, 0x011e, 0x011f, 0x012c, 0x012d, 0x012f, 0x013c, 
-    0x013d, 0x013e, 0x013f, 0x0168, 0x0169, 0x016f, 0x017f, 0x0180, 0x0181, 0x0182, 0x0183, 
-    0x0186, 0x0189, 0x018b, 0x018f, 0x0198, 0x0199, 0x019b, 0x01a8, 0x01a9, 0x01aa, 0x01ab, 
-    0x01ac, 0x01ad, 0x01ae, 0x01af, 0x01bf, 0x01e9, 0x01ea, 0x01eb, 0x01ee, 0x01ef, 0x01fe, 
-    0x033c, 0x033d, 0x033f, 0x0356, 0x0357, 0x0358, 0x0359, 0x035a, 0x035b, 0x035f, 0x0368, 
-    0x0369, 0x036c, 0x036e, 0x037d, 0x03c0, 0x03c1, 0x03c3, 0x03c7, 0x03cf, 0x03d4, 0x03d5, 
-    0x03d7, 0x03d8, 0x03d9, 0x03dc, 0x03dd, 0x03de, 0x03fc, 0x0660, 0x0661, 0x0666, 0x0669, 
-    0x066f, 0x0676, 0x067e, 0x0690, 0x0696, 0x0697, 0x069f, 0x06b1, 0x06b6, 0x06f0, 0x06f2, 
-    0x06f6, 0x06f9, 0x0776, 0x0778, 0x07b0, 0x07b1, 0x07b4, 0x07bc, 0x07f0, 0x07f2, 0x07f8, 
-    0x0ff0, 0x1683, 0x1696, 0x1698, 0x169e, 0x16e9, 0x178e, 0x17e8, 0x18e7, 0x19e6, 0x1be4, 
-    0x1ee1, 0x3cc3, 0x6996, 0x0000
-};
-
-static unsigned short s_RwtAigSubgraphs[] = 
-{
-    0x0008,0x0002, 0x000a,0x0002, 0x0008,0x0003, 0x000a,0x0003, 0x0009,0x0002, 
-    0x000c,0x0002, 0x000e,0x0002, 0x000c,0x0003, 0x000e,0x0003, 0x000d,0x0002, 
-    0x000c,0x0004, 0x000e,0x0004, 0x000c,0x0005, 0x000e,0x0005, 0x000d,0x0004, 
-    0x0010,0x0002, 0x0012,0x0002, 0x0010,0x0003, 0x0012,0x0003, 0x0011,0x0002, 
-    0x0010,0x0004, 0x0012,0x0004, 0x0010,0x0005, 0x0012,0x0005, 0x0011,0x0004, 
-    0x0010,0x0006, 0x0012,0x0006, 0x0010,0x0007, 0x0012,0x0007, 0x0011,0x0006, 
-    0x0016,0x0005, 0x0014,0x0006, 0x0016,0x0006, 0x0014,0x0007, 0x0016,0x0007, 
-    0x0015,0x0006, 0x0014,0x0008, 0x0016,0x0008, 0x0014,0x0009, 0x0016,0x0009, 
-    0x0015,0x0008, 0x0018,0x0006, 0x001a,0x0006, 0x0018,0x0007, 0x001a,0x0007, 
-    0x0019,0x0006, 0x0018,0x0009, 0x001a,0x0009, 0x0019,0x0008, 0x001e,0x0005, 
-    0x001c,0x0006, 0x001e,0x0006, 0x001c,0x0007, 0x001e,0x0007, 0x001d,0x0006, 
-    0x001c,0x0008, 0x001e,0x0008, 0x001c,0x0009, 0x001e,0x0009, 0x001d,0x0008, 
-    0x0020,0x0006, 0x0022,0x0006, 0x0020,0x0007, 0x0022,0x0007, 0x0021,0x0006, 
-    0x0020,0x0008, 0x0022,0x0008, 0x0020,0x0009, 0x0022,0x0009, 0x0021,0x0008, 
-    0x0024,0x0006, 0x0026,0x0006, 0x0024,0x0007, 0x0026,0x0007, 0x0025,0x0006, 
-    0x0026,0x0008, 0x0024,0x0009, 0x0026,0x0009, 0x0025,0x0008, 0x0028,0x0004, 
-    0x002a,0x0004, 0x0028,0x0005, 0x002a,0x0007, 0x0028,0x0008, 0x002a,0x0009, 
-    0x0029,0x0008, 0x002a,0x000b, 0x0029,0x000a, 0x002a,0x000f, 0x0029,0x000e, 
-    0x002a,0x0011, 0x002a,0x0013, 0x002c,0x0004, 0x002e,0x0004, 0x002c,0x0005, 
-    0x002c,0x0009, 0x002e,0x0009, 0x002d,0x0008, 0x002d,0x000c, 0x002e,0x000f, 
-    0x002e,0x0011, 0x002e,0x0012, 0x0030,0x0004, 0x0032,0x0007, 0x0032,0x0009, 
-    0x0031,0x0008, 0x0032,0x000b, 0x0032,0x000d, 0x0032,0x000f, 0x0031,0x000e, 
-    0x0032,0x0013, 0x0034,0x0004, 0x0036,0x0004, 0x0034,0x0005, 0x0036,0x0005, 
-    0x0035,0x0004, 0x0036,0x0008, 0x0034,0x0009, 0x0036,0x0009, 0x0035,0x0008, 
-    0x0036,0x000b, 0x0036,0x000d, 0x0036,0x0011, 0x0035,0x0010, 0x0036,0x0013, 
-    0x0038,0x0004, 0x0039,0x0004, 0x0038,0x0009, 0x003a,0x0009, 0x0039,0x0008, 
-    0x0038,0x000b, 0x003a,0x000b, 0x003a,0x000d, 0x003a,0x0011, 0x003a,0x0012, 
-    0x0038,0x0013, 0x003a,0x0013, 0x003c,0x0002, 0x003e,0x0002, 0x003c,0x0003, 
-    0x003e,0x0005, 0x003e,0x0007, 0x003c,0x0008, 0x003e,0x0008, 0x003c,0x0009, 
-    0x003e,0x0009, 0x003d,0x0008, 0x003e,0x000d, 0x003e,0x0011, 0x003e,0x0013, 
-    0x003e,0x0017, 0x003e,0x001b, 0x003e,0x001d, 0x0040,0x0002, 0x0042,0x0002, 
-    0x0042,0x0005, 0x0041,0x0006, 0x0042,0x0008, 0x0041,0x0008, 0x0042,0x000d, 
-    0x0042,0x0011, 0x0042,0x0015, 0x0042,0x0019, 0x0042,0x001b, 0x0042,0x001c, 
-    0x0041,0x001c, 0x0044,0x0002, 0x0046,0x0003, 0x0045,0x0004, 0x0046,0x0007, 
-    0x0045,0x0008, 0x0046,0x000b, 0x0046,0x000f, 0x0046,0x0013, 0x0045,0x0012, 
-    0x0046,0x0017, 0x0046,0x001b, 0x0046,0x0021, 0x0048,0x0002, 0x004a,0x0002, 
-    0x0048,0x0003, 0x004a,0x0003, 0x0049,0x0002, 0x0048,0x0008, 0x004a,0x0008, 
-    0x0048,0x0009, 0x004a,0x0009, 0x0049,0x0008, 0x004a,0x000b, 0x004a,0x000f, 
-    0x004a,0x0011, 0x004a,0x0012, 0x004a,0x0013, 0x004a,0x0015, 0x004a,0x0019, 
-    0x004a,0x001b, 0x004a,0x001d, 0x004c,0x0002, 0x004c,0x0003, 0x004d,0x0002, 
-    0x004c,0x0008, 0x004e,0x0008, 0x004c,0x0009, 0x004e,0x0009, 0x004d,0x0008, 
-    0x004c,0x000b, 0x004e,0x000b, 0x004c,0x000f, 0x004e,0x000f, 0x004e,0x0011, 
-    0x004c,0x0012, 0x004c,0x0013, 0x004e,0x0013, 0x004e,0x0015, 0x004c,0x0017, 
-    0x004e,0x0019, 0x004c,0x001b, 0x004e,0x001b, 0x004c,0x001c, 0x004c,0x001d, 
-    0x004e,0x001d, 0x0050,0x0004, 0x0052,0x0004, 0x0050,0x0006, 0x0052,0x0009, 
-    0x0052,0x000d, 0x0052,0x000f, 0x0052,0x0013, 0x0052,0x0017, 0x0052,0x0019, 
-    0x0052,0x001d, 0x0052,0x001f, 0x0052,0x0021, 0x0052,0x0023, 0x0052,0x0024, 
-    0x0052,0x0025, 0x0051,0x0024, 0x0052,0x0027, 0x0054,0x0004, 0x0056,0x0004, 
-    0x0054,0x0005, 0x0056,0x0006, 0x0054,0x0007, 0x0056,0x0011, 0x0056,0x001b, 
-    0x0056,0x001e, 0x0054,0x001f, 0x0056,0x001f, 0x0056,0x0020, 0x0054,0x0021, 
-    0x0055,0x0020, 0x0056,0x0024, 0x0054,0x0025, 0x0056,0x0025, 0x0055,0x0024, 
-    0x0054,0x0027, 0x0056,0x0027, 0x0055,0x0026, 0x005a,0x0007, 0x005a,0x0009, 
-    0x005a,0x000b, 0x005a,0x0015, 0x005a,0x001f, 0x0059,0x0020, 0x0058,0x0024, 
-    0x005a,0x0024, 0x005a,0x0027, 0x0059,0x0026, 0x005c,0x0004, 0x005e,0x0004, 
-    0x005c,0x0005, 0x005e,0x0006, 0x005c,0x0007, 0x005d,0x0006, 0x005e,0x000d, 
-    0x005e,0x0013, 0x005e,0x0017, 0x005c,0x001f, 0x005d,0x001e, 0x005e,0x0020, 
-    0x005e,0x0021, 0x005e,0x0022, 0x005e,0x0023, 0x005c,0x0024, 0x005e,0x0024, 
-    0x005c,0x0025, 0x005e,0x0025, 0x005d,0x0024, 0x005e,0x0026, 0x005e,0x0027, 
-    0x0062,0x0004, 0x0061,0x0004, 0x0062,0x0006, 0x0061,0x0006, 0x0060,0x000f, 
-    0x0060,0x0013, 0x0062,0x0013, 0x0060,0x0019, 0x0062,0x001c, 0x0060,0x001d, 
-    0x0062,0x001d, 0x0062,0x001f, 0x0060,0x0021, 0x0060,0x0023, 0x0062,0x0024, 
-    0x0060,0x0027, 0x0061,0x0026, 0x0064,0x0002, 0x0066,0x0002, 0x0064,0x0006, 
-    0x0066,0x0007, 0x0066,0x0009, 0x0066,0x000d, 0x0066,0x0013, 0x0066,0x0015, 
-    0x0066,0x0017, 0x0066,0x0019, 0x0066,0x001a, 0x0065,0x001a, 0x0066,0x001f, 
-    0x0066,0x0023, 0x0066,0x0027, 0x0066,0x002f, 0x0066,0x0030, 0x006a,0x0002, 
-    0x0068,0x0003, 0x0068,0x0006, 0x006a,0x0006, 0x006a,0x0011, 0x0068,0x0016, 
-    0x0068,0x0017, 0x006a,0x0017, 0x006a,0x001a, 0x006a,0x001b, 0x006a,0x0025, 
-    0x006a,0x002d, 0x006e,0x0003, 0x006e,0x0007, 0x006e,0x0009, 0x006e,0x000b, 
-    0x006e,0x0015, 0x006e,0x0016, 0x006e,0x0017, 0x006c,0x001a, 0x006e,0x001a, 
-    0x006e,0x001f, 0x006e,0x002b, 0x006e,0x0035, 0x0070,0x0002, 0x0070,0x0003, 
-    0x0072,0x0006, 0x0070,0x0007, 0x0071,0x0006, 0x0072,0x000b, 0x0072,0x000f, 
-    0x0072,0x0013, 0x0070,0x0015, 0x0071,0x0014, 0x0072,0x0017, 0x0072,0x0018, 
-    0x0070,0x0019, 0x0072,0x0019, 0x0070,0x001a, 0x0070,0x001b, 0x0072,0x001b, 
-    0x0071,0x001a, 0x0072,0x0021, 0x0072,0x0029, 0x0076,0x0002, 0x0076,0x0003, 
-    0x0075,0x0002, 0x0076,0x0006, 0x0074,0x0007, 0x0076,0x0007, 0x0075,0x0006, 
-    0x0076,0x000d, 0x0076,0x0011, 0x0076,0x0013, 0x0075,0x0014, 0x0076,0x0019, 
-    0x0076,0x001a, 0x0076,0x001b, 0x0075,0x001c, 0x0074,0x0023, 0x0075,0x0022, 
-    0x0074,0x0026, 0x0076,0x0026, 0x0074,0x0027, 0x0076,0x002b, 0x0076,0x002f, 
-    0x0078,0x0002, 0x0078,0x0004, 0x007a,0x0004, 0x007a,0x0005, 0x0079,0x0004, 
-    0x007a,0x0009, 0x007a,0x000a, 0x007a,0x000b, 0x007a,0x000d, 0x007a,0x000f, 
-    0x007a,0x0010, 0x007a,0x0011, 0x007a,0x0012, 0x007a,0x0013, 0x007a,0x0017, 
-    0x007a,0x001b, 0x007a,0x0021, 0x007a,0x0027, 0x007a,0x002b, 0x007a,0x002f, 
-    0x007a,0x0030, 0x0079,0x0034, 0x007a,0x0039, 0x007a,0x003a, 0x007e,0x0002, 
-    0x007c,0x0004, 0x007e,0x0004, 0x007e,0x000c, 0x007c,0x000d, 0x007e,0x0011, 
-    0x007e,0x0013, 0x007e,0x001b, 0x007e,0x0025, 0x007e,0x002d, 0x007e,0x0037, 
-    0x0082,0x0003, 0x0082,0x0005, 0x0082,0x0009, 0x0082,0x000b, 0x0080,0x0010, 
-    0x0082,0x0010, 0x0082,0x0012, 0x0082,0x0015, 0x0082,0x001f, 0x0082,0x002b, 
-    0x0082,0x0035, 0x0082,0x0039, 0x0082,0x003f, 0x0084,0x0002, 0x0086,0x0002, 
-    0x0084,0x0003, 0x0086,0x0003, 0x0085,0x0002, 0x0086,0x0004, 0x0084,0x0005, 
-    0x0085,0x0004, 0x0086,0x000a, 0x0084,0x000b, 0x0085,0x000a, 0x0086,0x000d, 
-    0x0086,0x000e, 0x0086,0x000f, 0x0084,0x0010, 0x0084,0x0011, 0x0086,0x0011, 
-    0x0085,0x0010, 0x0084,0x0012, 0x0084,0x0013, 0x0086,0x0013, 0x0085,0x0012, 
-    0x0086,0x0019, 0x0086,0x0023, 0x0086,0x0029, 0x0086,0x0033, 0x0086,0x0039, 
-    0x008a,0x0003, 0x0089,0x0002, 0x0088,0x0004, 0x008a,0x0004, 0x0088,0x0005, 
-    0x0089,0x0004, 0x008a,0x000b, 0x008a,0x0010, 0x0088,0x0011, 0x008a,0x0011, 
-    0x0089,0x0010, 0x0088,0x0012, 0x008a,0x0012, 0x0089,0x0012, 0x008a,0x0017, 
-    0x008a,0x001b, 0x0089,0x0020, 0x008a,0x0025, 0x0088,0x0027, 0x008a,0x002b, 
-    0x008a,0x002f, 0x008a,0x0039, 0x0088,0x003a, 0x008d,0x0044, 0x0092,0x0009, 
-    0x0092,0x0025, 0x0092,0x0029, 0x0092,0x002d, 0x0092,0x0033, 0x0092,0x0037, 
-    0x0092,0x003d, 0x0092,0x0041, 0x0095,0x0002, 0x0095,0x0004, 0x0095,0x0010, 
-    0x0095,0x0012, 0x0096,0x0021, 0x0096,0x0029, 0x0095,0x002e, 0x0096,0x0030, 
-    0x0096,0x0033, 0x0096,0x003a, 0x0096,0x0043, 0x009a,0x0008, 0x009a,0x0009, 
-    0x0099,0x0008, 0x009a,0x0011, 0x009a,0x0023, 0x009a,0x0033, 0x009a,0x003d, 
-    0x009a,0x0044, 0x009a,0x0045, 0x0099,0x0044, 0x009d,0x0002, 0x009e,0x0008, 
-    0x009c,0x0009, 0x009e,0x0009, 0x009d,0x0008, 0x009e,0x0011, 0x009d,0x0010, 
-    0x009e,0x001f, 0x009e,0x003f, 0x00a0,0x0009, 0x00a0,0x0011, 0x00a2,0x0030, 
-    0x00a2,0x0033, 0x00a6,0x0006, 0x00a6,0x0007, 0x00a6,0x0011, 0x00a6,0x0044, 
-    0x00a6,0x004b, 0x00aa,0x0007, 0x00aa,0x0015, 0x00ae,0x0006, 0x00ae,0x0011, 
-    0x00ae,0x001b, 0x00ae,0x0025, 0x00ae,0x003d, 0x00ae,0x0041, 0x00ae,0x0043, 
-    0x00ae,0x0045, 0x00b2,0x0006, 0x00b0,0x0007, 0x00b1,0x0006, 0x00b2,0x0017, 
-    0x00b1,0x0016, 0x00b0,0x0019, 0x00b2,0x0021, 0x00b2,0x003d, 0x00b5,0x004a, 
-    0x00ba,0x0009, 0x00ba,0x000f, 0x00bc,0x0009, 0x00be,0x0009, 0x00be,0x000f, 
-    0x00bd,0x000e, 0x00be,0x0017, 0x00c2,0x0009, 0x00c2,0x0019, 0x00c2,0x001f, 
-    0x00c2,0x0033, 0x00c6,0x0009, 0x00c5,0x000e, 0x00c6,0x0015, 0x00c6,0x0023, 
-    0x00c4,0x002d, 0x00c6,0x002f, 0x00c5,0x002e, 0x00c6,0x0045, 0x00ce,0x0007, 
-    0x00ce,0x0021, 0x00ce,0x0023, 0x00ce,0x0025, 0x00ce,0x0027, 0x00ce,0x0033, 
-    0x00ce,0x003d, 0x00d2,0x0006, 0x00d0,0x0015, 0x00d0,0x001b, 0x00d2,0x001b, 
-    0x00d1,0x001a, 0x00d0,0x001f, 0x00d2,0x0025, 0x00d1,0x0024, 0x00d2,0x0037, 
-    0x00d2,0x0041, 0x00d2,0x0045, 0x00d9,0x0044, 0x00e1,0x0004, 0x00e2,0x000d, 
-    0x00e2,0x0021, 0x00e0,0x003a, 0x00e6,0x003d, 0x00e6,0x0061, 0x00e6,0x0067, 
-    0x00e9,0x0004, 0x00ea,0x0008, 0x00ea,0x0009, 0x00ea,0x0039, 0x00e9,0x0038, 
-    0x00ea,0x003f, 0x00ec,0x000d, 0x00ee,0x000d, 0x00ee,0x0037, 0x00f2,0x003d, 
-    0x00f2,0x0062, 0x00f5,0x0002, 0x00fa,0x0017, 0x00fa,0x003d, 0x00fe,0x0006, 
-    0x00fd,0x0006, 0x00fc,0x0015, 0x00fe,0x001b, 0x00fc,0x0025, 0x00fe,0x0025, 
-    0x00fd,0x0024, 0x00fe,0x0041, 0x00fe,0x004d, 0x00fd,0x004e, 0x0101,0x0014, 
-    0x0106,0x004d, 0x010a,0x0009, 0x010a,0x000b, 0x0109,0x000a, 0x010a,0x004f, 
-    0x010a,0x0058, 0x010e,0x0008, 0x010c,0x0009, 0x010e,0x0009, 0x010d,0x0008, 
-    0x010e,0x000b, 0x010e,0x002b, 0x010d,0x002a, 0x010e,0x0035, 0x010e,0x003d, 
-    0x010e,0x003f, 0x010e,0x0049, 0x010e,0x0057, 0x010d,0x0056, 0x010d,0x0058, 
-    0x0111,0x0004, 0x0111,0x0006, 0x0110,0x0009, 0x0112,0x0009, 0x0111,0x0008, 
-    0x0112,0x002f, 0x0110,0x0035, 0x0110,0x0037, 0x0112,0x0039, 0x0112,0x003d, 
-    0x0112,0x003f, 0x0112,0x0045, 0x0111,0x0044, 0x0112,0x004b, 0x0112,0x0059, 
-    0x0112,0x0069, 0x0112,0x007f, 0x0116,0x0009, 0x0115,0x0008, 0x0114,0x000b, 
-    0x0116,0x000b, 0x0116,0x0058, 0x011a,0x0015, 0x011a,0x001f, 0x011a,0x002b, 
-    0x011a,0x003f, 0x011a,0x0049, 0x011a,0x0085, 0x011e,0x0007, 0x011e,0x0019, 
-    0x011e,0x001b, 0x011e,0x0023, 0x011e,0x0027, 0x011e,0x002f, 0x011e,0x0043, 
-    0x011e,0x004b, 0x011e,0x004e, 0x011e,0x004f, 0x011e,0x005f, 0x011e,0x0061, 
-    0x011e,0x0065, 0x011e,0x0083, 0x0122,0x0006, 0x0120,0x0007, 0x0122,0x0007, 
-    0x0121,0x0006, 0x0122,0x0049, 0x0121,0x004e, 0x0122,0x008f, 0x0125,0x0004, 
-    0x0124,0x0007, 0x0125,0x0006, 0x0124,0x001b, 0x0126,0x001b, 0x0126,0x0045, 
-    0x0126,0x0087, 0x0128,0x0007, 0x0129,0x0006, 0x012a,0x0019, 0x012a,0x003d, 
-    0x012a,0x0051, 0x012a,0x0065, 0x012a,0x0083, 0x012d,0x005a, 0x0132,0x0009, 
-    0x0132,0x008f, 0x0134,0x0009, 0x0135,0x003e, 0x013a,0x003d, 0x013a,0x0044, 
-    0x0139,0x0044, 0x013e,0x0009, 0x013d,0x0008, 0x013c,0x003d, 0x013c,0x0044, 
-    0x013c,0x0053, 0x013e,0x008f, 0x013e,0x0095, 0x0142,0x0044, 0x0142,0x0097, 
-    0x0142,0x009e, 0x0144,0x0007, 0x0148,0x0015, 0x0148,0x001c, 0x0148,0x001f, 
-    0x0148,0x0026, 0x0149,0x0086, 0x014d,0x0006, 0x014e,0x0044, 0x014d,0x0048, 
-    0x014e,0x009e, 0x0152,0x0009, 0x0151,0x00a6, 0x0155,0x0030, 0x015d,0x003a, 
-    0x0162,0x009e, 0x0164,0x000f, 0x0164,0x0013, 0x0169,0x000e, 0x0174,0x0009, 
-    0x0179,0x0008, 0x0180,0x0009, 0x0181,0x0044, 0x0186,0x0044, 0x0185,0x0044, 
-    0x018a,0x0068, 0x0195,0x004e, 0x01a6,0x0009, 0x01a5,0x0008, 0x01b1,0x003a, 
-    0x01c4,0x0029, 0x01c4,0x0030, 0x01ca,0x008f, 0x01ca,0x0095, 0x01cc,0x0029, 
-    0x01cc,0x0033, 0x01ce,0x003d, 0x01d6,0x00b2, 0x01d8,0x0009, 0x01d9,0x002a, 
-    0x01d9,0x0056, 0x01d9,0x00a4, 0x01dd,0x003a, 0x01e2,0x00b2, 0x01e6,0x0013, 
-    0x01e6,0x009f, 0x01e6,0x00ba, 0x01e6,0x00c0, 0x01e6,0x00d3, 0x01e6,0x00d5, 
-    0x01e6,0x00e5, 0x01e8,0x0005, 0x01f2,0x0013, 0x01f2,0x0095, 0x01f2,0x009f, 
-    0x01f2,0x00ba, 0x01f2,0x00c0, 0x01f2,0x00d3, 0x0202,0x008f, 0x0202,0x0095, 
-    0x0202,0x00f3, 0x0202,0x00f9, 0x020a,0x0044, 0x0209,0x00b4, 0x020e,0x0009, 
-    0x020d,0x0008, 0x020c,0x003d, 0x020c,0x0044, 0x020c,0x0053, 0x020e,0x008f, 
-    0x020e,0x0095, 0x020c,0x00b1, 0x020e,0x00f3, 0x020e,0x00f9, 0x0210,0x0013, 
-    0x0211,0x0024, 0x0210,0x0026, 0x0219,0x0004, 0x021e,0x008f, 0x021e,0x0095, 
-    0x0221,0x003a, 0x0230,0x0009, 0x0236,0x0009, 0x0234,0x0029, 0x0234,0x0030, 
-    0x0234,0x0033, 0x0234,0x003a, 0x0234,0x003d, 0x0234,0x0044, 0x0235,0x00a6, 
-    0x023a,0x0009, 0x023d,0x003a, 0x0245,0x0044, 0x0249,0x003a, 0x024e,0x009e, 
-    0x024e,0x0106, 0x0251,0x0026, 0x0258,0x0013, 0x0259,0x0024, 0x0258,0x0061, 
-    0x0259,0x0086, 0x0258,0x00c7, 0x0258,0x00df, 0x0259,0x00ec, 0x0258,0x00fc, 
-    0x025d,0x0024, 0x025d,0x00de, 0x0260,0x00f6, 0x0268,0x0009, 0x0269,0x0044, 
-    0x0268,0x00f3, 0x0268,0x00f9, 0x026d,0x003a, 0x0270,0x0068, 0x0275,0x003a, 
-    0x027a,0x0044, 0x0279,0x0044, 0x027e,0x007e, 0x0281,0x0044, 0x0285,0x0008, 
-    0x028d,0x0006, 0x028d,0x00d2, 0x0295,0x00cc, 0x0296,0x00f6, 0x0295,0x00f8, 
-    0x0299,0x0030, 0x029e,0x007e, 0x029d,0x0080, 0x02a6,0x008f, 0x02a6,0x0095, 
-    0x02aa,0x0029, 0x02aa,0x0030, 0x02b5,0x0008, 0x02b9,0x003a, 0x02bd,0x0004, 
-    0x02bd,0x00fc, 0x02c2,0x00b2, 0x02c1,0x00b4, 0x02c4,0x0029, 0x02c8,0x0029, 
-    0x02c8,0x0033, 0x02ca,0x003d, 0x02ce,0x0029, 0x02ce,0x0030, 0x02d2,0x0068, 
-    0x02d1,0x006a, 0x02d5,0x006a, 0x02d9,0x0008, 0x02de,0x012c, 0x02e2,0x012c, 
-    0x02e4,0x0009, 0x02e5,0x002a, 0x02e5,0x0056, 0x02e5,0x012c, 0x02ea,0x0029, 
-    0x02ea,0x0030, 0x02e9,0x0030, 0x02ec,0x0029, 0x02ec,0x0030, 0x02ee,0x012c, 
-    0x02f1,0x0068, 0x02f1,0x00b2, 0x02f1,0x0108, 0x02f1,0x012c, 0x02f6,0x0013, 
-    0x02f6,0x0015, 0x02f6,0x001f, 0x02f6,0x0030, 0x02f6,0x0065, 0x02f6,0x0067, 
-    0x02f6,0x009f, 0x02f6,0x00b6, 0x02f6,0x00b9, 0x02f6,0x00c0, 0x02f6,0x00cf, 
-    0x02f6,0x0107, 0x02f6,0x010b, 0x02f6,0x010f, 0x02f6,0x0115, 0x02f6,0x012d, 
-    0x02f6,0x0134, 0x02f6,0x0153, 0x02f6,0x0171, 0x02f6,0x0176, 0x02f8,0x0003, 
-    0x02fa,0x017b, 0x02fc,0x00ba, 0x02fc,0x00d3, 0x0302,0x0013, 0x0302,0x001f, 
-    0x0302,0x0030, 0x0302,0x005d, 0x0302,0x0065, 0x0302,0x0067, 0x0302,0x0099, 
-    0x0302,0x009f, 0x0302,0x00ad, 0x0302,0x00b9, 0x0302,0x00c0, 0x0302,0x00cf, 
-    0x0301,0x00d2, 0x0301,0x00fe, 0x0302,0x0107, 0x0302,0x010b, 0x0302,0x010f, 
-    0x0302,0x0117, 0x0302,0x0134, 0x0302,0x0153, 0x0302,0x0157, 0x0302,0x0176, 
-    0x0306,0x0029, 0x0308,0x00b2, 0x0309,0x00dc, 0x030d,0x00f8, 0x0312,0x00f3, 
-    0x0318,0x007e, 0x031d,0x0080, 0x0321,0x0008, 0x0321,0x0094, 0x0326,0x017b, 
-    0x0326,0x0181, 0x0329,0x012e, 0x032a,0x017b, 0x032a,0x0181, 0x032e,0x008f, 
-    0x032e,0x0095, 0x032e,0x00f3, 0x032e,0x00f9, 0x0332,0x0009, 0x0331,0x0008, 
-    0x0330,0x003d, 0x0330,0x0044, 0x0330,0x0053, 0x0332,0x008f, 0x0332,0x0095, 
-    0x0330,0x00b1, 0x0332,0x00f3, 0x0332,0x00f9, 0x0330,0x0127, 0x0332,0x017b, 
-    0x0332,0x0181, 0x033c,0x0013, 0x033c,0x001c, 0x033d,0x0086, 0x033d,0x00ec, 
-    0x033d,0x0172, 0x033e,0x019d, 0x0345,0x0002, 0x0344,0x008f, 0x0344,0x00f3, 
-    0x034d,0x0030, 0x0352,0x0033, 0x0354,0x0029, 0x0354,0x0030, 0x035a,0x0009, 
-    0x035a,0x017b, 0x035a,0x019b, 0x035a,0x01a2, 0x035e,0x0181, 0x0360,0x0009, 
-    0x0366,0x0009, 0x0364,0x0029, 0x0364,0x0030, 0x0364,0x0033, 0x0364,0x003a, 
-    0x0364,0x003d, 0x0364,0x0044, 0x0369,0x0030, 0x0370,0x0029, 0x0370,0x0030, 
-    0x0376,0x0033, 0x037a,0x0009, 0x037a,0x019b, 0x037a,0x01a2, 0x037c,0x0009, 
-    0x0382,0x0181, 0x0386,0x0009, 0x0384,0x0029, 0x0384,0x0030, 0x0384,0x0033, 
-    0x0384,0x003a, 0x0384,0x003d, 0x0384,0x0044, 0x038a,0x0044, 0x038a,0x009e, 
-    0x038a,0x0106, 0x038a,0x0198, 0x038d,0x010e, 0x038d,0x0152, 0x038d,0x0158, 
-    0x0392,0x009e, 0x0392,0x0106, 0x0392,0x0198, 0x0395,0x0086, 0x0395,0x009a, 
-    0x0395,0x00ec, 0x0395,0x0172, 0x0398,0x014e, 0x0398,0x0175, 0x0398,0x018d, 
-    0x039c,0x0023, 0x039c,0x0027, 0x039c,0x00ef, 0x039c,0x0139, 0x039c,0x0168, 
-    0x03a0,0x0019, 0x03a0,0x001d, 0x03a0,0x0023, 0x03a0,0x0027, 0x03a1,0x004e, 
-    0x03a4,0x0162, 0x03a4,0x0183, 0x03a8,0x0013, 0x03a8,0x0027, 0x03a8,0x0133, 
-    0x03a8,0x0148, 0x03a8,0x0181, 0x03ac,0x0013, 0x03ac,0x0027, 0x03b0,0x017b, 
-    0x03b0,0x0181, 0x03b4,0x004b, 0x03b4,0x00e0, 0x03b4,0x00fb, 0x03b8,0x000f, 
-    0x03b8,0x0013, 0x03b8,0x00ab, 0x03b8,0x00bf, 0x03b8,0x00d0, 0x03bd,0x00da, 
-    0x03bd,0x012c, 0x03c8,0x000f, 0x03c8,0x0013, 0x03c8,0x0019, 0x03c8,0x001d, 
-    0x03cd,0x0086, 0x03cd,0x00ec, 0x03cd,0x0172, 0x03d2,0x00e0, 0x03d2,0x00ef, 
-    0x03d2,0x0112, 0x03d2,0x0139, 0x03d2,0x0168, 0x03d6,0x017b, 0x03d6,0x0181, 
-    0x03da,0x0133, 0x03da,0x0148, 0x03e2,0x0023, 0x03e2,0x0027, 0x03e6,0x0027, 
-    0x03e6,0x0181, 0x03ee,0x017b, 0x03ee,0x0181, 0x03fe,0x003d, 0x0401,0x012a, 
-    0x0401,0x019e, 0x0405,0x01a0, 0x040a,0x000d, 0x040a,0x011f, 0x040a,0x016f, 
-    0x040d,0x012a, 0x0412,0x017b, 0x041a,0x0033, 0x041a,0x003d, 0x041a,0x0181, 
-    0x0421,0x0086, 0x0421,0x009a, 0x0421,0x00ec, 0x0421,0x0172, 0x042e,0x0205, 
-    0x043a,0x0205, 0x043e,0x017b, 0x0442,0x01f5, 0x044c,0x0007, 0x0452,0x0033, 
-    0x0452,0x01ce, 0x0452,0x01d0, 0x0452,0x01f1, 0x0452,0x01fb, 0x0452,0x0225, 
-    0x0454,0x0005, 0x045a,0x0033, 0x045a,0x0181, 0x045a,0x01ce, 0x045a,0x01d0, 
-    0x045a,0x01f1, 0x0469,0x01de, 0x046e,0x0181, 0x047a,0x01ce, 0x047a,0x01f1, 
-    0x0485,0x012c, 0x0489,0x012c, 0x0490,0x01d8, 0x0496,0x0033, 0x0496,0x003d, 
-    0x0498,0x008f, 0x0498,0x00f3, 0x049e,0x0044, 0x049e,0x0221, 0x04a1,0x0006, 
-    0x04a2,0x0044, 0x04a6,0x0221, 0x04a9,0x0004, 0x04ac,0x0027, 0x04b1,0x009a, 
-    0x04b6,0x0097, 0x04b8,0x0027, 0x04c6,0x0219, 0x04ca,0x017b, 0x04cc,0x004b, 
-    0x04d0,0x00ab, 0x04d6,0x017b, 0x04d8,0x000f, 0x04d8,0x0019, 0x04d8,0x0033, 
-    0x04d8,0x003d, 0x04de,0x003d, 0x04de,0x0103, 0x04de,0x018b, 0x04de,0x0231, 
-    0x04e2,0x0044, 0x04e2,0x009e, 0x04e2,0x0106, 0x04e2,0x0198, 0x04e5,0x01a4, 
-    0x04e5,0x01b6, 0x04ea,0x009e, 0x04ea,0x0106, 0x04ea,0x0198, 0x04ed,0x002e, 
-    0x04ed,0x0038, 0x04ed,0x00a2, 0x04f1,0x0086, 0x04f1,0x009a, 0x04f1,0x00ec, 
-    0x04f1,0x0172, 0x04f9,0x004e, 0x04f8,0x0229, 0x04f8,0x022d, 0x0500,0x023e, 
-    0x0504,0x0217, 0x0510,0x00f3, 0x0514,0x0043, 0x0514,0x004d, 0x0514,0x00c3, 
-    0x0514,0x013d, 0x0514,0x0215, 0x0514,0x0232, 0x0515,0x0260, 0x0519,0x002a, 
-    0x0518,0x0030, 0x0518,0x0067, 0x0518,0x00c9, 0x0518,0x01eb, 0x0518,0x01ef, 
-    0x051c,0x0139, 0x051c,0x0168, 0x0520,0x0027, 0x0526,0x014e, 0x0526,0x0175, 
-    0x0526,0x018d, 0x052d,0x0200, 0x0532,0x0021, 0x0532,0x00bf, 0x0532,0x00d0, 
-    0x0532,0x0239, 0x0532,0x0266, 0x053d,0x0024, 0x053d,0x00da, 0x054a,0x000f, 
-    0x054a,0x00ab, 0x054a,0x023a, 0x054e,0x0043, 0x054e,0x004d, 0x054e,0x00c3, 
-    0x054e,0x013d, 0x054e,0x0215, 0x054e,0x0232, 0x054e,0x029d, 0x0552,0x014e, 
-    0x0552,0x018d, 0x0556,0x00f3, 0x0556,0x01e4, 0x055a,0x0299, 0x055d,0x0086, 
-    0x055d,0x009a, 0x055d,0x00ec, 0x055d,0x0172, 0x0566,0x01dc, 0x0566,0x02a5, 
-    0x056d,0x020a, 0x057a,0x003d, 0x057a,0x01d4, 0x057a,0x01f3, 0x0579,0x025e, 
-    0x057e,0x0139, 0x057e,0x0168, 0x0581,0x0006, 0x0586,0x017b, 0x0586,0x0181, 
-    0x0586,0x028c, 0x0588,0x0007, 0x058e,0x0033, 0x058e,0x008f, 0x058e,0x01d0, 
-    0x058e,0x027c, 0x0590,0x0003, 0x0596,0x0033, 0x0596,0x008f, 0x0596,0x0095, 
-    0x0596,0x01d0, 0x0596,0x027c, 0x05a2,0x026f, 0x05a5,0x0284, 0x05aa,0x017b, 
-    0x05ac,0x0205, 0x05b2,0x008f, 0x05b6,0x017b, 0x05b8,0x01da, 0x05c1,0x0276, 
-    0x05c6,0x0248, 0x05c8,0x0247, 0x05c8,0x027e, 0x05cc,0x003d, 0x05cc,0x01d4, 
-    0x05cc,0x01f3, 0x05d0,0x014e, 0x05d0,0x018d, 0x05da,0x00f9, 0x05dd,0x0006, 
-    0x05de,0x0044, 0x05e5,0x002e, 0x05e6,0x02f1, 0x05ea,0x01d4, 0x05ea,0x01f3, 
-    0x05ea,0x022d, 0x05ed,0x0002, 0x05f6,0x0027, 0x05fa,0x0097, 0x05fc,0x003d, 
-    0x0602,0x003d, 0x0606,0x00f3, 0x060a,0x0027, 0x060e,0x003d, 0x060e,0x0103, 
-    0x060e,0x018b, 0x060e,0x0231, 0x060e,0x02d1, 0x0611,0x01fc, 0x0611,0x0234, 
-    0x061a,0x0287, 0x061d,0x0214, 0x0621,0x01d4, 0x062a,0x0027, 0x062a,0x022d, 
-    0x062e,0x009e, 0x062e,0x0106, 0x062e,0x0198, 0x0632,0x009e, 0x0632,0x0106, 
-    0x0632,0x0198, 0x0639,0x0042, 0x0639,0x00b2, 0x0639,0x0108, 0x063d,0x01f8, 
-    0x0641,0x0086, 0x0641,0x009a, 0x0641,0x00ec, 0x0641,0x0172, 0x0645,0x0044, 
-    0x0649,0x0042, 0x0648,0x0087, 0x0648,0x00ed, 0x0648,0x0173, 0x0649,0x01a0, 
-    0x0648,0x0241, 0x0648,0x026f, 0x0648,0x02df, 0x0648,0x0307, 0x064c,0x023a, 
-    0x064c,0x02b3, 0x0651,0x0062, 0x0650,0x0217, 0x0651,0x02ac, 0x0650,0x02d6, 
-    0x0655,0x0042, 0x065d,0x0042, 0x0664,0x02b1, 0x0664,0x02ce, 0x0669,0x0238, 
-    0x066d,0x002a, 0x066c,0x0039, 0x066d,0x01f6, 0x066c,0x0213, 0x066c,0x022e, 
-    0x066d,0x02a2, 0x066c,0x02e1, 0x0671,0x002a, 0x0670,0x0030, 0x0670,0x0067, 
-    0x0670,0x00c9, 0x0670,0x01eb, 0x0670,0x01ef, 0x0670,0x02c3, 0x0675,0x0020, 
-    0x0678,0x0133, 0x0678,0x0148, 0x067c,0x0027, 0x0681,0x023a, 0x0684,0x0021, 
-    0x0684,0x00bf, 0x0684,0x00d0, 0x0689,0x01fc, 0x068e,0x0162, 0x068e,0x0183, 
-    0x0691,0x0200, 0x0696,0x0023, 0x0696,0x00e0, 0x0696,0x00fb, 0x0696,0x0268, 
-    0x069a,0x0282, 0x069d,0x007e, 0x06a2,0x004b, 0x06a2,0x023e, 0x06a2,0x02dc, 
-    0x06a6,0x0097, 0x06aa,0x02b1, 0x06aa,0x02ce, 0x06ae,0x0039, 0x06ae,0x0213, 
-    0x06ae,0x022e, 0x06ae,0x02e1, 0x06b2,0x0162, 0x06b2,0x0183, 0x06b6,0x0023, 
-    0x06b6,0x00e0, 0x06b6,0x00fb, 0x06ba,0x008f, 0x06ba,0x01e4, 0x06be,0x034b, 
-    0x06c1,0x0086, 0x06c1,0x009a, 0x06c1,0x00ec, 0x06c1,0x0172, 0x06c6,0x01da, 
-    0x06c6,0x0280, 0x06c6,0x0351, 0x06ce,0x008f, 0x06d2,0x01e3, 0x06d2,0x0287, 
-    0x06d2,0x0353, 0x06d6,0x027a, 0x06d6,0x029b, 0x06da,0x0033, 0x06da,0x01ce, 
-    0x06da,0x01f1, 0x06de,0x0133, 0x06de,0x0148, 0x06e2,0x0021, 0x06e2,0x00bf, 
-    0x06e2,0x00d0, 0x06e5,0x023a, 0x06e9,0x0004, 0x06ee,0x028c, 0x06ee,0x0338, 
-    0x06f2,0x0328, 0x06f2,0x0330, 0x06f4,0x0005, 0x06f9,0x01e0, 0x06fe,0x0328, 
-    0x06fe,0x0330, 0x0702,0x003d, 0x0702,0x00f3, 0x0702,0x0330, 0x0704,0x0003, 
-    0x070a,0x003d, 0x070a,0x00f3, 0x070a,0x01d4, 0x070a,0x01f3, 0x070a,0x0330, 
-    0x0711,0x032a, 0x0711,0x032e, 0x0716,0x003d, 0x0718,0x0205, 0x0718,0x0282, 
-    0x071e,0x00f3, 0x0720,0x01dc, 0x0720,0x02a5, 0x0726,0x0324, 0x072a,0x028a, 
-    0x072a,0x02a7, 0x0729,0x031c, 0x0729,0x032a, 0x072e,0x003d, 0x072e,0x00f9, 
-    0x072e,0x022d, 0x072e,0x0248, 0x072e,0x02e4, 0x0730,0x003d, 0x0730,0x0247, 
-    0x0730,0x02e3, 0x0730,0x0324, 0x0732,0x0324, 0x0739,0x032e, 0x073e,0x003d, 
-    0x0740,0x003d, 0x0744,0x027a, 0x0744,0x029b, 0x0748,0x0033, 0x0748,0x01ce, 
-    0x0748,0x01f1, 0x074c,0x0162, 0x074c,0x0183, 0x0750,0x0023, 0x0750,0x00e0, 
-    0x0750,0x00fb, 0x0755,0x0246, 0x075a,0x0095, 0x075a,0x0397, 0x075d,0x0004, 
-    0x076a,0x03b3, 0x076d,0x0002, 0x0772,0x02fb, 0x0772,0x0301, 0x0772,0x0315, 
-    0x0772,0x0397, 0x0776,0x008f, 0x077e,0x0027, 0x078a,0x00a1, 0x0792,0x009d, 
-    0x0792,0x00c3, 0x0792,0x02fb, 0x0792,0x0301, 0x0792,0x0315, 0x0792,0x03bd, 
-    0x0796,0x0027, 0x0796,0x024f, 0x079e,0x009d, 0x07a6,0x009d, 0x07a6,0x02fb, 
-    0x07a6,0x0301, 0x07a6,0x0315, 0x07a6,0x03bd, 0x07aa,0x0027, 0x07aa,0x024f, 
-    0x07ae,0x009d, 0x07b9,0x004e, 0x07b8,0x0087, 0x07b8,0x00ed, 0x07b8,0x0173, 
-    0x07b8,0x0197, 0x07b9,0x021a, 0x07b9,0x02b8, 0x07b9,0x0364, 0x07be,0x0029, 
-    0x07be,0x0030, 0x07c0,0x017b, 0x07c6,0x017b, 0x07c8,0x00f3, 0x07ce,0x00f3, 
-    0x07d0,0x008f, 0x07d6,0x008f, 0x07d9,0x01e8, 0x07dd,0x0292, 0x07e2,0x0053, 
-    0x07e6,0x008f, 0x07e6,0x00f3, 0x07e6,0x017b, 0x07e8,0x0029, 0x07e8,0x0030, 
-    0x07ec,0x0021, 0x07ec,0x02ad, 0x07f2,0x0181, 0x07f2,0x0315, 0x07f4,0x0021, 
-    0x07f8,0x020f, 0x07fd,0x002e, 0x0800,0x008f, 0x0805,0x0006, 0x0809,0x03c2, 
-    0x080d,0x0084, 0x0812,0x0009, 0x0811,0x0008, 0x0812,0x00f3, 0x0812,0x00f9, 
-    0x0812,0x017b, 0x0812,0x0181, 0x0814,0x0033, 0x0818,0x0023, 0x081c,0x0285, 
-    0x0826,0x03bd, 0x082c,0x008f, 0x082c,0x017b, 0x0832,0x0043, 0x0832,0x011b, 
-    0x0832,0x01b3, 0x0832,0x01c3, 0x0835,0x032a, 0x0838,0x0085, 0x0839,0x032a, 
-    0x083e,0x0049, 0x083d,0x0084, 0x083e,0x02fb, 0x083e,0x0301, 0x083e,0x0315, 
-    0x083e,0x0397, 0x0842,0x0009, 0x0841,0x0008, 0x0844,0x0009, 0x0846,0x008f, 
-    0x084a,0x0033, 0x084e,0x0285, 0x0851,0x009a, 0x0856,0x00a1, 0x0859,0x031c, 
-    0x085d,0x00b2, 0x0861,0x0012, 0x0861,0x02cc, 0x0865,0x0058, 0x0865,0x007e, 
-    0x0869,0x004a, 0x0871,0x0010, 0x0876,0x003d, 0x0879,0x032c, 0x087e,0x0089, 
-    0x0882,0x0229, 0x0882,0x022d, 0x0882,0x02c7, 0x0882,0x02cb, 0x0886,0x0021, 
-    0x0886,0x02ad, 0x0885,0x0356, 0x088a,0x0017, 0x088a,0x020f, 0x0889,0x0354, 
-    0x088d,0x009c, 0x0892,0x0089, 0x0895,0x0246, 0x089a,0x03bd, 0x089e,0x008f, 
-    0x089e,0x02f9, 0x089e,0x0313, 0x08a1,0x032a, 0x08a6,0x0053, 0x08a6,0x0095, 
-    0x08a6,0x0397, 0x08a8,0x017b, 0x08ad,0x031a, 0x08b2,0x017b, 0x08b4,0x00f3, 
-    0x08b5,0x02a0, 0x08b8,0x0089, 0x08c1,0x0024, 0x08c4,0x00f3, 0x08c9,0x007e, 
-    0x08cd,0x007c, 0x08cd,0x0222, 0x08cd,0x0294, 0x08d1,0x003a, 0x08d6,0x0009, 
-    0x08d9,0x003a, 0x08dc,0x001f, 0x08e0,0x008f, 0x08e0,0x017b, 0x08e4,0x0009, 
-    0x08e8,0x01ed, 0x08ed,0x031c, 0x08f2,0x003d, 0x08f6,0x008f, 0x08f6,0x017b, 
-    0x08fa,0x0009, 0x08fe,0x003d, 0x0902,0x01e9, 0x0904,0x01e9, 0x0904,0x0381, 
-    0x090a,0x03b1, 0x090d,0x031a, 0x0910,0x0299, 0x0914,0x034b, 0x0919,0x0008, 
-    0x091c,0x0033, 0x091c,0x003d, 0x0920,0x0027, 0x0924,0x0027, 0x0924,0x01fb, 
-    0x092a,0x01ce, 0x092a,0x01f1, 0x092d,0x031c, 0x0930,0x001f, 0x0936,0x00c5, 
-    0x0938,0x00c5, 0x0938,0x0381, 0x093c,0x001b, 0x0942,0x017d, 0x094a,0x0027, 
-    0x094e,0x0027, 0x094e,0x01fb, 0x0952,0x03b1, 0x095a,0x0029, 0x095a,0x0030, 
-    0x095d,0x0030, 0x0961,0x0030, 0x0966,0x02f9, 0x0966,0x0313, 0x0968,0x02eb, 
-    0x096d,0x0008, 0x0970,0x017b, 0x0974,0x0033, 0x0979,0x0150, 0x097d,0x009a, 
-    0x0982,0x0293, 0x0984,0x0293, 0x0984,0x0379, 0x098a,0x02eb, 0x098e,0x0009, 
-    0x0992,0x003d, 0x0996,0x003d, 0x0999,0x0062, 0x099e,0x003d, 0x09a0,0x0027, 
-    0x09a5,0x0144, 0x09a8,0x02b5, 0x09ae,0x008f, 0x09ae,0x009d, 0x09b2,0x004d, 
-    0x09b2,0x0053, 0x09b2,0x00c3, 0x09b2,0x013d, 0x09b2,0x01c5, 0x09b2,0x0271, 
-    0x09b4,0x0025, 0x09ba,0x0033, 0x09ba,0x0079, 0x09bc,0x0015, 0x09c2,0x013f, 
-    0x09c4,0x013f, 0x09c4,0x0379, 0x09ca,0x02b5, 0x09cd,0x0006, 0x09da,0x0009, 
-    0x09d9,0x0008, 0x09dc,0x000b, 0x09dc,0x004f, 0x09dd,0x0086, 0x09e0,0x0009, 
-    0x09e6,0x00a1, 0x09e8,0x0009, 0x09ed,0x0086, 0x09f2,0x001f, 0x09f2,0x002f, 
-    0x09f2,0x0049, 0x09f2,0x006f, 0x09f2,0x0085, 0x09f2,0x0091, 0x09f2,0x00a9, 
-    0x09f2,0x00d3, 0x09f2,0x00d7, 0x09f2,0x011d, 0x09f2,0x0121, 0x09f2,0x0235, 
-    0x09f2,0x0393, 0x09f6,0x0324, 0x09f8,0x0049, 0x09f8,0x00a9, 0x09f8,0x011d, 
-    0x09fe,0x001f, 0x09fe,0x0029, 0x09fe,0x0033, 0x09fe,0x003d, 0x09fe,0x0085, 
-    0x09fe,0x008f, 0x09fe,0x00d3, 0x0a00,0x003d, 0x0a06,0x012d, 0x0a0e,0x00b3, 
-    0x0a10,0x000b, 0x0a10,0x0387, 0x0a16,0x0059, 0x0a18,0x0009, 0x0a1e,0x0043, 
-    0x0a24,0x0085, 0x0a2a,0x0009, 0x0a2d,0x0008, 0x0a32,0x028a, 0x0a32,0x02a7, 
-    0x0a31,0x031c, 0x0a35,0x032e, 0x0a39,0x0006, 0x0a3a,0x0105, 0x0a3a,0x024f, 
-    0x0a3c,0x0299, 0x0a42,0x01ed, 0x0a46,0x0299, 0x0a48,0x01ed, 0x0a4c,0x0059, 
-    0x0a52,0x000b, 0x0a52,0x0387, 0x0a56,0x000b, 0x0a5e,0x0009, 0x0a60,0x003d, 
-    0x0a66,0x0105, 0x0a6a,0x0195, 0x0a6c,0x000b, 0x0a76,0x0053, 0x0a78,0x0009, 
-    0x0a7a,0x008f, 0x0a82,0x0299, 0x0a86,0x01ed, 0x0a8a,0x0027, 0x0a8e,0x004b, 
-    0x0a92,0x003d, 0x0a95,0x0322, 0x0a99,0x0038, 0x0a99,0x0090, 0x0a9c,0x0061, 
-    0x0a9c,0x00c7, 0x0a9c,0x012d, 0x0a9c,0x016f, 0x0a9c,0x017d, 0x0a9c,0x02c9, 
-    0x0a9c,0x0383, 0x0aa1,0x0010, 0x0aa4,0x00b3, 0x0aa8,0x002f, 0x0aac,0x0027, 
-    0x0ab0,0x004b, 0x0ab4,0x0043, 0x0ab9,0x0090, 0x0abd,0x0010, 0x0ac4,0x0019, 
-    0x0acc,0x00f5, 0x0acc,0x022b, 0x0acc,0x037b, 0x0ad2,0x008f, 0x0ad2,0x01f1, 
-    0x0ad6,0x0324, 0x0ad9,0x0330, 0x0ade,0x008f, 0x0ade,0x01f1, 0x0ae0,0x017b, 
-    0x0ae4,0x008f, 0x0ae9,0x004e, 0x0aee,0x0027, 0x0af2,0x028a, 0x0af2,0x02a7, 
-    0x0af1,0x031c, 0x0af6,0x0027, 0x0af9,0x031c, 0x0afe,0x00e9, 0x0afe,0x02bb, 
-    0x0b02,0x000b, 0x0b06,0x00f5, 0x0b06,0x022b, 0x0b06,0x037b, 0x0b0a,0x003d, 
-    0x0000,0x0000 
-};
-
-