Major restructuring of the code.

61 files changed, 8750 insertions, 11293 deletions

diff --git a/src/sat/bsat/satChecker.c b/src/sat/bsat/satChecker.c
index 041bc9ed..7aec4a4d 100644
--- a/src/sat/bsat/satChecker.c
+++ b/src/sat/bsat/satChecker.c
@@ -23,7 +23,7 @@
 #include <string.h>
 #include <assert.h>
 #include <time.h>
-#include "vec.h"
+#include "misc/vec/vec.h"
 
 ABC_NAMESPACE_IMPL_START
 
diff --git a/src/sat/bsat/satInterA.c b/src/sat/bsat/satInterA.c
index a635516c..01a5ca31 100644
--- a/src/sat/bsat/satInterA.c
+++ b/src/sat/bsat/satInterA.c
@@ -24,7 +24,7 @@
 #include <assert.h>
 #include <time.h>
 #include "satStore.h"
-#include "aig.h"
+#include "src/aig/aig/aig.h"
 
 ABC_NAMESPACE_IMPL_START
 
diff --git a/src/sat/bsat/satInterB.c b/src/sat/bsat/satInterB.c
index 1ffb0dc5..5d348f62 100644
--- a/src/sat/bsat/satInterB.c
+++ b/src/sat/bsat/satInterB.c
@@ -24,7 +24,7 @@
 #include <assert.h>
 #include <time.h>
 #include "satStore.h"
-#include "aig.h"
+#include "src/aig/aig/aig.h"
 
 ABC_NAMESPACE_IMPL_START
 
diff --git a/src/sat/bsat/satInterP.c b/src/sat/bsat/satInterP.c
index ff0b0e94..b8ab473a 100644
--- a/src/sat/bsat/satInterP.c
+++ b/src/sat/bsat/satInterP.c
@@ -25,7 +25,7 @@
 #include <time.h>
 
 #include "satStore.h"
-#include "vec.h"
+#include "src/misc/vec/vec.h"
 
 ABC_NAMESPACE_IMPL_START
 
diff --git a/src/sat/bsat/satMem.h b/src/sat/bsat/satMem.h
index 8ea153a6..9dc9e692 100644
--- a/src/sat/bsat/satMem.h
+++ b/src/sat/bsat/satMem.h
@@ -18,14 +18,14 @@
 
 ***********************************************************************/
  
-#ifndef __SAT_MEM_H__
-#define __SAT_MEM_H__
+#ifndef ABC__sat__bsat__satMem_h
+#define ABC__sat__bsat__satMem_h
 
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
 
-#include "abc_global.h"
+#include "src/misc/util/abc_global.h"
 
 ABC_NAMESPACE_HEADER_START
 
diff --git a/src/sat/bsat/satProof.c b/src/sat/bsat/satProof.c
index 79179952..111b3ece 100644
--- a/src/sat/bsat/satProof.c
+++ b/src/sat/bsat/satProof.c
@@ -19,8 +19,8 @@
 ***********************************************************************/
 
 #include "satSolver2.h"
-#include "vec.h"
-#include "aig.h"
+#include "src/misc/vec/vec.h"
+#include "src/aig/aig/aig.h"
 #include "satTruth.h"
 #include "vecRec.h"
 
@@ -610,7 +610,7 @@ void * Sat_ProofInterpolant( sat_solver2 * s, void * pGloVars )
 
     // start the AIG
     pAig = Aig_ManStart( 10000 );
-    pAig->pName = Aig_UtilStrsav( "interpol" );
+    pAig->pName = Abc_UtilStrsav( "interpol" );
     for ( i = 0; i < Vec_IntSize(vGlobVars); i++ )
         Aig_ObjCreatePi( pAig );
 
diff --git a/src/sat/bsat/satSolver.h b/src/sat/bsat/satSolver.h
index 0ca934ed..30b3742b 100644
--- a/src/sat/bsat/satSolver.h
+++ b/src/sat/bsat/satSolver.h
@@ -19,8 +19,8 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA
 **************************************************************************************************/
 // Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
 
-#ifndef satSolver_h
-#define satSolver_h
+#ifndef ABC__sat__bsat__satSolver_h
+#define ABC__sat__bsat__satSolver_h
 
 
 #include <stdio.h>
diff --git a/src/sat/bsat/satSolver2.h b/src/sat/bsat/satSolver2.h
index baccf68d..29279b86 100644
--- a/src/sat/bsat/satSolver2.h
+++ b/src/sat/bsat/satSolver2.h
@@ -19,8 +19,8 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA
 **************************************************************************************************/
 // Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
 
-#ifndef satSolver2_h
-#define satSolver2_h
+#ifndef ABC__sat__bsat__satSolver2_h
+#define ABC__sat__bsat__satSolver2_h
 
 
 #include <stdio.h>
diff --git a/src/sat/bsat/satSolver_old.h b/src/sat/bsat/satSolver_old.h
index 4c577b1e..d2228f79 100644
--- a/src/sat/bsat/satSolver_old.h
+++ b/src/sat/bsat/satSolver_old.h
@@ -19,8 +19,8 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA
 **************************************************************************************************/
 // Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
 
-#ifndef satSolver_h
-#define satSolver_h
+#ifndef ABC__sat__bsat__satSolver_old_h
+#define ABC__sat__bsat__satSolver_old_h
 
 
 #include <stdio.h>
diff --git a/src/sat/bsat/satStore.h b/src/sat/bsat/satStore.h
index 0293aea7..206c6939 100644
--- a/src/sat/bsat/satStore.h
+++ b/src/sat/bsat/satStore.h
@@ -18,8 +18,8 @@
 
 ***********************************************************************/
  
-#ifndef __SAT_STORE_H__
-#define __SAT_STORE_H__
+#ifndef ABC__sat__bsat__satStore_h
+#define ABC__sat__bsat__satStore_h
 
 
 /*
diff --git a/src/sat/bsat/satTruth.h b/src/sat/bsat/satTruth.h
index e07518b0..2f17b6f0 100644
--- a/src/sat/bsat/satTruth.h
+++ b/src/sat/bsat/satTruth.h
@@ -18,8 +18,8 @@
 
 ***********************************************************************/
  
-#ifndef __SAT_TRUTH_H__
-#define __SAT_TRUTH_H__
+#ifndef ABC__sat__bsat__satTruth_h
+#define ABC__sat__bsat__satTruth_h
 
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
@@ -29,7 +29,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
-#include "abc_global.h"
+#include "src/misc/util/abc_global.h"
 
 ABC_NAMESPACE_HEADER_START
 
diff --git a/src/sat/bsat/satVec.h b/src/sat/bsat/satVec.h
index bf117521..01740580 100644
--- a/src/sat/bsat/satVec.h
+++ b/src/sat/bsat/satVec.h
@@ -19,10 +19,10 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA
 **************************************************************************************************/
 // Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
 
-#ifndef satVec_h
-#define satVec_h
+#ifndef ABC__sat__bsat__satVec_h
+#define ABC__sat__bsat__satVec_h
 
-#include "abc_global.h"
+#include "src/misc/util/abc_global.h"
 
 ABC_NAMESPACE_HEADER_START
 
diff --git a/src/sat/bsat/vecRec.h b/src/sat/bsat/vecRec.h
index e92129be..82d7183d 100644
--- a/src/sat/bsat/vecRec.h
+++ b/src/sat/bsat/vecRec.h
@@ -18,8 +18,8 @@
 
 ***********************************************************************/
  
-#ifndef __VEC_REC_H__
-#define __VEC_REC_H__
+#ifndef ABC__sat__bsat__vecRec_h
+#define ABC__sat__bsat__vecRec_h
 
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/sat/cnf/cnf.h b/src/sat/cnf/cnf.h
new file mode 100644
index 00000000..0b6fc8c2
--- /dev/null
+++ b/src/sat/cnf/cnf.h
@@ -0,0 +1,195 @@
+/**CFile****************************************************************
+
+  FileName    [cnf.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [DAG-aware AIG rewriting.]
+
+  Synopsis    [External declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnf.h,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__aig__cnf__cnf_h
+#define ABC__aig__cnf__cnf_h
+
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <time.h>
+
+#include "src/misc/vec/vec.h"
+#include "src/aig/aig/aig.h"
+#include "src/opt/dar/darInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+
+
+ABC_NAMESPACE_HEADER_START
+ 
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Cnf_Man_t_            Cnf_Man_t;
+typedef struct Cnf_Dat_t_            Cnf_Dat_t;
+typedef struct Cnf_Cut_t_            Cnf_Cut_t;
+
+// the CNF asserting outputs of AIG to be 1
+struct Cnf_Dat_t_
+{
+    Aig_Man_t *     pMan;            // the AIG manager, for which CNF is computed
+    int             nVars;           // the number of variables
+    int             nLiterals;       // the number of CNF literals
+    int             nClauses;        // the number of CNF clauses
+    int **          pClauses;        // the CNF clauses
+    int *           pVarNums;        // the number of CNF variable for each node ID (-1 if unused)
+    int *           pObj2Clause;     // the mapping of objects into clauses
+    int *           pObj2Count;      // the mapping of objects into clause number
+};
+
+// the cut used to represent node in the AIG
+struct Cnf_Cut_t_
+{
+    char            nFanins;         // the number of leaves
+    char            Cost;            // the cost of this cut
+    short           nWords;          // the number of words in truth table
+    Vec_Int_t *     vIsop[2];        // neg/pos ISOPs
+    int             pFanins[0];      // the fanins (followed by the truth table)
+};
+
+// the CNF computation manager
+struct Cnf_Man_t_
+{
+    Aig_Man_t *     pManAig;         // the underlying AIG manager
+    char *          pSopSizes;       // sizes of SOPs for 4-variable functions
+    char **         pSops;           // the SOPs for 4-variable functions
+    int             aArea;           // the area of the mapping
+    Aig_MmFlex_t *  pMemCuts;        // memory manager for cuts
+    int             nMergeLimit;     // the limit on the size of merged cut
+    unsigned *      pTruths[4];      // temporary truth tables
+    Vec_Int_t *     vMemory;         // memory for intermediate ISOP representation
+    int             timeCuts; 
+    int             timeMap;
+    int             timeSave;
+};
+
+
+static inline Dar_Cut_t *  Dar_ObjBestCut( Aig_Obj_t * pObj ) { Dar_Cut_t * pCut; int i; Dar_ObjForEachCut( pObj, pCut, i ) if ( pCut->fBest ) return pCut; return NULL; }
+
+static inline int          Cnf_CutSopCost( Cnf_Man_t * p, Dar_Cut_t * pCut ) { return p->pSopSizes[pCut->uTruth] + p->pSopSizes[0xFFFF & ~pCut->uTruth]; }
+
+static inline int          Cnf_CutLeaveNum( Cnf_Cut_t * pCut )    { return pCut->nFanins;                               }
+static inline int *        Cnf_CutLeaves( Cnf_Cut_t * pCut )      { return pCut->pFanins;                               }
+static inline unsigned *   Cnf_CutTruth( Cnf_Cut_t * pCut )       { return (unsigned *)(pCut->pFanins + pCut->nFanins); }
+
+static inline Cnf_Cut_t *  Cnf_ObjBestCut( Aig_Obj_t * pObj )                       { return (Cnf_Cut_t *)pObj->pData;  }
+static inline void         Cnf_ObjSetBestCut( Aig_Obj_t * pObj, Cnf_Cut_t * pCut )  { pObj->pData = pCut;  }
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                           ITERATORS                              ///
+////////////////////////////////////////////////////////////////////////
+
+// iterator over the clauses
+#define Cnf_CnfForClause( p, pBeg, pEnd, i )                         \
+    for ( i = 0; i < p->nClauses && (pBeg = p->pClauses[i]) && (pEnd = p->pClauses[i+1]); i++ )
+
+// iterator over leaves of the cut
+#define Cnf_CutForEachLeaf( p, pCut, pLeaf, i )                         \
+    for ( i = 0; (i < (int)(pCut)->nFanins) && ((pLeaf) = Aig_ManObj(p, (pCut)->pFanins[i])); i++ )
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/*=== cnfCore.c ========================================================*/
+extern Vec_Int_t *     Cnf_DeriveMappingArray( Aig_Man_t * pAig );
+extern Cnf_Dat_t *     Cnf_Derive( Aig_Man_t * pAig, int nOutputs );
+extern Cnf_Dat_t *     Cnf_DeriveOther( Aig_Man_t * pAig );
+extern Cnf_Man_t *     Cnf_ManRead();
+extern void            Cnf_ClearMemory();
+/*=== cnfCut.c ========================================================*/
+extern Cnf_Cut_t *     Cnf_CutCreate( Cnf_Man_t * p, Aig_Obj_t * pObj );
+extern void            Cnf_CutPrint( Cnf_Cut_t * pCut );
+extern void            Cnf_CutFree( Cnf_Cut_t * pCut );
+extern void            Cnf_CutUpdateRefs( Cnf_Man_t * p, Cnf_Cut_t * pCut, Cnf_Cut_t * pCutFan, Cnf_Cut_t * pCutRes );
+extern Cnf_Cut_t *     Cnf_CutCompose( Cnf_Man_t * p, Cnf_Cut_t * pCut, Cnf_Cut_t * pCutFan, int iFan );
+/*=== cnfData.c ========================================================*/
+extern void            Cnf_ReadMsops( char ** ppSopSizes, char *** ppSops );
+/*=== cnfFast.c ========================================================*/
+extern void            Cnf_CollectLeaves( Aig_Obj_t * pRoot, Vec_Ptr_t * vSuper, int fStopCompl );
+extern void            Cnf_ComputeClauses( Aig_Man_t * p, Aig_Obj_t * pRoot, Vec_Ptr_t * vLeaves, 
+                           Vec_Ptr_t * vNodes, Vec_Int_t * vMap, Vec_Int_t * vCover, Vec_Int_t * vClauses );
+extern void            Cnf_DeriveFastMark( Aig_Man_t * p );
+extern Cnf_Dat_t *     Cnf_DeriveFast( Aig_Man_t * p, int nOutputs );
+/*=== cnfMan.c ========================================================*/
+extern Cnf_Man_t *     Cnf_ManStart();
+extern void            Cnf_ManStop( Cnf_Man_t * p );
+extern Vec_Int_t *     Cnf_DataCollectPiSatNums( Cnf_Dat_t * pCnf, Aig_Man_t * p );
+extern Cnf_Dat_t *     Cnf_DataAlloc( Aig_Man_t * pAig, int nVars, int nClauses, int nLiterals );
+extern Cnf_Dat_t *     Cnf_DataDup( Cnf_Dat_t * p );
+extern void            Cnf_DataFree( Cnf_Dat_t * p );
+extern void            Cnf_DataLift( Cnf_Dat_t * p, int nVarsPlus );
+extern void            Cnf_DataFlipLastLiteral( Cnf_Dat_t * p );
+extern void            Cnf_DataPrint( Cnf_Dat_t * p, int fReadable );
+extern void            Cnf_DataWriteIntoFile( Cnf_Dat_t * p, char * pFileName, int fReadable );
+extern void *          Cnf_DataWriteIntoSolver( Cnf_Dat_t * p, int nFrames, int fInit );
+extern void *          Cnf_DataWriteIntoSolverInt( void * pSat, Cnf_Dat_t * p, int nFrames, int fInit );
+extern int             Cnf_DataWriteOrClause( void * pSat, Cnf_Dat_t * pCnf );
+extern int             Cnf_DataWriteAndClauses( void * p, Cnf_Dat_t * pCnf );
+extern void            Cnf_DataTranformPolarity( Cnf_Dat_t * pCnf, int fTransformPos );
+extern int             Cnf_DataAddXorClause( void * pSat, int iVarA, int iVarB, int iVarC );
+/*=== cnfMap.c ========================================================*/
+extern void            Cnf_DeriveMapping( Cnf_Man_t * p );
+extern int             Cnf_ManMapForCnf( Cnf_Man_t * p );
+/*=== cnfPost.c ========================================================*/
+extern void            Cnf_ManTransferCuts( Cnf_Man_t * p );
+extern void            Cnf_ManFreeCuts( Cnf_Man_t * p );
+extern void            Cnf_ManPostprocess( Cnf_Man_t * p );
+/*=== cnfUtil.c ========================================================*/
+extern Vec_Ptr_t *     Aig_ManScanMapping( Cnf_Man_t * p, int fCollect );
+extern Vec_Ptr_t *     Cnf_ManScanMapping( Cnf_Man_t * p, int fCollect, int fPreorder );
+extern Vec_Int_t *     Cnf_DataCollectCiSatNums( Cnf_Dat_t * pCnf, Aig_Man_t * p );
+extern Vec_Int_t *     Cnf_DataCollectCoSatNums( Cnf_Dat_t * pCnf, Aig_Man_t * p );
+/*=== cnfWrite.c ========================================================*/
+extern Vec_Int_t *     Cnf_ManWriteCnfMapping( Cnf_Man_t * p, Vec_Ptr_t * vMapped );
+extern void            Cnf_SopConvertToVector( char * pSop, int nCubes, Vec_Int_t * vCover );
+extern Cnf_Dat_t *     Cnf_ManWriteCnf( Cnf_Man_t * p, Vec_Ptr_t * vMapped, int nOutputs );
+extern Cnf_Dat_t *     Cnf_ManWriteCnfOther( Cnf_Man_t * p, Vec_Ptr_t * vMapped );
+extern Cnf_Dat_t *     Cnf_DeriveSimple( Aig_Man_t * p, int nOutputs );
+extern Cnf_Dat_t *     Cnf_DeriveSimpleForRetiming( Aig_Man_t * p );
+
+
+
+ABC_NAMESPACE_HEADER_END
+
+
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/src/sat/cnf/cnfCore.c b/src/sat/cnf/cnfCore.c
new file mode 100644
index 00000000..eb46e704
--- /dev/null
+++ b/src/sat/cnf/cnfCore.c
@@ -0,0 +1,296 @@
+/**CFile****************************************************************
+
+  FileName    [cnfCore.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfCore.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+static Cnf_Man_t * s_pManCnf = NULL;
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Converts AIG into the SAT solver.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Cnf_DeriveMappingArray( Aig_Man_t * pAig )
+{
+    Vec_Int_t * vResult;
+    Cnf_Man_t * p;
+    Vec_Ptr_t * vMapped;
+    Aig_MmFixed_t * pMemCuts;
+    int clk;
+    // allocate the CNF manager
+    if ( s_pManCnf == NULL )
+        s_pManCnf = Cnf_ManStart();
+    // connect the managers
+    p = s_pManCnf;
+    p->pManAig = pAig;
+
+    // generate cuts for all nodes, assign cost, and find best cuts
+clk = clock();
+    pMemCuts = Dar_ManComputeCuts( pAig, 10, 0 );
+p->timeCuts = clock() - clk;
+
+    // find the mapping
+clk = clock();
+    Cnf_DeriveMapping( p );
+p->timeMap = clock() - clk;
+//    Aig_ManScanMapping( p, 1 );
+
+    // convert it into CNF
+clk = clock();
+    Cnf_ManTransferCuts( p );
+    vMapped = Cnf_ManScanMapping( p, 1, 0 );
+    vResult = Cnf_ManWriteCnfMapping( p, vMapped );
+    Vec_PtrFree( vMapped );
+    Aig_MmFixedStop( pMemCuts, 0 );
+p->timeSave = clock() - clk;
+
+   // reset reference counters
+    Aig_ManResetRefs( pAig );
+//ABC_PRT( "Cuts   ", p->timeCuts );
+//ABC_PRT( "Map    ", p->timeMap  );
+//ABC_PRT( "Saving ", p->timeSave );
+    return vResult;
+}
+ 
+/**Function*************************************************************
+
+  Synopsis    [Converts AIG into the SAT solver.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_Derive( Aig_Man_t * pAig, int nOutputs )
+{
+    Cnf_Man_t * p;
+    Cnf_Dat_t * pCnf;
+    Vec_Ptr_t * vMapped;
+    Aig_MmFixed_t * pMemCuts;
+    int clk;
+    // allocate the CNF manager
+    if ( s_pManCnf == NULL )
+        s_pManCnf = Cnf_ManStart();
+    // connect the managers
+    p = s_pManCnf;
+    p->pManAig = pAig;
+
+    // generate cuts for all nodes, assign cost, and find best cuts
+clk = clock();
+    pMemCuts = Dar_ManComputeCuts( pAig, 10, 0 );
+p->timeCuts = clock() - clk;
+
+    // find the mapping
+clk = clock();
+    Cnf_DeriveMapping( p );
+p->timeMap = clock() - clk;
+//    Aig_ManScanMapping( p, 1 );
+
+    // convert it into CNF
+clk = clock();
+    Cnf_ManTransferCuts( p );
+    vMapped = Cnf_ManScanMapping( p, 1, 1 );
+    pCnf = Cnf_ManWriteCnf( p, vMapped, nOutputs );
+    Vec_PtrFree( vMapped );
+    Aig_MmFixedStop( pMemCuts, 0 );
+p->timeSave = clock() - clk;
+
+   // reset reference counters
+    Aig_ManResetRefs( pAig );
+//ABC_PRT( "Cuts   ", p->timeCuts );
+//ABC_PRT( "Map    ", p->timeMap  );
+//ABC_PRT( "Saving ", p->timeSave );
+    return pCnf;
+}
+ 
+/**Function*************************************************************
+
+  Synopsis    [Converts AIG into the SAT solver.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_DeriveOther( Aig_Man_t * pAig )
+{
+    Cnf_Man_t * p;
+    Cnf_Dat_t * pCnf;
+    Vec_Ptr_t * vMapped;
+    Aig_MmFixed_t * pMemCuts;
+    int clk;
+    // allocate the CNF manager
+    if ( s_pManCnf == NULL )
+        s_pManCnf = Cnf_ManStart();
+    // connect the managers
+    p = s_pManCnf;
+    p->pManAig = pAig;
+
+    // generate cuts for all nodes, assign cost, and find best cuts
+clk = clock();
+    pMemCuts = Dar_ManComputeCuts( pAig, 10, 0 );
+p->timeCuts = clock() - clk;
+
+    // find the mapping
+clk = clock();
+    Cnf_DeriveMapping( p );
+p->timeMap = clock() - clk;
+//    Aig_ManScanMapping( p, 1 );
+
+    // convert it into CNF
+clk = clock();
+    Cnf_ManTransferCuts( p );
+    vMapped = Cnf_ManScanMapping( p, 1, 1 );
+    pCnf = Cnf_ManWriteCnfOther( p, vMapped );
+    Vec_PtrFree( vMapped );
+    Aig_MmFixedStop( pMemCuts, 0 );
+p->timeSave = clock() - clk;
+
+   // reset reference counters
+    Aig_ManResetRefs( pAig );
+//ABC_PRT( "Cuts   ", p->timeCuts );
+//ABC_PRT( "Map    ", p->timeMap  );
+//ABC_PRT( "Saving ", p->timeSave );
+    return pCnf;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Man_t * Cnf_ManRead()
+{
+    return s_pManCnf;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ClearMemory()
+{
+    if ( s_pManCnf == NULL )
+        return;
+    Cnf_ManStop( s_pManCnf );
+    s_pManCnf = NULL;
+}
+
+
+#if 0
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_Derive_old( Aig_Man_t * pAig )
+{
+/*
+    // iteratively improve area flow
+    for ( i = 0; i < nIters; i++ )
+    {
+clk = clock();
+        Cnf_ManScanMapping( p, 0 );
+        Cnf_ManMapForCnf( p );
+ABC_PRT( "iter ", clock() - clk );
+    }
+*/
+    // write the file
+    vMapped = Aig_ManScanMapping( p, 1 );
+    Vec_PtrFree( vMapped );
+
+clk = clock();
+    Cnf_ManTransferCuts( p );
+
+    Cnf_ManPostprocess( p );
+    Cnf_ManScanMapping( p, 0 );
+/*
+    Cnf_ManPostprocess( p );
+    Cnf_ManScanMapping( p, 0 );
+    Cnf_ManPostprocess( p );
+    Cnf_ManScanMapping( p, 0 );
+*/
+ABC_PRT( "Ext ", clock() - clk );
+
+/*
+    vMapped = Cnf_ManScanMapping( p, 1 );
+    pCnf = Cnf_ManWriteCnf( p, vMapped );
+    Vec_PtrFree( vMapped );
+
+    // clean up
+    Cnf_ManFreeCuts( p );
+    Dar_ManCutsFree( pAig );
+    return pCnf;
+*/
+    Aig_MmFixedStop( pMemCuts, 0 );
+    return NULL;
+}
+
+#endif
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfCut.c b/src/sat/cnf/cnfCut.c
new file mode 100644
index 00000000..fef199c7
--- /dev/null
+++ b/src/sat/cnf/cnfCut.c
@@ -0,0 +1,376 @@
+/**CFile****************************************************************
+
+  FileName    [cnfCut.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfCut.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+#include "src/bool/kit/kit.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates cut of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Cut_t * Cnf_CutAlloc( Cnf_Man_t * p, int nLeaves )
+{
+    Cnf_Cut_t * pCut;
+    int nSize = sizeof(Cnf_Cut_t) + sizeof(int) * nLeaves + sizeof(unsigned) * Abc_TruthWordNum(nLeaves);
+    pCut = (Cnf_Cut_t *)Aig_MmFlexEntryFetch( p->pMemCuts, nSize );
+    pCut->nFanins = nLeaves;
+    pCut->nWords = Abc_TruthWordNum(nLeaves);
+    pCut->vIsop[0] = pCut->vIsop[1] = NULL;
+    return pCut;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deallocates cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutFree( Cnf_Cut_t * pCut )
+{
+    if ( pCut->vIsop[0] )
+        Vec_IntFree( pCut->vIsop[0] );
+    if ( pCut->vIsop[1] )
+        Vec_IntFree( pCut->vIsop[1] );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates cut for the given node.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Cut_t * Cnf_CutCreate( Cnf_Man_t * p, Aig_Obj_t * pObj )
+{
+    Dar_Cut_t * pCutBest;
+    Cnf_Cut_t * pCut;
+    unsigned * pTruth;
+    assert( Aig_ObjIsNode(pObj) );
+    pCutBest = Dar_ObjBestCut( pObj );
+    assert( pCutBest != NULL );
+    assert( pCutBest->nLeaves <= 4 );
+    pCut = Cnf_CutAlloc( p, pCutBest->nLeaves );
+    memcpy( pCut->pFanins, pCutBest->pLeaves, sizeof(int) * pCutBest->nLeaves );
+    pTruth = Cnf_CutTruth(pCut);
+    *pTruth = (pCutBest->uTruth << 16) | pCutBest->uTruth;
+    pCut->Cost = Cnf_CutSopCost( p, pCutBest );
+    return pCut;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deallocates cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutPrint( Cnf_Cut_t * pCut )
+{
+    int i;
+    printf( "{" );
+    for ( i = 0; i < pCut->nFanins; i++ )
+        printf( "%d ", pCut->pFanins[i] );
+    printf( " } " );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates cut of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutDeref( Cnf_Man_t * p, Cnf_Cut_t * pCut )
+{
+    Aig_Obj_t * pObj;
+    int i;
+    Cnf_CutForEachLeaf( p->pManAig, pCut, pObj, i )
+    {
+        assert( pObj->nRefs > 0 );
+        pObj->nRefs--;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates cut of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutRef( Cnf_Man_t * p, Cnf_Cut_t * pCut )
+{
+    Aig_Obj_t * pObj;
+    int i;
+    Cnf_CutForEachLeaf( p->pManAig, pCut, pObj, i )
+    {
+        pObj->nRefs++;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates cut of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutUpdateRefs( Cnf_Man_t * p, Cnf_Cut_t * pCut, Cnf_Cut_t * pCutFan, Cnf_Cut_t * pCutRes )
+{
+    Cnf_CutDeref( p, pCut );
+    Cnf_CutDeref( p, pCutFan );
+    Cnf_CutRef( p, pCutRes );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Merges two arrays of integers.]
+
+  Description [Returns the number of items.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Cnf_CutMergeLeaves( Cnf_Cut_t * pCut, Cnf_Cut_t * pCutFan, int * pFanins )
+{
+    int i, k, nFanins = 0;
+    for ( i = k = 0; i < pCut->nFanins && k < pCutFan->nFanins; )
+    {
+        if ( pCut->pFanins[i] == pCutFan->pFanins[k] )
+            pFanins[nFanins++] = pCut->pFanins[i], i++, k++;
+        else if ( pCut->pFanins[i] < pCutFan->pFanins[k] )
+            pFanins[nFanins++] = pCut->pFanins[i], i++;
+        else
+            pFanins[nFanins++] = pCutFan->pFanins[k], k++;
+    }
+    for ( ; i < pCut->nFanins; i++ )
+        pFanins[nFanins++] = pCut->pFanins[i];
+    for ( ; k < pCutFan->nFanins; k++ )
+        pFanins[nFanins++] = pCutFan->pFanins[k];
+    return nFanins;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes the stretching phase of the cut w.r.t. the merged cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline unsigned Cnf_TruthPhase( Cnf_Cut_t * pCut, Cnf_Cut_t * pCut1 )
+{
+    unsigned uPhase = 0;
+    int i, k;
+    for ( i = k = 0; i < pCut->nFanins; i++ )
+    {
+        if ( k == pCut1->nFanins )
+            break;
+        if ( pCut->pFanins[i] < pCut1->pFanins[k] )
+            continue;
+        assert( pCut->pFanins[i] == pCut1->pFanins[k] );
+        uPhase |= (1 << i);
+        k++;
+    }
+    return uPhase;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes the fanin variable.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutRemoveIthVar( Cnf_Cut_t * pCut, int iVar, int iFan )
+{
+    int i;
+    assert( pCut->pFanins[iVar] == iFan );
+    pCut->nFanins--;
+    for ( i = iVar; i < pCut->nFanins; i++ )
+        pCut->pFanins[i] = pCut->pFanins[i+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the fanin variable.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutInsertIthVar( Cnf_Cut_t * pCut, int iVar, int iFan )
+{
+    int i;
+    for ( i = pCut->nFanins; i > iVar; i-- )
+        pCut->pFanins[i] = pCut->pFanins[i-1];
+    pCut->pFanins[iVar] = iFan;
+    pCut->nFanins++;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Merges two cuts.]
+
+  Description [Returns NULL of the cuts cannot be merged.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Cut_t * Cnf_CutCompose( Cnf_Man_t * p, Cnf_Cut_t * pCut, Cnf_Cut_t * pCutFan, int iFan )
+{
+    Cnf_Cut_t * pCutRes;
+    static int pFanins[32];
+    unsigned * pTruth, * pTruthFan, * pTruthRes;
+    unsigned * pTop = p->pTruths[0], * pFan = p->pTruths[2], * pTemp = p->pTruths[3];
+    unsigned uPhase, uPhaseFan;
+    int i, iVar, nFanins, RetValue;
+
+    // make sure the second cut is the fanin of the first
+    for ( iVar = 0; iVar < pCut->nFanins; iVar++ )
+        if ( pCut->pFanins[iVar] == iFan )
+            break;
+    assert( iVar < pCut->nFanins );
+    // remove this variable
+    Cnf_CutRemoveIthVar( pCut, iVar, iFan );
+    // merge leaves of the cuts
+    nFanins = Cnf_CutMergeLeaves( pCut, pCutFan, pFanins );
+    if ( nFanins+1 > p->nMergeLimit )
+    {
+        Cnf_CutInsertIthVar( pCut, iVar, iFan );
+        return NULL;
+    }
+    // create new cut
+    pCutRes = Cnf_CutAlloc( p, nFanins );
+    memcpy( pCutRes->pFanins, pFanins, sizeof(int) * nFanins );
+    assert( pCutRes->nFanins <= pCut->nFanins + pCutFan->nFanins );
+
+    // derive its truth table
+    // get the truth tables in the composition space
+    pTruth    = Cnf_CutTruth(pCut);
+    pTruthFan = Cnf_CutTruth(pCutFan);
+    pTruthRes = Cnf_CutTruth(pCutRes);
+    for ( i = 0; i < 2*pCutRes->nWords; i++ )
+        pTop[i] = pTruth[i % pCut->nWords];
+    for ( i = 0; i < pCutRes->nWords; i++ )
+        pFan[i] = pTruthFan[i % pCutFan->nWords];
+    // move the variable to the end
+    uPhase = Kit_BitMask( pCutRes->nFanins+1 ) & ~(1 << iVar);
+    Kit_TruthShrink( pTemp, pTop, pCutRes->nFanins, pCutRes->nFanins+1, uPhase, 1 );
+    // compute the phases
+    uPhase    = Cnf_TruthPhase( pCutRes, pCut    ) | (1 << pCutRes->nFanins);
+    uPhaseFan = Cnf_TruthPhase( pCutRes, pCutFan );
+    // permute truth-tables to the common support
+    Kit_TruthStretch( pTemp, pTop, pCut->nFanins+1,  pCutRes->nFanins+1, uPhase,    1 );
+    Kit_TruthStretch( pTemp, pFan, pCutFan->nFanins, pCutRes->nFanins,   uPhaseFan, 1 );
+    // perform Boolean operation
+    Kit_TruthMux( pTruthRes, pTop, pTop+pCutRes->nWords, pFan, pCutRes->nFanins );
+    // return the cut to its original condition
+    Cnf_CutInsertIthVar( pCut, iVar, iFan );
+    // consider the simple case
+    if ( pCutRes->nFanins < 5 )
+    {
+        pCutRes->Cost = p->pSopSizes[0xFFFF & *pTruthRes] + p->pSopSizes[0xFFFF & ~*pTruthRes];
+        return pCutRes;
+    }
+
+    // derive ISOP for positive phase
+    RetValue = Kit_TruthIsop( pTruthRes, pCutRes->nFanins, p->vMemory, 0 );
+    pCutRes->vIsop[1] = (RetValue == -1)? NULL : Vec_IntDup( p->vMemory );
+    // derive ISOP for negative phase
+    Kit_TruthNot( pTruthRes, pTruthRes, pCutRes->nFanins );
+    RetValue = Kit_TruthIsop( pTruthRes, pCutRes->nFanins, p->vMemory, 0 );
+    pCutRes->vIsop[0] = (RetValue == -1)? NULL : Vec_IntDup( p->vMemory );
+    Kit_TruthNot( pTruthRes, pTruthRes, pCutRes->nFanins );
+
+    // compute the cut cost
+    if ( pCutRes->vIsop[0] == NULL || pCutRes->vIsop[1] == NULL )
+        pCutRes->Cost = 127;
+    else if ( Vec_IntSize(pCutRes->vIsop[0]) + Vec_IntSize(pCutRes->vIsop[1]) > 127 )
+        pCutRes->Cost = 127;
+    else
+        pCutRes->Cost = Vec_IntSize(pCutRes->vIsop[0]) + Vec_IntSize(pCutRes->vIsop[1]);
+    return pCutRes;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfData.c b/src/sat/cnf/cnfData.c
new file mode 100644
index 00000000..3d3cdf37
--- /dev/null
+++ b/src/sat/cnf/cnfData.c
@@ -0,0 +1,4789 @@
+/**CFile****************************************************************
+
+  FileName    [cnfData.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfData.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+static const char s_Data3[82] = "!#&()*+,-.0123456789:;<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZ[]abcdefghijklmnopqrstuvwxyz|";
+
+static const char * s_Data4[] = {
+"! B a . 8 .B 8a K !K T Ta j 8j Tj s ( + (B +a (. +8 .B( +8a (K +K T( +T j( ",
+"+j Tj( s+ E !E H Ha E. 8E H. H8 EK EK! HT HTa jE 8jE Hj sH d +d Hd g d. 8d ",
+"Hd. g8 dK +dK Td gT dj +jd Hjd gs 2 !2 2B a2 5 58 5B 5a 2K 2K! T2 Ta2 5j 58",
+"j 5T s5 ; +; ;B a; 5; > 5;B >a ;K +;K T; +T; ;j >j 5T; s> E2 !E2 H2 Ha2 5E ",
+"58E H5 H58 EK2 !E2K HT2 TaH2 5jE 8j5E H5T sH5 d; +d; H; g; 5d >d H5d g> dK;",
+" dK+; H;T gT; 5dj >jd H;j gs> N !N NB aN N. 8N .BN 8aN Q Q! QT Qa Qj Q8 QTj",
+" sQ (N +N (BN +aN N.( +8N (BN. 8a+N Q( +Q QT( +QT Qj( +Q8 TjQ( s+Q W W! HW ",
+"Wa W. W8 HW. H8W WQ Q!W Z Za Wj W8Q Zj sZ Wd +W HWd gW Wd. +W8 WdH. gW8 Qd ",
+"+WQ Zd gZ Wjd +Wj Zdj gZs m m! mB am 5m 8m 5mB 5am Qm Q!m Tm Qam p p8 pT sp",
+" m; +m m;B +ma 5m; >m m;5B >ma Q; +Qm Q;T +Tm p; p> pT; sp> Wm W!m Hm Hma 5",
+"W 5W8 H5W H8m WQm WmQ! Zm Zam pW pW8 Zp sZp v v+ vH gv v5 v> vH5 gv> vQ v+Q",
+" Zv gZv pv pv> Zpv y # & #B a& #. 8& .B# 8a& #K &K T# T& j# &j Tj# s& #( +&",
+" #B( +a& #(. +8& #(.B 8a+& #(K +&K T#( +T& j#( +j& j#T( s+& #E &E H# H& #E.",
+" 8&E H#. H8& EK# &EK HT# H&T j#E &jE Hj# sH& d# d& Hd# g& d#. 8d& d#H. g8& ",
+"dK# d&K Td# gT& dj# d&j H#dj gs& #2 &2 2B# a&2 5# 5& 5B# 5a& 2K# &2K T#2 T&",
+"2 5j# 5&j 5T# s5& ;# ;& ;#B a;& 5;# >& ;#5B >&a ;#K ;&K T;# T;& ;j# >&j 5#T",
+"; s>& #E2 &E2 H#2 H&2 5#E 5&E H5# H5& #E2K EK&2 T#H2 H2T& j#5E 5E&j H#5T H5",
+"s& d;# d&; H;# g;& 5d# >&d H#5d g>& ;#dK dK;& H#T; T;g& 5#dj d&>j H#;j >&gs",
+" #N &N #BN a&N N.# 8&N #BN. aN8& Q# Q& QT# Qa& Qj# Q8& TjQ# sQ& #(N +&N #(N",
+"B a&+N #(N. 8&+N .BN#( +8a&N Q#( +Q& T#Q( Q&+T j#Q( Q&+j QTj#( +Qs& W# W& H",
+"W# H&W W#. W8& W#H. W8H& WQ# W&Q Z# Z& Wj# W&j Zj# sZ& Wd# +W& WdH# gW& d#W",
+". 8dW& HWd#. W8g& Qd# Qd& Zd# gZ& W#dj W&+j djZ# Z&gs m# m& m#B am& 5m# 5&m",
+" m#5B am5& Qm# Q&m Tm# Tm& p# p& pT# sp& m;# +m& ;#mB m&a; m;5# >m& 5m;#B a",
+"m>& Q;# Q;& Q#T; T;Q& p;# p>& T;p# p&s> Wm# W&m Hm# Hm& 5W# 5W& H#5W 5WH& Q",
+"mW# WQm& Zm# Z&m pW# p&W Zp# Zp& v# v& vH# gv& v5# v>& H5v# v&g> vQ# v&Q Zv",
+"# Zv& pv# pv& Z#pv y& C !C D Da C. 8C D. D8 CK CK! DT DTa jC 8jC Dj sD C( +",
+"C D( +D C(. +8C D(. +D8 CK( +CK DT( +DT jC( +jC Dj( s+D CE !CE HD HDa CE. 8",
+"CE HD. H8D EKC !CEK HDT DTHa jCE jC8E HjD sHD dC +dC Dd gD dC. 8dC Dd. gD8 ",
+"dKC dK+C DdT gDT djC +Cdj Ddj gsD C2 !C2 D2 Da2 5C 58C 5D 5D8 2KC !C2K DT2 ",
+"T2Da 5jC 8j5C 5DT s5D ;C +;C D; +D; 5;C >C 5D; >D ;CK ;C+K D;T D;+T ;jC >jC",
+" D;j s>D CE2 CE!2 HD2 H2Da 5CE 8C5E H5D 5DH8 CE2K !E2CK H2DT HDTa2 jC5E 58j",
+"CE 5DHj H5sD d;C d;+C H;D gD; 5dC >Cd 5Dd g>D ;CdK +d;CK TdD; D;gT 5Cdj dj>",
+"C Dd5T >Dgs CN !CN DN DaN N.C 8CN DN. D8N QC Q!C QD QDa QjC Q8C QDj sQD C(N",
+" +CN D(N +DN C(N. 8C+N N.D( +ND8 QC( +QC QD( +QD jCQ( +CQ8 Q(Dj +QsD WC W!C",
+" WD WDa WC. W8C WD. WD8 WQC WCQ! ZD ZDa WjC WCQ8 ZDj sZD WdC +WC WDd gWD dC",
+"W. +CW8 W.Dd WDg8 QdC +CQd ZDd gZD WCdj +CWj DdZj gDsZ mC mC! Dm Dma 5mC 8m",
+"C 5Dm D8m QmC mCQ! QDm DmQa pC p8C pD spD m;C +mC Dm; +Dm m;5C >mC 5mD; >Dm",
+" Q;C +CQ; QD; QD+m p;C p>C pD; p>D WmC mCW! HmD DmWa 5WC 5CW8 5WD WD5a QmWC",
+" Q!WmC ZDm DmZa pWC W8pC ZpD pDsZ vC v+C vD gvD v5C v>C vD5 v>D vQC +QvC Zv",
+"D vDgZ pvC >Cpv pvD yD b b& bD c b. b8 bD. c8 bK bK& bT cT bj b8j bTj sc b(",
+" b+ bD( c+ b(. b+8 D(b. c+8 bK( b+K bT( c+T bj( b+j b(Dj sc+ bE b&E bH cH b",
+"E. b8E bH. cH8 bKE &EbK bHT cHT bjE bE&j bHj scH bd b+d bHd gc bd. b8d b.Dd",
+" gc8 bdK bKd& bTd gcT bdj +jbd Hjbd gsc b2 b&2 bD2 c2 b5 b58 b5D c5 bK2 &2b",
+"K bT2 c2T b5j 5&bj b5T sc5 b; b+; b;D c; b5; >b 5Db; c> b;K bK;& bT; c;T b;",
+"j >bj 5Tb; c>s bE2 &Eb2 bH2 c2H b5E bE5& bH5 c5H EKb2 bK&E2 HTb2 HTc2 5jbE ",
+"&jEb5 H5bT sHc5 bd; d&b; bH; gc; b5d >bd H5bd c>g dKb; d&;bK H;bT gTc; 5dbj",
+" bd>j H;bj gsc> bN b&N bDN cN bN. b8N DNb. c8N bQ bQ& bQD cQ bQj bQ8 QDbj s",
+"cQ b(N b+N D(bN c+N N.b( +8bN bD(N. +8cN bQ( b+Q b(QD cQ+ Qjb( +Qb8 bQDj( s",
+"+cQ bW bW& bHW cW bW. bW8 b.WD cW8 bWQ W&bQ Zb Zc bWj W8bQ Zbj Zcs bWd b+W ",
+"WDbd gcW Wdb. +Wb8 bHWd. g8cW bQd +WbQ Zbd Zcg Wjbd +Wbj bdZj gsZc bm bm& b",
+"mD cm b5m b8m 5Dbm c5m bQm Q&bm bTm cQm pb pb8 pbD cp bm; b+m Dmb; cm+ 5mb;",
+" >bm b5Dm; c>m bQ; +Qbm QDb; cQ; pb; p>b bTp; cp> bWm W&bm bHm cWm b5W 5Wb8",
+" H5bW c5W WQbm bWQm& Zbm Zcm pbW bWp& Zpb cpZ vb vb+ vbH cv vb5 v>b bHv5 cv",
+"> vbQ b+vQ Zvb cvZ pvb v>pb pvZb yc 0 !0 0B a0 1 18 1B 1a 0K !K0 T0 Ta0 1j ",
+"18j 1T s1 0( +0 0B( +a0 1( 1+ 1(B 1+a 0(K +0K T0( +T0 1j( 1+j 1T( s1+ E0 !E",
+"0 H0 Ha0 1E 18E 1H 1H8 EK0 !0EK HT0 TaH0 1jE 8j1E 1HT s1H d0 +d0 Hd0 g0 1d ",
+"1+d 1Hd g1 dK0 dK+0 Td0 gT0 1dj +j1d 1Td gs1 02 !02 2B0 a02 15 158 15B 1a5 ",
+"2K0 !02K T02 T2a0 15j 581j 1T5 s15 ;0 +;0 ;0B a;0 1; >1 1;B >1a ;0K ;0+K T;",
+"0 +0T; 1;j >j1 1T; s>1 E02 E0!2 H02 a0H2 15E 581E 1H5 H51a E02K !E20K T0H2 ",
+"HTa02 5j1E 158jE H51T 1Hs5 d;0 d;+0 H;0 g;0 1d5 >1d 1H; g>1 ;0dK +d;0K H0T;",
+" T;g0 dj1; 1d>j H;1T s>g1 0N !0N 0BN a0N 1N 18N 1NB 1aN Q0 Q!0 QT0 Qa0 1Q 1",
+"Q8 1QT s1Q 0(N +0N 0(NB a0+N 1(N 1+N (B1N +a1N Q0( +Q0 T0Q( +0Qa 1Q( 1+Q QT",
+"1( 1+sQ W0 W!0 HW0 Wa0 1W 1W8 1HW 1Wa WQ0 W0Q! Z0 Za0 1WQ W81Q Z1 sZ1 Wd0 +",
+"W0 WdH0 gW0 1Wd 1+W HW1d g1W Qd0 +0Qd Zd0 gZ0 1Qd +W1Q Z1d gZ1 m0 m0! m0B a",
+"m0 1m 1m8 1mB 1am Qm0 m0Q! Tm0 Q0am p1 p18 p1T sp1 m;0 +m0 ;0mB +0am 1m; >m",
+"1 m;1B 1a>m Q;0 +0Q; Q0T; +0Tm p1; p>1 1Tp; s1p> Wm0 m0W! Hm0 H0am 1W5 W81m",
+" 1Hm H81m QmW0 Q!Wm0 Zm0 amZ0 p1W 1Wp8 Zp1 Z1sp v0 v+0 vH0 gv0 v1 v>1 v1H g",
+"v1 vQ0 +Qv0 Zv0 g0Zv pv1 v1p> Zv1 y1 9 9& 9B 9a 91 : 91B :a 9K 9&K 9T 9Ta 9",
+"j :j 9T1 s: 9( 9+ 9(B 9+a 91( :+ 1B9( :+a 9(K 9+K 9T( 9+T 9j( :+j 9(1T s:+ ",
+"9E 9&E 9H 9Ha 91E :E 9H1 :H 9EK &E9K 9HT H&9T 9jE :jE 9Hj s:H 9d 9+d 9Hd g9",
+" 9d1 :d 1H9d g: 9dK 9Kd& 9Td g9T 9dj :dj 1T9d g:s 92 9&2 92B 9a2 95 :5 95B ",
+":5a 92K &29K 9T2 92T& 95j :5j 95T s:5 9; 9+; 9;B 9a; 95; :> 1B9; :>a 9;K 9K",
+";& 9T; +T9; 9;j :>j 1T9; s:> 9E2 &E92 9H2 92H& 95E :5E 9H5 :H5 EK92 9&E2K H",
+"T92 9HT&2 5j9E 5j:E H59T s5:H 9d; d&9; 9H; g9; 95d :>d 1H9; g:> dK9; d&;9K ",
+"H;9T 9Tg; 5d9j >j:d H;9j s:g> 9N 9&N 9NB 9aN 91N :N 1B9N :aN 9Q 9Q& 9QT 9Qa",
+" 9Q1 :Q 1Q9T s:Q 9(N 9+N (B9N +a9N 1(9N :+N 91(NB +a:N 9Q( 9+Q QT9( +Q9T 9(",
+"1Q :Q+ 9Q1T( s+:Q 9W 9W& 9HW 9Wa 9W1 :W 1H9W :HW 9WQ W&9Q Z9 Z9a 9Wj :WQ Z9",
+"1 Z: 9Wd 9+W HW9d g9W 1W9d :W+ 9H1Wd g:W 9Qd +W9Q Z9d gZ9 1Q9d :Qd 9dZ1 Z:g",
+" 9m 9m& 9mB 9am 95m :m 1B9m :ma 9Qm Q&9m 9Tm Qa9m p9 :p p9T :ps 9m; 9+m m;9",
+"B +m9a 1m9; :>m 95;mB :a>m 9Q; +Q9m Q;9T +T9m p9; :p> 9Tp; s>:p 9Wm W&9m 9H",
+"m Hm9a 95W :W5 1H9m :Hm WQ9m 9WQm& Z9m 9aZm p9W :pW Zp9 Z:p v9 v9+ v9H gv9 ",
+"v91 :v 9Hv1 :vg v9Q 9+vQ Zv9 Zvg9 pv9 :vp pvZ9 y: C0 !C0 D0 Da0 1C 18C 1D 1",
+"D8 CK0 !0CK DT0 TaD0 1jC 8j1C 1DT s1D C0( +C0 D0( +D0 1C( 1+C 1D( 1+D 0(CK ",
+"CK+0 T0D( DT+0 jC1( 1C+j 1(Dj 1+sD CE0 CE!0 HD0 DaH0 1CE 8C1E 1HD H81D C0EK",
+" !E0CK DTH0 HDTa0 jC1E 18jCE Hj1D 1HsD dC0 dC+0 Dd0 gD0 1dC 1C8d 1Dd g1D CK",
+"d0 +dC0K D0Td DTg0 1Cdj djC1+ Dd1T s1gD C02 C0!2 D02 D2a0 15C 581C 1D5 5D1a",
+" C02K C02!K T2D0 DTa02 5j1C 158jC 5D1T 1Ds5 ;C0 ;C+0 D;0 +0D; 1;C >C1 1D; >",
+"D1 CK;0 +;C0K D0T; a;0DT 1C;j 1j>C D;1T s1>D E0C2 C02!E D0H2 HDa02 5C1E 158",
+"CE H51D 1H5D8 C02EK EK0!C2 HDT02 DTaH02 15jCE 58j1CE 1H5Dj s1H5D ;Cd0 +d;C0",
+" H0D; D;g0 1C5d 1d>C H;1D >Dg1 dK;C0 dK;+C0 H;DT0 gDT;0 djC1; >j1dC 1H;Dj g",
+"s>1D C0N C0!N D0N a0DN 1CN 8C1N 1DN 1ND8 QC0 !CQ0 QD0 DaQ0 1QC 1CQ8 1QD 1Qs",
+"D 0(CN C0+N 0(DN D0+N C(1N +C1N D(1N 1N+D C0Q( QC+0 D0Q( +0QD QC1( 1C+Q 1(Q",
+"D +Q1D WC0 !CW0 WD0 DaW0 1WC 1CW8 1WD WD1a QCW0 Q!WC0 ZD0 DaZ0 1CWj 1WQ8C Z",
+"1D sDZ1 dCW0 WC+0 W0Dd WDg0 Wd1C 1C+W WD1d 1WgD dCQ0 +WQC0 DdZ0 ZDg0 1CQd 1",
+"+WQC 1DZd gDZ1 mC0 !Cm0 Dm0 D0am 1mC 1C8m 1Dm D81m mCQ0 Q!mC0 Q0Dm am0QD p1",
+"C 18pC pD1 s1pD ;Cm0 mC+0 m;D0 +0Dm m;1C 1m>C Dm1; 1D>m ;CQ0 +QmC0 Q0D; +QD",
+"m0 1;pC p1>C 1Dp; p1>D mCW0 W!mC0 H0Dm am0WD 1C5W 1W58C Hm1D 1HmD8 WQmC0 Wm",
+"CQ!0 DmZ0 ZDam0 1WpC p1W8C pDZ1 Zp1sD vC0 +Cv0 vD0 g0vD v1C >Cv1 v1D vDg1 Q",
+"Cv0 v+QC0 Z0vD ZvDg0 pCv1 pv>1C v1pD y1D b9 b9& 9D c9 b1 :b b1D :c b9K 9&bK",
+" bT9 c9T b1j :bj b1T s:c b9( b+9 9D( c9+ b1( :b+ b(1D :c+ 9(bK bK9+ b(9T 9+",
+"cT b(9j b+:j b(1T s+:c b9E 9&bE bH9 c9H b1E :bE b1H :cH 9EbK b9&EK 9HbT 9Hc",
+"T bE9j bj:E 9Hbj :Hsc bd9 9+bd 9Dd gc9 b1d :db 1Hbd g:c bK9d d&Kb9 9Tbd c9g",
+"T 9dbj bd:j 1Tbd s:gc b92 9&b2 9D2 c29 b15 :b5 95D :c5 92bK b9&2K b29T 9Tc2",
+" 95bj b5:j 95bT c5s: b;9 9+b; 9D; c;9 b1; :>b 1Db; c>: bK9; ;&Kb9 9Tb; 9Tc;",
+" 9;bj :b>j 1Tb; s:c> 9Eb2 b9&E2 b29H 9Hc2 bE95 b5:E 9Hb5 c5:H b9E2K 9&EbK2 ",
+"bH9T2 c29HT b15jE :b5jE b1H5T :cHs5 9db; d&;b9 9Hb; c;g9 95bd >b:d 1Hb; c>g",
+": bd9;K bd9;&K bH;9T c;9gT b1d;j :>bdj b1HT; g:sc> b9N 9&bN 9DN c9N b1N :bN",
+" bN1D :cN bQ9 b9Q& 9QD cQ9 b1Q :Qb 1QbT :cQ 9(bN bN9+ D(9N 9+cN 1(bN b+:N b",
+"1D(N cN:+ b(9Q 9+bQ 9(QD 9+cQ b(1Q b+:Q b1QD( :+cQ bW9 b9W& 9WD cW9 b1W :Wb",
+" 1HbW :cW 9WbQ bW9Q& Zb9 Zc9 9Wbj bW:Q Zb1 Z:c 9Wbd 9+bW WD9d cWg9 1Wbd b+:",
+"W b1HWd :Wgc 9Qbd b+W9Q bdZ9 g9Zc 1Qbd bQ:d b1Zd Zcg: bm9 b9m& 9Dm cm9 b1m ",
+":mb 1Dbm :cm 9Qbm bQ9m& 9Tbm 9Qcm pb9 :pb p9D cp: 9mb; 9+bm Dm9; 9+cm 1mb; ",
+">b:m b1mD; :mc> 9Qb; b+Q9m QD9; 9Qc; b1p; pb:> 9Dp; c>:p 9Wbm bW9m& 9Hbm 9H",
+"cm 95bW b5:W 1Hbm c5:W bW9Qm 9WQbm& bmZ9 cmZ9 b1pW pb:W pbZ9 cpZ: vb9 b+v9 ",
+"v9D cv9 vb1 :vb b1vD :vc bQv9 vb9+Q vbZ9 Z9cv vbp9 pb:v vbZ1 y:c L !L LB aL",
+" L. 8L .BL 8aL M M! TM aM Mj 8M TMj sM (L +L (BL +aL (L. +8L (L.B 8a+L M( +",
+"M TM( +TM Mj( +M8 MjT( s+M EL !EL HL HaL EL. 8EL HL. H8L ME ME! HM HMa MjE ",
+"8ME HMj sHM dL +dL HdL gL dL. 8dL dLH. g8L dM +Md HMd gM dMj 8dM dMHj gsM L",
+"2 !L2 2BL aL2 5L 58L 5BL 5aL M2 M2! TM2 aM2 5M 5M8 5TM s5M ;L +;L ;LB a;L 5",
+";L >L ;L5B >La M; +M; T;M aM; 5M; >M T;5M >Ms EL2 EL!2 HL2 aLH2 5EL 8E5L H5",
+"L HL5a ME2 !EM2 HM2 H2aM 5ME 5E8M H5M H5sM d;L d;+L H;L g;L 5dL >Ld HL5d g>",
+"L dM; +dM; HM; gM; 5dM >Md 5dHM >Mg LN !LN NBL aLN N.L 8LN LBN. aN8L QM Q!M",
+" QTM QaM QMj Q8M TMQj sQM (LN +LN (LNB aL+N (LN. 8L+N (BLN. +8aLN QM( +QM T",
+"MQ( Qa+M MjQ( Q8+M QTMj( +QsM WL W!L HWL WaL WL. W8L WLH. HLW8 WM WM! ZM Za",
+"M WMj W8M ZMj sZM WdL +WL WdHL gWL dLW. +LW8 HWdL. W8gL WMd +WM ZdM gZM dMW",
+"j W8+M dMZj sZgM mL mL! mLB amL 5mL 8mL mL5B 5Lam Mm Mm! TmM aMm pM p8M pTM",
+" spM m;L +mL ;LmB +Lam m;5L >mL 5m;LB am>L Q;M +Mm MmT; Tm+M pM; >Mp T;pM s",
+"p>M WmL mLW! HmL HLam 5WL 5LW8 HL5W HL8m WMm W!Mm ZMm aMZm pWM W8pM ZpM sMZ",
+"p vL v+L vHL gvL v5L v>L H5vL >Lgv vM vM+ ZvM gvM pvM >Mv vMZp yM #L &L #BL",
+" a&L #L. 8&L #L.B a&8L M# M& TM# T&M Mj# 8M& MjT# sM& #(L +&L #(LB a&+L (L#",
+". 8&+L #L.(B +8a&L M#( +M& M#T( T&+M j#M( M&+j TMj#( +Ms& #EL &EL H#L H&L E",
+"L#. &E8L #LH. 8&HL M#E M&E HM# HM& j#ME 8EM& MjH# HMs& d#L d&L d#HL g&L #Ld",
+". 8Ld& Hd#L. 8&gL dM# dM& H#dM gM& Mjd# d&8M dMjH# sMg& #L2 &L2 #L2B &2aL 5",
+"#L 5&L #B5L a&5L M#2 M&2 M#T2 T2M& 5M# 5M& TM5# 5Ms& ;#L ;&L #B;L aL;& ;#5L",
+" >&L 5;#LB a&>L M;# M;& T#M; M;T& 5#M; >M& M;#5T sM>& EL#2 EL&2 #LH2 &LH2 #",
+"E5L &E5L 5#HL HL5& #EM2 &EM2 M#H2 H2M& M#5E 5EM& H#5M 5MH& ;#dL dL;& ;#HL ;",
+"&gL d#5L d&>L H5d#L g&>L d#M; M;d& H#M; M;g& 5#dM dM>& H5Md# >&gM #LN &LN #",
+"LNB &LaN #LN. &L8N #LN.B 8a&LN QM# Q&M TMQ# aMQ& MjQ# 8MQ& QTMj# Q&sM (L#N ",
+"&L+N #LN(B +a&LN #LN(. +8&LN N.#(BL 8a&+LN M#Q( Q&+M QTM#( +QTM& QMj#( +Q8M",
+"& TMjQ#( s+QM& W#L W&L W#HL HLW& #LW. 8&WL HW#L. H8W&L WM# WM& ZM# Z&M MjW#",
+" 8MW& MjZ# sMZ& d#WL +LW& HWd#L W&gL Wd#L. d&LW8 Wd#HL. gW8&L W#dM W&+M dMZ",
+"# Z&gM dMjW# dM&W8 ZdMj# Z&Mgs m#L m&L #BmL aLm& m#5L 5Lm& 5m#LB am&5L Mm# ",
+"Mm& T#Mm MmT& pM# p&M TMp# sMp& ;#mL +Lm& m;#LB am&+L 5m;#L m&>L m;#5BL >ma",
+"&L Q#M; M;Q& Mm#T; aMm;& M;p# p&>M pTM;# >Mps& m#WL WLm& m#HL HLm& W#5L 5LW",
+"& H5W#L H5&WL W#Mm MmW& MmZ# MmZ& WMp# WMp& pMZ# ZMp& v#L v&L H#vL gLv& 5#v",
+"L >Lv& vH5#L gv>&L vM# vM& Z#vM vMZ& p#vM vMp& ZpvM# y&M U U! UD Ua U. U8 U",
+"D. U8D UM U!M V Va Uj U8M Vj Vs U( U+ UD( U+D U(. U+8 D(U. +DU8 UM( U+M V( ",
+"V+ Uj( U+j Vj( Vs+ UE U!E UH UHa UE. U8E UH. UH8 UME MEU! VH VHa UjE UE8M V",
+"Hj VsH Ud U+d UHd gU Ud. U8d U.Dd gU8 UdM +MUd Vd gV Udj +jUd Vdj gVs U2 U!",
+"2 UD2 Ua2 U5 U58 U5D U5a UM2 M2U! V2 V2a U5M 5MU8 V5 Vs5 U; U+; U;D Ua; U5;",
+" >U 5DU; >UD U;M +MU; V; V+; U;j >MU V5; V> UE2 !EU2 UH2 HaU2 U5E 58UE UH5 ",
+"H5U8 MEU2 U!ME2 V2H HaV2 UE5M U58ME V5H sHV5 Ud; +dU; UH; gU; U5d >Ud H5Ud ",
+"g>U dMU; dM;U+ Vd; gV; 5dUj Ud>M V5d V>g UN U!N UDN UaN UN. U8N DNU. UND8 U",
+"Q UQ! VQ VQa UQj UQ8 VQj VsQ U(N U+N D(UN UN+D N.U( +8UN UD(N. U+D8N UQ( U+",
+"Q VQ( V+Q QjU( +QU8 QjV( sQV+ UW UW! UHW UWa UW. UW8 U.WD H8UW UWQ Q!UW VZ ",
+"VZa UWj W8UQ VZj sZV UWd U+W WDUd gUW WdU. +WU8 UHWd. UWg8 UQd +WUQ VZd gVZ",
+" WjUd +WUj ZjVd sZgV Um Um! UmD Uam U5m U8m 5DUm 5aUm UQm Q!Um Vm Vma pU pU",
+"8 Vp Vps Um; U+m DmU; +DUm 5mU; >Um U5Dm; Ua>m UQ; +QUm Vm; V+m pU; p>U Vp;",
+" V>p UWm W!Um UHm HmUa U5W 5WU8 H5UW H8Um WMUm Mm!UW VZm ZaVm pUW UWp8 VpZ ",
+"sZVp vU vU+ vUH gvU vU5 v>U UHv5 v>gU vUQ U+vM Vv Vvg pvU v>pU Vvp yV bU U&",
+" bUD cU bU. b8U UDb. cU8 bM bM& Vb Vc bMj b8M Vbj scV bU( b+U UDb( cU+ U(b.",
+" U+b8 bUD(. U+c8 bM( b+M Vb( Vc+ b(Uj U+bj bjV( V+sc bUE U&E bHU cUH UEb. b",
+"EU8 b.UH UHc8 bME bEM& VbH VcH bEUj bE8M bHVj sHVc bdU Ud& UHbd gcU b.Ud U8",
+"bd bHUd. cUg8 bdM +Mbd Vdb gVc Udbj 8dbM bdVj scgV bU2 U&2 UDb2 c2U b5U U5&",
+" bU5D c5U bM2 b2M& V2b Vc2 b5M 5Mb8 V5b c5V b;U U;& bUD; c;U U5b; >bU b5UD;",
+" c>U bM; +Mb; V;b c;V U;bj >Mb b5V; V>c UEb2 &EU2 b2UH UHc2 bEU5 UE5& UHb5 ",
+"UHc5 MEb2 M&Eb2 bHV2 cHV2 bE5M b5M8E bHV5 cHV5 Udb; d&U; UHb; c;gU U5bd bd>",
+"U bH5Ud gUc> dMb; dM&b; bHV; c;gV 5dbM bd>M b5Vd c>gV bUN U&N UDbN cUN UNb.",
+" bNU8 bUDN. U8cN bQU UQ& VbQ cQV UQbj UQb8 bQVj VscQ U(bN bNU+ bUD(N U+cN b",
+"U(N. b+U8N UD(bN. cU+8N b(UQ U+bQ bQV( V+cQ bQUj( b+QU8 VbQj( cQVs+ bWU UW&",
+" UHbW cWU b.UW UWb8 bHUW. UWc8 bWM WMU& ZbV ZcV UWbj W8bM VbZj VZsc UWbd U+",
+"bW bHUWd cWgU bWUd. b+WU8 UHWbd. cWUg8 UQbd +WbM VdZb ZcgV bWMdj d&jUW ZbVd",
+"j gVZsc bmU Um& bUDm cmU U5bm U8bm b5UDm U5cm bMm Q&Um Vmb cmV pbU pU& Vpb ",
+"cpV Umb; U+bm bmUD; U+cm b5Um; bm>U U5Dbm; >Ucm UQb; +Mbm bQV; V+cm bMp; pb",
+">M V;pb V>cp UWbm W&Um UHbm UHcm U5bW 5WU& bH5UW U5cW WMbm Mm&bW VmZb VZcm ",
+"bWpU UWp& ZbVp VpZc vbU vU& bHvU cvU b5vU >bvU vbUH5 vUc> vbM b+vM Vvb cvV ",
+"vbpU vb>M pbVv yVc k k! kB ak 1k 8k 1kB 1ak kM kM! Tk Tka l l8 lT ls k( +k ",
+"k(B +ka 1k( 1+k k(1B +k1a kM( +kM Tk( +Tk l( l+ lT( ls+ kE kE! Hk Hka 1kE 8",
+"kE 1Hk H8k kME M!kE HkT akHM lE l8E lH lsH dk +kd Hkd gk 1dk 8dk Hk1d g1k d",
+"kM dk+M Tdk gkT ld l+d lHd gl k2 k2! k2B ak2 5k 5k8 5kB 5ak kM2 M!k2 Tk2 T2",
+"ak l5 l58 l5T ls5 k; +k; k;B ak; 1;k >k 1Bk; >ka k;M k;+M Tk; T;+k l; l> l;",
+"T l>s kE2 !Ek2 Hk2 H2ak 5kE 5E8k H5k 5aHk MEk2 kME!2 H2Tk ak2HM l5E 58lE lH",
+"5 sHl5 dk; +dk; Hk; gk; 5dk >kd Hk1; >kg k;dM dkM+; TkH; Tkg; ld5 l>d lH; g",
+"l> kN kN! kNB akN 1kN 8kN kN1B 1Nak Qk Qk! QkT Qak lQ lQ8 lQT lsQ k(N +kN (",
+"BkN +Nak k(1N 1N+k 1k(NB akN1+ Qk( +Qk Q(Tk Qa+k lQ( l+Q QTl( s+lQ Wk Wk! H",
+"kW Wak 1Wk W8k Hk1W W8Hk WkQ Q!Wk Zk Zka lW lW8 lZ lZs Wkd +Wk HWdk gkW Wk1",
+"d +k1W 1HWdk 1Wgk Qdk Wk+Q Zkd gZk lWd l+W lZd glZ km km! kmB akm 1mk 8km 1",
+"Bkm ak1m Qkm Q!km Tkm akTm lp lp8 lpT lsp km; +km m;kB ak+m km1; >km km;1B ",
+"ak>m Qk; Qk+m TkQ; Tk+m l;p l>p pTl; spl> Wkm W!km Hkm akHm 5Wk W85k Hk1m W",
+"a5k kmWM km!WM Zkm akZm lWp pWl8 lZp splZ vk vk+ vkH gvk v1k >kv 1Hvk gv>k ",
+"vkQ +Qvk Zvk Zvgk lv lv> lvZ yl 9k k& 9kB 9ak 91k :k 1B9k :ak 9M 9M& 9Tk 9a",
+"M l9 l: l9T ls: 9k( 9+k k(9B +k9a 1k9( :+k 91k(B +k:a 9M( 9+M 9(Tk +T9M l9(",
+" l:+ 9Tl( s:l+ 9kE k&E 9Hk Hk& 1k9E :kE 91Hk :Hk 9ME 9EM& 9HM HM9a l9E l:E ",
+"lH9 l:H 9dk dk& Hk9d g9k 91dk :dk 9H1dk g:k 9dM +M9d HM9d g9M ld9 l:d 9Hld ",
+"gl: 9k2 k&2 k29B 92ak 95k :5k 9B5k 5a:k 9M2 92M& 92Tk 92aM l95 l:5 95lT l5s",
+": 9;k k;& 9Bk; ak9; 5k9; >k: k;B95 :a>k 9M; +M9; Tk9; aM9; l;9 l>: 9Tl; s:l",
+"> kE92 &Ek2 92Hk H2k& 9E5k 5k:E Hk95 H5:k ME92 k&EM2 92HM 9HM&2 95lE :5lE 9",
+"Hl5 l5:H dk9; k;d& Hk9; 9;gk 5k9d :d>k 9H5dk >kg: dM9; dk&M; HM9; 9Mg; 95ld",
+" :>ld 9Hl; g:l> 9kN k&N kN9B 9Nak 1k9N :kN 91kNB ak:N 9Qk Qk& Qk9T Qa9M l9Q",
+" l:Q 9QlT :Qls k(9N 9N+k 9k(NB akN9+ 91k(N +k:N 1k(9NB :+akN 9(Qk +Q9M 9QTk",
+"( 9+QTk 9Ql( :Ql+ l9QT( :Q+ls 9Wk Wk& Hk9W Wk9a 91Wk :Wk 9H1Wk Hk:W 9WM W&9",
+"M Z9k Zk& lW9 l:W lZ9 Z:l Wk9d +k9W 9HWdk 9Wgk 9W1dk +W:k 1HW9dk :Wgk WM9d ",
+"+W9M 9dZk Z9gk 9Wld :Wl+ Z9ld Z:gl 9mk km& 9Bkm ak9m 5k9m :mk kmB95 ak:m 9M",
+"m kmQ& Tk9m aM9m p9l :pl lTp9 ls:p km9; +k9m km;9B akm9+ km;95 :m>k 95;kmB ",
+":>akm Qk9; +M9m 9Q;Tk ak;9Q p9l; :pl> l;p9T l>ps: Wk9m kmW& Hk9m kmH& 5k9W ",
+"5W:k 9H5Wk Hk:m WM9m km&WM 9MZm kmZ& p9lW lW:p p9lZ lZ:p v9k vk& 9Hvk v9gk ",
+"95vk :vk v91Hk gk:v v9M 9+vM v9Zk v9gM lv9 lv: Z9lv yl: Uk U!k Dk Uak 1U 1U",
+"8 1UD 1Ua UkM kMU! Vk Vak lU lU8 Vl lsV Uk( U+k Dk( +Dk 1U( 1U+ 1(Dk U+1D k",
+"MU( Uk+M Vk( V+k lU( l+U Vl( l+V UkE kEU! UHk HkUa 1UE 1EU8 1UH UH1a kMUE U",
+"!kME VHk HkVa lUE U8lE lHV VslH Udk +kUd Ddk gUk 1Ud U+1d UH1d g1U UkdM dkM",
+"U+ Vdk gVk ldU U+ld ldV glV Uk2 k2U! Dk2 U2ak 1U5 5kU8 5Dk U51a kMU2 U!kM2 ",
+"V2k akV2 lU5 U5l8 Vl5 V5ls U;k +kU; Dk; D;+k 1U; >kU U;1D >kD UkM; k;MU+ V;",
+"k +kV; l;U l>U l;V V>l kEU2 U!kE2 U2Hk ak2UH 1EU5 1U58E U51H 1UH5a UkME2 kM",
+"EU!2 HkV2 V2Hak U5lE lU58E V5lH lsVH5 dkU; dk;U+ HkU; U;gk U51d 1U>d UH1; g",
+"U>k dkMU; U+dk;M HkV; V;gk U5ld >Uld V5ld V>gl UkN kNU! DkN UNak 1UN 1NU8 1",
+"NDk 1NUa UQk U!Qk VQk QaVk lUQ UQl8 VlQ lQVs k(UN UN+k k(DN +NDk U(1N 1NU+ ",
+"1UD(N 1U+DN U(Qk +kUQ QkV( +QVk UQl( U+lQ VQl( lQV+ UWk U!Wk WDk WkUa 1UW U",
+"81W UH1W UW1a WkUQ UWQk! ZkV VaZk lWU UWl8 lZV VlsZ WkUd +kUW DdWk UWgk UW1",
+"d U+1W 1UHWd 1UgW QkUd U+WQk VdZk ZkgV UWld U+lW VZld lZgV Umk U!km Dkm akU",
+"m 1Um U81m Um1D Ua1m QkUm km!UQ Vmk akVm pUl l8pU Vpl lsVp kmU; +kUm kmD; D",
+"k+m Um1; 1U>m 1UmD; Dk>m QkU; U+Qkm QkV; +kVm pUl; pUl> l;Vp Vpl> WkUm km!U",
+"W HkUm akmUH U51W 1UW8m UH1m 1UH8m UWQkm UWQkm! VmZk ZkVam pUlW lWpU8 lZVp ",
+"VplsZ vUk U+vk vDk vUgk v1U vU>k 1UvD v1gU UQvk vU+Qk Vvk gkVv lvU vUl> lvV",
+" ylV t t& tD tc t1 t: t1D t:c tM tM& Vt tcV lt lt: ltV u t( t+ tD( tc+ t1( ",
+"t:+ 1Dt( :ct+ tM( t+M Vt( t+V lt( lt+ l(Vt u+ tE t&E tH tcH t1E t:E tH1 t:H",
+" tME M&tE tHV VctH ltE lEt: ltH uH td t+d tHd gt td1 t:d 1Htd gt: tdM +Mtd ",
+"tdV gtV ltd t:ld tHld ug t2 t&2 tD2 tc2 t5 t:5 t5D tc5 tM2 M&t2 Vt2 V2tc lt",
+"5 t5l: t5V u5 t; t+; t;D tc; t5; t> 1Dt; t>c t;M +Mt; t;V Vtc; lt; t>l Vlt;",
+" u> tE2 &Et2 tH2 c2tH t5E :5tE tH5 :Ht5 MEt2 tM&E2 V2tH tcVH2 lEt5 t:5lE t5",
+"lH uH5 td; d&t; tH; gt; t5d t>d 1Ht; gt> dMt; t+dM; Vdt; t;gV t5ld ldt> tHl",
+"; ug> tN t&N tDN tcN t1N t:N 1DtN tN:c tQ tQ& tQV tcQ ltQ t:Q VltQ uQ t(N t",
+"+N D(tN c+tN 1(tN :+tN t1D(N t:c+N tQ( t+Q VQt( cQt+ l(tQ tQl+ tQVl( u+Q tW",
+" tW& tHW tcW tW1 t:W 1HtW :ctW tWQ WMt& tZ tZc ltW t:lW tZl uZ tWd t+W WDtd",
+" gtW 1Wtd :Wt+ tH1Wd tWg: tQd +WtQ tZd gtZ tWld t+lW ldtZ uZg tm tm& tmD tc",
+"m t5m t:m 1Dtm :ctm tQm Q&tm tmV cQtm tp tp: tpV up tm; t+m Dmt; cmt+ 1mt; ",
+"t>m t5Dm; tmc> tQ; +Qtm Vmt; cQt; tp; tp> t;Vp up> tWm W&tm tHm cWtm t5W :W",
+"t5 1Htm :Htm WMtm tWQm& tZm tmZc tpW tW:p tZp uZp tv tv+ tvH gtv tv1 tv: v1",
+"tH :vgt tvQ vMt+ tZv cvtZ lvt t>lv tZlv yu ) !) )B a) ). 8) .B) 8a) )K !K) ",
+"T) Ta) j) 8j) Tj) s) * +* *B a* *. 8* *B. 8*a *K +*K T* +T* *j +j* T*j s* E",
+") !E) H) Ha) E). 8E) H). H8) EK) !)EK HT) TaH) jE) jE8) Hj) sH) d* +d* H* g",
+"* d*. 8d* H*. g8* dK* dK+* H*T gT* dj* dj8* H*j gs* )2 !)2 2B) a)2 5) 58) 5",
+"B) 5a) 2K) !)2K T)2 T2a) 5j) 8j5) 5T) s5) ;* +;* *B; a;* 5* >* 5*B >*a ;*K ",
+";*+K T;* a;T* 5*j >*j 5T* s>* E)2 E)!2 H)2 a)H2 5E) 8E5) H5) H)5a E)2K !)2E",
+"K T)H2 HTa)2 jE5) 58jE) H)5T H5s) d;* d;+* H;* g;* 5d* >*d H5* g>* ;*dK +d;",
+"*K T;H* T;g* dj5* dj>* 5TH* s*g> )N !)N )BN a)N N.) 8)N )BN. aN8) Q) Q!) QT",
+") Qa) Qj) Q8) TjQ) sQ) *N +*N *BN a*N *N. 8*N .B*N aN8* Q* +Q* Q*T Qa* Q*j ",
+"Q8* QT*j s*Q W) W!) HW) Wa) W). W8) W)H. H)W8 WQ) W)Q! Z) Za) Wj) W)Q8 Zj) ",
+"sZ) W* +W* H*W gW* W*. W8* H.W* W8g* W*Q W*+Q Z* gZ* W*j W*+j Z*j sZ* m) m)",
+"! m)B am) 5m) 8m) m)5B 5)am Qm) m)Q! Tm) Q)am p) p8) pT) sp) m* +m* m*B am*",
+" 5*m >m* 5m*B am>* Q;* Q*+m Tm* T*+m p* p>* p*T sp* Wm) m)W! Hm) H)am 5W) 5",
+")W8 H)5W H)8m QmW) Q!Wm) Zm) amZ) pW) W8p) Zp) s)Zp v* v+* vH* gv* v5* v>* ",
+"H5v* >*gv vQ* +Qv* Zv* Z*gv pv* v>p* Zp* y* , ,& ,B ,a ,. ,8 ,.B ,8a ,K ,&K",
+" ,T ,Ta ,j ,8j ,Tj s, ,* - *B, -a ,*. -8 ,.*B -8a ,*K -K ,T* -T ,j* -j T*,j",
+" s- ,E ,&E ,H ,Ha ,E. ,8E ,H. ,H8 ,EK &E,K ,HT H&,T ,jE ,E&j ,Hj s,H ,d -d ",
+",Hd g- ,d. -8d ,.H* g-8 ,dK -dK ,Td g-T ,dj -jd H*,j s-g ,2 ,&2 ,2B ,a2 ,5 ",
+",58 ,5B ,5a ,2K &2,K ,T2 ,2T& ,5j 5&,j ,5T s,5 ,; -; ,;B -a; ,5; -> *B,5 ->",
+"a ,;K -;K ,T; -T; ,;j ->j 5T,; s-> ,E2 &E,2 ,H2 ,2H& ,5E ,E5& ,H5 H5,8 EK,2",
+" ,&E2K HT,2 ,HT&2 5j,E &jE,5 H5,T ,Hs5 ,d; -d; ,H; g-; ,5d ->d H5,d g-> dK,",
+"; dK-; H;,T g;-T 5d,j -d>j H;,j g>s- ,N ,&N ,NB ,aN ,N. ,8N .B,N 8a,N ,Q ,Q",
+"& ,QT ,Qa ,Qj ,Q8 QT,j s,Q ,*N -N ,N*B -aN *N,. -8N *B,N. 8a-N ,Q* -Q Q*,T ",
+"-QT Q*,j -Q8 ,QT*j s-Q ,W ,W& ,HW ,Wa ,W. ,W8 HW,. H8,W ,WQ W&,Q Z, Z&, ,Wj",
+" W8,Q Z,j sZ, ,Wd -W H*,W g-W ,.W* -W8 ,HWd. g8-W ,Qd -WQ Z*, Z- W*,j -Wj ,",
+"dZj Z-s ,m ,m& ,mB ,am ,5m ,8m 5m,B 5a,m ,Qm Q&,m ,Tm Qa,m p, p&, p,T sp, ,",
+"m; -m *B,m -ma 5*,m ->m m*B,5 -a>m ,Q; -Qm Q;,T -Tm p*, -p ,Tp* -ps ,Wm W&,",
+"m ,Hm Hm,a ,5W 5W,8 H5,W H8,m WQ,m ,WQm& Z,m ,aZm p,W ,Wp& Zp, Zps, v, -v v",
+",H -vg v,5 -v> ,Hv5 g>-v v,Q -vQ Zv, Z-v pv, -pv pvZ, y- C) !C) D) Da) C). ",
+"8C) D). D8) CK) !)CK DT) TaD) jC) jC8) Dj) sD) *C +*C D* +D* *C. 8*C D*. D8",
+"* *CK *C+K D*T D*+T *jC +C*j D*j s*D CE) CE!) HD) DaH) E)C. CE8) D)H. H)D8 ",
+"C)EK CE)!K DTH) HDTa) CEj) 8jCE) H)Dj HDs) d*C d*+C H*D gD* *Cd. d*8C H.D* ",
+"D8g* *CdK +d*CK TdD* D*gT dC*j dj*+C D*Hj gDs* C)2 C)!2 D)2 D2a) 5C) 8C5) 5",
+"D) 5)D8 C)2K !)2CK T2D) DTa)2 jC5) 58jC) 5)Dj 5Ds) ;*C ;*+C D;* a;D* 5*C >*",
+"C 5D* >D* *C;K +;*CK T;D* a;*DT 5C*j *j>C D*5T >Ds* E)C2 CE)!2 D)H2 HDa)2 C",
+"E5) 58CE) H)5D H5D8) CE)2K EKC!)2 HDT)2 DTaH)2 5jCE) 8jC5E) H5DT) sH5D) ;*d",
+"C +d;*C D;H* D;g* d*5C d*>C 5DH* gD>* dK;*C dK;+*C H;DT* gDT;* dj*5C >*djC ",
+"H5*Dj >D*gs C)N C)!N D)N a)DN C)N. C)8N N.D) 8)DN QC) !CQ) QD) DaQ) jCQ) 8C",
+"Q) Q)Dj QDs) *CN *C+N D*N +ND* N.*C *C8N *ND. DN8* Q*C +CQ* QD* Q*+D QC*j Q",
+"C8* DjQ* QDs* WC) !CW) WD) DaW) C)W. 8CW) D)W. W)D8 QCW) Q!WC) ZD) DaZ) jCW",
+") W8QC) DjZ) ZDs) W*C +CW* WD* WDg* *CW. WC8* W.D* D8W* WCQ* +WQ*C Z*D gDZ*",
+" WC*j +Wj*C D*Zj sDZ* mC) !Cm) Dm) D)am mC5) mC8) 5)Dm D)8m mCQ) Q!mC) Q)Dm",
+" am)QD pC) 8Cp) pD) s)pD m*C +Cm* Dm* D*+m 5Cm* m*>C Dm5* Dm>* QCm* m*C+Q D",
+"mQ* am*QD p*C >Cp* pD* pDs* mCW) W!mC) H)Dm am)WD WC5) 5W8C) 5)WD H8mD) WQm",
+"C) WmCQ!) DmZ) ZDam) WCp) pW8C) Z)pD ZpDs) v*C +*vC vD* g*vD 5*vC v*>C 5Dv*",
+" >*vD Q*vC v+Q*C vDZ* ZvDg* v*pC pv>*C pDZ* y*D ,b ,b& ,D c, ,b. ,8b ,D. c8",
+", ,bK bK,& ,DT cT, ,jb b8,j ,Dj sc, b* -b ,D* c- b*. -b8 ,.D* c-8 b*K -bK b",
+"T* c-T b*j -jb D*,j s-c ,bE b&,E ,Hb cH, bE,. ,Eb8 ,.bH ,Hc8 bK,E ,b&EK bH,",
+"T ,HcT ,Ebj &jE,b bH,j cHs, ,db -bd ,Dd gc- ,.bd b8-d ,.Dd g8c- ,Kbd bd-K b",
+"T,d -Tgc bd,j bd-j H*bj gcs- ,b2 b&,2 ,D2 c2, ,5b b5,8 ,5D c5, bK,2 ,b&2K ,",
+"2bT ,Tc2 b5,j ,5b&j b5,T c5s, ,;b -b; ,D; c-; b5* ->b 5D,; c>- ,Kb; b;-K bT",
+",; -Tc; b;,j >b-j 5Tb* c>s- bE,2 ,b&E2 ,2bH ,Hc2 ,Eb5 ,5b8E bH,5 ,Hc5 ,bE2K",
+" bK&,E2 ,HbT2 c2H,T ,5bjE ,5b&jE ,H5bT s,Hc5 bd,; bd-; bH,; c;g- b5,d -d>b ",
+"H5b* g-c> ,db;K -bd;K ,H;bT c-Tg; ,5dbj ->bdj ,H;bj s-gc> ,bN b&,N ,DN c,N ",
+"bN,. ,Nb8 DN,. ,8cN ,Qb ,bQ& ,QD cQ, bQ,j bQ,8 QD,j cQs, b*N -bN ,ND* c-N *",
+"Nb. b8-N ,D*N. -8cN bQ* -Qb QDb* c-Q Q*bj bQ-j ,QD*j cQs- ,Wb ,bW& ,WD cW, ",
+",.bW bW,8 ,.WD ,Wc8 bW,Q ,WbQ& Zb, Zc, bW,j ,W8bQ ,DZj s,Zc bW* -Wb H*bW c-",
+"W b.W* bW-8 ,WDd. c8-W bQ,d bW-Q Zb* Z-c W*bj bW-j b*Zj Zcs- ,mb ,bm& ,Dm c",
+"m, b5,m b8,m 5D,m ,5cm bQ,m ,Qbm& bT,m ,Qcm pb, ,8pb pD, cp, bm* -mb Dm,; c",
+"-m 5*bm >b-m ,5Dm* ->cm bQ,; bQ-m QD,; -Qcm pb* -pb ,Dp* cp- bW,m ,Wbm& bH,",
+"m ,Hcm b5,W ,5Wb8 5W,D ,5cW ,WbQm bWQ,m& ,DZm cmZ, ,Wpb pbW,8 pbZ, Z,cp vb*",
+" -vb vD, cv- ,5vb vb-> ,5vD -vc> ,Qvb vb-Q vbZ* cvZ- vbp* pb-v pbZ* yc- 0) ",
+"!0) )B0 a0) 1) 18) 1)B 1a) 0)K 0)!K T0) a0T) 1j) 8j1) 1T) s1) *0 +*0 *B0 a*",
+"0 1* 1+* 1*B 1a* *0K *0+K T*0 +0T* 1*j +j1* 1T* s*1 E0) E0!) H0) a0H) 1E) 8",
+"E1) 1H) 1)H8 0)EK !E)0K T0H) HTa0) jE1) 18jE) 1)Hj 1Hs) d*0 d*+0 H*0 g*0 1d",
+"* 8d1* 1H* g1* *0dK +d*0K H0T* T*g0 dj1* dj*1+ H*1T s*g1 0)2 0)!2 0)2B 0)a2",
+" 15) 581) 5B1) 1)5a 0)2K 0)2!K 0)T2 Ta0)2 5j1) 158j) 1)5T 15s) ;*0 ;*+0 ;0*",
+"B ;*a0 1;* >*1 *B1; 1a>* *0;K +;*0K ;*T0 a;*T0 ;j1* 1*>j 5T1* s1>* 0)E2 0)2",
+"!E 0)H2 Ha0)2 5E1) 158E) 1)H5 1H58) 0)2EK EK0!)2 HT0)2 Ta0H)2 15jE) 58j1E) ",
+"1H5T) s1H5) ;*d0 +d;*0 ;*H0 ;*g0 5d1* 1d>* H51* >*g1 dK;*0 dK;+*0 H;T*0 gT;",
+"*0 dj*1; >*1dj 1H;T* s*1g> 0)N 0)!N 0)NB 0)aN 1)N 8)1N )B1N a)1N Q0) !0Q) T",
+"0Q) a0Q) 1Q) 1)Q8 QT1) 1Qs) *0N *0+N 0B*N *0aN 1*N 1N8* 1N*B 1Na* Q*0 +0Q* ",
+"Q0T* Q0a* 1Q* +Q1* Q*1T 1Qs* W0) !0W) W0H) a0W) 1W) 1)W8 HW1) 1)Wa Q0W) Q!W",
+"0) Z0) a0Z) 1)Wj 1WQ8) Z1) s)Z1 W*0 +0W* H0W* W*g0 1W* +W1* H*1W 1Wg* W0Q* ",
+"+WQ*0 Z*0 g0Z* W*1Q 1+WQ* Z1* Z1s* m0) !0m) )Bm0 m0a) 1m) 1)8m m)1B 1)am m0",
+"Q) Q!m0) m0T) am0Q) p1) 18p) 1Tp) p1s) m*0 +0m* m0*B a0m* 1m* 1m>* *B1m am1",
+"* Q0m* m*0+Q T0m* am*Q0 p*1 p1>* 1Tp* s1p* m0W) W!m0) m0H) am0H) 1)5W 1W58)",
+" 1)Hm 1Hm8) WQm0) Wm0Q!) m0Z) Zam0) 1Wp) p1W8) p1Z) Zp1s) v*0 +*v0 H*v0 v*g",
+"0 v1* >*v1 1Hv* g*v1 Q*v0 v+Q*0 v*Z0 Zv*g0 v1p* pv>1* p*Z1 y*1 ,9 ,9& ,9B ,",
+"a9 ,1 :, ,1B :a, ,9K 9&,K ,T9 9T,a ,1j :j, ,1T s:, 9* -9 9*B -9a ,1* :- *B,",
+"1 :-a 9*K -9K 9T* -T9 9*j :-j 1T9* s-: ,9E 9&,E ,H9 9H,a ,1E :,E ,1H :H, 9E",
+",K ,9&EK 9H,T ,H9T& ,E9j ,j:E 9H,j :Hs, ,d9 -9d 9H* g-9 ,1d :-d 1H,d g:- ,K",
+"9d 9d-K 9T,d -Tg9 9d,j -j:d 1T,d s-g: ,92 9&,2 92,B ,29a ,15 :5, ,B95 ,5:a ",
+"92,K ,9&2K ,29T ,T9&2 95,j ,5:j 95,T :5s, ,;9 -9; *B9; 9a-; ,1; :-> *B95 :a",
+"-> ,K9; 9;-K 9T,; 9T-; 9;,j -j:> 1T,; :-s> 9E,2 ,9&E2 ,29H ,H9&2 ,E95 ,5:E ",
+"9H,5 ,H:5 ,9E2K 9&E,2K ,H9T2 9HT,a2 ,15jE :5j,E ,1H5T s,H:5 9d,; 9d-; 9H,; ",
+"-9g; 95,d ->:d 1H,; :-g> ,d9;K -9d;K ,H;9T -T9g; ,1d;j :->dj ,1HT; g:s-> ,9",
+"N 9&,N 9N,B ,N9a ,1N :,N 1N,B ,a:N ,Q9 ,9Q& 9Q,T 9Q,a ,1Q :Q, 1Q,T :Qs, 9*N",
+" -9N 9N*B 9a-N ,N1* :-N ,1*NB -a:N 9Q* -Q9 Q*9T 9Q-T 1Q9* :-Q ,1QT* :Qs- ,W",
+"9 ,9W& 9H,W 9W,a ,1W :W, 1H,W ,H:W 9W,Q ,W9Q& Z9, ,aZ9 9W,j ,W:Q Z1, Z:, 9W",
+"* -W9 H*9W -Wg9 1W,d :-W ,1HW* :Wg- 9Q,d 9W-Q Z9* Z-9 1Q,d -W:Q ,1Z* Z:- ,m",
+"9 ,9m& ,B9m 9a,m ,1m :m, ,B1m ,a:m 9Q,m ,Q9m& 9T,m ,Qa9m p9, :p, ,1pT s,:p ",
+"9m* -m9 *B9m 9a-m 1m,; :-m ,1m*B :a-m 9Q,; 9Q-m Tm9* 9T-m p9* -p: 9Tp* :ps-",
+" 9W,m ,W9m& 9H,m ,Hm9a 95,W ,5:W 1H,m ,H:m ,W9Qm 9WQ,m& ,mZ9 Z9a,m ,1pW p,:",
+"W p9Z, Z,:p v9* -v9 ,Hv9 g9-v v1, :v- ,1vH -vg: ,Qv9 v9-Q v9Z* Z9-v v9p* -p",
+":v p9Z* y:- C0) C0!) D0) a0D) 1C) 8C1) 1D) 1)D8 0)CK C0)!K T0D) DTa0) jC1) ",
+"18jC) 1)Dj 1Ds) *C0 *C+0 D*0 +0D* 1*C 1C8* 1D* +D1* CK*0 +*C0K D0T* a*0DT 1",
+"C*j *jC1+ D*1T 1Ds* E0C) C0)!E D0H) HDa0) CE1) 18CE) HD1) 1HD8) C0)EK EK)!C",
+"0 HDT0) DTaH0) 1jCE) 8jC1E) 1HDT) s1HD) *Cd0 +d*C0 H0D* D*g0 d*1C 1+d*C H*1",
+"D 1Dg* dK*C0 dK*+C0 H*DT0 gDT*0 dj*1C 1+d*jC 1H*Dj s*1gD 0)C2 C02!) 0)D2 Da",
+"0)2 5C1) 158C) 1)5D 1D58) C02)K 2K!C0) DT0)2 Ta0D)2 15jC) 58j1C) 1D5T) s15D",
+") *C;0 +;*C0 ;*D0 a;*D0 1C5* 1*>C 5D1* 1D>* ;*C0K ;*C+0K D;T*0 D;Ta*0 ;jC1*",
+" >*1jC 1D;T* >D*s1 C02E) !E)C02 HD0)2 Da0H)2 15CE) 58C1E) 1H5D) H5D1a) EKC0",
+")2 0)C2EK! DT0H)2 0)T2HDa 5jC1E) 5C1)8jE H5D1T) 1H5sD) d;*C0 d;*+C0 H;D*0 g",
+"D;*0 1d5*C >*1dC 1H;D* >D*g1 ;*CdK0 dK+*;C0 D;TH*0 D;Tg*0 1d5*jC dj*>C1 H;j",
+"1D* gs1>D* 0)CN C0N!) 0)DN Da0)N C)1N 18C)N D)1N 1D8)N C0Q) Q!C0) D0Q) QDa0",
+") QC1) 1Q8C) 1)QD s1QD) C0*N +*C0N *0DN a*0DN *C1N 1+*CN 1ND* 1+D*N *CQ0 +Q",
+"*C0 Q0D* +QD*0 1CQ* 1+Q*C QD1* s*1QD C0W) W!C0) D0W) WDa0) WC1) 1W8C) 1)WD ",
+"1WD8) WQC0) WC0Q!) D0Z) ZDa0) 1WQC) W8C1Q) 1DZ) Z1Ds) *CW0 +W*C0 W0D* gWD*0",
+" 1CW* 1+W*C WD1* g1DW* W*QC0 W*C+Q0 D*Z0 Z*Dg0 1W*QC *jC1+W 1DZ* Z1*gD C0m)",
+" mC0!) m0D) am0D) mC1) 1m8C) 1)Dm 1Dm8) QmC0) mC0Q!) QDm0) QD0am) 1Cp) p18C",
+") 1Dp) pD1s) *Cm0 m*C+0 D0m* am*D0 1Cm* >m1*C Dm1* >Dm1* m*CQ0 +QCm*0 QD;*0",
+" am0QD* 1*pC p>1*C 1Dp* p>D1* WmC0) mC0W!) HmD0) WD0am) 1W5C) W8C1m) 1HmD) ",
+"am)1WD QmCW0) QCW0m)! ZDm0) am0ZD) p1WC) 1W8pC) Zp1D) sZ1pD) *Cv0 v+*C0 D*v",
+"0 gvD*0 1*vC v>1*C 1Dv* gv1D* vQ*C0 +Q*vC0 ZvD*0 gvDZ*0 pv1*C v>1p*C Zp*1D ",
+"1Dy* ,b9 b9,& ,D9 c9, ,1b :b, ,1D :c, b9,K ,b9&K 9D,T ,Tc9 b1,j ,j:b b1,T :",
+"cs, b*9 -b9 9D* c-9 b1* :-b 1Db* :c- bK9* b9-K 9Tb* c9-T 9*bj :b-j 1Tb* :cs",
+"- b9,E ,b9&E 9H,D ,Hc9 ,Eb1 ,b:E b1,H cH:, ,b9EK b9&,EK ,H9bT c9H,T ,1bjE :",
+"bj,E ,1HbT s,H:c 9db* bd-9 9Hb* c-g9 b1,d -b:d 1Hb* :cg- ,db9K -b9dK ,Dd9T ",
+"c-9gT ,1dbj :-bdj ,1DTd g:sc- b9,2 ,b9&2 ,29D ,9c2 b1,5 ,5:b 95,D :,c5 ,b92",
+"K b9&,2K ,D9T2 c29,T ,1b5j :b5,j ,1D5T s,5:c 9;b* b;-9 9D,; -9c; b1,; >b:- ",
+"1D,; :-c> ,;b9K -b9;K ,D;9T c-9T; ,1;bj :->bj ,1DT; s-:c> ,b9E2 b9&,E2 ,H9b",
+"2 c29,H ,1b5E :b5,E ,1Hb5 :cH,5 b9E,2K b9,&EK2 bH9,T2 ,H9c2T b15,jE ,5b:jE ",
+"b1H,5T :cHs,5 ,db9; -b9d; ,H;9D c-9g; ,1db5 :->bd ,1Hb; g:c-> bd9,;K bd9-;K",
+" 9H;bT* -T9gc; b1d,;j ->b:dj b1H,T; s-cg:> b9,N ,b9&N ,N9D ,9cN ,Nb1 ,b:N ,",
+"N1D cN:, ,b9Q ,Qb9& 9Q,D ,Qc9 b1,Q ,Q:b 1Q,D :,cQ bN9* b9-N 9ND* -9cN bN1* ",
+"-b:N ,1D*N cN:- 9Qb* bQ-9 QD9* c9-Q 1Qb* :b-Q ,1QD* c-:Q ,b9W ,Wb9& 9W,D ,W",
+"c9 b1,W ,W:b 1W,D :,cW ,Wb9Q bW9,Q& ,DZ9 c9Z, ,1WbQ :Wb,Q ,1Zb :cZ, 9Wb* bW",
+"-9 WD9* c9-W 1Wb* :b-W ,1WDd c-:W ,Qdb9 -Wb9Q b*Z9 c-Z9 ,1Qbd :-WbQ b1Z* :c",
+"Z- ,b9m ,mb9& 9D,m ,mc9 b1,m ,m:b 1D,m :,cm ,Qb9m bQ9,m& ,QD9m cQ9,m ,1pb :",
+"bp, ,1pD p,:c 9mb* bm-9 Dm9* c9-m 1mb* :b-m ,1Dm* c-:m ,Q;b9 -Qb9m ,QD9; c-",
+"Q9m b1p* pb:- 9Dp* :c-p ,Wb9m bW9,m& ,Hm9D cW9,m ,1Wb5 :Wb,5 ,1Hbm :cW,5 bW",
+"9,Qm WQ9m,b& Zb9,m Zc9,m pb9,W :pb,W Zpb,1 cpZ:, b*v9 -bv9 ,Dv9 v9c- ,1vb v",
+"b:- ,1vD :c-v vb9,Q -vb9Q Zvb9* cvZ-9 pvb,1 :v-pb Zpb9* :cy- )L !)L )BL a)L",
+" )L. 8)L )L.B a)8L M) M)! TM) aM) Mj) 8M) MjT) sM) *L +*L *BL a*L *L. 8*L .",
+"B*L 8La* M* +M* T*M aM* M*j 8M* TM*j s*M E)L E)!L H)L a)HL )LE. E)8L )LH. 8",
+")HL ME) !EM) HM) H)aM jEM) ME8) MjH) HMs) d*L d*+L H*L g*L *Ld. d*8L *LH. 8",
+"*gL dM* +dM* HM* gM* M*dj dM8* M*Hj s*gM )L2 )L!2 )L2B )La2 5)L 8)5L )B5L a",
+")5L M)2 !)M2 M)T2 M2a) 5M) 5)8M TM5) 5Ms) ;*L ;*+L ;L*B ;*aL 5*L >*L 5L*B a",
+"*>L M;* +;M* M;T* M;a* 5M* >M* T*5M s*>M )LE2 !)2EL )LH2 Ha)L2 E)5L 58E)L 5",
+")HL H58)L E)M2 ME)!2 M)H2 aM)H2 ME5) 5M8E) H)5M sH5M) ;*dL +d;*L ;*HL ;*gL ",
+"d*5L d*>L HL5* g*>L d;M* dM;+* M;H* M;g* dM5* dM>* 5MH* >*gM )LN )L!N )LNB ",
+")LaN )LN. )L8N .BL)N 8a)LN QM) M)Q! TMQ) Q)aM MjQ) Q)8M QTMj) QMs) *LN *L+N",
+" NB*L *LaN N.*L *L8N *BLN. a*L8N Q*M Q*+M QTM* aMQ* QM*j 8MQ* M*jQT Q*sM W)",
+"L !)WL W)HL a)WL )LW. 8)WL HW)L. H8W)L WM) M)W! ZM) aMZ) MjW) W)8M MjZ) ZMs",
+") W*L +LW* HLW* W*gL *LW. WL8* H*WL. gW8*L WM* W*+M Z*M Z*gM M*Wj 8MW* M*Zj",
+" sMZ* m)L !)mL )BmL m)aL m)5L m)8L 5m)LB am)5L Mm) M!m) T)Mm a)Mm pM) 8Mp) ",
+"TMp) pMs) m*L +Lm* mL*B aLm* 5Lm* m*>L m*L5B >ma*L Mm* M*+m MmT* Mma* p*M p",
+"*>M T*pM sMp* m)WL W!m)L m)HL am)HL W)5L 5W8)L H5W)L H8m)L W)Mm Mm)W! MmZ) ",
+"aMmZ) WMp) pW8M) pMZ) ZpMs) v*L +*vL H*vL v*gL 5*vL v*>L vH5*L gv>*L vM* +M",
+"v* vMZ* g*vM vMp* >*vM ZMp* y*M ,L ,&L ,LB ,aL ,L. ,8L .B,L 8a,L ,M ,M& ,TM",
+" ,aM ,Mj ,8M TM,j s,M ,*L -L ,L*B -aL *L,. -8L *B,L. 8a-L ,M* -M T*,M -TM M",
+"*,j -M8 M*j,T s-M ,EL &E,L ,HL ,LH& EL,. 8E,L HL,. ,LH8 ,ME ,EM& ,HM HM,a M",
+"j,E ,E8M HM,j ,HsM ,dL -dL ,LH* g-L dL,. 8d-L ,HdL. -8gL ,dM -Md HM,d g-M d",
+"M,j 8d-M ,HMdj gMs- ,L2 &L,2 2B,L aL,2 ,5L ,L5& 5B,L ,L5a ,M2 ,2M& TM,2 ,2a",
+"M ,5M 5M,8 5T,M ,5sM ,;L -;L ;L,B a;-L ,L5* ->L ,5;LB -a>L ,M; -M; T;,M T;-",
+"M 5M,; >M- ,5TM; >Ms- EL,2 ,&EL2 HL,2 ,HaL2 5E,L ,58EL ,LH5 ,H58L ME,2 M&E,",
+"2 ,2HM ,HM&2 ,E5M ,5M8E H5,M s,H5M d;,L d;-L ,LH; -;gL ,L5d -d>L ,H5dL >Lg-",
+" dM,; dM-; HM,; g;-M 5d,M -d>M ,H5dM g->M ,LN &L,N NB,L aL,N N.,L 8L,N ,LN.",
+"B ,8aLN ,QM Q&,M QT,M Qa,M QM,j Q8,M ,QTMj ,QsM *L,N -LN *B,LN aL-N ,*LN. 8",
+"L-N ,LN*B. -8aLN Q*,M -QM ,QTM* Qa-M M*j,Q Q8-M ,QTM*j sQ-M ,WL ,LW& HW,L ,",
+"LWa WL,. ,LW8 ,HWL. ,H8WL ,WM W&,M Z,M ,aZM WM,j W8,M ,MZj sMZ, ,LW* -WL ,H",
+"WdL gL-W ,WdL. W8-L H*L,W. -W8gL WM,d -WM ,dZM Z-M ,WMdj W8-M Z*M,j -MsZ ,m",
+"L ,Lm& mL,B ,Lam 5m,L ,L8m ,5mLB ,5amL ,Mm M&,m Tm,M aM,m p,M ,8pM ,TpM sMp",
+", ,Lm* -mL m*L,B am-L m*L,5 >L-m ,5Lm*B ->amL Q;,M -Mm Mm*,T Tm-M ,Mp* -pM ",
+"p*T,M -Msp Wm,L m&L,W ,LHm ,HmaL ,L5W ,5W8L ,H5WL ,H8mL WM,m Mm&,W ,MZm Z&M",
+",m ,WpM p&W,M ZMp, Zp&,M v,L -vL ,HvL gL-v ,5vL >L-v v,H5L -vg>L vM, -vM vM",
+"Z, gM-v vMp, >M-v Zp*,M y-M U) U!) UD) Ua) U). U8) D)U. U)D8 UM) M)U! V) Va",
+") Uj) U)8M Vj) Vs) U* U+* U*D Ua* U*. U8* U.D* D8U* U*M +MU* V* V+* U*j +jU",
+"* V*j s*V UE) !EU) UH) HaU) E)U. 8EU) H)U. U)H8 MEU) U!ME) VH) HaV) jEU) U8",
+"ME) HjV) VHs) Ud* +dU* UH* gU* d*U. 8dU* U.H* U8g* dMU* dM*U+ Vd* gV* djU* ",
+"U+jd* H*Vj s*gV U)2 !)U2 D)U2 a)U2 U5) 58U) U)5D U)5a M)U2 U!M)2 V2) a)V2 U",
+")5M U58M) V5) s)V5 U;* +;U* D;U* a;U* U5* >U* 5DU* Ua>* M;U* M;*U+ V;* a;V*",
+" 5MU* U*>M V5* V>* E)U2 U!E)2 H)U2 UHa)2 5EU) U58E) U)H5 UH58) UME)2 ME)U!2",
+" H)V2 V2Ha) U5ME) 5MEU8) H5V) VsH5) d;U* U+d;* H;U* U;g* 5dU* Ud>* H5U* >*g",
+"U dM;U* U+dM;* H;V* g;V* U5dM* >MUd* H5V* V*g> U)N !)UN D)UN a)UN N.U) 8)UN",
+" UD)N. U8D)N UQ) U)Q! VQ) QaV) QjU) U)Q8 QjV) VQs) U*N +*UN UND* UNa* *NU. ",
+"UN8* U*DN. U8*DN UQ* +QU* V*Q +QV* Q*Uj Q8U* Q*Vj sQV* UW) W!U) U)WD U)Wa W",
+")U. U)W8 UHW). UH8W) U)WM UWQ!) VZ) VaZ) U)Wj UW8Q) VjZ) s)VZ UW* +WU* H*UW",
+" UWg* U.W* W8U* UH*W. gUW8* WMU* U+WQ* Z*V Z*gV W*Uj U+W*j ZjV* VZs* Um) m)",
+"U! U)Dm U)am 5mU) U)8m U5Dm) U5am) U)Mm Mm)U! Vm) amV) pU) U8p) Vp) s)Vp Um",
+"* +mU* DmU* amU* 5*Um Um>* U5*Dm >DmU* Q;U* Mm*U+ Vm* +mV* pU* >Up* Vp* s*V",
+"p WmU) UWm!) U)Hm UHma) U)5W U5W8) UH5W) UH8m) Mm)UW UW)Mm! Z)Vm VZam) UWp)",
+" pUW8) Z)Vp VpZs) vU* U+v* UHv* g*vU U5v* >*vU vUH5* gvU>* UQv* vU+Q* Vv* V",
+"*gv vUp* >MvU* Z*Vp yV* ,U ,U& ,UD cU, ,U. ,U8 UD,. ,Uc8 ,UM U&,M V, Vc, ,U",
+"j b8,M V,j s,V ,U* -U U*,D c-U ,.U* -U8 ,UD*. c8-U bM* -UM V*b V- U*,j -Uj ",
+",jV* V-s ,UE ,EU& ,UH ,UcH UE,. ,EU8 ,.UH UH,8 ,EbM M&E,U V,H cHV, ,EUj ,U8",
+"ME ,HVj sHV, ,Ud -Ud UH,d g-U ,.Ud U8-d ,UHd. g8-U bd,M bd-M Vd, V-g Ud,j U",
+"d-j ,dVj s-gV ,U2 ,2U& UD,2 ,Uc2 ,U5 U5,8 U5,D ,Uc5 ,2bM M&2,U V,2 c2V, b5,",
+"M ,U58M V5, V5s, ,U; -U; U;,D -Uc; U5,; ->U ,U5D; -Uc> bM,; bM-; V;, V-; U;",
+",j -U>M ,5V; V-> UE,2 ,U&E2 ,2UH c2U,H ,EU5 ,U58E UH,5 c5U,H ,UME2 ,UEM&2 ,",
+"HV2 VcH,2 ,U5ME M&E,U5 ,HV5 s,VH5 Ud,; Ud-; UH,; g;-U U5,d -d>U ,UH5d ->gU ",
+",UdM; -UdM; ,HV; V;g- ,U5dM >M-bd ,5Vd g-V> ,UN ,NU& UD,N ,UcN UN,. ,NU8 ,U",
+"DN. cU8,N ,UQ U&,Q V,Q V,cQ UQ,j UQ,8 ,QVj sQV, ,NU* -UN ,UD*N cN-U ,U*N. U",
+"8-N U*N,D. c-U8N UQb* -UQ ,QV* V-Q ,UQ*j UQ-j V*bQj -QVs ,UW U&,W UH,W ,UcW",
+" ,.UW UW,8 ,UHW. cWU,8 bW,M ,UWQ& Z,V VcZ, UW,j ,UWQ8 ZjV, VZs, UW,d -UW ,U",
+"HW* -UcW ,UWd. UW-8 ,U.WD* c-WU8 UQ,d bW-M VdZ, Z-V ,UWdj UW-j Zb*Vj sZV- ,",
+"Um U&,m Um,D ,Ucm U5,m U8,m ,U5Dm c5U,m bM,m Mm&,U Vm, V,cm pU, ,Up& Vp, s,",
+"Vp Um,; -Um ,UmD; -Ucm ,U5m* >U-m U5*,Dm c>-Um UQ,; bM-m ,QV; V-m ,Up* -pU ",
+"V*pb V-p UW,m ,UWm& UH,m cWU,m U5,W ,U5W8 ,UH5W c5W,U ,UWMm ,UWMm& VmZ, ZcV",
+",m ,UpW pU&,W Z,Vp cpZV, vU, -vU ,UvD gU-v ,Uv5 v>-U vU,H5 cv->U ,UvM vb-M ",
+"Vv, V-v vUp, pv-U V,pv yV- k) k)! k)B ak) 1k) 8k) k)1B 1)ak kM) M!k) Tk) T)",
+"ak l) l8) lT) ls) k* +k* k*B ak* 1*k 8k* 1k*B ak1* k*M k*+M Tk* T*+k l* l+*",
+" l*T ls* kE) !Ek) Hk) H)ak kE1) kE8) 1)Hk H)8k MEk) kME!) H)Tk ak)HM lE) 8E",
+"l) lH) sHl) dk* +dk* Hk* gk* dk1* dk8* Hk1* 1*gk k*dM dkM+* TkH* Tkg* ld* 8",
+"dl* lH* gl* k)2 !)k2 2Bk) k2a) 5k) 5)8k k)5B 5)ak M)k2 kM)!2 k)T2 ak)T2 l5)",
+" 58l) 5Tl) s5l) k;* +;k* *Bk; k;a* 5k* >k* *B5k ak>* M;k* k;M+* k;T* ak;T* ",
+"l;* l>* 5Tl* s>l* E)k2 kE)!2 k)H2 ak)H2 kE5) 5k8E) H)5k H5k8) kME)2 ME)k2! ",
+"HkT)2 Hk)aM2 5El) l58E) H5l) lsH5) d;k* dk;+* k;H* k;g* dk5* dk>* 5kH* >*gk",
+" dkM;* +kdM;* Hk;T* gkT;* 5dl* >*ld H5l* g>l* k)N !)kN )BkN k)aN k)1N kN8) ",
+"1k)NB ak)1N Qk) k)Q! Q)Tk Q)ak lQ) Q8l) QTl) sQl) k*N +Nk* kN*B aNk* 1Nk* k",
+"N8* k*N1B ak*1N Qk* Q*+k TkQ* akQ* l*Q +Ql* Q*lT lQs* Wk) k)W! H)Wk W)ak 1)",
+"Wk W)8k 1HWk) 1Wak) W)Qk WkQ!) Zk) akZ) lW) W8l) lZ) l)sZ Wk* W*+k WkH* Wkg",
+"* Wk1* 8kW* 1H*Wk g1Wk* QkW* +WkQ* Zk* Z*gk lW* +Wl* lZ* l*gZ km) k!m) m)kB",
+" a)km 1)km 8)km km)1B akm1) Q)km km)Q! T)km akmQ) lp) p8l) pTl) l)sp km* k*",
+"+m *Bkm kma* km1* km>* km*1B >kam* kmQ* km*+Q kmT* akmQ* l*p p>l* lTp* spl*",
+" W)km km)W! H)km akmH) 5)Wk 5Wk8) 1Hmk) H8km) km)WM Wk)Mm! kmZ) Zkam) pWl) ",
+"lWp8) l)Zp lZps) vk* +kv* Hkv* g*vk 1*vk >*vk v1Hk* >kgv* Qkv* vk+Q* vkZ* Z",
+"vkg* lv* v>l* Zpl* yl* ,k ,k& ,kB ,ak ,1k :k, 1k,B ,a:k ,kM k&,M ,Tk 9a,M l",
+", l:, l,T ls, ,k* -k *B,k -ka 1*,k :-k k*B,1 :a-k 9M* -kM Tk9* -Tk l*9 l- ,",
+"Tl* l-s ,kE ,Ek& ,Hk Hk,a 1k,E ,k:E 1H,k ,H:k ,E9M k&E,M 9H,M ,HkT& l,E :,l",
+"E lH, s,lH ,dk -kd Hk,d g-k 1d,k -k:d ,1Hdk :-gk 9d,M 9d-M HM9* -Tgk ld, l-",
+"d ,Hld gl- ,k2 ,2k& k2,B ,2ak ,5k ,5:k ,B5k 5a,k ,29M k&2,M ,2Tk ,Tk&2 l,5 ",
+":5l, ,5lT l5s, ,k; -k; ,Bk; ak-; 1;,k >k- ,1;kB -a>k 9M,; 9M-; Tk,; Tk-; l;",
+", l-> ,Tl; s-l> kE,2 k&E,2 ,2Hk ,Hk&2 ,E5k :5k,E H5,k :H5,k ,kME2 ,kEM&2 ,H",
+"kT2 ak2,HM ,5lE l:5,E ,Hl5 ls,H5 dk,; dk-; Hk,; g;-k 5d,k -d>k ,1Hk; g->k ,",
+"dkM; -kdM; ,HkT; -Tkg; ,5ld ->ld ,Hl; g-l> ,kN ,Nk& kN,B ,Nak 1k,N ,k:N ,1k",
+"NB :ak,N ,Qk Q&,k Qk,T Qa,k l,Q :Ql, ,QlT lQs, ,Nk* -kN k*N,B ak-N k*N,1 :N",
+"-k ,1Nk*B :-akN Qk9* -Qk ,QkT* Qa-k ,Ql* l-Q l*9QT -Qls ,Wk W&,k Hk,W Wa,k ",
+"1W,k ,W:k ,1HWk :HW,k 9W,M ,WkQ& Zk, ,aZk lW, :Wl, lZ, l,Z: Wk,d -Wk ,HkW* ",
+"-Wgk ,1Wdk -k:W 1H*,Wk g:-Wk WM9* 9W-M ,dZk Z-k ,Wld l-W Z9l* l-Z ,km k&,m ",
+",Bkm ak,m 1m,k ,k:m ,1mkB :ma,k 9M,m km&,Q Tk,m akm,Q l,p l,:p lTp, spl, km",
+",; -km km*,B ak-m km*,1 -k:m kmB,1; :-mak Qk,; 9M-m km*,T Tk-m p9l* l-p l;,",
+"pT ls-p Wk,m km&,W Hk,m akm,H 5W,k :W5,k ,1Hkm :Hm,k ,WkMm ,WkMm& ,kZm Zk&,",
+"m p,lW :pl,W Zpl, lZ,:p vk, -vk ,Hvk gk-v ,1vk >k-v v1,Hk :v-gk ,Qvk v9-M v",
+"kZ, Zk-v lv, l-v Zvl, yl- Uk) k)U! Dk) U)ak 1U) 1)U8 1)Dk 1)Ua kMU) U!kM) V",
+"k) akV) lU) U8l) Vl) l)Vs U*k +kU* Dk* D*+k 1U* U+1* U*1D Ua1* UkM* k*MU+ V",
+"*k +kV* l*U U+l* l*V Vls* kEU) U!kE) U)Hk ak)UH UE1) 1U8E) 1)UH 1UH8) UkME)",
+" kMEU!) HkV) VHak) UEl) lU8E) VHl) lsVH) dkU* dk*U+ HkU* U*gk Ud1* 1U+d* UH",
+"1* 1Ug* dkMU* U+dk*M HkV* V*gk Udl* l+Ud* Vdl* l*gV k)U2 U!k)2 k)D2 ak)U2 1",
+")U5 1U58) 5)Dk 1Ua5) UkM)2 kM)U!2 k)V2 V2ak) U5l) lU58) l)V5 lsV5) k;U* k;*",
+"U+ k;D* ak;U* U51* 1U>* Dk5* Dk>* k;MU* U+kM;* k;V* V+k;* U5l* >Ul* V5l* l*",
+"V> UkE)2 kE)U!2 UHk)2 UH)ak2 1U5E) 5kEU8) 1UH5) ak)UH5 kMEU)2 !)k2UME V2Hk)",
+" ak)V2H lU5E) U58lE) Vl5H) Vs5lH) dk;U* U+dk;* UH;k* gUk;* 1Ud5* >kUd* 1UH5",
+"* >kgU* UdkM;* dkU;+M* Vdk;* gVk;* ldU5* l>Ud* lH;V* V>lg* k)UN U!k)N k)DN ",
+"ak)UN U)1N 1U8)N 1UD)N 1Ua)N U)Qk UQk!) QkV) VQak) UQl) lUQ8) VQl) lsVQ) UN",
+"k* k*NU+ DNk* ak*UN 1NU* 1U+*N 1U*DN 1Ua*N QkU* U+Qk* QkV* V+Qk* UQl* l+UQ*",
+" lQV* s*VlQ U)Wk UWk!) W)Dk UWak) 1)UW 1UW8) 1UHW) 1UWa) UWQk) Wk)UQ! VkZ) ",
+"ZkVa) UWl) lWU8) l)VZ lZVs) WkU* U+Wk* DkW* gUWk* UW1* 1U+W* 1UHW* g1UW* UW",
+"*Qk +WkUQ* V*Zk gVZk* UWl* l+WU* VlZ* glZV* U)km km)U! D)km akmU) 1)Um 1Um8",
+") 1UmD) 1Uam) km)UQ UQ)km! kmV) Vmak) l)pU pUl8) l)Vp Vpls) kmU* km*U+ kmD*",
+" akmU* Um1* >kUm* km*1D >kDm* km*UQ U+Qkm* kmV* V+mk* pUl* l>pU* l*Vp V>lp*",
+" km)UW UW)km! UHmk) ak)UHm 1UW5) km)UW8 1UHm) ak)U5W UWQkm) W)QkUm! ZkVm) V",
+"maZk) lWpU) pU8lW) VplZ) lZsVp) U*vk vU+k* Dkv* gvUk* 1Uv* >kvU* v1UH* >kvD",
+"* vUQk* U+Qvk* vkV* Vvgk* vUl* lv>U* l*Vv l*yV t, t&, tD, tc, t1, t:, ,1tD ",
+"t,:c tM, ,Mt& Vt, V,tc lt, t:l, l,V u, t* t- t*D t-c t*1 t-: 1Dt* :ct- t*M ",
+"t-M t*V V-t lt* l-t Vlt* u- t,E ,&tE tH, cHt, ,1tE :,tE ,1tH t,:H ,MtE tM&,",
+"E V,tH tcV,H t,lE t:,lE tHl, uH, td* t-d tH* gt- ,1td :-td 1Ht* t-g: ,dtM -",
+"Mtd Vdt* V-gt tdl* ldt- tHl* ug- t,2 ,&t2 ,Dt2 c2t, t5, :5t, ,5tD t,c5 ,Mt2",
+" tM&,2 t,V2 tcV,2 t5l, t:5l, V5l, u5, t;* t-; ,Dt; c-t; t5* t>- 5Dt* c>t- ,",
+"Mt; -Mt; V;t* t;V- t5l* t>l- V5t* u-> ,Et2 t&,E2 ,Ht2 tcH,2 ,5tE t:5,E ,Ht5",
+" t:H,5 tM,E2 M&Et,2 tHV,2 Vc,tH2 t5,lE l:,t5E tH5l, ,Hu5 ,dt; -dt; ,Ht; t;g",
+"- ,5td ->td H5t* g-t> tdM,; t-dM; tH;V* V-gt; t5dl* l-t>d tH5l* g-u> t,N ,&",
+"tN ,DtN c,tN ,1tN :,tN t1D,N t:c,N tQ, ,Qt& V,tQ t,cQ tQl, t,:Q lQV, uQ, t*",
+"N t-N D*tN tNc- 1*tN tN:- t*1DN t-:cN tQ* t-Q V*tQ tQV- tQl* tQl- tQ*Vl u-Q",
+" tW, ,Wt& ,HtW t,cW ,1tW t,:W tH1,W t:H,W ,WtQ tWQ,& tZ, Z,tc tWl, t:Wl, l,",
+"tZ uZ, tW* t-W H*tW tWg- 1Wt* :-tW tH*1W t-Wg: ,Qtd -WtQ tZ* tZ- tWl* lWt- ",
+"l*tZ uZ- tm, ,mt& ,Dtm t,cm ,1tm t,:m t5D,m t:mc, ,Qtm tQm,& V,tm tcQ,m tp,",
+" p,t: l,Vp up, tm* t-m Dmt* c-tm 1mt* :-tm t5*Dm t-mc> ,Qt; -Qtm Vmt* tmV- ",
+"tp* tp- t*Vp up- ,Wtm tWm,& ,Htm tcW,m ,5tW t:W,5 tH5,W t:H,m tWQ,m Mm&tW, ",
+"Z,tm tZc,m p,tW tp:,W Z,tp Zpu, tv* tv- vDt* t-cv v1t* t-:v tv1,H gtv:- vMt",
+"* tQ-v t*Vv Z-tv l*tv tvl- l,Vv yu- F !F FB aF F. 8F .BF 8aF FK !KF TF TaF ",
+"jF 8jF TjF sF (F +F (BF +aF (F. +8F (F.B 8a+F (FK +FK T(F +TF j(F +jF j(TF ",
+"s+F G G! GH Ga G. G8 GH. G8H GK GK! GT GTa Gj G8j GTj sG Gd +G GHd gG Gd. +",
+"G8 HdG. gG8 GdK +GK GTd gGT Gjd +Gj TdGj gsG F2 !F2 2BF aF2 5F 58F 5BF 5aF ",
+"2KF !F2K TF2 T2aF 5jF 8j5F 5TF s5F ;F +;F ;FB a;F 5;F >F ;F5B >Fa ;FK ;F+K ",
+"T;F +FT; ;jF >jF 5FT; s>F G2 G2! GH2 Ga2 G5 G58 G5H G5a G2K 2KG! GT2 TaG2 G",
+"5j 58Gj G5T sG5 G; +G; G;H gG; G5d >G H5G; g>G G;K GK+; GT; GTg; G;j >Gj H;",
+"Gj s>G FN !FN NBF aFN N.F 8FN FBN. aN8F QF Q!F QTF QaF QjF Q8F TjQF sQF (FN",
+" +FN (FNB aF+N (FN. 8F+N .BN(F +8aFN Q(F +QF T(QF +FQa j(QF +FQ8 QTj(F +QsF",
+" GW W!G GHW GaW GW. G8W HWG. W8Ga GQ GQ! ZG ZGa GQj GQ8 ZGj sZG GWd +GW HWG",
+"d gGW WdG. G8+W GHWd. G8gW GQd +GQ ZGd gZG QdGj GQ+j GjZd sGgZ mF mF! mFB a",
+"mF 5mF 8mF mF5B 5Fam QmF mFQ! TmF QFam pF p8F pTF spF m;F +mF ;FmB +Fam m;5",
+"F >mF 5m;FB am>F Q;F +FQ; QFT; +FTm p;F p>F T;pF >Fsp Gm Gm! GmH Gam G5W G8",
+"m H5Gm H8Gm GQm Q!Gm ZGm GaZm pG pG8 ZpG spG vG v+G vGH gvG vG5 v>G G5vH >G",
+"gv vGQ +GvQ ZvG gGZv pvG p>G pGZv yG #F &F #BF a&F #F. 8&F #F.B a&8F #FK &F",
+"K T#F T&F j#F &jF j#TF s&F #(F +&F #(FB a&+F (F#. 8&+F #BF(. +8a&F (F#K &F+",
+"K #(TF +FT& #(jF +F&j Tj#(F +&sF G# G& GH# Ga& G#. G8& H#G. H8G& G#K G&K GT",
+"# GT& Gj# G&j G#Hj sG& Gd# +G& HdG# gG& d#G. 8dG& GHd#. G8g& dKG# GKd& G#Td",
+" GTg& G#dj G&+j dj#GT g&sG #F2 &F2 #F2B &2aF 5#F 5&F #B5F a&5F #F2K 2K&F #F",
+"T2 &FT2 j#5F 5F&j T#5F 5&sF ;#F ;&F #B;F aF;& ;#5F >&F 5;#FB a&>F #F;K &F;K",
+" ;#TF TF;& j#;F &j>F ;j#TF s&>F G#2 G&2 H#G2 G2H& G5# G5& G#H5 H5G& 2KG# &2",
+"GK T#G2 G2T& 5jG# 5&Gj G#5T G5s& G;# G;& G#H; G;g& G#5d >G& G5Hd# gG>& ;#GK",
+" GK;& G#T; T;G& G#;j G&>j G5Td# >&sG #FN &FN #FNB &FaN #FN. &F8N #FN.B 8a&F",
+"N Q#F Q&F T#QF QFT& j#QF QF&j QTj#F Q&sF (F#N &F+N #FN(B +a&FN #FN(. +8&FN ",
+"#BFN.( 8a&+FN #(QF +FQ& QT#(F +QT&F Qj#(F &jF+Q Tj#Q(F s+Q&F GW# G&W HWG# W",
+"aG& W#G. W8G& GHW#. G8HW& GQ# GQ& ZG# Z&G G#Wj W&Gj GjZ# Z&sG WdG# G&+W GHW",
+"d# G&gW GWd#. +GW8& HWdG#. gGW8& G#Qd G&+Q GdZ# gGZ& dj#GQ d&jGQ ZGdj# Z&Gg",
+"s m#F m&F #BmF aFm& m#5F 5Fm& 5m#FB am&5F m#QF QFm& m#TF TFm& p#F p&F T#pF ",
+"sFp& ;#mF +Fm& m;#FB am&+F 5m;#F m&>F m;#5BF >ma&F ;#QF QF;& Q;T#F +Tm&F ;#",
+"pF >Fp& pT;#F p>&sF Gm# Gm& G#Hm HmG& G#5W 5WG& G5HW# G5aW& QmG# Q&Gm GmZ# ",
+"GmZ& pG# pG& Z#pG pGZ& vG# v&G GHv# gGv& G5v# >Gv& vGH5# gv>G& GQv# GQv& vG",
+"Z# ZGv& vGp# v&pG ZpvG# y&G I I! DI aI I. 8I DI. D8I IK IK! TI TIa Ij 8Ij D",
+"jI sI I( +I DI( +DI I(. +I8 I(D. D8+I I(K +IK TI( +TI Ij( +Ij D(Ij sI+ GI G",
+"I! J Ja GI. G8I J. J8 GIK IKG! JT JTa GjI 8IGj Jj sJ Id +GI Jd gJ Id. 8Id J",
+"d. gJ8 IdK GK+I JTd gJT Idj Gj+I Jjd sJg I2 I2! DI2 aI2 5I 5I8 5DI 5aI I2K ",
+"2KI! TI2 I2Ta 5Ij 58Ij 5TI sI5 I; +I; D;I aI; 5I; >I D;5I >DI I;K +KI; TI; ",
+"T;+I I;j >Ij T;5I s>I GI2 I2G! J2 Ja2 G5I 5IG8 J5 J58 I2GK GI2!K JT2 TaJ2 5",
+"IGj G58Ij J5T sJ5 G;I G;+I J; gJ; 5Id >GI J5d J> GKI; IdK+; J;T gTJ; I;Gj G",
+"j>I J;j J>s IN IN! DIN aIN IN. 8IN IND. DN8I QI QI! QDI QaI QIj Q8I DjQI sI",
+"Q I(N +IN I(DN +NaI N.I( +N8I DI(N. +D8IN QI( +QI Q(TI QD+I Q(Ij Q8+I Ij(QD",
+" +QsI WI WI! JW JWa WI. W8I JW. J8W GQI Q!WI ZJ ZJa WIj Q8WI ZJj sJZ WId +W",
+"I JWd gJW W.Id W8+I WdJ. gWJ8 QId GQ+I ZJd gZJ IdWj WI+j ZdJj gZsJ Im Im! D",
+"mI aIm 5Im 8Im Dm5I 8IDm QIm Q!Im TIm aITm pI pI8 pDI spI Im; +Im ImD; Dm+I",
+" 5mI; >Im Im;5D Dm>I QI; QI+m D;QI TI+m pI; p>I D;pI p>sI GmI W!Im Jm Jma 5",
+"WI W85I J5W J8m QIGm Im!GQ ZJm ZaJm pGI G8pI Jp Jps vI vI+ Jv Jvg vI5 v>I J",
+"v5 J>v vIQ +QvI JvZ gZJv pvI v>pI Jpv yJ bI I& bDI cI bI. b8I DIb. c8I bKI ",
+"I&K bTI cTI bjI I&j TIbj scI bI( b+I DIb( c+I I(b. +Ib8 bDI(. +Ic8 I(bK bK+",
+"I b(TI +TcI b(Ij +Ibj Ij(bT c+sI bG bG& Jb cJ bG. bG8 Jb. cJ8 bGK bKG& JbT ",
+"cJT bGj G8bj Jjb sJc bGd b+G Jbd gJc b.Id +Gb8 bdJ. J8gc bKId bK+G bTJd gTc",
+"J Gjbd +Gbj bdJj gcsJ bI2 I&2 DIb2 c2I b5I 5I& bD5I c5I I2bK &2IK b2TI TIc2",
+" 5Ibj Ij5& 5IbT c5sI b;I I;& bDI; c;I 5Ib; >bI b5DI; c>I bKI; IK;& TIb; TIc",
+"; I;bj bj>I I;jbT sIc> bG2 b2G& Jb2 cJ2 bG5 G5b8 J5b cJ5 G2bK I&2GK bTJ2 JT",
+"c2 G5bj I&jG5 b5Jj c5sJ bG; +Gb; J;b cJ; G5bd >bG b5J; J>c bKG; I;&GK bTJ; ",
+"cTJ; G;bj bG>j b;Jj c>sJ bIN I&N DIbN cIN INb. bN8I bDIN. 8IcN bQI QI& QIbT",
+" cQI QIbj QIb8 bQDIj cQsI I(bN bN+I bDI(N +IcN bI(N. I&N+8 DI(bN. c+8IN b(Q",
+"I +IbQ bQDI( +QcI Ij(bQ I&j+Q bQDIj( sI+cQ bGW WI& JbW cJW b.WI G8bW bWJ. J",
+"8cW bGQ G&bQ ZJb ZcJ GQbj GQb8 JjZb ZcsJ WIbd +GbW bWJd cWgJ Id.bW b+GW8 Jb",
+"Wd. cJWg8 GQbd +GbQ JbZd gJZc IdjbW IdjW& ZJbdj sJZgc bmI Im& bDIm cmI 5Ibm",
+" 8Ibm b5DIm 5Icm QIbm ImQ& TIbm QIcm pbI pI& bTpI cpI Imb; +Ibm Im;bD +Icm ",
+"Im;b5 bm>I b5DIm; >Icm QIb; I;Q& bQ;TI QIc; b;pI >bpI pbDI; pIc> bGm G&bm J",
+"mb cJm G5bW G8bm b5Jm J5cW GQbm Im&GQ JmZb cmZJ pbG bGp& Jpb cpJ vbG vI& Jv",
+"b cvJ bGv5 >bvI vbJ5 J>cv bGvQ QIv& ZbJv JvZc vbpG vIp& pbJv yJc 0F !0F 0BF",
+" a0F 1F 18F 1FB 1aF 0FK 0F!K T0F a0TF 1jF 8j1F 1TF s1F 0(F +0F 0(FB a0+F 1(",
+"F 1+F (B1F +a1F (F0K 0F+K 0(TF T0+F j(1F 1F+j T(1F 1+sF G0 G0! GH0 Ga0 1G 1",
+"G8 1GH 1Ga G0K !KG0 GT0 TaG0 1Gj 18Gj 1GT sG1 Gd0 +G0 HdG0 gG0 1Gd 1+G GH1d",
+" g1G dKG0 GK+0 G0Td GTg0 Gj1d +j1G GT1d sGg1 0F2 0F!2 0F2B 0Fa2 15F 581F 5B",
+"1F 1F5a 0F2K 2K0!F 0FT2 Ta0F2 5j1F 158jF 1F5T 15sF ;0F ;0+F 0B;F ;0aF 1;F >",
+"F1 ;F1B 1a>F 0F;K +;0FK ;0TF a;0TF 1F;j 1j>F 1FT; s1>F G02 !0G2 H0G2 a0G2 1",
+"G5 15G8 G51H G51a 2KG0 G02!K T0G2 GTa02 15Gj 1G58j G51T 1Gs5 G;0 +0G; G0H; ",
+"G;g0 1G; >G1 G;1H >Gg1 ;0GK +G;0K G0T; gGT;0 Gj1; 1G>j GT1; s1>G 0FN 0F!N 0",
+"FNB 0FaN 1FN 8F1N NB1F aF1N Q0F !0QF T0QF a0QF 1QF 1FQ8 QT1F 1QsF (F0N 0F+N",
+" 0B(FN +a0FN (F1N +F1N 1(FNB 1+aFN 0(QF Q0+F QT0(F +QT0F Q(1F 1F+Q 1QT(F s1",
+"+QF GW0 G0W! HWG0 G0Wa 1GW G81W GH1W Ga1W GQ0 G0Q! ZG0 GaZ0 1GQ G81Q Z1G Z1",
+"sG WdG0 GW+0 GHWd0 GWg0 GW1d +G1W 1GHWd 1GgW G0Qd +0GQ GdZ0 ZGg0 GQ1d +G1Q ",
+"1GZd gGZ1 m0F !0mF 0BmF m0aF 1mF 1F8m mF1B 1Fam m0QF Q!m0F m0TF am0QF p1F 1",
+"8pF 1TpF p1sF ;0mF m0+F m;0FB am0+F m;1F 1m>F 1m;FB >m1aF ;0QF +Qm0F Q;T0F ",
+"+Tm0F 1;pF p1>F p1T;F p>1sF Gm0 m0G! G0Hm G0am 1Gm G81m Gm1H Ga1m QmG0 GQm!",
+"0 GmZ0 ZGam0 pG1 1Gp8 pGZ1 s1pG vG0 +Gv0 GHv0 vGg0 v1G >Gv1 1GvH gGv1 GQv0 ",
+"v+GQ0 vGZ0 ZvGg0 v1pG p1>G ZGv1 y1G 9F 9&F 9FB 9aF 91F :F 1B9F :aF 9FK &F9K",
+" 9TF 9FT& 9jF :jF 9F1T s:F 9(F 9+F (B9F +a9F 1(9F :+F 91(FB +a:F (F9K +F9K ",
+"T(9F 9F+T j(9F +j:F 9T1(F :+sF 9G 9G& 9GH 9Ga 9G1 :G 1G9H :GH 9GK 9KG& 9GT ",
+"GT9a 9Gj :Gj 1G9T s:G 9Gd 9+G GH9d g9G 1G9d :G+ 9G1Hd g:G Gd9K 9K+G GT9d 9G",
+"gT Gj9d +G:j 9GT1d sGg: 9F2 &F92 2B9F aF92 95F :5F 5B9F 5a:F 2K9F 9&F2K TF9",
+"2 9TaF2 5j9F 5j:F 9F5T :5sF 9;F 9F;& ;F9B 9Fa; 9F1; :>F 95;FB :a>F ;F9K ;&F",
+"9K 9FT; 9+T;F 9F;j :j>F 95T;F >Fs: 9G2 92G& GH92 92Ga 9G5 :G5 G59H G5:H G29",
+"K 9G&2K 92GT 9GT&2 G59j G5:j G59T s5:G 9G; +G9; G;9H 9Gg; 1G9; :>G 9G5H; :G",
+"g> 9KG; 9+G;K GT9; g9GT; G;9j >j:G 9G5Td :>sG 9FN &F9N NB9F aF9N 1F9N :FN 9",
+"1FNB aF:N 9QF 9FQ& QT9F 9FQa 9F1Q :QF 9Q1TF sF:Q (F9N +F9N 9(FNB 9+aFN 91(F",
+"N +F:N 1(F9NB :+aFN Q(9F 9F+Q 9QT(F 9+QTF 9Q1(F +Q:F 1Q(9TF :Q+sF 9GW G&9W ",
+"GH9W Ga9W 1G9W :GW 9G1HW Ga:W 9GQ G&9Q Z9G 9GZ& 1G9Q :GQ 9GZ1 Z:G GW9d +G9W",
+" 9GHWd 9GgW 9G1Wd +G:W 1GH9Wd gG:W GQ9d +G9Q 9GZd gGZ9 9GQ1d +G:Q Z91Gd :Gg",
+"Z 9mF 9Fm& mF9B 9Fam 9F1m :mF 95mFB am:F Qm9F m&F9Q 9FTm 9QamF p9F :pF 9TpF",
+" sF:p m;9F 9F+m 9m;FB 9+maF 95;mF >F:m 1mF9;B :>amF 9FQ; 9+QmF 9Q;TF 9+TmF ",
+"9;pF >F:p p9T;F :ps>F 9Gm G&9m Gm9H Ga9m 1G9m :Gm 9G5Hm Ga:m GQ9m 9GQm& 9GZ",
+"m Z9Gam p9G :pG pGZ9 sG:p v9G 9+vG 9GvH gGv9 9Gv1 :vG v91GH :Ggv 9GvQ v9+GQ",
+" ZGv9 Zv9gG v9pG pv:G Zp9vG y:G I0 I0! DI0 aI0 1I 1I8 1DI 1aI I0K !KI0 TI0 ",
+"T0aI 1Ij 18Ij 1TI sI1 I0( +I0 I0D( +0aI 1I( 1+I DI1( +D1I 0(IK I0+K I0T( +0",
+"TI 1(Ij +j1I 1(TI 1+sI GI0 I0G! J0 Ja0 1GI G81I J1 J18 I0GK GI0!K JT0 TaJ0 ",
+"Gj1I 1G8Ij J1T sJ1 Id0 +0Id Jd0 gJ0 1Id +G1I J1d gJ1 I0dK Id0+K TdJ0 JTg0 I",
+"j1d Idj1+ 1TJd g1sJ I02 !0I2 I2D0 I2a0 1I5 158I 5D1I 5a1I 2KI0 I02!K I2T0 T",
+"Ia02 15Ij 1I58j 5T1I 1Is5 I;0 +0I; D0I; a0I; 1I; >I1 D;1I 1D>I ;0IK I;0+K T",
+"0I; +TI;0 Ij1; 1I>j TI1; s1>I I0G2 GI0!2 J02 a0J2 G51I 1G58I J15 1aJ5 GI02K",
+" I02GK! T0J2 JTa02 1G5Ij G581Ij 1TJ5 s1J5 G0I; Id0+; J;0 g0J; G;1I 1G>I J1;",
+" J>1 Id0;K +G0I;K T;J0 gJT;0 Idj1; >I1Gj 1TJ; J1s> I0N !0IN I0DN I0aN 1IN 1",
+"N8I DI1N 1NaI QI0 I0Q! Q0TI Q0aI 1QI Q81I QD1I 1QsI 0(IN I0+N DI0(N +DI0N I",
+"(1N 1N+I 1DI(N 1+DIN I0Q( +0QI QDI0( +QDI0 1(QI +Q1I 1QDI( sI1+Q WI0 I0W! J",
+"W0 WaJ0 1WI W81I J1W 1WJ8 G0QI GQI!0 ZJ0 JaZ0 GQ1I 1GQ8I ZJ1 Z1sJ W0Id +0WI",
+" WdJ0 JWg0 WI1d +W1I 1WJd gWJ1 Q0Id +GQI0 JdZ0 g0ZJ QI1d 1+GQI ZdJ1 ZJg1 Im",
+"0 I!m0 D0Im a0Im 1Im 8I1m Dm1I aI1m Q0Im Im0Q! T0Im QaIm0 pI1 1Ip8 1DpI s1p",
+"I m;I0 +0Im Im;D0 +DmI0 Im1; 1I>m 1DmI; >Dm1I Q0I; +QIm0 QD;I0 +TIm0 1Ip; p",
+"1>I pD1I; p>D1I G0Im Im0W! Jm0 amJ0 Gm1I 1Gm8I J1m 1aJm Im0GQ GQ0Im! Z0Jm Z",
+"Jam0 1GpI pG81I Jp1 J1sp vI0 +Iv0 Jv0 g0Jv v1I >Iv1 Jv1 g1Jv QIv0 vI+Q0 Z0J",
+"v JvZg0 v1pI pvI>1 Z1Jv yJ1 9I 9I& 9DI c9I b1I :I 1D9I :cI 9IK 9KI& 9TI 9Tc",
+"I 9Ij :Ij 1T9I s:I 9I( 9+I DI9( 9+cI b(1I :I+ b1DI( c+:I I(9K 9K+I 9(TI +T9",
+"I 9(Ij +I:j b1TI( s+:I bG9 G&9I J9 cJ9 b1G :Gb J91 :J bK9G I&K9G J9T cTJ9 9",
+"Gbj bG:j J9j :Js 9Id 9+bG J9d gJ9 1Gbd :Id b1Jd :Jg 9KId b+G9K 9TJd gTJ9 Id",
+"9j Id:j 9dJj sJg: 9I2 92I& DI92 9Ic2 95I :I5 5D9I c5:I I29K I&29K 92TI c29T",
+"I 5I9j 5I:j 5T9I s5:I 9I; +I9; D;9I 9Ic; 1Ib; :>I b1;DI :Ic> 9KI; I;&9K TI9",
+"; c;9TI I;9j >j:I I;j9D :>sI b29G I&29G J92 c2J9 9Gb5 bG:5 J95 :J5 bG92K 9G",
+"2I&K 9TJ2 cJ9T2 b1G5j :Gb5j 95Jj J5s: 9Gb; I;&9G J9; J9c; 1Gb; >b:G b1J; :J",
+"> bG;9K I;K9+G 9TJ; cJ;9T Idj95 :>Gbj 9;Jj s:J> 9IN 9NI& DI9N 9IcN bN1I :IN",
+" b1DIN cN:I 9QI Q&9I QD9I 9QcI 1Q9I :QI b1QTI :QsI I(9N 9N+I 9DI(N c9+IN b1",
+"I(N +I:N 1D(9IN :c+IN 9(QI +Q9I 9QDI( cQ9+I b1QI( +Q:I Ij(9QD :cQ+I 9WI W&9",
+"I J9W J9cW 1GbW :WI b1JW :JW 9GbQ bGQ9& ZJ9 cJZ9 1GbQ bG:Q J9Z1 Z:J WI9d +W",
+"9I 9WJd gWJ9 b1GWd +W:I J91Wd :WgJ QI9d b+G9Q ZdJ9 ZJg9 Idj9W QI:d ZJ91d gZ",
+":J 9Im I&9m Dm9I 9Icm 1Ibm :Im b1mDI cm:I QI9m Im&9Q TI9m cQ9Im p9I :pI 9Dp",
+"I sI:p Im9; +I9m 9DmI; cm9+I b1mI; >I:m 1Dm9I; c>:Im QI9; I;&9Q 9QDI; cQ;9I",
+" 9Ip; p>:I p9DI; cp:>I 9Gbm Im&9G J9m J9cm 1Gbm bG:m b1Jm :Jm bGQ9m 9GQIm& ",
+"JmZ9 ZJ9cm b1pG pb:G Jp9 :Jp v9I 9+vI Jv9 g9Jv b1vI :vI vbJ1 :Jv 9QvI v9I+Q",
+" Z9Jv cvZJ9 v9pI pv:I pvJ9 yJ: FL !FL LBF aFL FL. 8FL FL.B aF8L MF MF! TMF ",
+"aMF MjF 8MF MjTF sMF (FL +FL (FLB aF+L FL(. 8F+L (BLF. +8aFL M(F +MF M(TF +",
+"FaM j(MF +F8M TMj(F +MsF GL GL! GHL GaL GL. G8L HLG. GLH8 GM GM! GTM GaM GM",
+"j G8M HMGj sGM GdL +GL HdGL gGL dLG. +LG8 GHdL. G8gL GMd +GM TdGM gMG dMGj ",
+"G8+M dMjGT sGgM FL2 FL!2 FL2B FLa2 5FL 8F5L LB5F aF5L MF2 !FM2 MFT2 M2aF 5M",
+"F 5F8M TM5F 5MsF ;FL ;F+L LB;F ;FaL ;F5L >FL 5;FLB aF>L M;F +FM; TFM; aFM; ",
+"5FM; >MF M;F5T sM>F GL2 !LG2 HLG2 aLG2 G5L 58GL GLH5 GL5a GM2 M2G! G2HM G2a",
+"M G5M 5MG8 H5GM G5sM G;L +LG; GLH; G;gL GL5d >GL G5HdL gG>L GM; G;+M HMG; G",
+"Mg; 5dGM >MG G5TdM sG>M FLN FL!N FLNB FLaN FLN. FL8N .BLFN 8aFLN QMF MFQ! T",
+"MQF QFaM MjQF QF8M QTMjF QMsF FL(N FL+N (BLFN +aFLN N.(FL +8FLN (BFN.L 8aF+",
+"LN M(QF QM+F QTM(F aMF+Q QMj(F +Q8MF TMjQ(F s+QMF GWL GLW! HWGL GLWa WLG. G",
+"LW8 GHWL. G8HWL GQM Q!GM ZGM GaZM WMGj W8GM GMZj ZGsM WdGL GW+L GHWdL GWgL ",
+"GWdL. +GW8L HWdGL. gGW8L QdGM GQ+M GMZd ZGgM dMjGQ +GQ8M ZGdMj gZsGM mFL !F",
+"mL LBmF mFaL mF5L mF8L 5mFLB amF5L MmF M!mF TFMm aFMm pMF 8MpF TMpF pMsF ;F",
+"mL mF+L m;FLB amF+L 5m;FL mF>L m;F5BL >maFL QFM; +FMm MmFT; aMm+F M;pF pM>F",
+" pTM;F >MpsF GmL mLG! GLHm GLam GL5W GL8m G5HWL G5aWL GMm G!Mm GMZm aMGm pG",
+"M G8pM ZMpG sMpG vGL +GvL GHvL vGgL G5vL vG>L vGH5L gv>GL vMG +GvM ZGvM gGv",
+"M vMpG pG>M ZpvGM yGM #FL &FL #FLB &FaL FL#. &F8L #L.FB 8a&FL M#F M&F M#TF ",
+"TFM& j#MF 8FM& TMj#F M&sF (F#L &F+L (BL#F +a&FL #L.(F +8&FL (BF#L. 8a&+FL #",
+"(MF +FM& TM#(F aMF+& Mj#(F M&F+j Mj#T(F s+M&F G#L G&L H#GL GLH& #LG. 8&GL G",
+"H#L. G8H&L GM# GM& G#HM HMG& MjG# 8MG& GTMj# GMs& d#GL +LG& GHd#L G&gL Gd#L",
+". d&LG8 Hd#GL. gG8&L G#dM G&+M dM#GT GMg& dMjG# dM&G8 GTMdj# gsGM& FL#2 FL&",
+"2 #L2FB a&FL2 #F5L &F5L 5B#FL 5a&FL #FM2 &FM2 TM#F2 aMF&2 M#5F 5FM& 5TM#F s",
+"5M&F #F;L &F;L ;#FLB a;&FL 5;#FL &F>L ;#F5BL >&aFL ;#MF MF;& M;#TF aM;&F M;",
+"#5F M&>F 5T#M;F >Ms&F #LG2 &LG2 GH#L2 Ga&L2 5#GL GL5& G5H#L G5a&L M#G2 G2M&",
+" GTM#2 GT&M2 G#5M 5MG& G5TM# sG5M& ;#GL GL;& G;H#L gG;&L G5d#L G&>L H5#G;L ",
+"g>G&L G#M; M;G& GT;M# gMG;& G5Md# GM>& dM#G5T >MgG& FL#N FL&N #LNFB a&FLN #",
+"LNF. 8&FLN .BL#FN a&F8LN M#QF QFM& QTM#F aMFQ& QMj#F M&FQ8 TMjQ#F sQM&F #LN",
+"(F +&FLN #FN(BL a&F+LN #(FN.L 8&F+LN (FLBN.# 8a+&FLN QM#(F M&F+Q TM#Q(F +QT",
+"M&F Mj#Q(F +Q8M&F #(TFQMj M&Fs+Q W#GL GLW& GHW#L GaW&L GW#L. G8W&L HW#GL. H",
+"8WG&L G#WM WMG& GMZ# GMZ& GQMj# GQ8M& ZGMj# Z&GsM GWd#L d&LGW HWdG#L gGW&L ",
+"Wd#GL. G8Wd&L WdG#HL. G8Wg&L dM#GQ dM&GQ ZGdM# Z&GgM GQMdj# GQ8dM& dMjZG# g",
+"sGZ&M #FmL &FmL m#FLB am&FL 5m#FL m&F5L m#F5BL 5aFm&L m#MF MFm& Mm#TF aMm&F",
+" M#pF M&pF pTM#F p&MsF m;#FL m&F+L ;#FmLB m&Fa;L m;#5FL >m&FL LBmF5;# am&>F",
+"L Mm#;F Mm&+F Tm#M;F aMFQ;& pM;#F >Mp&F M;#pTF p&F>Ms m#GL GLm& GmH#L Gam&L",
+" G5W#L G5&WL H5#GmL amLG5& G#Mm MmG& ZGMm# Z&GMm GMp# GMp& ZpGM# Zp&GM G#vL",
+" G&vL vGH#L gvG&L vG5#L v>G&L G5Hv#L v&Gg>L GMv# GMv& ZvGM# Zv&GM pvGM# >Mv",
+"G& pGMZv# GMy& UI U!I UDI UaI UI. U8I DIU. 8IUa IM IM! VI VaI UjI 8IM VIj s",
+"IV UI( U+I DIU( +IUa I(U. +IU8 UDI(. U+D8I IM( +IM VI( V+I U(Ij +IUj IjV( V",
+"+sI UG UG! JU JUa UG. UG8 JU. J8U UGM U!GM VJ VJa UGj G8Uj JjV sJV UGd U+G ",
+"JUd gJU U.Id +GU8 UdJ. J8gU IdM +MUG VJd gVJ GjUd +GUj VdJj sJgV UI2 I2U! D",
+"IU2 U2aI U5I 5IU8 UD5I 5IUa IM2 I!M2 V2I aIV2 5IM 8I5M V5I V5sI U;I +IU; UD",
+"I; aIU; 5IU; >UI U5DI; Ua>I IM; I;+M V;I +IV; I;Uj >MI 5IV; V>I UG2 G2U! JU",
+"2 UaJ2 UG5 G5U8 J5U U5J8 U2GM IM2G! VJ2 JaV2 G5Uj UG58M J5V VsJ5 UG; +GU; J",
+";U J;gU G5Ud >UG U5J; J>U GMU; IdM+; J;V J;gV G;Uj UG>M V5J; J>V UIN INU! D",
+"IUN UNaI INU. UN8I UDIN. U8IDN UQI Q!IM VQI QaVI QIUj QIU8 QIVj VQsI I(UN U",
+"N+I UDI(N U+DIN UI(N. U+8IN DI(UN. +DIU8N U(QI +IUQ QIV( +QVI IM(Qj U+Q8I V",
+"QIj( sIV+Q UGW U!WI JUW UWJa U.WI G8UW UWJ. UWJ8 UGQ Q!UG ZJV ZaVJ GQUj GQU",
+"8 VZJj VZsJ WIUd +GUW UWJd JUgW Id.UW U+GW8 JUWd. gJUW8 GQUd +GUQ VdZJ ZJgV",
+" IdMWj IdMW8 ZJVdj gVZsJ UmI U!Im UDIm aIUm 5IUm 8IUm U5DIm U5aIm IMm I!Mm ",
+"VmI aIVm pUI U8pI VpI sIVp ImU; +IUm Im;UD U+maI Im;U5 Um>I U5DIm; >DmUI QI",
+"U; IM+m QIV; +IVm U;pI pI>M pIV; pIV> UGm U!Gm JmU UaJm G5UW G8Um U5Jm U8Jm",
+" GQUm IMmW! JmV JaVm pUG UGp8 JpV VpsJ vUG U+vI JvU gUJv UGv5 >UvI vUJ5 vUJ",
+"> vIM +IvM VvJ JvgV vUpG vI>M VvJp yJV bUI U&I UDbI cUI UIb. 8IU& bUDI. U8c",
+"I bMI IM& VbI VcI IMbj 8IbM bjVI VcsI UIb( +IU& bUDI( U+cI bUI(. b+U8I UDIb",
+"(. cU+8I b(IM +IbM bIV( cIV+ IM(bj IM&+j VbIj( sIVc+ bGU UG& JbU cJU b.UG U",
+"Gb8 bUJ. cUJ8 bGM GMU& VJb cJV UGbj G8bM VbJj VJsc UGbd U+bG bdJU cJgU Id.b",
+"U b+GU8 JbUd. cJUg8 GMbd +GbM JbVd cJgV IdMbj IdMb8 JjVbd gVJsc UIb2 U2I& b",
+"UDI2 UIc2 bU5I 5IU& b5UDI U5cI b2IM I2M& bIV2 cIV2 5IbM IM5& b5VI cIV5 bUI;",
+" I;U& b;UDI U;cI b5UI; U&>I U5Db;I cU>I IMb; M;I& b;VI cIV; IM;b5 bM>I V5bI",
+"; >IVc b2UG U2G& bUJ2 JUc2 UGb5 G5U& b5JU cUJ5 b2GM IM&G2 JbV2 V2cJ G5bM IM",
+"&G5 JbV5 VJc5 UGb; G;U& b;JU cUJ; bG5Ud bG>U J5bUd >UcJ GMb; IdM;& JbV; VJc",
+"; IdMb5 bG>M J5Vbd cJV> UIbN UNI& bUDIN UIcN bUIN. I&NU8 UDIbN. cU8IN QIbM ",
+"QIU& bQVI VQcI bQUIj IM&Q8 VbQIj sIVcQ bUI(N I&NU+ UDIb(N cU+IN UI(bN. U+8I",
+"&N UDbIN.( U+8cIN IM(bQ IM&+Q VbQI( cQV+I bQUIj( U+QI&j Ij(VbQ cQVsI+ UGbW ",
+"G&UW bWJU JUcW bGUW. bG8UW JbUW. cJUW8 UGbQ GQU& VJZb VZcJ bGQUj IM&W8 ZJVb",
+"j sJZVc bGUWd b+GUW JbUWd cJUgW bWUId. U+GbW8 bWUJd. gJUcW8 IdMbW IdMW& ZJV",
+"bd gVZcJ bWMIdj bW8IdM JjVZbd sJZgVc bUIm ImU& bmUDI UmcI b5UIm Im&U5 U5Dbm",
+"I c5UIm IMbm MmI& bmVI cIVm bMpI U&pI VbpI pIVc Im;bU Im&U+ UmDb;I cmU+I b5",
+"UIm; >ImU& Imb;U5D c>UIm IMmb; IMmb+ VmbI; cQ;VI pbUI; >MbpI VpbI; cpV>I UG",
+"bm GmU& bmJU cUJm bG5UW bG8Um J5bUW cJ5UW GMbm IMmG& JbVm VJcm bGpU UGp& pb",
+"VJ cJVp bGvU UGv& JbvU vUcJ vbUG5 v>bUG JvbU5 cvJ>U bGvM IMv& vbVJ cJVv pvb",
+"UG >MvbG JpVvb cJyV kF kF! kFB akF 1kF 8kF kF1B 1Fak kMF M!kF TkF TFak lF l",
+"8F lTF lsF k(F +kF (BkF +Fak k(1F 1F+k 1k(FB akF1+ M(kF kM+F k(TF +FTk l(F ",
+"l+F T(lF sFl+ Gk Gk! GkH Gak 1Gk G8k Gk1H Gk1a GkM kMG! GTk TkGa lG lG8 lGH",
+" lsG Gkd +Gk GHdk gkG Gk1d +k1G 1GHdk 1Ggk dkGM Gk+M TdGk GTgk lGd l+G GTld",
+" glG kF2 !Fk2 2BkF k2aF 5kF 5F8k kF5B 5Fak MFk2 kMF!2 kFT2 akFT2 l5F 58lF 5",
+"TlF sFl5 k;F +Fk; ;FkB aFk; 1Fk; >kF k;F1B ak>F kFM; k;M+F TFk; ak;TF l;F l",
+">F T;lF >Fls Gk2 k2G! G2Hk G2ak G5k 5kG8 H5Gk 5aGk kMG2 GkM!2 G2Tk GTka2 lG",
+"5 G5l8 G5lH l5sG Gk; G;+k HkG; Gkg; Gk1; >kG 1G;Hk >Ggk k;GM +GkM; TkG; gkG",
+"T; lG; l>G GTl; g>lG kFN !FkN NBkF kFaN kF1N kN8F 1kFNB akF1N QkF kFQ! QFTk",
+" QFak lQF Q8lF QTlF sFlQ (FkN kF+N k(FNB akF+N 1k(FN 1+kFN k(F1NB 1+FakN k(",
+"QF +FQk QkT(F +QkTF Q(lF +QlF lQT(F ls+QF GkW W!Gk GHWk WaGk Gk1W W8Gk 1GHW",
+"k 1GaWk GQk Q!Gk ZkG GaZk lGW GQl8 lZG sZlG GWdk Gk+W GkHWd GkgW 1GWdk 1+GW",
+"k GkH1Wd g1GWk QdGk GQ+k GkZd gGZk GQld +GlW ZGld lGgZ kmF k!mF mFkB aFkm 1",
+"Fkm 8Fkm kmF1B akm1F QFkm kmFQ! TFkm akmQF lpF p8lF pTlF sFlp m;kF +Fkm km;",
+"FB akm+F km;1F km>F 1mFk;B >kamF QFk; +QkmF Qk;TF ak;QF p;lF >Flp l;pTF l>p",
+"sF Gkm G!km HkGm akGm Gk1m 8kGm 1GmHk akm1G QkGm GQkm! GkZm ZkGam lGp l8pG ",
+"ZplG splG vkG +Gvk GkvH gGvk 1Gvk >Gvk v1GHk >kgvG GQvk vk+GQ ZGvk ZvkgG lv",
+"G p>lG ZvlG ylG 9kF k&F kF9B 9Fak 1k9F :kF 91kFB ak:F 9MF 9FM& 9FTk 9FaM l9",
+"F l:F 9TlF sFl: k(9F 9F+k 9k(FB akF9+ 91k(F +k:F 1k(9FB :+akF M(9F 9F+M 9Tk",
+"(F 9+TkF 9(lF :+lF l9T(F ls:+F 9Gk Gk& Gk9H Gk9a 91Gk :Gk 9G1Hk Ga:k 9GM G&",
+"9M GT9M Ga9M lG9 l:G 9GlH s:lG Gk9d +k9G 9GHdk 9Ggk 9G1dk +G:k 1GH9dk :Ggk ",
+"GM9d +G9M 9GTdk 9GgM 9Gld :Gl+ lG9Td lGg: kF92 &Fk2 9kF2B akF92 9F5k 5k:F 9",
+"5kFB :5akF MF92 k&FM2 9TkF2 9aMF2 95lF :5lF l95TF ls:5F 9Fk; kF;& k;F9B ak;",
+"9F k;F95 :k>F 95Fk;B :>akF 9FM; k;&MF 9T;kF aM;9F 9;lF >Fl: l;9TF l>s:F 92G",
+"k G2k& 9GHk2 9Gak2 Gk95 G5:k 9G5Hk :GH5k 92GM 9GM&2 9GTk2 9GaM2 9Gl5 l5:G l",
+"G9H5 lsG:5 Gk9; k;G& 9G;Hk g9Gk; 9G5dk :G>k G5k9H; g:>Gk GM9; k;&GM 9GTk; g",
+"9MG; 9Gl; :>lG lG;9H l>Gg: kF9N &FkN 9kFNB akF9N 91kFN kF:N 1kF9NB :akFN 9F",
+"Qk QFk& 9QTkF 9QakF 9QlF lF:Q l9QTF :QFls 9k(FN k&F+N k(F9NB 9+FakN 1k(9FN ",
+":+kFN 1k9(NBF akF:+N 9Qk(F 9+QkF Qk(9TF akF9+Q l9Q(F :Q+lF 9QTl(F ls+:QF Gk",
+"9W WkG& 9GHWk 9GaWk 9G1Wk Gk:W 1GH9Wk :GHWk GQ9M QkG& 9GZk GkZ& 9GlW :GlW Z",
+"9lG lGZ: 9GWdk dk&GW GkH9Wd g9GWk 1GW9dk :G+Wk 91GkHWd g:GWk 9GQdk dk&GQ Z9",
+"Gdk Zk&gG lG9Qd :GQl+ lZ9Gd glZ:G 9Fkm kFm& kmF9B akm9F kmF95 km:F 95FkmB :",
+"makF 9FMm km&QF 9TmkF aMm9F lFp9 lF:p p9lTF :plsF km;9F km&+F 9mFk;B akF9+m",
+" 95;kmF :>mkF km1;9FB >ka:mF 9Q;kF k;&QF kmF9T; akF9Q; l;p9F l>p:F p9Tl;F :",
+"psl>F Gk9m kmG& 9GmHk akm9G 9G5Wk Gk:m G5k9Hm :GmHk GM9m km&GQ Z9Gkm Zk&Gm ",
+"p9lG lG:p Zp9lG :pGlZ 9Gvk Gkv& v9GHk gv9Gk v91Gk vk:G 9G5vkH :vGgk 9GvM v9",
+"M+G Zv9Gk ZvkG& v9lG lG:v lvZ9G l:yG Ik Ik! DkI aIk 1UI 8Ik Dk1I Ua1I IkM I",
+"!kM VIk aIVk lI lI8 lIV lsI Ik( +Ik D(Ik Dk+I 1(Ik U+1I Ik(1D 1U+aI kMI( Ik",
+"+M IkV( +IVk lI( l+I VIl( sIl+ UGk U!Gk Jk Jka 1UG U81G J1U J8k IkGM IkMG! ",
+"JkV VaJk lGU UGl8 lJ lJs Idk +kUG Jkd gJk UG1d U+1G 1UJd J1gU dkIM Idk+M Vd",
+"Jk JkgV lId U+lG lJd glJ Ik2 I!k2 I2Dk I2ak 5Ik 8I5k Dk5I aI5k kMI2 IkM!2 I",
+"kV2 V2aIk lI5 5Il8 V5lI l5sI Ik; I;+k IkD; Ika; U;1I >kI Ik;1D Dk>I k;IM Ik",
+";+M IkV; V+Ik; lI; l>I V;lI lIV> U2Gk Ik2G! Jk2 akJ2 U51G 1UG58 J5k 5aJk Ik",
+"MG2 Gk2IM! V2Jk JkVa2 UGl5 lGU58 lJ5 J5ls GkU; Idk+; Jk; J;gk UG1; 1U>G 1UJ",
+"; J>k IdkM; +GkIM; V;Jk gVJk; UGl; >UlG lJ; J>l IkN I!kN DNIk aNIk 1NIk IN8",
+"k IkN1D 1UaIN QIk Q!Ik QIVk aIQk lIQ Q8lI VQlI lQsI k(IN +NIk Ik(DN +DkIN I",
+"k(1N 1U+IN 1D(IkN akN1+I Q(Ik QI+k VQIk( V+QIk QIl( +QlI VlQI( lsI+Q WIk W!",
+"Ik JkW WaJk UG1W 8IWk 1UJW W8Jk GkUQ UGQk! ZJk ZaJk lWI W8lI lJZ lZsJ IdWk ",
+"WI+k WkJd gWJk Idk1W IdkW8 J1UWd gJ1UW IdQk Idk+Q ZdJk ZJgk WIld +WlI ZJld ",
+"gZlJ Ikm I!km IkDm Ikam Um1I Ik8m Ikm1D akm1I ImQk IkmQ! IkVm VmaIk lIp l8p",
+"I lIVp splI kmI; Ik+m IkmD; akm+I Ikm1; Ik>m 1DmIk; >kDIm IkQ; Ikm+Q VmIk; ",
+"V+mIk pIl; p>lI VplI; V>lpI GkUm IkmW! Jkm akJm UG1m IkmG8 1UJm 8kJm IkmGQ ",
+"Ik!GMm JmZk ZJkam pUlG lGpU8 Jpl lsJp vIk +Ivk Jvk gkJv 1UvI vI>k v1Jk >kJv",
+" QIvk vIk+Q ZkJv VvJgk lvI v>lI lvJ ylJ tI tI& tDI tcI t1I t:I 1DtI :Itc tI",
+"M IMt& VtI tIVc ltI l:I VtlI uI tI( t+I DIt( c+tI 1It( :It+ t1DI( t:c+I IMt",
+"( +ItM VIt( tIV+ tIl( t+lI ltVI( u+I tG tG& tJ tJc tG1 t:G tJ1 :Jt tGM GMt&",
+" tJV VJtc ltG t:lG lJt uJ tGd t+G tJd gtJ 1Gtd :Gt+ J1td :Jgt GMtd +GtM VJt",
+"d tJgV tGld t+lG ldtJ uJg tI2 I&t2 DIt2 c2tI t5I :It5 5DtI tIc5 IMt2 IM&t2 ",
+"tIV2 tcVI2 t5lI l5:I tIV5 u5I t;I +It; D;tI tIc; 1It; t>I t5DI; >Itc IMt; t",
+"+IM; tIV; tc;VI t;lI lIt> t5VI; u>I tG2 G&t2 tJ2 c2tJ tG5 :Gt5 tJ5 t5:J GMt",
+"2 tGM&2 V2tJ tJVc2 t5lG t:Gl5 t5lJ uJ5 tG; +Gt; tJ; t;gJ 1Gt; t>G J1t; t>J ",
+"GMt; t+GM; VJt; tJ;gV tGl; lGt> l;tJ uJ> tIN I&tN DItN cItN 1ItN tN:I t1DIN",
+" t:cIN tQI QIt& VQtI tIcQ tQlI :QlI tQVlI uQI I(tN +ItN tDI(N tc+IN t1I(N t",
+":+IN 1DIt(N :cIt+N QIt( +QtI tQVI( tcQ+I tQIl( t:Q+I Vl(tQI +QuI tGW G&tW t",
+"JW cJtW 1GtW :GtW J1tW tW:J tGQ GQt& tZJ ZctJ tGlW :GtQ lJtZ uZJ WItd +GtW ",
+"JWtd tWgJ tG1Wd t:G+W tJ1Wd gtJ:W GQtd +GtQ ZJtd gZtJ tGQld t:G+Q lJZtd gZu",
+"J tmI Imt& DmtI tIcm 1Itm :Itm t5DIm t:mcI QItm tQIm& tIVm tcQIm tpI lI:p p",
+"IVt upI Imt; +Itm tmDI; tcm+I t5Im; >Itm 1Dmt;I t>cIm QIt; t+QIm tQ;VI tcQI",
+"; pIt; pIt> tpVI; p>uI tGm Gmt& tJm cJtm 1Gtm :Gtm J1tm tm:J GQtm tGQm& ZJt",
+"m tJmZc tpG tG:p tpJ uJp tvG vIt+ tvJ tJcv v1tG tG:v t5Jv :Jtv vItQ tv+GQ t",
+"JVv cvVtJ lGtv lI:v Jptv yuJ e e! eB ae e. 8e e.B 8ea eK eK! Te Tea ej 8ej ",
+"Tej se e* +e *Be +ea e*. +e8 e.*B ae8* e*K +eK Te* +Te ej* +ej ejT* se+ Ge ",
+"Ge! He Gae Ge. G8e He. H8e GeK eKG! GTe TeGa Gje 8eGj Hej sGe f f+ fH gf f.",
+" f8 fH. gf8 fK f+K fT gfT fj f8j fTj sf e2 e2! e2B ae2 5e 5e8 5eB 5ae e2K 2",
+"Ke! Te2 T2ae 5ej 58ej 5Te se5 e; +e; e;B ae; 5e; >e *B5e >ea e;K +Ke; Te; T",
+";+e e;j >ej Te5* >es Ge2 e2G! He2 G2ae G5e 5eG8 H5e 5aHe e2GK Ge2!K G2Te ae",
+"2GT 5eGj G58ej 5THe G5se f; f+; fH; gf; f5 f> f5H f>g f;K +;fK fT; g;fT f5j",
+" f>j f5T sf> eN eN! eNB aeN eN. 8eN .BeN aN8e Qe Qe! QeT Qae Qej Q8e QTej s",
+"eQ e*N +eN eN*B +Nae *Ne. +N8e *BeN. aeN8* Qe* +Qe TeQ* Qa+e ejQ* Q8+e ej*Q",
+"T +Qse We We! HeW Wae We. W8e H.We W8He GQe Q!We Ze Zea Wej Q8We Zej sZe fW",
+" f+W fHW gfW fW. f8W HWf. gWf8 fQ fQ+ Zf Zfg fQj fQ8 Zfj sfZ em em! emB aem",
+" 5em 8em 5Bem ae8m Qem Q!em Tem aeTm pe pe8 peT spe em; +em *Bem ae+m em5* ",
+">em em;5B ae>m Qe; Qe+m TeQ; Te+m pe; >ep Tep* sp>e Gme W!em Hem aeGm 5We W",
+"85e 5WHe Wa5e QeGm em!GQ Zem aeZm pGe G8pe Zpe Zpse fv fv+ fvH gfv fv5 f>v ",
+"vHf5 gvf> fvQ v+fQ Zfv gvZf fp fp> fpZ yf ,e e& ,eB ,ae ,e. ,8e e.,B 8e,a ,",
+"eK e&K ,Te Te& ,je e&j Te,j se& ,e* -e ,e*B -ae e*,. -8e *Be,. 8e-a e*,K -e",
+"K ,eT* -Te ,e*j -je ej*,T s-e ,G ,G& ,GH ,Ga ,G. ,G8 ,.He G8,H ,GK ,KG& ,GT",
+" GT,a ,Gj G8,j GT,j sG, f, f- fH, gf- f,. f-8 ,Hf. f8g- f,K f-K fT, f-T fj,",
+" f-j ,Hfj sf- ,e2 e&2 e2,B ,2ae ,5e 5e& ,B5e 5e,a e2,K &2eK ,2Te T2e& 5e,j ",
+"ej5& 5e,T ,5se ,;e -e; ,Be; ae-; 5e,; >e- e;B,5 -a>e ,Ke; e;-K Te,; Te-; e;",
+",j -j>e e;j,T >es- ,G2 ,2G& ,2He ,2Ga ,G5 G5,8 G5,H G5,a G2,K e&2GK ,2GT ,G",
+"T&2 G5,j e&jG5 G5,T ,Gs5 f;, f-; ,Hf; g;f- f5, f>- ,Hf5 g-f> ,;fK fK-; ,Tf;",
+" f;-T ,5fj ->fj ,5fT f>s- ,eN e&N eN,B ,Nae eN,. ,N8e ,eN.B aeN,8 ,Qe Qe& Q",
+"e,T Qe,a Qe,j Qe,8 ,QTej ,Qse e*,N -eN *Be,N ae-N ,e*N. 8e-N ,eN*B. -8aeN ,",
+"eQ* -Qe ,QTe* Qa-e ej*,Q Q8-e ,QTej* -Qse ,GW We& He,W Ga,W ,.We G8,W ,GHW.",
+" ,G8Wa ,GQ G&,Q Ze, Ze& GQ,j GQ,8 ,GZj Zes, fW, f-W ,HfW -Wgf ,Wf. -Wf8 fHW",
+",. f-Wg8 fQ, f-Q Zf, Z-f ,Wfj -Wfj fjZ, Z-sf ,me em& ,Bem ae,m 5e,m 8e,m em",
+"B,5 aem,5 Qe,m emQ& Te,m emT& pe, pe& ,Tpe pes, em,; -me em;,B ae-m em;,5 -",
+"m>e ,5em*B >e-am Qe,; Qe-m ,Q;Te Te-m ,;pe -pe peT,; se-p ,Gm G&,m Gm,H Ga,",
+"m G5,W G8,m ,G5Hm em&H5 GQ,m em&GQ ,GZm emZ& pG, ,Gp& pGZ, pGs, fv, -vf fHv",
+", gf-v v,f5 -vf> fvH,5 f>g-v v,fQ fQ-v fvZ, -vZf fp, fp- Z,fp yf- Ie Ie! De",
+" Dea Ie. 8Ie De. D8e IeK I!eK DeT aITe Ije Ij8e Dej sIe I* +Ie De* +De I*. ",
+"8I* D.I* D8+e I*K +KI* TI* De+T I*j I*+j I*Dj sI* GIe IeG! Je Jae IeG. GI8e",
+" Je. J8e IeGK GIe!K JTe TeJa GIej IjeG8 Jje sJe fI f+I Jf gJf fI. f8I Jf. J",
+"f8 fIK +IfK JfT fTgJ fjI +Ifj Jfj sfJ Ie2 I!e2 De2 I2ae 5Ie 8I5e 5De D85e e",
+"2IK Ie2!K I2Te ae2TI Ij5e Ije58 De5T 5Dse I;e I;+e De; D;+e 5I* >eI De5* >e",
+"D IKe; I;e+K TeD; ae;TI Ij5* I*>j TI5* sI>e IeG2 GIe!2 Je2 aeJ2 GI5e G58Ie ",
+"J5e 5aJe GIe2K Ie2GK! TeJ2 JTae2 IjeG5 G58Ije 5TJe J5se fI; +If; Jf; J;gf f",
+"5I f>I Jf5 J>f I;fK f+I;K fTJ; JfTg; 5Ifj >Ifj f5Jj J>sf IeN I!eN DeN DNae ",
+"eNI. IN8e eND. DN8e QIe IeQ! QDe DeQa IjQe 8IQe DjQe QDse I*N +NI* DNI* +ND",
+"e *NI. IN8* I*ND. +De8N QI* QI+e DeQ* QD+e IjQ* 8IQ* I*jQD QIs* WIe IeW! JW",
+"e WaJe IeW. 8IWe WeJ. W8Je QIWe GQIe! ZJe JaZe IjWe GQ8Ie JjZe ZJse fWI +Wf",
+"I JfW gWJf WIf. W8fI fWJ. JWf8 fQI +QfI ZfJ gJZf WIfj Q8fI JjZf ZfsJ Ime I!",
+"em Dem aeDm Im5e Im8e Dm5e 8eDm ImQe ImeQ! DmQe aemQD pIe 8Ipe pDe pDse Im*",
+" Im+e ImD* De+m Im5* Im>e Im*5D De>m ImQ* Im*+Q DeQ; ae;QD pI* pI>e Dep* pD",
+">e ImWe ImeW! Jme aeJm WI5e G8mIe 5WJe 8eJm ImeGQ GQIem! JmZe ZJaem WIpe pG",
+"8Ie Jpe seJp fvI f+vI Jvf gfJv vIf5 vIf> fvJ5 f>Jv vIfQ fv+QI JvZf ZfJgv fp",
+"I pIf> Jpf yJf h h& hD hc h. h8 hD. hc8 hK h&K hT hcT hj h8j hTj hs h* h- h",
+"D* hc- h*. h-8 D*h. c-h8 h*K h-K hT* h-T hj* h-j D*hj hs- hG hG& hJ hJc hG.",
+" h8G hJ. hJ8 hGK G&hK hJT cJhT hjG G8hj hJj hsJ hf hf- hJf i hf. hf8 h.Jf i",
+"8 hfK hKf- hfT iT hfj f-hj Jfhj is h2 h&2 hD2 hc2 h5 h58 h5D hc5 h2K &2hK h",
+"T2 c2hT h5j 5&hj h5T hs5 h; h-; h;D hc; h5; h> 5Dh; h>c h;K -;hK hT; c;hT h",
+";j h>j 5Th; hs> hG2 G&h2 hJ2 h2cJ h5G G5h8 hJ5 cJh5 G2hK hG&2K JTh2 cJTh2 G",
+"5hj h5G&j J5hT h5sJ hf; f-h; hJ; i; hf5 h>f Jfh5 i> f;hK f-;hK J;hT iT; f5h",
+"j hjf> J;hj is> hN h&N hDN hcN hN. h8N DNh. c8hN hQ hQ& hQD hcQ hQj hQ8 QDh",
+"j hsQ h*N h-N D*hN hNc- *Nh. -8hN hD*N. c-8hN hQ* h-Q QDh* c-hQ Q*hj -Qh8 h",
+"QD*j hQs- hW hW& hJW hcW hW. hW8 JWh. cWh8 hWQ GQh& hZ hZc hWj GQh8 hZj hZs",
+" hfW h-W JfhW iW fWh. f8hW JfWh. iW8 hfQ f-hQ hZf iZ fQhj fQh8 hjZf iZs hm ",
+"hm& hmD hcm h5m h8m 5Dhm c5hm hQm Q&hm hTm cQhm hp hp8 hpD hps hm; h-m Dmh;",
+" c-hm 5*hm h>m h5Dm* hmc> hQ; -Qhm QDh; cQh; hp; hp- pDh; cph> hWm Gmh& hJm",
+" cJhm h5W G8hm J5hW c5hW GQhm hWQm& hZm hmZc hpG pGh8 hZp cphZ hv hv- hvJ i",
+"v hv5 hv> h5Jv iv> hvQ hQ-v hZv iZv hpf fph> Jphv yi e0 e0! e0B ae0 1e 1e8 ",
+"1eB 1ae e0K !Ke0 Te0 T0ae 1ej 18ej 1Te se1 e*0 +e0 e0*B +0ae 1e* 1+e *B1e +",
+"e1a *0eK e0+K e*T0 +0Te ej1* +j1e Te1* 1+se Ge0 e0G! He0 G0ae 1Ge G81e 1He ",
+"Ga1e e0GK Ge0!K G0Te ae0GT Gj1e 1G8ej GT1e 1Gse f0 f+0 fH0 gf0 f1 f1+ f1H g",
+"f1 f0K +0fK fT0 g0fT f1j 1+fj f1T sf1 e02 !0e2 2Be0 e2a0 1e5 158e 1B5e 5a1e",
+" 2Ke0 e02!K e0T2 ae0T2 15ej 1e58j 5T1e 1es5 e;0 +0e; ;0eB a0e; 1e; >e1 1Be;",
+" 1a>e ;0eK e;0+K T0e; ae;T0 ej1; 1e>j Te1; s1>e e0G2 Ge0!2 e0H2 ae0G2 G51e ",
+"1G58e H51e 1Ga5e Ge02K e02GK! GTe02 GT0ae2 1G5ej G581ej 1GT5e se1G5 f;0 +;f",
+"0 H;f0 f;g0 f15 f>1 1Hf5 g1f> ;0fK f+;0K T;f0 fT;g0 1;fj >jf1 1Tf5 f1s> e0N",
+" !0eN 0BeN e0aN 1eN 1N8e eN1B 1Nae Qe0 e0Q! Q0Te Q0ae 1Qe Q81e Qe1T 1Qse *0",
+"eN e0+N *Be0N ae0+N e*1N 1N+e 1e*NB 1+eaN e*Q0 +0Qe QeT*0 +QeT0 Qe1* +Q1e 1",
+"QeT* se1+Q We0 e0W! H0We W0ae 1We W81e He1W Wa1e G0Qe GQe!0 Ze0 aeZ0 GQ1e 1",
+"GQ8e Z1e Z1se fW0 +Wf0 HWf0 fWg0 f1W 1+fW 1HfW gWf1 fQ0 +Qf0 Zf0 g0Zf f1Q 1",
+"+fQ Zf1 g1Zf em0 e!m0 m0eB a0em 1em 8e1m 1Bem ae1m Q0em em0Q! T0em aemQ0 pe",
+"1 1ep8 1Tpe s1pe e0m* +0em em;0B aem+0 em1; 1e>m 1em*B >e1am Q0e; +Qem0 Qe;",
+"T0 ae;Q0 1ep* p1>e pe1T; >eps1 G0em em0W! H0em aemG0 Gm1e 1Gm8e He1m aem1G ",
+"em0GQ GQ0em! emZ0 Zeam0 1Gpe pG81e peZ1 Zpes1 fv0 v+f0 vHf0 g0fv fv1 v>f1 f",
+"Hv1 fvg1 vQf0 fv+Q0 Z0fv Zfgv0 fp1 p>f1 Z1fp yf1 9e 9e& 9eB 9ae ,1e :e ,B1e",
+" :ea 9eK 9Ke& 9Te Te9a 9ej :ej 1T9e s:e 9e* -9e *B9e 9a-e 1e9* :-e ,1e*B -a",
+":e e*9K 9e-K Te9* 9T-e ej9* -j:e ,1Te* :-se ,G9 G&9e 9He 9G,a ,1G :Ge 1G,H ",
+":He ,K9G e&K9G 9G,T ,GT9a 9G,j ,G:j 1G,T :Gse f9 f-9 f9H gf9 f91 :f ,1fH :f",
+"g f9K fK-9 f9T fTg9 f9j :fj ,1fT sf: 9e2 92e& e29B 92ae 95e :e5 9B5e 5a:e e",
+"29K e&29K 92Te 9Te&2 5e9j 5e:j 5T9e s5:e 9e; 9e-; 9Be; ae9; 1e,; >e: ,1;eB ",
+":a>e 9Ke; -9e;K Te9; -T9e; e;9j >j:e e;j9T s:>e ,29G e&29G 92He ,Ga92 9G,5 ",
+",G:5 H59e H5:e ,G92K 9G2e&K ,GT92 ae29GT ,1G5j :G5,j ,1G5T :Hes5 f9; -9f; 9",
+"Hf; g;f9 f95 :f> 9Hf5 f>g: 9;fK f-9;K 9Tf; f-T9; 95fj fj:> 95fT s:f> 9eN 9N",
+"e& eN9B 9Nae ,N1e :eN ,1eNB ae:N 9Qe Q&9e Qe9T Qa9e 1Q9e :Qe ,1QTe :Qse e*9",
+"N 9e-N 9e*NB -9aeN ,1e*N -e:N 1eN9*B :-aeN Qe9* 9Q-e 9QeT* -Q9Te ,1Qe* -Q:e",
+" 1Qe9T* s-:Qe 9We W&9e He9W Wa9e 1G,W :We ,1GHW He:W 9G,Q ,GQ9& Z9e 9aZe 1G",
+",Q ,G:Q ,1Ze Z:e f9W -Wf9 9HfW gWf9 ,1fW :fW f91HW :Wgf f9Q -Qf9 Zf9 g9Zf ,",
+"1fQ :fQ f9Z1 Z:f 9em e&9m 9Bem ae9m 1e,m :em ,1meB ae:m Qe9m em&9Q Te9m aem",
+"9Q p9e :pe 9Tpe se:p em9; 9e-m 9em*B -m9ae ,1me; :m>e emB,1; :-mae Qe9; -Q9",
+"em 9QeT; -Tm9e 9ep* >e:p p9eT; -ps:e 9G,m em&9G He9m aem9G 1G,m ,G:m ,1GHm ",
+"He:m ,GQ9m 9GQem& 9eZm Z9eam ,1pG pG:e p9Ze Ze:p fv9 f9-v fHv9 fvg9 v9f1 :f",
+"v fv91H gf:v v9fQ -vf9Q fvZ9 Zf9-v fp9 :fp Z9fp y:f Ie0 I!e0 De0 D0ae 1Ie 8",
+"I1e 1De D81e e0IK Ie0!K D0Te ae0TI Ij1e Ije18 De1T 1Dse I*0 +0I* D0I* +0De ",
+"1I* +I1e De1* +D1e *0IK I*0+K T0I* +DeT0 Ij1* I*j1+ TI1* 1Is* IeG0 GIe!0 Je",
+"0 aeJ0 GI1e 1G8Ie J1e 1aJe GIe0K Ie0GK! TeJ0 JTae0 Ije1G 1G8Ije 1TJe J1se f",
+"I0 +If0 Jf0 g0Jf f1I 1+fI Jf1 Jfg1 I0fK f+I0K J0fT JfTg0 1Ifj f1+Ij f1Jj J1",
+"sf e0I2 Ie0!2 e0D2 ae0I2 5I1e 1I58e 5D1e 1De5a Ie02K e02IK! DeT02 TI0ae2 Ij",
+"e15 5I81ej 1De5T sI15e I0e; I;e+0 D0e; ae;D0 5I1* 1I>e De1; 1D>e I;e0K +I0e",
+";K De;T0 ae0TI; I;j1e >I1ej e;j1D sI*>1 GIe02 Ie0G2! e0J2 Jae02 1G5Ie G581I",
+"e 1eJ5 J158e Ie0G2K !0I2GeK JTe02 ae0JT2 1G5Ije 8eGj1I5 J15Te sJ15e I;f0 f+",
+"I;0 f;J0 Jf;g0 1If5 >If1 f1J5 J1f> fI;0K I;0f+K JfT;0 fT;gJ0 f15Ij f>1Ij Jf",
+"15T J>sf1 e0IN Ie0!N e0DN ae0DN Ie1N 1I8eN 1NDe 1DeaN IeQ0 QIe!0 Q0De QDea0",
+" QI1e 1QI8e QD1e sI1Qe *0IN I*0+N I*0DN +De0N 1NI* 1+IeN 1De*N 1+DeN Q0I* +",
+"QIe0 QDe*0 +QDe0 QI1* 1+QI* 1QDI* sI*1Q IeW0 WIe!0 WeJ0 JWae0 WI1e 1WI8e 1W",
+"Je J1W8e GQIe0 QI0We! JeZ0 ZJae0 1GQIe W8I1Qe J1Ze sJZ1e WIf0 f+WI0 fWJ0 Jf",
+"Wg0 1WfI f1+WI JWf1 Jf1gW QIf0 fQ+I0 Z0Jf ZfJg0 1QfI f1Q+I JfZ1 Zf1sJ I0em ",
+"Ime!0 D0em aemD0 Im1e 1Im8e De1m aem1D ImeQ0 QI0em! QDem0 ae0TIm 1Ipe pI81e",
+" 1Dpe pDes1 I0m* Im*+0 Im*D0 am*I0 Im1* >I1em Im*1D >eD1m Im*Q0 Im0+Qe Im*T",
+"0 ae0QD; 1Ip* >ep1I pDe1; sI*p1 ImeG0 WI0em! emJ0 Jmae0 1GmIe W8I1em 1eJm J",
+"1m8e GQIem0 ImQeW!0 ZJem0 JmaZe0 pG1Ie 1WIpe8 peJ1 Jps1e f0vI fv+I0 J0fv Jv",
+"gf0 vIf1 f>v1I fvJ1 J>fv1 fvQI0 vI+fQ0 ZfJv0 JvgZf0 pIf1 fp>1I J1fp Jfy1 h9",
+" h9& h9D hc9 h1 h: h1D h:c h9K 9&hK hT9 c9hT h1j h:j h1T hs: h9* h-9 9Dh* h",
+"9c- h1* h:- 1Dh* :ch- 9*hK -9hK 9Th* h9-T 9*hj :-hj 1Th* s-h: h9G 9Gh& hJ9 ",
+"J9hc h1G h:G hJ1 :Jh 9GhK h9G&K J9hT cJ9hT 9Ghj :Ghj J9hj :Jhs hf9 f9h- Jf9",
+" i9 hf1 :fh Jfh1 i: hKf9 f-9hK f9hT i9T f9hj hj:f f9Jj is: h92 9&h2 9Dh2 c2",
+"h9 h15 h:5 95hD :ch5 92hK h9&2K 9Th2 hc9T2 95hj :5hj 95hT s:h5 h;9 -9h; 9Dh",
+"; h9c; h1; h>: 1Dh; c>h: 9;hK h-9;K 9Th; hc;9T 9;hj :>hj 1Th; s:h> 9Gh2 h9G",
+"&2 h2J9 cJ9h2 9Gh5 :Gh5 J9h5 h5:J h9G2K 9G&h2K J9Th2 hcTJ92 h1G5j h:G5j J95",
+"hT hsJ:5 f9h; f-9h; J9h; i9; f9h5 :fh> J1h; i:> f9;hK h-;f9K Jf9T; 9Ti; f95",
+"hj h>:fj Jf95T s:i> h9N 9&hN 9DhN c9hN h1N h:N 1DhN hN:c hQ9 9Qh& 9QhT h9cQ",
+" h1Q h:Q 1QhT s:hQ 9*hN -9hN h9D*N c-9hN 1*hN hN:- h1D*N h:c-N 9Qh* h9-Q hQ",
+"9D* c-Qh9 1Qh* :-hQ h1QD* h:Qs- hW9 9Wh& J9hW h9cW h1W h:W J1hW hW:J 9GhQ h",
+"W9Q& hZ9 Z9hc 9Whj :GhQ hZ1 hZ: f9hW h9-W JWf9 i9W f1hW hW:f Jf91W i:W f9hQ",
+" f-Qh9 Z9hf iZ9 f1hQ hQ:f h1Zf iZ: hm9 9mh& 9Dhm h9cm h1m h:m 1Dhm :chm 9Qh",
+"m hQ9m& 9Thm hcQ9m hp9 hp: p9hT h:cp 9mh; h9-m hm9D; c-mh9 1mh; :-hm h1mD; ",
+"h:mc> 9Qh; h-Q9m hQ;9D cQ;h9 p9h; h:-p hp9D; cp-h: 9Ghm hW9m& J9hm cJmh9 95",
+"hW :Ghm J1hm hm:J hW9Qm 9GQhm& Z9hm hZc9m p9hW hW:p h1Jp Z:hp hv9 v9h- J9hv",
+" iv9 hv1 hv: h1Jv i:v v9hQ hv-9Q Z9hv Zvi9 h1fp :fhp Zvh1 yi: eL eL! eLB ae",
+"L eL. 8eL .BeL 8Lae Me Me! TeM aMe Mej 8Me TMej seM e*L +eL eL*B +Lae *Le. ",
+"+L8e *BeL. aeL8* Me* +Me MeT* Te+M ejM* 8M+e Me*Tj +Mse GeL eLG! HeL GLae e",
+"LG. GL8e eLH. HL8e GMe G!Me HMe aMHe MeGj 8eGM MeHj GMse fL f+L fHL gfL fL.",
+" f8L HLf. gLf8 fM fM+ fTM gfM fMj f8M HMfj sfM eL2 !Le2 2BeL e2aL 5eL 5L8e ",
+"eL5B 5Lae Me2 M!e2 T2Me M2ae 5Me 8M5e Te5M 5Mse e;L +Le; ;LeB aLe; 5Le; >eL",
+" e;L5B ae>L Me; M;+e MeT; Mea; Me5* >Me Me;5T se>M eLG2 GeL!2 eLH2 aeLG2 GL",
+"5e G58eL HL5e G5aeL G2Me Me2G! H2Me aMeG2 5eGM G5M8e 5MHe se5GM f;L +;fL H;",
+"fL f;gL f5L f>L H5fL >Lgf fM; +Mf; HMf; g;fM f5M f>M H5fM >Msf eLN !LeN NBe",
+"L eLaN N.eL eN8L eLN.B aeL8N QeM Q!Me QTMe aMQe QMej 8MQe MejQT QesM *LeN e",
+"L+N *BeLN aeL+N e*LN. +e8LN eLN*B. 8eLa*N MeQ* Qe+M Me*QT aMe+Q Me*Qj +Qe8M",
+" QeTM*j se+QM WeL eLW! HLWe WLae eLW. WL8e HeWL. H8eWL WMe W!Me ZeM aMZe Me",
+"Wj 8MWe MeZj sMZe fWL +WfL HWfL fWgL WLf. W8fL fHWL. f8WgL fQM +WfM ZfM gMZ",
+"f WMfj W8fM ZMfj fMsZ emL e!mL mLeB aLem 5Lem 8Lem emL5B aem5L Mem M!em MeT",
+"m Meam peM 8Mpe TepM sMpe eLm* +Lem em;LB aem+L em;5L em>L 5eLm*B >eamL MeQ",
+"; Me+m MemT; aMe+m Mep* pe>M peTM; >Mesp GLem emLW! HLem aemGL 5LWe G8meL H",
+"5eWL H8emL MeGm MemW! MeZm ZeaMm GMpe pG8Me ZMpe ZpesM fvL v+fL vHfL gLfv v",
+"5fL >Lfv fvH5L f>gvL fvM f+vM fMZv fvgM fpM >Mfp fMZp yfM ,eL e&L eL,B ,Lae",
+" eL,. ,L8e ,eL.B aeL,8 ,Me Me& Te,M ae,M Me,j 8e,M Mej,T ,Mse e*,L -eL *Be,",
+"L ae-L ,e*L. 8e-L ,eL*B. -8aeL ,eM* -Me Me*,T Te-M Me*,j 8M-e ,TMej* -Mse ,",
+"GL ,LG& ,LHe ,LGa GL,. ,LG8 ,GHL. ,G8HL ,GM G&,M GT,M Ga,M GM,j G8,M ,GTMj ",
+",GsM f,L f-L ,HfL gLf- ,Lf. -8fL fH,L. f-8gL fM, f-M ,HfM f-gM ,Mfj -Mf8 fT",
+"M,j fMs- eL,2 &Le2 ,eL2B aeL,2 ,L5e 5Le& ,5eLB ,5aeL ,2Me M2e& Me2,T aMe,2 ",
+"5e,M Me5& ,5TMe se5,M ,Le; e;-L e;L,B ae;-L e;L,5 -e>L ,5Le;B >e-aL Me,; Me",
+"-; Me;,T -TMe; Me;,5 -M>e ,5TMe; s->Me GL,2 e&LG2 ,GHL2 ,GaL2 ,LG5 ,G58L ,G",
+"5HL ,G5aL ,2GM Me&G2 ,GTM2 Me&H2 G5,M Me&G5 ,G5HM sG,5M ,;fL -;fL fH;,L f-;",
+"gL ,5fL >Lf- f5H,L f>g-L ,Mf; f;-M fTM,; f-TM; ,5fM f->M f5T,M f>Ms- eL,N &",
+"LeN ,eLNB aeL,N ,eLN. e&L8N eLN,.B ,8LaeN Qe,M MeQ& ,QTMe aMe,Q Mej,Q Me&Q8",
+" ,QTMej seM,Q ,e*LN eL-N ,eL*BN -aeLN e*L,N. -8eLN NB*L,e. aeL-8N Me*,Q Qe-",
+"M ,QTMe* -QTMe ,QMej* -Q8Me QMej,T* s-QMe ,LWe WLe& ,GHWL ,GaWL ,GWL. ,G8WL",
+" HeL,W. aeL,W8 GQ,M MeW& ,GZM MeZ& ,GQMj Me&W8 ZeM,j Ze&sM ,WfL fL-W fHW,L ",
+"f-WgL fW,L. f-W8L ,HWfL. gf8-WL ,WfM -WfM fMZ, fMZ- fQM,j f-Q8M ZfM,j sfZ-M",
+" ,Lem eLm& emL,B aem,L emL,5 em&5L ,5LemB aeL,8m Me,m emM& Mem,T aMe,m ,Mpe",
+" Mep& peT,M pe&sM em;,L em-L ,mLe;B -maeL ,5em*L >e-mL 5m*B,eL -ma>eL Mem,;",
+" Me-m ,TmMe; -TmMe peM,; pe-M Me;p,T -psMe ,LGm em&GL ,GmHL em&HL ,G5WL ,G8",
+"mL emL,H5 aeL,5W GM,m MemG& ZeM,m Ze&Mm ,GpM pG&,M Zpe,M ZpeM& fLv, fL-v fv",
+"H,L -vgfL fv5,L f>-vL v,Hf5L -vgf>L v,fM fM-v Zfv,M -vMZf p,fM fM-p fpZ,M f",
+"-yM Ue Ue! UeD Uae Ue. U8e U.De D8Ue UeM U!Me Ve Vea Uej 8MUe Vej seV Ue* U",
+"+e DeU* +DUe U.I* +eU8 I*.UD U+eD8 IM* +MUe Ve* V+e I*Uj +eUj I*Vj V+se UGe",
+" GeU! JUe UaJe GeU. G8Ue UeJ. U8Je GMUe IM!Ge VJe JaVe GjUe UG8Me VeJj VJse",
+" fU fU+ JfU gfU fU. fU8 J.fU fUJ8 fUM U+fM Vf Vfg fUj U+fj Vfj sfV Ue2 e2U!",
+" U2De U2ae U5e 5eU8 5DUe 5aUe U2Me IM2e! Ve2 aeV2 5MUe U5e8M V5e V5se Ue; +",
+"eU; DeU; aeU; 5IU* >eU U5eD; Ua>e MeU; IM;+e Ve; +eV; IM5* Ue>M 5IV* V>e Ge",
+"U2 UGe!2 UeJ2 JUae2 G5Ue UG58e U5Je J5U8e IM2Ge UG2Me! JeV2 VJae2 UG5Me G5M",
+"U8e VeJ5 seVJ5 fU; U+f; fUJ; g;fU fU5 f>U fUJ5 gUf> U;fM fU+M; Vf; V;gf U5f",
+"M fU>M Vf5 Vf> UeN eNU! UNDe UNae eNU. UN8e UeDN. U8eDN UQe Q!Ue VeQ QaVe Q",
+"eUj Q8Ue QeVj sQVe UNI* UN+e I*NUD U+eDN I*NU. U+e8N DeNU*. aeNU8* QIU* +QU",
+"e QIV* +QVe IM*Qj IM*Q8 VeQ*j sI*VQ UWe U!We UWJe WaUe U.We W8Ue JUWe. J8UW",
+"e GQUe UGQe! ZeV ZaVe WeUj UGQ8e ZjVe VZse fUW U+fW JWfU gWfU UWf. UWf8 JfU",
+"W. Jf8UW fUQ U+fQ VfZ ZfgV UWfj UQf8 fjVZ sZVf Uem U!em DeUm aeUm 5eUm 8eUm",
+" U5eDm aemU5 QeUm IMme! Vem aeVm pUe U8pe Vpe seVp ImU* +eUm Im*UD aemU+ Im",
+"*U5 Ue>m 5DeUm* >eUDm QeU; IMm+e QeV; +eVm Uep* pU>e pIV* >eVp GmUe UGme! U",
+"eJm JmUae 5WUe UG8em J5UWe J8mUe IMmWe Im!WMe VeJm ZeVam UGpe pUG8e ZeVp Jp",
+"Vse fvU f+vU fUJv fvgU vUf5 v>fU JvfU5 J>fvU vUfQ fvU+Q Vfv gfVv fpU p>fU f",
+"pV yVf hU hU& hUD hcU hU. h8U UDh. cUh8 hM hM& Vh Vhc hMj h8M Vhj hsV hU* h",
+"-U U*hD -Uhc U*h. -Uh8 hUD*. c-Uh8 hM* h-M Vh* V-h U*hj -Uhj V*hj V-hs hUG ",
+"UGh& hJU hUcJ UGh. UGh8 JUh. hUJ8 hMG GMh& VhJ cJVh UGhj G8hM JjVh VhsJ hfU",
+" f-U fUhJ iU h.fU fUh8 JfUh. iU8 hfM f-hM Vfh iV fUhj f8hM hjVf iVs hU2 U&h",
+"2 UDh2 c2hU h5U U5h8 U5hD hUc5 hM2 M&h2 Vh2 h2Vc h5M 5Mh8 Vh5 c5Vh h;U -Uh;",
+" U;hD hUc; U5h; h>U h5UD; >Uhc hM; -Mh; Vh; h;V- U;hj h>M V5h; h>V UGh2 hUG",
+"&2 JUh2 cJUh2 UGh5 h5UG8 hUJ5 cJ5hU GMh2 hMG&2 h2VJ VhJc2 G5hM h5MG8 J5Vh V",
+"h5sJ fUh; f;-U hUJ; iU; fUh5 fUh> Jf5hU i>U fMh; f-UM; h;Vf iV; f5hM hf>M h",
+"5Vf iV> hUN U&hN UDhN cUhN UNh. U8hN hUDN. hcU8N hQU UQh& VhQ cQVh UQhj UQh",
+"8 VQhj VshQ U*hN hN-U hUD*N c-UhN hU*N. -U8hN U*DhN. hc8-UN UQh* -UhQ V*hQ ",
+"hQV- hQU*j -UQh8 VhQ*j V-hsQ hWU UWh& JUhW hUcW UWh. UWh8 hJUW. hJ8UW hWM W",
+"Mh& hZV VhZc UWhj W8hM VZhj sZVh fUhW -UhW JfUhW iUW fUWh. f-UW8 hJWfU. UWi",
+"8 fUhQ -UfQ VfhZ iZV fUQhj f-UWj VfZhj sZiV hmU Umh& UmhD hUcm U5hm U8hm h5",
+"UDm hc5Um hMm Mmh& Vhm cmVh hpU pUh8 hpV Vphs Umh; -Uhm hmUD; c-mhU h5Um* >",
+"Uhm U5*hmD h>cUm UQh; -Mhm Vmh; hmV- pUh; >Mhp h;Vp V-hp UGhm hWUm& hUJm cJ",
+"mhU U5hW h5WU8 hJ5UW c5WhU GMhm hWMm& JmVh VhmZc pUhW hpUG8 VphZ cpJVh hvU ",
+"fU-v vUhJ ivU vUh5 vUh> hvJU5 v>iU hvM hM-v hvV iVv hMfp >Mhv Vfhp yiV ke k",
+"e! keB ake 1ek 8ke 1Bke ak1e keM M!ke Tke akTe le le8 leT lse ke* +ke *Bke ",
+"ak+e ke1* +k1e ke*1B ake1+ Mek* ke+M keT* Tk+e le* l+e Tel* sel+ Gke G!ke H",
+"ke akHe Gk1e 8eGk Hk1e 8kHe keGM keMG! TkHe akeGT lGe G8le lHe sGle fk fk+ ",
+"fkH gfk f1k f8k 1Hfk f1gk fkM +kfM fTk fTgk lf lf+ lfH glf ke2 k!e2 e2kB k2",
+"ae 5ke 8k5e 5Bke ak5e k2Me keM!2 T2ke akeT2 le5 5el8 5Tle l5se ke; k;+e kBe",
+"; kea; ke1; >ke ke;1B ak>e Mek; ke;+M keT; akeT; le; l>e Tel; >els G2ke ke2",
+"G! H2ke akeG2 5eGk G5k8e 5kHe akeG5 keMG2 Gk2Me! GTke2 ak2HMe G5le lG58e H5",
+"le lsG5e fk; +kf; Hkf; g;fk f5k f>k H5fk gf>k k;fM fk+M; Tkf; fTkg; lf5 lf>",
+" f5lH l>sf keN k!eN eNkB aNke 1Nke kN8e keN1B ake1N Qke Q!ke TkQe akQe leQ ",
+"Q8le QelT lQse e*kN +Nke ke*NB ake+N ke*1N 1+ekN 1eNk*B akN1+e keQ* Qk+e Qk",
+"eT* ake+Q Qel* +Qle leQT* lse+Q Wke W!ke WkHe akWe Wk1e 8kWe 1HeWk ake1W Qk",
+"We GQke! Zke akZe lWe W8le lZe sZle fkW +Wfk HkfW gWfk 1Wfk W8fk f1HWk f8kg",
+"W fQk +Qfk Zfk gkZf lfW fQl+ lfZ Zfgl kem k!em kBem keam ke1m ke8m kem1B ak",
+"e1m kmQe kemQ! keTm akeTm lep l8pe lTpe sple emk; ke+m kem*B ake+m kem1; ke",
+">m keB1m* >keam keQ; kem+Q kemT; akeQ; pel; p>le lepT; l>esp keGm kemW! keH",
+"m akeGm Wk5e kemG8 kem1H ake5W kemGQ ke!GMm keZm Zkeam pGle lGp8e Zple lZes",
+"p fvk f+vk fHvk fvgk v1fk fv>k fv1Hk f>kgv vkfQ fvk+Q fvZk Zfkgv lfp l>fp Z",
+"flv ylf ,ke ke& ,Bke ak9e 1e,k :ek keB,1 ak:e 9Me Mek& Tk9e aM9e le9 l:e ,T",
+"le s:le ke9* -ke ke*,B ak-e ke*,1 -k:e ,1ek*B :-ake Me9* 9M-e ,Tke* Tk-e 9e",
+"l* l-e le9T* les- ,Gk G&,k Gk,H Ga,k 1G,k ,G:k ,1GHk Hk:e 9G,M ke&GM GT,k a",
+"Me9G lG, :Gle ,GlH sGl, f9k f-k ,Hfk f-gk ,1fk :fk f91Hk gk:f f9M -kfM ,Tfk",
+" f9gM lf9 lf: f9lH sfl- ,2ke k2e& ke2,B ake,2 5k9e 5k:e ,5keB :e5ak 92Me ke",
+"&M2 ,Tke2 aMe92 ,5le l5:e le95T lse:5 ke,; ke-; ke;,B -kae; ke;,1 :e>k keB,",
+"1; >k-ae Me9; -kMe; ke;,T -Tke; ,;le >el- le;,T l>es- ,2Gk ke&G2 ,GkH2 ke&H",
+"2 G5,k :G5,k ,G5Hk :He5k ,GkM2 ke2GM& ,GTk2 ak2,GT ,Gl5 l:G,5 lG,H5 :Hel5 ,",
+"kf; f;-k f9Hk; f-kg; ,5fk >k:f f95Hk f>kg: 9Mf; f-kM; f9Tk; f-Tk; f9l; l>:f",
+" lf9H5 glf:> ,Nke kNe& keN,B ake,N keN,1 ke:N ,1NkeB :eakN Qk9e keQ& ,QkTe ",
+"ake,Q ,Qle :Qle le9QT :Qels ke*,N ke-N 9eNk*B -kaeN ,1ek*N :-keN ke1*,NB -k",
+"a:eN ,Qke* Qk-e Qke9T* -QkTe le9Q* -Qle 9Qel*T l-sQe Gk,W keW& ,GkHW ake,W ",
+",1GWk Wk:e 1He,Wk :HeWk GQ,k ke&GQ ,GZk keZ& ,GlW :Wle Z9le leZ: ,Wfk -Wfk ",
+"f9HWk f-kgW f91Wk fk:W ,1HfkW :fgWk ,Qfk -Qfk f9Zk f-Zk f9lW lW:f l,Zf Z:lf",
+" ke,m emk& kem,B ake,m kem,1 ke:m keB,1m :emak Me9m kemQ& kem,T aMe9m p9le ",
+"le:p lep,T :pels kem,; ke-m keB9m* -kmae ,1mke; :-mke ke,m1;B :ea-km ke;,Q ",
+"-Qkem ,Tmke; -Tkem lep,; le-p leTp9* l-pse Gk,m kemG& kem,H akm,G ,1Gkm :Gm",
+",k ,1Hkem :Hekm Mem9G ,GQkm& Z9ekm Zkem& pGl, :pGle lZep9 Z:elp v9fk fk-v f",
+"v9Hk -vkgf fv95k fk:v f1Hvk, :fvgk v9fM -vkfQ Zf9vk Z-kfv l,fp :flv fp9lZ l",
+"fy: Uek U!ke Dke akUe 1Ue U81e Ue1D Ua1e keIM IkMe! Vek akVe lIe U8le leV s",
+"Ile Ik* +kUe IkD* Dk+e Ue1* U+1e Ik*1D ak*1I k*IM Ik*+M IkV* +kVe lI* U+le ",
+"Vel* sIl* GkUe Ik!Ge Jke akJe UG1e 1UG8e 1UJe 8kJe IkMGe UGkMe! VeJk JkVae ",
+"UGle lGU8e lJe lesJ fUk U+fk Jfk Jfgk f1U 1Uf8 f1Jk f1gU IkfM fU+kM Vfk gkV",
+"f lfU fUl+ lfJ Vfgl U2ke Ik2e! D2ke akeU2 U51e 1Ue58 Dk5e akeU5 IkMe2 ke2IM",
+"! keV2 Veka2 U5le lI58e V5le seVl5 keU; Ik;+e keD; akeU; Ue1; 1U>e Ik*5D Dk",
+">e Ik;Me +IkMe; keV; V+ek; Uel; lI>e Vel; leV> Ik2Ge UG2ke! keJ2 Jkae2 1UG5",
+"e G5kU8e 5kJe J5k8e UGkMe2 IkGMe2! JkVe2 VeaJk2 lGU5e UG5le8 J5le lJs5e U;f",
+"k fU+k; fkJ; Jfkg; 1Uf5 fU>k f5Jk Jf>k fUkM; Ik;fM+ V;fk Vfgk; fUl; lIf> l;",
+"Vf J>lf UNke IkNe! DNke akeUN 1NUe 1Ue8N 1UeDN 1UaeN QkUe UQek! QkVe VeQak ",
+"UQle lIQ8e lQVe seVlQ INk* Ik*+N Ik*DN ak*IN Ik*1N Ik*8N IkN1D* akN1I* IkQ*",
+" Ik*+Q VeQk* V+eQk QIl* l+IQe lI*VQ sI*lQ WkUe UWek! WkJe JkWae UW1e 1UW8e ",
+"J1UWe J8kWe UGQke Ik!WMe JkZe ZJkae UWle lWI8e ZJle lJZse UWfk fU+Wk JWfk J",
+"fkgW 1UfW f1U+W Jf1UW Jf8Wk UQfk fUQ+k ZkVf VfZgk fUlW lfU+W ZflJ glJZf keU",
+"m Ikme! keDm akeUm Ue1m Ikm8e kem1D aem1U IkmQe Ik!Mem keVm Vemak pUle lIp8",
+"e leVp Vpels kmI* Ikm+e IkmD* akmI* Ikm1* >kIem 1Dekm* >kDem IkmQ* U+Qkem V",
+"emk; V+ekm pIl* l>Ipe Vpel; V>elp IkmWe Im!Wke keJm Jkmae 1UGem UG8kem J1mU",
+"e J8kem UGQkem ImQkWe! ZJkem ZkaVem lGpUe lG8pUe leJp Jplse vUfk fvU+k fvJk",
+" Jvkgf v1fU f>Uv1 Jv1fU J>kfv fvUQk fQ+vIk fkVv Vfvgk lIfp fpUl> Jplf lfyJ ",
+"ht ht& htD htc ht1 h:t t1hD t:hc htM tMh& Vht tcVh lh lh: lhV uh ht* t-h hD",
+"t* hct- t*h1 t-h: t*1hD h:tc- t*hM hMt- t*Vh Vht- lh* l-h l*Vh uh- htG h&tG",
+" tJh hctJ tGh1 tGh: h1tJ tJh: tGhM tGMh& VhtJ tJVhc lhG lGh: lJh uJh tf tf-",
+" tfJ it tf1 tf: J1tf it: tfM fMt- tfV iVt lfh tfl- lJtf ui ht2 t&h2 tDh2 h2",
+"tc ht5 t:h5 hDt5 tch5 tMh2 htM&2 h2Vt Vhtc2 lh5 h5l: t5Vh uh5 ht; h;t- hDt;",
+" tch; t5h; h>t t5*hD htc> t;hM t-hM; t;Vh V-ht; lh; h>l l;Vh uh> h2tG tG&h2",
+" h2tJ tJhc2 tGh5 t:Gh5 h5tJ tJ5h: tGMh2 hM&tG2 tJVh2 VhctJ2 h5lG lh:G5 h5lJ",
+" hJu5 tf; f-t; h;tJ it; tf5 tf> Jft5 it> fMt; tf-M; t;Vf t;iV l;tf h>lf hJl",
+"; ui> htN t&hN tDhN hNtc t1hN hNt: ht1DN h:tcN htQ h&tQ tQVh tchQ lhQ hQl: ",
+"VlhQ uhQ hNt* hNt- t*DhN t-hcN t*1hN h:t-N h1Dt*N t-ch:N t*hQ hQt- tQ*Vh V-",
+"htQ hQl* hQl- lhVQ* h-uQ htW h&tW hWtJ tchW tWh1 t:hW tJh1W h:WtJ tGhQ tGQh",
+"& hZt htZc lhW lWh: hZl uZh tfW hWt- JftW itW f1tW tW:f tfJ1W t:iW tfQ f-tQ",
+" tZf iZt lWtf h-lW hZlf uiZ htm h&tm hDtm tchm t5hm t:hm ht5Dm h:mtc tQhm h",
+"tQm& tmVh Vhmtc hpl h:tp Vplh uph tmh; hmt- tm*hD t-mhc t5*hm hmt> tmDh1; h",
+">tcm tQh; t-Qhm Vhmt; V-mht l;hp hpl- lh;Vp hpu- tGhm tGmh& hmtJ tJmhc t5hW",
+" h:Wt5 tJ5hW :Jmht tGQhm tG&hMm hmtZ hZtcm lGhp lhW:p tZhp hZup hvt t-hv tJ",
+"hv itv h1tv tvh> hvtJ1 tvi: hQtv hvt-Q tZhv tZiv lvh hvl- hZlv uiy 3 !3 3B ",
+"a3 3. 83 .B3 8a3 3K !K3 T3 Ta3 j3 8j3 Tj3 s3 3( +3 3B( +a3 3(. +83 3(.B 8a+",
+"3 3(K +3K T3( +T3 j3( +j3 j3T( s+3 E3 !E3 H3 Ha3 E3. 8E3 H3. H83 EK3 !3EK H",
+"T3 TaH3 jE3 jE83 Hj3 sH3 d3 +d3 Hd3 g3 d3. 8d3 d3H. g83 dK3 dK+3 Td3 gT3 dj",
+"3 +3dj H3dj gs3 4 4! 4B 4a 45 48 45B 48a 4K 4K! 4T 4Ta 4j 48j 4T5 s4 4; 4+ ",
+"4;B 4+a 45; >4 5;4B >4a 4;K 4+K 4T; 4+T 4j; >j4 T;4j s>4 4E 4E! 4H 4Ha 45E ",
+"48E 4H5 4H8 4EK EK4! 4HT HT4a 4jE 8j4E 4Hj s4H 4d 4+d 4Hd g4 4d5 >4d H54d g",
+">4 4dK +d4K 4Td g4T 4dj 4d>j H;4j gs4 3N !3N 3BN a3N N.3 83N 3BN. aN83 Q3 Q",
+"!3 QT3 Qa3 Qj3 Q83 TjQ3 sQ3 3(N +3N 3(NB a3+N 3(N. 83+N 3(N.B +8a3N Q3( +Q3",
+" T3Q( +3Qa j3Q( +3Q8 QTj3( +Qs3 W3 W!3 HW3 Wa3 W3. W83 W3H. H3W8 WQ3 W3Q! Z",
+"3 Za3 Wj3 W3Q8 Zj3 sZ3 Wd3 +W3 WdH3 gW3 d3W. +3W8 HWd3. W8g3 Qd3 +3Qd Zd3 g",
+"Z3 W3dj +3Wj djZ3 g3sZ 4m 4m! 4mB 4am 45m 48m 5m4B 8m4a 4Q 4Q! 4QT 4Qa p4 p",
+"48 p4T sp4 4m; 4+m m;4B +m4a 5m4; >m4 45m;B 4a>m 4Q; 4+Q Q;4T +Q4T p4; p>4 ",
+"4Tp; p>s4 4W 4W! 4HW 4Wa 4W5 4W8 H54W H84W 4WQ Q!4W Z4 Z4a p4W 4Wp8 Zp4 sZ4",
+" v4 v4+ v4H gv4 v45 v>4 4Hv5 v>g4 v4Q 4+vQ Zv4 gZ4 pv4 p4v> pvZ4 y4 #3 &3 #",
+"B3 a&3 #3. 8&3 #3.B a&83 #3K &3K T#3 T&3 j#3 &j3 j#T3 s&3 #3( +&3 #3(B a&+3",
+" 3(#. 8&+3 .B3#( +8a&3 3(#K &3+K #3T( +3T& #3j( +3&j Tj#3( +&s3 #E3 &E3 H#3",
+" H&3 E3#. &E83 #3H. 8&H3 #3EK EK&3 T#H3 H3T& #Ej3 jE&3 j#H3 H&s3 d#3 d&3 d#",
+"H3 g&3 #3d. 83d& Hd#3. 8&g3 #3dK &3dK d#T3 T&g3 j#d3 d3&j dj#H3 s&g3 4# 4& ",
+"4#B 4a& 45# 48& 5B4# 5a4& 4#K 4&K 4T# 4T& 4j# 4&j 4#5T s4& 4;# 4+& ;#4B a;4",
+"& 5;4# >&4 45;#B 4a>& ;#4K 4K;& 4#T; +T4& 4#;j 4&>j ;j#4T >&s4 4#E 4&E 4H# ",
+"4H& 5#4E 4E5& 4#H5 H54& EK4# &E4K HT4# H&4T j#4E 4E&j 4#Hj 4Hs& 4d# 4d& 4#H",
+"; g4& 4#5d 4d>& 4H5d# >&g4 dK4# 4Kd& 4#Td 4Tg& 4#dj d&4j 4Hjd# g&s4 #3N &3N",
+" #3NB &3aN #3N. &38N 3BN#. 8a&3N Q#3 Q&3 T#Q3 Q3T& j#Q3 Q3&j QTj#3 Q&s3 3(#",
+"N &3+N 3(N#B +a&3N 3(N#. +8&3N 3B(N.# 8a&+3N #3Q( +3Q& QT#3( +QT&3 Qj#3( &j",
+"3+Q Tj#Q3( s+Q&3 W#3 W&3 W#H3 H3W& #3W. 8&W3 HW#3. H8W&3 Q#W3 W3Q& Z#3 Z&3 ",
+"j#W3 W3&j j#Z3 s3Z& d#W3 +3W& HWd#3 W&g3 Wd#3. d&3W8 Wd#H3. gW8&3 d#Q3 Q3d&",
+" d#Z3 g3Z& dj#W3 d&jW3 Zdj#3 Z&3gs 4m# 4&m m#4B am4& 5m4# 8m4& 45m#B am&48 ",
+"4Q# 4Q& 4#Tm Qa4& p4# p&4 4Tp# p&s4 m;4# +m4& 4m;#B am&4+ 45m;# 4&>m 5m;4#B",
+" >m4a& 4#Q; +Q4& 4QT;# 4+QT& 4;p# p4>& p4T;# p>4s& 4W# 4W& 4#Hm Hm4& 4#5W 5",
+"W4& 4H5W# 4H8W& WQ4# W&4Q Z4# Z4& 4Wp# 4Wp& p4Z# Z&s4 v4# v&4 4Hv# v&g4 45v",
+"# v4>& v4H5# gv>4& 4Qv# 4Qv& v4Z# Z&g4 v4p# p4v& Zpv4# y&4 C3 !C3 D3 Da3 C3",
+". 8C3 D3. D83 CK3 !3CK DT3 TaD3 jC3 jC83 Dj3 sD3 C3( +C3 D3( +D3 3(C. 8C+3 ",
+"3(D. +3D8 3(CK CK+3 T3D( DT+3 C3j( jC+3 j3D( +Ds3 CE3 CE!3 HD3 DaH3 E3C. CE",
+"83 D3H. H3D8 C3EK EKC!3 DTH3 HDTa3 CEj3 8jCE3 H3Dj HDs3 dC3 dC+3 Dd3 gD3 C3",
+"d. dC83 d3D. D8g3 CKd3 +dC3K D3Td DTg3 jCd3 djC+3 D3dj sDg3 4C 4C! 4D 4Da 4",
+"5C 48C 4D5 4D8 4CK CK4! 4DT DT4a 4jC 8j4C 4Dj s4D 4;C 4+C 4D; 4+D 5;4C >C4 ",
+"45D; >D4 ;C4K +C4K D;4T +D4T 4C;j 4j>C D;4j >Ds4 4CE !C4E 4HD HD4a 5C4E 8C4",
+"E H54D H84D EK4C 4CE!K HD4T 4HDTa jC4E 48jCE Hj4D 4HsD 4dC +d4C 4Dd g4D 4C5",
+"d 4d>C 5D4d >Dg4 dK4C 4+dCK Dd4T 4DgT 4Cdj >j4dC Dd4j gDs4 C3N C3!N D3N a3D",
+"N C3N. C38N N.D3 83DN QC3 !CQ3 QD3 DaQ3 jCQ3 8CQ3 Q3Dj QDs3 3(CN C3+N 3(DN ",
+"D3+N C3N(. +8C3N D3(N. +D83N C3Q( QC+3 D3Q( +3QD QjC3( +Q8C3 QDj3( s+QD3 WC",
+"3 !CW3 WD3 DaW3 C3W. 8CW3 D3W. W3D8 QCW3 Q!WC3 ZD3 DaZ3 jCW3 W8QC3 DjZ3 ZDs",
+"3 dCW3 WC+3 W3Dd WDg3 WdC3. +W8C3 WDd3. gWD83 dCQ3 +WQC3 DdZ3 ZDg3 djCW3 +W",
+"jC3 ZDdj3 gZsD3 4mC mC4! 4Dm Dm4a 5m4C 4C8m 45Dm Dm48 4QC 4CQ! 4QD QD4a p4C",
+" 48pC pD4 pDs4 m;4C 4C+m 4mD; +m4D 45m;C 4m>C 4D5m; 4D>m 4CQ; 4C+Q Q;4D +Q4",
+"D 4;pC p4>C 4Dp; p4>D 4WC W!4C 4WD WD4a 4C5W 4CW8 5W4D WD48 WQ4C 4WQ!C Z4D ",
+"4DZa 4WpC p4W8C pDZ4 sDZ4 v4C 4+vC vD4 vDg4 45vC v4>C 4Dv5 v4>D 4QvC v4+QC ",
+"vDZ4 gDZ4 v4pC pv>4C p4vD y4D b3 b&3 bD3 c3 b3. b83 D3b. c83 bK3 &3bK bT3 c",
+"T3 bj3 b3&j b3Dj sc3 b3( b+3 D3b( c+3 3(b. +8b3 bD3(. +8c3 3(bK +3bK T3b( +",
+"Tc3 j3b( b3+j bTj3( c+s3 bE3 &Eb3 bH3 cH3 E3b. 8Eb3 H3b. H8c3 EKb3 bK&E3 HT",
+"b3 HTc3 jEb3 &jEb3 b3Hj cHs3 bd3 b3d& b3Dd gc3 d3b. b38d bHd3. c8g3 dKb3 d&",
+"3bK b3Td cTg3 b3dj d&jb3 bHjd3 g3sc 4b 4b& 4bD c4 4b5 4b8 b54D c45 4bK bK4&",
+" 4bT c4T 4bj b84j b54T sc4 4b; 4b+ b;4D c4+ 45b; >b4 4b5D; c>4 4Kb; 4Kb+ b;",
+"4T 4+cT b;4j 4b>j 4bT;j s4c> 4bE b&4E 4bH c4H 4Eb5 4Eb8 b54H 4Hc5 bK4E 4b&E",
+"K bH4T 4HcT 4Ebj 4b8jE bH4j sHc4 4bd b+4d bH4d gc4 b54d 4b>d 4bH5d g4c> 4Kb",
+"d 4b+dK bT4d gTc4 bd4j >b4dj 4bHdj scg4 b3N &3bN D3bN c3N N.b3 83bN bD3N. 8",
+"3cN bQ3 b3Q& b3QD cQ3 Qjb3 b3Q8 bQDj3 s3cQ 3(bN +3bN bD3(N +3cN b3(N. b+83N",
+" D3(bN. c+83N Q3b( b3+Q bQD3( +Qc3 bQj3( b+Q83 QD3bj( cQ+s3 bW3 b3W& b3WD c",
+"W3 W3b. b3W8 bHW3. W8c3 WQb3 bWQ&3 Zb3 Zc3 b3Wj bW8Q3 bjZ3 s3Zc Wdb3 b3+W b",
+"HWd3 g3cW bWd3. b+W83 WD3bd. cW8g3 b3Qd b+WQ3 bdZ3 g3Zc bWjd3 b+Wj3 Zbdj3 Z",
+"cgs3 4bm bm4& bm4D c4m 45bm bm48 4b5Dm 48cm 4bQ bQ4& bQ4D c4Q pb4 4bp& 4bpD",
+" cp4 4mb; bm4+ 4bDm; 4+cm 4b5m; 4b>m b5m4D; >mc4 b;4Q b+4Q 4bQD; 4+cQ 4bp; ",
+"p4>b pb4D; p>c4 4bW bW4& bH4W c4W b54W bW48 4bH5W 4Wc5 bW4Q 4bWQ& Z4b Zc4 4",
+"bpW pb4W8 pbZ4 s4Zc vb4 4bv& 4bvD cv4 4bv5 v4>b vb4H5 v>c4 4bvQ vb4+Q vbZ4 ",
+"g4Zc p4vb pvb>4 Zpbv4 yc4 6 6! 6B 6a 61 68 61B 68a 6K 6!K 6T 6Ta 6j 68j 6T1",
+" s6 6( 6+ 6(B 6+a 61( 6+1 1(6B 1+6a 6(K 6+K 6T( 6+T 6j( 6+j 6(1T s6+ 6E 6!E",
+" 6H 6Ha 61E 68E 6H1 6H8 6EK EK6! 6HT HT6a 6jE 8j6E 6Hj s6H 6d 6+d 6Hd g6 6d",
+"1 68d 1H6d g61 6dK +d6K 6Td g6T 6dj +j6d 1T6d gs6 46 6!4 46B 4a6 7 78 7B 7a",
+" 46K 4K6! 4T6 6T4a 7j 78j 7T 7s 6; 4+6 6;B 6a; 7; 7> 7B; 7>a 6;K 4K6+ 6T; 6",
+"+4T 7;j 7>j 7T; 7s> 46E 4E6! 4H6 6H4a 7E 78E 7H 7H8 6E4K 6!4EK 6H4T 4H6Ta 7",
+"jE 8j7E 7HT 7sH 4d6 6+4d 6H; g46 7d 7>d 7Hd g7 4K6d 4+6dK 6T4d 4Tg6 7dj >j7",
+"d 7Td g7s 6N 6!N 6NB 6aN 61N 68N 1N6B 6N1a 6Q 6Q! 6QT 6Qa 6Q1 6Q8 1Q6T s6Q ",
+"6(N 6+N (B6N +a6N 1(6N 6N1+ 61(NB 6+1aN 6Q( 6+Q QT6( +Q6T 6(1Q 1+6Q 6Q1T( 6",
+"+sQ 6W 6W! 6HW 6Wa 6W1 6W8 1H6W 1W6a 6WQ Q!6W Z6 Z6a 6Wj W86Q Z61 sZ6 6Wd 6",
+"+W HW6d g6W 1W6d 1+6W 6H1Wd 6Wg1 6Qd +W6Q Z6d gZ6 1Q6d +W6j 6dZ1 sZg6 6m 6m",
+"! 6mB 6am 7m 78m 7Bm 7am 4Q6 Q!6m 6Tm 6Q4a 7p 7p8 7pT 7sp 6m; 6+m m;6B +m6a",
+" 7m; 7>m m;7B >m7a 6Q; 6+4Q Q;6T +T6m 7p; 7p> pT7; 7ps> 4W6 6!4W 6Hm 6W4a 7",
+"W 7W8 7HW 7Wa 6W4Q 4WQ6! Z46 4aZ6 7pW pW78 7Z 7Zs v6 v6+ v6H gv6 7v 7v> 7vH",
+" g7v v6Q 6+vQ Zv6 Zvg6 7vp pv7> 7Zv y7 69 6& 69B 6a9 691 :6 916B :6a 69K 6&",
+"K 6T9 6T& 6j9 :6j 9T6j s:6 69( 6+9 9(6B 9+6a 916( :6+ 691(B 6+:a 9(6K 6K9+ ",
+"6(9T 9+6T 6(9j 6+:j 6T91( :6s+ 69E 6&E 6H9 6H& 916E :6E 691H :H6 9E6K &E6K ",
+"9H6T H&6T 6E9j 6j:E 9H6j :Hs6 6d9 6d& 9H6d g69 691d :d6 6H91d g:6 6K9d 6Kd&",
+" 9T6d 6Tg9 9d6j 6d:j 6Hj9d s:g6 49 49& 49B 49a 79 7: 7B9 7:a 49K 4K6& 49T 6",
+"T4& 79j 7:j 7T9 7s: 49; 49+ 4B9; 9+4a 79; 7:> 9;7B :>7a 4K9; 4K9+ 9T6; 9+4T",
+" 9;7j >j7: 9T7; 7:s> 49E 4E6& 49H 6H4& 79E 7:E 7H9 7:H 9E4K 49&EK 9H4T 49HT",
+"& 9j7E :j7E 9H7T 7Hs: 49d 6d4& 9H4d g49 7d9 7:d 9H7d g7: 4K9d 49+dK 9T4d 49",
+"gT 9d7j 7j:d 9T7d 7sg: 69N 6&N 9N6B 6N9a 916N :6N 691NB 6a:N 6Q9 6Q& 9Q6T 9",
+"Q6a 9Q6j :Q6 6Q91T :Qs6 9(6N 6N9+ 69(NB 6+9aN 691(N 6+:N 91(6NB :6+aN 6(9Q ",
+"9+6Q 6Q9T( 6+Q9T 6Q91( 6+:Q 9Q16T( :Q6s+ 6W9 6W& 9H6W 9W6a 691W :W6 6H91W 6",
+"H:W 9W6Q W&6Q Z69 Z6& 9W6j 6W:Q 6jZ9 Z:6 9W6d 9+6W 6H9Wd 6Wg9 6W91d 6+:W 9H",
+"16Wd :Wg6 9Q6d Qd6& 6dZ9 Z6g9 6Wj9d 6Q:d Z691d g6Z: 49m 6m& 4B9m 9a6m 79m 7",
+":m 9m7B :m7a 49Q 6Q4& 9Q4T 9Q4a 7p9 :p7 p97T :p7s 9m6; 9+6m 49m;B 49+am 9m7",
+"; :m7> 7B9m; 7:>am 9Q6; 9+4Q 49QT; 49+Qa 7;p9 7>:p 7p9T; 7p>s: 49W 6W4& 9H4",
+"W 9W4a 7W9 7:W 9H7W :H7W 9W4Q 49WQ& Z49 49Z& p97W 7W:p 7Z9 7Z: v69 v6& 49vH",
+" v6g9 7v9 :v7 v97H :vg7 49vQ 6Qv& v6Z9 Z4g9 p97v :p7v Z97v y7: 6C 6!C 6D 6D",
+"a 61C 68C 6D1 6D8 6CK CK6! 6DT DT6a 6jC 8j6C 6Dj s6D 6C( 6+C 6D( 6+D 1C6( 6",
+"C1+ 6(1D 1+6D CK6( +C6K DT6( +D6T jC6( 6C+j 6(Dj 6+sD 6CE !C6E 6HD HD6a 1C6",
+"E 8C6E 1H6D H86D EK6C 6!CEK HD6T 6HDTa jC6E 68jCE Hj6D 6HsD 6dC +d6C 6Dd g6",
+"D 6C1d 6C8d 1D6d 6Dg1 dK6C 6+dCK Dd6T 6DgT 6Cdj 6+jdC Dd6j gDs6 46C 4C6! 4D",
+"6 6D4a 7C 78C 7D 7D8 6C4K 6!4CK 6D4T 4DT6a 7jC 8j7C 7DT 7sD 6;C 4C6+ 6D; 6+",
+"4D 7;C 7>C 7D; 7>D ;C6K 4+6CK D;6T 4+D6T ;j7C 7j>C D;7T 7Ds> 6C4E 6!4CE 6H4",
+"D 4H6Da 7CE 8C7E 7HD H87D 46CEK 4CE6!K 4H6DT 6HD4Ta jC7E 78jCE Hj7D sH7D 4C",
+"6d 4+6dC 6D4d 4Dg6 7dC >C7d 7Dd g7D 4d6CK 6+C4dK 4Dd6T g46DT dj7C 7>djC Dd7",
+"T 7Dgs 6CN !C6N 6DN Da6N 1C6N 8C6N 6N1D 6ND8 6QC 6CQ! 6QD QD6a 6C1Q 6CQ8 1Q",
+"6D 6QsD C(6N +C6N D(6N 6N+D 61C(N 6+1CN 6D1(N 6+D1N QC6( 6C+Q 6(QD +Q6D 6Q1",
+"C( 6+Q1C 6QD1( s6+QD 6WC W!6C 6WD WD6a 6C1W 6CW8 1W6D WD68 WQ6C 6WQ!C Z6D 6",
+"DZa 6CWj 6W8QC 6DZ1 sDZ6 Wd6C 6C+W WD6d 6WgD 6W1dC 6+W1C 6WD1d g61WD 6CQd 6",
+"+WQC 6DZd gDZ6 6WjdC 6+WjC Z61Dd gZ6sD 6mC mC6! 6Dm Dm6a 7mC 8m7C 7Dm D87m ",
+"4C6Q 4Q6!C 6Q4D 4QD6a 7pC p87C 7pD 7Dsp m;6C 6C+m Dm6; +D6m m;7C 7m>C Dm7; ",
+">m7D 6CQ; 4+Q6C QD6; 4+Q6D p;7C >C7p 7;pD p>7D 4C6W 4W6!C 6W4D 4WD6a 7WC W8",
+"7C 7WD WD7a 4WQ6C 6WC4Q! 4DZ6 Z46Da pW7C 7pW8C 7ZD 7DsZ v6C 6+vC v6D vDg6 7",
+"vC >C7v 7vD 7Dgv 6QvC v6+QC vDZ6 Zv6gD 7Cpv 7p>vC 7DZv y7D b6 b6& b6D c6 b6",
+"1 :b6 6Db1 :c6 b6K bK6& b6T c6T b6j b6:j 6Dbj sc6 b6( b6+ b(6D c6+ 61b( b6:",
+"+ b61D( :+c6 6(bK bK6+ b(6T 6+cT b(6j 6+bj b6T1( s+c6 b6E bE6& b6H c6H 61bE",
+" b6:E 6Hb1 c6:H 6EbK b6&EK 6HbT 6HcT bE6j :b6jE 6Hbj sHc6 b6d 6+bd 6Hbd gc6",
+" 6db1 b6:d b6H1d :cg6 bK6d b6+dK 6Tbd gTc6 6dbj :db6j b6Hdj scg6 4b6 b64& 4",
+"9D c46 7b 7:b 7bD 7c 4Kb6 4b6&K b64T 49cT 7bj :b7j 7bT 7cs b6; b64+ 6Db; c6",
+"; 7b; 7>b b;7D 7c> bK6; 4b+6K 6Tb; 6Tc; b;7j >j7b bT7; c>7s 4Eb6 4b6&E b64H",
+" 49cH 7bE 7E:b 7bH 7cH 4b6EK b6E4&K 4bH6T c46HT bj7E 7:bjE bH7T 7Hsc b64d 4",
+"b+6d 6Hb; c4g6 7bd :d7b bH7d g7c 4bd6K d&Kb6; 4bT6d c6;gT bd7j 7:dbj bT7d g",
+"s7c b6N bN6& bN6D c6N 61bN b6:N b61DN cN:6 b6Q 6&bQ 6QbT c6Q 6Qb1 b6:Q b6Q1",
+"D c6:Q 6(bN bN6+ b6D(N 6+cN b61(N :b6+N 6D(b1N :c6+N b(6Q 6+bQ b6QD( 6+cQ b",
+"6Q1( :Qb6+ b6(1QD :cQ6+ b6W 6&bW 6HbW c6W 6Wb1 b6:W b6H1W c6:W 6WbQ b6WQ& Z",
+"b6 Zc6 6Wbj :Wb6Q b6Z1 s6Zc 6Wbd 6+bW b6HWd cWg6 b6W1d :Wb6+ 6WDb1d g:c6W 6",
+"Qbd b6+Qd b6Zd g6Zc b6Wdj :Qdb6 Zb61d Zc6g: b6m 6&bm 6Dbm c6m 7bm :m7b bm7D",
+" 7cm b64Q 4bQ6& 6Tbm 49cQ 7pb 7b:p pb7D 7cp 6mb; 6+bm 49Dm; 6+cm bm7; >m7b ",
+"7bDm; cm7> 6Qb; 4b+6Q 49QD; 6Qc; 7;pb p>7b 7pbD; 7pc> b64W 4bW6& 6Hbm 49cW ",
+"7bW :W7b bH7W 7cW 4bW6Q b6W4Q& 4bZ6 c4Z6 pb7W 7pb:W 7Zb 7Zc vb6 b6v& 49vD c",
+"v6 7vb 7b:v vb7H 7cv b6vQ vb6+Q vbZ6 Z6cv pv7b :vb7p Zv7b y7c 3L !3L 3BL a3",
+"L 3L. 83L 3L.B a38L M3 M3! TM3 aM3 Mj3 8M3 MjT3 sM3 3(L +3L 3(LB a3+L (L3. ",
+"83+L 3L.(B +8a3L M3( +M3 M3T( +3aM j3M( +38M TMj3( +Ms3 E3L E3!L H3L a3HL 3",
+"LE. E38L 3LH. 83HL ME3 !EM3 HM3 H3aM jEM3 ME83 MjH3 HMs3 d3L d3+L d3HL g3L ",
+"3Ld. d38L Hd3L. 83gL dM3 +3dM H3dM gM3 Mjd3 83dM dMjH3 sMg3 4L 4L! 4LB 4aL ",
+"45L 48L 5B4L 4L5a 4M 4M! 4TM 4aM 4M5 48M 5T4M s4M 4;L 4+L ;L4B 4La; 5;4L >L",
+"4 45;LB 4a>L 4M; 4+M T;4M +T4M M;4j >M4 4T5M; s4>M 4EL !E4L 4HL Ha4L 5E4L 8",
+"E4L 4LH5 4LH8 4ME ME4! 4HM HM4a 4E5M 4E8M H54M 4HsM 4dL +d4L 4LH; g4L 4L5d ",
+"4d>L 4H5dL >Lg4 4dM +M4d HM4d g4M 5d4M 4d>M 4HM5d g4>M 3LN 3L!N 3LNB 3LaN 3",
+"LN. 3L8N 3L.NB 8a3LN QM3 M3Q! TMQ3 Q3aM MjQ3 Q38M QTMj3 QMs3 (L3N 3L+N 3(NL",
+"B +a3LN 3L.(N +83LN .BL3(N 8a3+LN M3Q( QM+3 QTM3( aM3+Q QMj3( +Q8M3 TMjQ3( ",
+"s+QM3 W3L !3WL W3HL a3WL 3LW. 83WL HW3L. H8W3L WM3 M3W! ZM3 aMZ3 MjW3 W38M ",
+"MjZ3 ZMs3 d3WL W3+L HWd3L W3gL Wd3L. +W83L Wd3HL. gW83L W3dM +3WM dMZ3 ZMg3",
+" dMjW3 +WM83 ZdMj3 gZsM3 4mL mL4! mL4B 4Lam 5m4L 4L8m 45mLB amL48 4QM Q!4M ",
+"Tm4M Qa4M p4M 48pM 4TpM p4sM m;4L 4L+m 4m;LB amL4+ 45m;L 4m>L 5m;4LB >m4aL ",
+"Q;4M +Q4M 4QTM; aMm4+ 4Mp; p4>M p4TM; >Mps4 4WL W!4L 4LHm 4LWa 4L5W 4LW8 4H",
+"5WL 4H8WL 4WM 4!WM Z4M 4aZM 4WpM W84M p4ZM sMZ4 v4L 4+vL 4HvL v4gL 45vL v4>",
+"L v4H5L gv>4L vM4 4+vM vMZ4 Z4gM p4vM v4>M Zpv4M y4M #3L &3L #3LB &3aL 3L#.",
+" &38L 3L.#B 8a&3L M#3 M&3 M#T3 T3M& j#M3 83M& TMj#3 M&s3 3(#L &3+L (BL#3 +a",
+"&3L 3L.#( +8&3L 3B(#L. 8a&+3L #3M( +3M& TM#3( aM3+& Mj#3( M&3+j Mj#T3( s+M&",
+"3 E3#L E3&L #3HL &3HL 3L.#E 8&E3L H#3L. H8&3L #EM3 &EM3 M#H3 H3M& Mj#E3 M&E",
+"83 HMj#3 sHM&3 #3dL &3dL Hd#3L &3gL d#3L. d&38L d#3HL. g8&3L M#d3 d3M& dM#H",
+"3 M&g3 dMj#3 dM&83 HM#dj3 gsM&3 4#L 4&L #B4L a&4L 5#4L 4L5& 45#LB 48a&L 4M#",
+" 4M& TM4# T&4M 4#5M 5M4& 4T5M# 4Ms& ;#4L 4L;& 4;#LB a;&4L 45;#L 4&>L 5;#4LB",
+" >&4aL 4#M; +M4& M;#4T aM;4& M;#4j 4M>& 4T5M;# >Ms4& #E4L &E4L H#4L 4LH& 45",
+"#EL 48&EL 4H5#L 4H8&L M#4E 4EM& 4#HM HM4& 4M5#E 48M&E 4HM5# s4HM& d#4L 4Ld&",
+" 4Hd#L 4&gL 4d5#L >&4dL H5#4dL g>4&L 4#dM dM4& 4HMd# 4Mg& 4dM5# >M4d& dM#4H",
+"j >Mg4& 3L#N 3L&N #LN3B a&3LN 3L.#N 8&3LN #L.3BN a&38LN M#Q3 Q3M& QTM#3 aM3",
+"Q& QMj#3 M&3Q8 TMjQ#3 sQM&3 3(N#L +&3LN 3B(#LN a&3+LN #L.3(N 8&3+LN 3LNB#(.",
+" 3L+N8a& QM#3( M&3+Q TM#Q3( +QTM&3 Mj#Q3( +Q8M&3 TMQj#3( M&3s+Q #3WL &3WL H",
+"W#3L H&W3L W#3L. W8&3L W#3HL. W83H&L M#W3 W3M& M#Z3 M&Z3 WMj#3 W8M&3 ZMj#3 ",
+"Z&Ms3 Wd#3L d&3WL Wd#H3L gW&3L d#3WL. W83d&L W3HLd#. W8&g3L dM#W3 dM&W3 ZdM",
+"#3 Z&Mg3 WM#dj3 dM3W&j dMjZ#3 gsMZ&3 m#4L 4Lm& 4m#LB am&4L 45m#L m&L48 5m#4",
+"LB 48am&L 4#Mm Q&4M Mm#4T aMm4& 4Mp# 4Mp& p4TM# p&4sM 4m;#L m&L4+ m;#4LB 4+",
+"am&L 5m;4#L >m4&L mL4B5;# am&>L4 Mm#4; Mm&4+ 4QTM;# 4+TMm& p4M;# >Mp4& M;#p",
+"4T p&4>Ms W#4L 4LW& 4HW#L 4H&WL 4W5#L 4W8&L H5#4WL m&L4H8 4#WM WM4& 4MZ# 4M",
+"Z& p4WM# p&4WM Zp4M# Zp&4M 4#vL 4&vL v4H#L gv4&L v45#L v>4&L 4H5v#L v>&g4L ",
+"4Mv# 4Mv& Zv4M# Zv&4M pv4M# >Mv4& pvMZ4# 4My& U3 U!3 UD3 Ua3 U3. U83 D3U. U",
+"3D8 UM3 M3U! V3 Va3 Uj3 U38M Vj3 Vs3 U3( U+3 D3U( U3+D 3(U. +8U3 UD3(. U+D8",
+"3 M3U( U3+M V3( V+3 j3U( U3+j j3V( s3V+ UE3 !EU3 UH3 HaU3 E3U. 8EU3 H3U. U3",
+"H8 MEU3 U!ME3 VH3 HaV3 jEU3 U8ME3 HjV3 VHs3 Ud3 +dU3 U3Dd gU3 d3U. U38d UHd",
+"3. U8g3 U3dM dM3U+ Vd3 gV3 U3dj U+jd3 djV3 g3Vs 4U 4U! 4UD 4Ua 4U5 4U8 U54D",
+" U54a 4UM U!4M V4 V4a 4Uj U84M V45 s4V 4U; 4U+ U;4D U+4D 45U; >U4 4U5D; 4U>",
+"D U;4M U+4M V4; V4+ U;4j 4U>M 4jV; V>4 4UE U!4E 4UH UH4a 4EU5 4EU8 U54H UH4",
+"8 UM4E 4UM!E V4H 4HVa 4EUj 4U8ME 4HV5 sHV4 4Ud U+4d UH4d g4U U54d 4U>d 4UH5",
+"d >Ug4 Ud4M 4U+dM V4d gV4 Ud4j >M4Ud 4dV5 g4V> U3N !3UN D3UN a3UN N.U3 83UN",
+" UD3N. U8D3N UQ3 U3Q! VQ3 QaV3 QjU3 U3Q8 QjV3 VQs3 3(UN +3UN UD3(N U+D3N U3",
+"(N. U+83N D3(UN. +D3U8N Q3U( U3+Q Q3V( +QV3 UQj3( U+Q83 VQj3( Vs+Q3 UW3 W!U",
+"3 U3WD U3Wa W3U. U3W8 UHW3. UH8W3 U3WM UWQ!3 VZ3 VaZ3 U3Wj UW8Q3 VjZ3 s3VZ ",
+"WdU3 U3+W UHWd3 UWg3 UWd3. U+W83 WD3Ud. gUW83 U3Qd U+WQ3 Z3Vd g3VZ UWjd3 U+",
+"Wj3 VZdj3 gVZs3 4Um 4!Um Um4D Um4a 45Um Um48 4U5Dm 4U8Dm 4UQ Q!4U V4Q 4QVa ",
+"pU4 4Up8 Vp4 s4Vp 4mU; Um4+ 4UDm; 4U+Dm 4U5m; 4U>m U5m4D; >Dm4U U;4Q U+4Q 4",
+"QV; 4+Vm 4Up; p4>U p4V; p>V4 4UW 4!UW UH4W UW4a U54W UW48 4UH5W 4UHW8 UW4Q ",
+"4UWQ! Z4V ZaV4 4UpW pU4W8 Z4Vp VZs4 vU4 4Uv+ 4UvD vUg4 4Uv5 v4>U vU4H5 gvU>",
+"4 4UvM vU4+Q Vv4 g4Vv p4vU >Mv4U pvV4 yV4 bU3 U&3 UDb3 cU3 U3b. b3U8 bUD3. ",
+"U8c3 bM3 b3M& Vb3 Vc3 b3Uj b38M bjV3 s3Vc U3b( b3U+ bUD3( U+c3 bU3(. b+U83 ",
+"UD3b(. cU+83 M3b( b3+M b3V( c3V+ bMj3( b+M83 Vbj3( Vs+c3 UEb3 &EU3 b3UH UHc",
+"3 bUE3. b8UE3 bHU3. cUH83 MEb3 M&Eb3 bHV3 VHc3 bMjE3 b8ME3 VbHj3 VsHc3 b3Ud",
+" U3d& bHUd3 cUg3 bdU3. b8dU3 UH3bd. gcU83 b3dM dM&b3 bdV3 g3Vc bdMj3 d&jU3 ",
+"Vdbj3 gVsc3 4bU 4U& bU4D c4U b54U b84U 4bU5D 4Uc5 4bM bM4& V4b c4V b54M b84",
+"M 4bV5 Vsc4 b;4U b+4U 4bUD; 4Uc; 4bU5; 4b>U b5U4D; >Uc4 b;4M b+4M 4bV; V4c;",
+" 4bM;j 4b>M V4b;j c4V> bU4E 4EU& bH4U 4UcH 4bU5E 4b8UE 4bHU5 c4UH5 4EbM 4bM",
+"&E 4bVH cHV4 4bM5E 4b8ME V4bH5 c4VsH bd4U Ud4& 4bHUd c4gU 4bdU5 >b4Ud bH54U",
+"d c>g4U bd4M dM&4b 4bVd c4gV 4bdUj >Mb4d V4db5 V>gc4 U3bN &3UN bUD3N U3cN b",
+"U3N. b8U3N UD3bN. cU83N b3UQ U3Q& bQV3 VQc3 bQUj3 bQ8U3 VbQj3 cQVs3 bU3(N b",
+"+U3N UD3b(N cU+3N U3(bN. U+3b8N D3UNb(. U+8c3N bQU3( b+QU3 VbQ3( cQV+3 UQ3b",
+"j( &j3U+Q bQjV3( Vs+cQ3 b3UW U3W& bHUW3 UWc3 bWU3. bW8U3 UH3bW. cWU83 b3WM ",
+"bWM&3 VbZ3 Z3Vc bWMj3 bW8M3 ZbVj3 ZcVs3 bWUd3 b+WU3 UHWbd3 cWUg3 UW3bd. d&3",
+"UW8 W.DdbU3 gU8cW3 bWMd3 b+WM3 ZbVd3 gVZc3 dM3bWj dM3bW8 VdjZb3 ZcsgV3 bm4U",
+" Um4& 4bUDm 4Ucm 4bU5m 4b8Um b5U4Dm c4U8m bQ4U UQ4& 4bVm V4cQ 4bpU 4Up& pbV",
+"4 c4Vp 4bUm; 4b+Um bmU4D; c4U+m b5m4U; >b4Um 5mD;4bU c>4Um 4bQU; 4b+UQ V4bQ",
+"; c4V+Q pb4U; >Mbp4 Vp4b; cpV>4 bW4U UW4& 4bHUW 4UcW 4bWU5 4bWU8 bH54UW c4W",
+"U5 bW4M 4bWM& V4Zb VZc4 pb4UW pU&4W ZpbV4 cpZV4 4bvU 4Uv& vb4UH vUc4 vb4U5 ",
+"v>b4U 4bHvU5 cv>4U 4bvM vbM4+ vbV4 c4Vv pvb4U >Mv4b Vvp4b c4yV 6k 6!k 6kB 6",
+"ak 61k 68k 1k6B 8k6a 6M 6M! 6Tk 6aM l6 l68 l6T ls6 6k( 6+k k(6B +k6a 1k6( +",
+"k68 61k(B 6+1ak 6M( 6+M 6(Tk +T6M l6( l+6 6Tl( s6l+ 6kE kE6! 6Hk Hk6a 1k6E ",
+"6E8k 61Hk Hk68 6ME ME6! 6HM HM6a l6E 68lE lH6 s6lH 6dk +k6d Hk6d g6k 61dk 8",
+"k6d 6H1dk 68gk 6dM +M6d HM6d g6M ld6 6+ld 6Hld gl6 4k 4k! 4kB 4ak 7k 78k 7B",
+"k 7ak 4kM 6!4M 4Tk 6a4M 7l 7l8 7lT 7sl 4k; 4+k 4Bk; +k4a 7k; >k7 k;7B 7a>k ",
+"6M; 6+4M Tk6; +T4k l;7 l>7 7Tl; 7sl> 4kE kE4! 4Hk Hk4a 7kE 8k7E 7Hk H87k 4E",
+"6M 4kM!E 6H4M 4HkaM 7lE 78lE lH7 lH7s 4dk +k4d Hk4d g4k 7dk 7d>k Hk7d g7k 6",
+"d4M 4+kdM HM6; 4Tgk ld7 7>ld 7Hld gl7 6kN kN6! kN6B 6Nak 1k6N 6N8k 61kNB ak",
+"N68 6Qk Q!6M Qk6T Qa6M l6Q 6Ql8 6QlT lQs6 k(6N 6N+k 6k(NB akN6+ 61k(N 6+1kN",
+" 1k(6NB 6+1akN 6(Qk +Q6M 6QTk( 6+QTk 6Ql( 6+lQ l6QT( ls6+Q 6Wk 6!Wk Hk6W Wk",
+"6a 61Wk Wk68 6H1Wk 6H8Wk 6WM 6!WM Z6k 6aZk lW6 6Wl8 lZ6 s6lZ Wk6d +k6W 6HWd",
+"k 6Wgk 6W1dk 6+W8k 1HW6dk g61Wk WM6d +W6M 6dZk Z6gk 6Wld 6+lW Z6ld g6lZ 4km",
+" 6!km 4Bkm ak6m 7km 8k7m km7B ak7m 4Qk Q!4k Qk4T Qa4k 7lp l87p lp7T 7lsp km",
+"6; +k6m km;4B akm4+ km7; 7k>m 7Bkm; 7>akm Qk6; +Q4k 4QkT; ak;4Q 7pl; 7pl> 7",
+"lpT; l>p7s 4Wk 4!Wk Hk4W Wa4k 7Wk W87k Hk7W Wa7k 6W4M 4WkQ! Z4k 4aZk lW7 l8",
+"7W 7Zl lZ7s v6k 4+vk 4Hvk v6gk 7vk >k7v vk7H gk7v v6M 6+vM v6Zk Z4gk lv7 7v",
+"l> 7Zlv yl7 69k 6&k 9k6B ak6& 916k :6k 691kB 6a:k 6M9 6M& 9T6M 9a6M l69 l:6",
+" 6Tl9 s6l: 9k6( +k6& 69k(B 6+9ak 691k( 6+:k 91k6(B :6+ak 6(9M 9+6M 6T9k( 6+",
+"T9M 69l( :6l+ l69T( ls:6+ 9k6E 6Ek& 69Hk Hk6& 691kE 6k:E 6H91k 6H:k 6E9M 6E",
+"M& 9H6M HM6& 69lE :6lE 6Hl9 l6:H 69dk dk6& 6H9dk 6&gk 6d91k 6d:k 9H16dk :6g",
+"k 9d6M dM6& 6HM9d 6Mg9 6dl9 l6:d lH69d g6l: 49k 4k& 9k4B 9a4k 79k 7:k 9k7B ",
+":a7k 49M 6M4& 9T4k 9a4M 7l9 l:7 l97T l:7s 9;4k 9+4k k;B49 ak;49 9;7k 7:>k 7",
+"B9k; 7:>ak 9M6; 9+4M 49Tk; aM;49 79l; 7:l> 7l9T; l>7s: 9k4E 4Ek& 9H4k Hk4& ",
+"9k7E :k7E 9H7k 7k:H 4E9M 49M&E 9H4M 49HaM 79lE lE7: l97H 7:lH 9d4k dk4& 49H",
+"dk 49gk 9d7k 7k:d 7H9dk 7:gk 9d4M dk&4M 49HdM 49gM l97d 7:ld 7Tdl9 l:g7 9k6",
+"N 6Nk& 69kNB akN6& 691kN 6k:N 91k6NB :6akN 9Q6M Qk6& 6Q9Tk 6Qa9M 6Ql9 l6:Q ",
+"l69QT :Q6ls 69k(N k&N6+ 9k(6NB 6+9akN 91k6(N :6+kN 916k(BN akN:6+ 6Q9k( 6+Q",
+"9M 9QT6M( 9+Q6aM l69Q( :Q6l+ 6Q9lT( ls6:Q+ 69Wk Wk6& 6H9Wk 6H&Wk 6W91k 6W:k",
+" 9H16Wk :H6Wk 9W6M WM6& 6MZ9 6MZ& 6Wl9 l6:W l6Z9 Z6l: 6W9dk dk&6W 9HW6dk g6",
+"9Wk 9W16dk :W6+k 691HWkd g:6Wk 6WM9d dk&6Q Z69dk Z6&gk lW69d :Qdl6 lZ69d gl",
+"Z:6 9m4k km4& kmB49 akm49 9m7k 7k:m 7B9km 7:akm 9Q4k Qk4& 49QTk aMm49 p97l ",
+"7l:p 7lp9T 7sl:p km;49 km&4+ 49mk;B 49+akm 79km; 7:>km km;7B9 :>m7ak 49Qk; ",
+"k;&4Q 9Q;4Tk 49+aMm 7lp9; l>p7: l;p7T9 7spl>: 9W4k Wk4& 49HWk km&4H 9W7k 7k",
+":W 7H9Wk 7:HWk 9W4M Mm&6W 49Zk 4kZ& l97W 7:lW Z97l l:7Z 49vk 4kv& v69Hk gv6",
+"k& 79vk vk7: 7v9Hk :vkg7 49vM 6Mv& Zv69M Zv6k& v97l l:7v lvZ79 l:y7 6U 6U! ",
+"6UD 6Ua 6U1 6U8 1U6D 1U6a 6UM U!6M V6 V6a l6U 6Ul8 Vl6 s6V 6U( 6U+ 6(Dk U+6",
+"D 6(1U 1U6+ 6U1D( 6U+1D UM6( U+6M V6( V6+ 6Ul( 6Ul+ l(V6 V6l+ 6UE U!6E 6UH ",
+"UH6a 6E1U 6EU8 1U6H UH68 UM6E 6UM!E V6H 6HVa 6UlE l6U8E V6lH sHV6 6Ud U+6d ",
+"UH6d g6U 1U6d U86d 6UH1d 6Ug1 Ud6M 6U+dM V6d gV6 6Uld l+6Ud V6ld s6gV 4U6 6",
+"!4U 4Dk 6U4a 7U 7U8 7UD 7Ua 6U4M 4U6M! V46 4aV6 7lU l87U 7V 7Vs 6U; 6U4+ U;",
+"6D Ua6; 7U; 7>U U;7D 7D>k U;6M 4U+6M V6; 4+V6 7Ul; 7Ul> 7V; 7V> 4E6U 4U6!E ",
+"6U4H 4UH6a 7UE U87E 7UH UH7a 4U6ME 6UE4M! 4HV6 V46Ha lE7U 7lU8E 7VH Vs7H 6U",
+"4d 4U+6d UH6; 4Ug6 7Ud >U7d UH7d g7U 4Ud6M 6U+4dM 4dV6 V4g6 7Uld l>7Ud 7Vd ",
+"g7V 6UN U!6N 6NDk 6NUa 6N1U 6NU8 6U1DN 6U8DN 6UQ Q!6U V6Q 6QVa 6UlQ UQ68 lQ",
+"V6 sQV6 U(6N 6NU+ 6UD(N 6U+DN 6U1(N 6U+1N 1U(6DN 6UN1+D 6(UQ U+6Q 6QV( 6+VQ",
+" l6UQ( l+6UQ Vl6Q( l+V6Q 6UW 6!UW UH6W UW6a 1U6W UW68 6UH1W 6UHW8 UW6Q 6UWQ",
+"! Z6V ZaV6 6UlW lW6U8 VlZ6 VZs6 UW6d U+6W 6UHWd 6UgW 6UW1d 6U+1W 1UW6Dd g6U",
+"1W UQ6d 6U+WM VdZ6 Z6gV lW6Ud l+W6U Z6Vld gV6lZ 6Um 6!Um Um6D Ua6m 7Um U87m",
+" Um7D Ua7m 6U4Q 4UQ6! V6m 6aVm 7pU 78pU 7Vp Vp7s Um6; U+6m 4Dkm; 4+Dkm Um7;",
+" >m7U 7UDm; 7>UDm UQ6; 4U+6Q 6QV; 6+Vm 7;pU p>7U V;7p 7pV> 6U4W 4UW6! UH6m ",
+"4UW6a 7UW UW78 UH7W UW7a 4UW6Q Mm!6UW V4Z6 Z4V6a 7UlW 7pUW8 7ZV sZ7V v6U 6U",
+"v+ 4Dvk v6gU 7vU v>7U vU7H gU7v 6UvM v6U+Q Vv6 g6Vv 7Ulv 7vUl> 7Vv y7V t6 t",
+"6& t6D tc6 t61 t:6 6Dt1 c6t: t6M 6Mt& Vt6 c6V lt6 l6t: V6lt u6 t6( t+6 6Dt(",
+" c6t+ 61t( :6t+ t61D( t:c6+ 6Mt( 6+tM t(V6 V6t+ t6l( l6t+ ltV6( u6+ t6E 6&t",
+"E tH6 c6tH 61tE :6tE 6Ht1 t6:H 6MtE t6M&E V6tH cHV6 t6lE t:6lE l6tH u6H td6",
+" 6+td 6Htd gt6 6dt1 t6:d tH61d t:g6 6dtM t+6dM V6td c6gV l6td t:dl6 tdVl6 u",
+"g6 t4 t4& t4D tc4 7t 7t: 7tD 7ct t4M 4Mt& t4V Vtc4 7tl l:7t 7Vt u7 t4; t4+ ",
+"4Dt; c4t+ 7t; t>7 7Dt; 7ct> 4Mt; 4+tM V4t; V4t+ l;7t 7tl> t;7V u7> t4E 4&tE",
+" t4H c4tH 7tE tE7: 7tH tH7c 4MtE t4M&E V4tH tc4VH lE7t 7tl:E lH7t u7H t4d 4",
+"+td 4Htd gt4 7td 7:td 7Htd g7t 4dtM t4+dM V4td t4gV ld7t 7tdl> td7V ug7 t6N",
+" 6&tN 6DtN tNc6 61tN :6tN t61DN t:c6N tQ6 6Qt& V6tQ c6tQ l6tQ t6:Q tQVl6 u6",
+"Q 6(tN 6+tN t6D(N tc6+N t61(N t:6+N 6D1t(N :c6t+N 6Qt( 6+tQ tQV6( tcQ6+ tQ6",
+"l( t:Q6+ Vl6tQ( 6+uQ tW6 6Wt& 6HtW c6tW 6Wt1 t6:W tH61W t:H6W 6WtQ tW6Q& tZ",
+"6 Z6tc l6tW t:Wl6 Z6lt uZ6 6Wtd 6+tW tH6Wd tWg6 tW61d t:W6+ 6WDtd1 gt:6W 6Q",
+"td t+W6Q Z6td g6tZ tQdl6 t:Q6d tZl6d gZu6 t4m 4&tm 4Dtm c4tm 7tm 7:tm 7Dtm ",
+"tm7c t4Q 4Qt& V4tQ c4tQ tp7 :p7t 7Vtp up7 6mt; 4+tm t4Dm; tc4+m 7mt; 7>tm 7",
+"tDm; t>7cm 4Qt; 4+tQ t4VQ; tc4+Q 7pt; 7pt> tp7V; 7pu> t4W 4Wt& 4HtW c4tW 7t",
+"W 7:tW 7HtW tW7c 4WtQ t4WQ& tZ4 t4Zc lW7t 7tW:p tZ7 uZ7 tv4 v6t+ v6tH g4tv ",
+"tv7 7t:v tH7v tvg7 v6tQ tv4+Q t4Vv g4tZ 7tlv lvt7: 7Ztv yu7 < <! <B a< <. 8",
+"< <.B 8<a <K <K! T< T<a <j 8<j T<j s< <* +< *B< +<a <*. +<8 <.*B a<8* <*K +",
+"<K T<* +T< <j* +<j <jT* s<+ <E <E! H< H<a <E. 8<E H<. H8< <EK EK<! H<T HTa<",
+" <jE 8E<j H<j s<H <d +<d H<d g< <d. 8<d H.<d g<8 <dK +K<d T<d g<T <dj <d+j ",
+"<dHj gs< 4< 4<! 4<B 4a< 5< 48< 5<B 5a< 4<K <K4! 4T< T<4a 4j< 8<4j 5T< s4< =",
+" =+ =B =a =5 >= =B5 =a> =K =+K =T =T+ =j =j> =T5 s= 4<E <E4! 4H< H<4a 5<E 4",
+"E8< H5< H<48 <E4K 4<E!K H<4T 4HTa< 4E<j <jE48 H<4j 4Hs< =d =+d =H g= =5d >=",
+"d =H5 g=> =dK +d=K =HT g=T =jd =d>j =Hj s=g <N <N! <NB a<N <N. 8<N .B<N aN8",
+"< Q< Q<! Q<T Qa< Q<j Q8< QT<j s<Q <*N +<N <N*B +Na< *N<. +N8< *B<N. a*N8< Q",
+"<* +Q< T<Q* Qa+< <jQ* Q8+< <j*QT +Qs< W< W<! H<W Wa< W<. W8< H.W< W8H< W<Q ",
+"Q!W< Z< Z<a W<j Q8W< Z<j sZ< W<d +W< W<H* g<W W.<d W8+< <d.HW W8g< Q<d W<+Q",
+" Z<d gZ< <dWj W<+j <dZj sZg< <m <m! <mB a<m 5<m 8<m 5B<m a<8m 4Q< Q!<m T<m ",
+"Q<4a p< p<8 p<T sp< =m =+m =Bm =am =5m >=m 5m=B >m=a =Q =Q+ =QT =Qa p= p=> ",
+"p=T s=p 4W< 4!W< H<m W<4a 5W< W85< 5WH< Wa5< W<4Q <m!WQ Z4< 4aZ< p<W W8p< Z",
+"p< Zps< v= v=+ =Hv g=v v=5 v>= vH=5 v>g= =Qv v+=Q Z= Z=g p=v v>p= Z=p y= ,<",
+" <& ,<B ,a< ,<. ,8< <.,B 8<,a ,<K <&K ,T< T<& ,j< <&j T<,j s<& ,<* -< ,<*B ",
+"-a< <*,. -8< *B<,. 8<-a <*,K -<K ,<T* -T< ,<*j -j< <j*,T s-< ,<E <&E ,H< H<",
+"& <E,. ,E8< ,.H< H<,8 <E,K &E<K H<,T T<H& ,E<j <E&j H<,j ,Hs< ,d< -<d H<,d ",
+"g-< ,.<d 8<-d <d.,H -8g< ,K<d <d-K T<,d -Tg< <d,j <d-j <dj,H g<s- ,4 ,4& ,4",
+"B ,4a ,45 ,48 4B,5 48,a ,4K ,K4& ,4T 4T,a ,4j 48,j 4T,5 s4, =, -= =B, =a- =",
+"5, ->= ,5=B ->=a =,K -=K =T, =T- =j, =j- ,5=T s=- ,4E ,E4& ,4H 4H,a ,E5< ,E",
+"48 4H,5 4H,8 4E,K <&E4K 4H,T ,4HT& ,E4j <&j4E 4H,j ,4sH =d, -=d =H, g=- ,5=",
+"d =d-> ,H=5 ->g= ,d=K -d=K ,H=T g-=T ,d=j =d-j ,H=j s-g= ,<N <&N <N,B ,Na< ",
+"<N,. ,N8< ,<N.B <&N8a ,Q< Q<& Q<,T Q<,a Q<,j Q<,8 ,QT<j ,Qs< <*,N -<N *B<,N",
+" a<-N ,<*N. 8<-N ,<N*B. -8a<N ,<Q* -Q< ,QT<* Qa-< <j*,Q Q8-< ,QT<j* -Qs< ,W",
+"< W<& H<,W W<,a ,.W< W<,8 ,HW<. ,H8W< W<,Q Q<W& Z<, Z<& W<,j <&Wj ,jZ< Z<s,",
+" W<,d -W< ,HW<d -Wg< <d.,W W8-< ,HW<d. -W8g< Q<,d W<-Q ,dZ< Z-< <dj,W W<-j ",
+"Z<d,j s<Z- ,4m <m& 4B,m 4a,m 5<,m 48,m <mB,5 <m&5a ,4Q 4&,Q 4Q,T 4Q,a p<, p",
+"<& ,4pT p<s, =m, -=m ,m=B -m=a ,5=m >=-m =B5,m =a->m =Q, =Q- ,Q=T -Q=T p=, ",
+"-p= p,=T -ps= ,4W 4&,W 4H,W 4W,a 4W,5 4W,8 ,4H5W <m&H5 4W,Q <m&WQ Z4, ,4Z& ",
+",4pW W<p& p<Z, Z4s, v=, -v= v,=H -vg= =5v, v>-= =Hv,5 g=-v> v,=Q =Q-v Z=, Z",
+"-= v=p, p=-v Z,p= y-= <C <C! D< D<a <C. 8<C D<. D8< <CK CK<! D<T DTa< <jC 8",
+"C<j D<j s<D <*C +<C D<* +D< *C<. +C8< <*D. D8+< *C<K <C+K T<D* D<+T <C*j +C",
+"<j <jD* +Ds< <CE !C<E H<D HDa< CE<. <C8E H.D< D8H< EK<C <CE!K HDT< H<DTa jC",
+"<E <jC8E D<Hj H<sD <dC +C<d D<d g<D dC<. 8C<d D.<d D8g< <CdK <dC+K T<Dd D<g",
+"T <Cdj <dj+C <dDj gDs< 4<C <C4! 4D< D<4a 5<C 4C8< 5D< D85< <C4K 4<C!K D<4T ",
+"4DTa< 4C<j <jC48 D<4j 4Ds< =C =+C =D =D+ =5C >=C =D5 =D> =CK +C=K =DT +D=T ",
+"=jC >C=j =Dj s=D <C4E 4<C!E H<4D 4HDa< <C5E 48<CE 5DH< 4H8D< 4<CEK <CE4K! 4",
+"HDT< H<D4Ta <jC4E 48C<jE 4HjD< s<H4D =dC +d=C =HD g=D 5d=C =d>C H5=D g>=D d",
+"K=C =+dCK Dd=T gD=T dj=C =j>dC Hj=D gs=D <CN !C<N D<N DNa< N.<C <N8C <ND. D",
+"N8< Q<C <CQ! QD< D<Qa QC<j QC8< DjQ< QDs< *C<N <C+N <*DN +ND< <*CN. +<8CN D",
+"<*N. +D<8N <*QC +CQ< D<Q* QD+< <j*QC +Q<8C QD<*j s<+QD W<C <CW! WD< D<Wa <C",
+"W. WC8< W.D< D8W< WCQ< W<Q!C Z<D D<Za WC<j W8<QC D<Zj sDZ< WC<d +CW< D<W* W",
+"Dg< <dCW. +W<8C WD<d. g<WD8 QC<d +W<QC D<Z* gDZ< <djWC +W<jC Z<Ddj gZ<sD <m",
+"C <!mC D<m a<Dm 5C<m 8C<m Dm5< 8<Dm 4CQ< <mCQ! Q<4D 4QDa< p<C 8<pC pD< pDs<",
+" =mC +m=C =Dm +D=m 5m=C =m>C 5D=m >m=D =QC +Q=C =QD +Q=D p=C >Cp= p=D sp=D ",
+"4CW< <mCW! W<4D 4WDa< 5CW< 4W8<C WD5< 4WD8< <mCWQ W<C4Q! 4DZ< Z4Da< W<pC p<",
+"W8C pDZ< Zp<sD v=C v+=C =Dv gv=D v5=C >Cv= =5vD v>=D vQ=C =Qv+C Z=D =DgZ =C",
+"pv p=v>C Zp=D y=D b< b<& ,D< c< b<. b8< ,.D< c<8 b<K bK<& bT< c<T b<j 8<bj ",
+"D<,j sc< b<* -b< D<b* c-< <*b. b8-< ,D<*. -8c< <*bK b<-K T<b* -Tc< <jb* b<-",
+"j ,Dj<* c-s< b<E bE<& bH< c<H <Eb. bE8< b.H< H8c< <EbK <&EbK H<bT H<cT bE<j",
+" <&jbE H<bj sHc< b<d b<-d H<bd gc< b.<d 8<bd ,Dd<. g8c< bK<d -b<dK T<bd gTc",
+"< <dbj -jb<d <dj,D scg< ,4b b<4& ,4D c4< b5< 4b,8 4D,5 c5< ,K4b <&K4b 4b,T ",
+",4cT 4b,j <&j4b 4D,j c4s< =b =b- =bD c= =b5 =b> ,5=D c=> =bK -b=K =bT c=T =",
+"bj -j=b ,D=j s=c ,E4b <&E4b 4b,H ,4cH bE5< ,48bE H5b< H5c< ,4bEK 4bE<&K ,4H",
+"bT c4H,T ,4jbE <&E4bj ,4Hbj c5<sH =bd -b=d =bH c=g b5=d =d>b bH=5 c>g= bd=K",
+" =b-dK bH=T gc=T bd=j =b>dj bH=j gsc= b<N bN<& ,ND< c<N <Nb. bN8< ,D<N. 8<c",
+"N bQ< Q&b< QDb< cQ< Q<bj Q8b< ,QD<j cQs< <*bN b<-N ,D<*N -<cN b<*N. -b8<N D",
+"<Nb*. c-8<N Q<b* bQ-< ,QD<* -Qc< bQ<*j -Qb8< QD<b*j s-cQ< bW< W&b< H<bW cW<",
+" b.W< W8b< ,WD<. W8c< W<bQ bW<Q& Zb< Zc< W<bj <&jbW b<Zj s<Zc W<bd bW-< ,WD",
+"<d cWg< bW<d. -Wb8< <d.,WD c-W8< Q<bd -WbQ< b<Z* g<Zc <djbW -Wjb< Zb<dj Zc<",
+"s- b<m <&bm 4D,m c<m 5<bm 8<bm ,4D5m 5<cm 4b,Q <m&bQ 4Q,D ,4cQ pb< b8p< ,4p",
+"D cp< =bm -m=b ,D=m c=m b5=m >m=b =b5Dm >=cm =bQ -Q=b ,Q=D c=Q p=b =b-p pb=",
+"D cp= 4b,W <m&bW 4W,D ,4cW 5Wb< ,4Wb8 ,4W5D 5Wc< ,4WbQ bW<4Q& ,4Zb c4Z< bWp",
+"< pb<W8 pbZ< Z<cp =bv =b-v vb=H cv= =5vb v>=b =bvH5 v>c= vb=Q -v=bQ Z=b Z=c",
+" pv=b -pv=b Zp=b yc= 6< 6!< 6<B 6a< 1< 68< 1<B 1a< 6<K <K6! 6T< T<6a 6j< 8<",
+"6j 1T< s6< 6* 6+< 6*B 6a* 6*1 68* *B1< 1a6* 6*K 6K+< 6T* +T6* 6*j +<6j 1T6*",
+" s6* 6<E <E6! 6H< H<6a 1<E 6E8< 1H< H81< <E6K 6!<EK H<6T 6HTa< 6E<j <jE68 H",
+"<6j 6Hs< 6d< +<6d 6H* g6< 1<d +<1d 1H6* g1< 6K<d <dK6+ H*6T 6Tg< <d6j <dj6+",
+" H*6j s6g< 46< 4<6! 6<4B 46a< 7< 78< 7B< 7a< 6<4K 6!4<K 46T< 4T6a< 7<j 8<7j",
+" 7T< 7s< =6 =6+ =B6 =a6 7= 7>= 7=B =a7 =6K 6+=K =T6 6+=T =j7 7>=j =T7 s=7 6",
+"<4E 6!4<E 46H< 4H6a< 7<E 8<7E 7H< H87< 46<EK 4<E6!K 4H6T< 6HT4a< <j7E 78<jE",
+" H<7T 7Hs< =6d 6+=d =H6 g=6 7=d >=7d =H7 g7= 6d=K =6+dK 6H=T g6=T 7d=j 7>=d",
+"j 7H=T s=g7 6<N <N6! <N6B 6Na< 1<N 6N8< <N1B 1Na< 6Q< 6!Q< Q<6T Q<6a 1Q< Q8",
+"1< Q<1T 6Qs< 6*N 6N+< 6N*B 6Na* 6N1* 6N8* 6*1NB 68*aN 6Q* +Q6* Q*6T Qa6* 1Q",
+"6* +Q1< 6Q*1T 6Qs* 6W< 6!W< H<6W W<6a 1W< W81< H<1W Wa1< W<6Q 6WQ<! Z6< 6aZ",
+"< W<6j 6W8Q< Z1< Z6s< 6W* +W6* H*6W 6Wg< 1W6* +W1< 6H*1W 1Wg< W*6Q 6+WQ< Z6",
+"* Z6g< W*6j 6+W<j 6*Z1 Z6s* 6m< 6!<m 6B<m a<6m 7<m 8<7m <m7B a<7m Q<6m <m!6",
+"Q T<6m 4Qa6< 7p< 78p< p<7T 7ps< =6m 6+=m 6m=B 6a=m 7=m >m7= =m7B =m7a =Q6 6",
+"+=Q 6Q=T 6Q=a p=7 7>p= 7p=T p=7s W<6m <m!6W H<6m 4Wa6< 7W< W87< H<7W Wa7< 4",
+"WQ6< 6WQ<m! 6mZ< Z46a< p<7W 7pW8< 7Z< s<7Z v=6 =+v6 v6=H v=g6 7v= v>7= =H7v",
+" 7vg= v6=Q =Qv6+ Z=6 g6Z= p=7v 7p>v= 7Z= y7= ? ?& ?B ?a ?1 ?: ?B1 ?:a ?K ?&",
+"K ?T ?Ta ?j ?:j ?T1 s? ?* ?- ?B* ?-a ?1* ?:- 1*?B :-?a ?*K ?-K ?T* ?-T ?j* ",
+"?-j 1T?* s?- ?E ?&E ?H ?Ha ?1E ?:E ?H1 ?:H ?EK &E?K ?HT H&?T ?jE :j?E ?Hj s",
+"?H ?d ?-d ?Hd g? ?d1 ?:d 1H?d g?: ?dK -d?K ?Td g?T ?dj :d?j 1T?d g?s ?4 ?4&",
+" ?B4 ?a4 7? ?:7 7?B ?a7 ?4K 4&?K ?T4 4T?a ?j7 7:?j ?T7 s?7 ?= ?-= ?=B =a? ?",
+"=7 A =B7? Aa ?=K =K?- =T? ?-=T =j? Aj ?T=j As ?4E 4&?E ?H4 4H?a 7?E ?E7: ?H",
+"7 7:?H 4E?K ?4&EK 4H?T ?H4T& 7j?E ?:7jE 7H?T ?H7s ?=d -=?d =H? g?= ?d7 Ad 7",
+"?=H Ag =K?d ?-=dK ?H=T =Tg? ?d=j Ajd ?H=j Ags ?N ?&N ?BN ?aN ?1N ?:N 1N?B :",
+"a?N ?Q ?Q& ?QT ?Qa ?Q1 ?:Q 1Q?T s?Q ?*N ?-N *B?N -a?N 1*?N ?N:- ?B1*N ?:-aN",
+" ?Q* ?-Q Q*?T -Q?T 1Q?* :-?Q ?Q1T* ?Qs- ?W ?W& ?HW ?Wa ?W1 ?:W 1H?W :H?W ?W",
+"Q W&?Q ?Z ?Za ?Wj :W?Q ?Z1 s?Z ?Wd ?-W H*?W g?W 1W?d :-?W ?H1W* ?Wg: ?Qd -W",
+"?Q ?Zd g?Z 1Q?d :Q?d Z1?d Z:g? ?m ?m& ?mB ?am ?m7 ?:m 7B?m 7a?m ?Q4 4Q?& ?T",
+"m 4Q?a ?p ?p: ?pT s?p ?=m ?-m =B?m ?m=a 7=?m Am ?=7mB Aam =Q? ?-=Q ?Q=T ?Q=",
+"a ?p= Ap =T?p Aps ?W4 4W?& ?Hm 4W?a ?W7 7:?W 7H?W 7W?a 4W?Q ?W4Q& ?Z4 Z4?a ",
+"?pW ?W:p ?Zp 7Zs? ?v ?v- ?vH g?v ?v7 Av ?H7v Agv ?vQ ?Q-v ?Zv Z-?v ?pv Apv ",
+"7Z?v yA 6<C <C6! 6D< D<6a 1<C 6C8< 1D< D81< <C6K 6!<CK D<6T 6DTa< 6C<j <jC6",
+"8 D<6j 6Ds< 6*C 6C+< 6D* +D6* 6C1* 6C8* 1D6* +D1< *C6K 6+<CK D*6T 6+DT< 6C*",
+"j 6+j<C D*6j 6Ds* <C6E 6!<CE H<6D 6HDa< <C1E 68<CE H<1D 6H8D< 6<CEK <CE6!K ",
+"6HDT< H<D6Ta <jC6E 68C<jE 6HjD< s<H6D 6C<d <dC6+ H*6D 6Dg< 1C<d 68d<C D<1d ",
+"1Dg< <dC6K 6+C<dK 6H*DT g6DT< <dj6C <dC6+j <dj6D gs6D< 6<4C 6!4<C 46D< 4D6a",
+"< 7<C 8<7C 7D< D87< 46<CK 4<C6!K 4DT6< 6DT4a< <j7C 78<jC D<7T 7Ds< =6C 6+=C",
+" =D6 6+=D 7=C >C7= =D7 7>=D 6C=K =6+CK 6D=T =D6+T 7j=C 7>=jC 7D=T =D7s 46<C",
+"E 4<C6!E 4H6D< 6HD4a< <C7E 78<CE H<7D 7HD8< 6<C4EK 4<6!EKC 6HD4T< HD6a4T< 7",
+"<jCE <jC78E 7HDT< 7sHD< 6d=C =6+dC 6H=D g6=D =C7d 7>=dC 7H=D =Dg7 =6dCK 6+d",
+"=CK =H6DT g=6DT 7=djC =j>7dC 7Dd=T g7s=D <C6N 6!<CN 6ND< 6Da<N <C1N 68<CN 1",
+"ND< 6D8<N 6CQ< 6Q<!C Q<6D 6QDa< 1CQ< 6Q8<C QD1< s<Q6D *C6N 6+<CN 6ND* 6+D<N",
+" 6*1CN 68*CN 6D*1N 6D8*N 6CQ* 6+Q<C QD6* 6+QD< 6Q*1C 6Q8*C 6QD1* s6*QD 6CW<",
+" 6W<!C W<6D 6WDa< 1CW< 6W8<C WD1< 6WD8< 6WQ<C W<C6Q! 6DZ< Z6Da< 6Wj<C <jC6W",
+"8 1DZ< Z1<sD 6CW* 6+W<C WD6* g6WD< 6W*1C 6W8*C 6WD1* g1<WD 6W*QC <dC6+Q 6DZ",
+"* Z6*gD 6W*jC <dC6Q8 Z6*1D Z6*sD 6C<m <mC6! D<6m 6Dma< <m7C 78<mC D<7m 7D8<",
+"m <mC6Q 6QC<m! 4QD6< QD<6am 7Cp< 7p8<C p<7D 7pDs< 6m=C =6+mC 6D=m =D6+m 7m=",
+"C 7>=mC =m7D 7>D=m 6Q=C =Q6+C 6Q=D =QD6+ =C7p 7p>=C 7p=D p=D7s <mC6W 6WC<m!",
+" 4WD6< WD<6am W<7C 7W8<C WD7< 7WD8< 6WQ<mC WQ4C6!< Z46D< 6DmZ<a 7pW<C p<87W",
+"C Z<7D 7ZsD< =Cv6 v=6+C v6=D g=v6D =C7v 7v>=C =D7v 7vDg= =Qv6C v6+=QC Z6=D ",
+"Z=g6D 7vp=C p=>7vC =D7Z =Dy7 ?b ?b& ?D ?c ?b1 ?:b ?D1 ?c: ?bK bK?& ?DT ?cT ",
+"?jb :b?j ?Dj s?c ?b* ?-b ?D* ?c- b1?* ?b:- 1D?* :c?- b*?K -b?K bT?* c-?T b*",
+"?j ?b-j D*?j ?cs- ?bE b&?E ?Hb ?cH b1?E :b?E b1?H :c?H bK?E ?b&EK bH?T cH?T",
+" bj?E ?:bjE bH?j ?Hsc ?db -b?d ?Dd g?c b1?d ?b:d 1D?d ?cg: bd?K ?-bdK bT?d ",
+"?Tgc bd?j ?:dbj Dd?j gs?c ?4b 4b?& ?D4 ?c4 7?b 7b?: ?D7 7c? 4b?K ?4b&K 4b?T",
+" c4?T 7b?j ?:7bj 7b?T 7cs? =b? ?-=b =D? c=? =b7 Ab 7?=D Ac ?b=K ?-=bK ?D=T ",
+"=T?c ?j=b Ajb ?D=j Asc 4b?E ?4b&E 4b?H c4?H ?E7b ?:7bE 7b?H ?H7c ?4bEK 4b&?",
+"EK ?H4bT ?c4HT ?j7bE 7:b?jE ?H7bT s?7cH ?d=b ?-=bd ?H=b c=g? 7b?d Abd 7b=H ",
+"Agc ?=dbK =b-?dK ?Dd=T c=?gT ?d7bj bdAj ?Hj=b gsAc ?bN b&?N ?DN ?cN b1?N :b",
+"?N 1D?N ?N:c ?Qb bQ?& ?QD ?cQ b1?Q ?b:Q 1Q?D ?Qsc b*?N -b?N D*?N ?Nc- ?b1*N",
+" ?:-bN ?D1*N ?c:-N bQ?* ?b-Q QD?* c-?Q ?Qb1* ?:Q-b ?QD1* ?cQs- ?Wb bW?& ?WD",
+" ?cW b1?W ?b:W 1W?D :c?W bW?Q ?WbQ& ?Zb ?Zc bW?j ?:WbQ Zb?j ?cZ: bW?d ?b-W ",
+"WD?d ?Wgc ?Wb1d ?:W-b ?WD1d ?cWg: bQ?d ?-WbQ Zb?d ?cZ- ?Wjbd ?:Qbd ?Zb1d g?",
+"Zsc ?mb bm?& ?Dm ?cm 7b?m ?b:m 7D?m ?m7c 4b?Q ?Q4b& 4Q?D c4?Q ?pb pb?: ?pD ",
+"?pc ?m=b ?b-m ?m=D ?mc= =m7b Abm ?D7=m Acm ?Q=b ?-Q=b ?Q=D =Q?c =b?p Apb =D",
+"?p Apc 4b?W ?W4b& 4W?D c4?W 7b?W ?:W7b 7W?D ?W7c ?W4bQ 4bW?Q& Z4?D ?mZc pb?",
+"W ?p:bW ?D7Z 7c?Z ?vb vb?- ?vD ?vc =b7v Avb ?D7v Acv vb?Q ?v-bQ =b?Z cv?Z p",
+"b?v pvAb =b7Z yAc <L <L! <LB a<L <L. 8<L .B<L 8La< <M <M! T<M a<M <Mj 8<M T",
+"M<j s<M <*L +<L <L*B +La< *L<. +L8< *B<L. a*L8< <M* +<M <MT* T<+M M*<j 8<+M",
+" <M*Tj +<sM <EL !E<L H<L HLa< EL<. <E8L <LH. HL8< <ME <!ME H<M a<HM Mj<E 8E",
+"<M <MHj H<sM <dL +L<d HL<d g<L dL<. 8L<d <dLH. 8<gL <dM <d+M <dHM g<M dM<j ",
+"<d8M <dMHj s<gM 4<L <L4! <L4B 4La< 5<L 4L8< <L5B 5La< 4M< 4!<M T<4M a<4M 5<",
+"M 8<4M T<5M 4Ms< =L =+L =BL =aL =5L >=L 5B=L >L=a =M =M+ =TM =aM =M5 >M= 5T",
+"=M s=M <E4L 4<E!L 4LH< 4Ha<L <E5L 48<EL HL5< 4H8<L 4E<M <ME4! H<4M 4HMa< 5E",
+"<M 48M<E 5<HM s<H4M =dL +d=L =HL g=L 5d=L =d>L H5=L >Lg= =Md +M=d =HM g=M 5",
+"d=M =d>M H5=M >Mg= <LN !L<N NB<L <LaN N.<L <N8L <LN.B 8<aLN Q<M Q!<M QT<M a",
+"MQ< QM<j 8MQ< <MjQT Q<sM *L<N <L+N *B<LN a*L<N <*LN. +<8LN <LN*B. 8<La*N <M",
+"Q* Q<+M <M*QT aM*Q< <M*Qj +Q<8M Q<TM*j s<+QM W<L <LW! HLW< WLa< <LW. WL8< H",
+"<WL. H8<WL W<M W!<M Z<M a<ZM <MWj 8<WM <MZj sMZ< WL<d +LW< <dLHW W<gL <dLW.",
+" +W<8L W<LH*. g<W8L <dWM W<+M <dZM Z<gM <dMWj <dMW8 Z<dMj gZ<sM <mL <!mL mL",
+"<B aL<m 5L<m 8L<m <mL5B 5a<mL <Mm <!Mm <MTm <Mam p<M 8<pM T<pM sMp< =mL +m=",
+"L mL=B am=L 5m=L =m>L =B5mL =a>mL =QM +Q=M Tm=M Qa=M p=M >Mp= pT=M sp=M 4LW",
+"< <mLW! HL<m 4Wa<L 5LW< 4W8<L H5<WL H8<mL W<4M <MmW! 4MZ< Z4a<M W<pM p<W8M ",
+"ZMp< Zp<sM v=L v+=L vH=L =Lgv v5=L >Lv= =Hv5L g=v>L =Mv =+vM Z=M =MgZ pv=M ",
+"v>=M Zp=M y=M ,<L <&L <L,B ,La< <L,. ,L8< ,<L.B <&L8a ,M< <M& T<,M a<,M <M,",
+"j 8<,M <Mj,T ,Ms< <*,L -<L *B<,L a<-L ,<*L. 8<-L ,<L*B. -8a<L ,<M* -M< <M*,",
+"T T<-M <M*,j 8<-M ,T<M*j -Ms< <E,L &E<L ,LH< HL<& ,<EL. <&E8L ,H<L. ,H8<L ,",
+"E<M <EM& H<,M <MH& <Mj,E <M&8E ,HM<j s<H,M ,L<d <d-L <dL,H -<gL <dL,. -8<dL",
+" ,HL<d. g-8<L <d,M <d-M <dM,H -Mg< <dM,j -M8<d ,HM<dj s-g<M ,4L ,L4& 4B,L ,",
+"L4a ,L5< ,L48 ,45LB ,48aL ,4M 4&,M 4T,M 4a,M 4M,5 48,M ,4T5M ,4sM =,L -=L ,",
+"L=B -a=L ,5=L >L-= =B5,L =a->L =M, =M- ,T=M -T=M ,5=M ->=M =T5,M =Ms- 4E,L ",
+"<&E4L ,L4H ,4HaL ,45EL ,48EL ,4H5L ,4H8L ,E4M <M&4E 4H,M <M&4H ,4M5E <M&5E ",
+",4H5M s4,HM ,d=L -d=L ,H=L =Lg- =5d,L ->=dL =H5,L g=->L ,d=M =d-M ,H=M g-=M",
+" =M5,d >M-=d =HM,5 g=Ms- <L,N &L<N ,<LNB <&LaN ,<LN. <&L8N <LN,.B 8<L,aN Q<",
+",M <MQ& ,QT<M <M&Qa <Mj,Q <M&Q8 ,QT<Mj s<Q,M ,<*LN <L-N ,<L*BN -a<LN <*L,N.",
+" -8<LN NB*L,<. 8<a-LN <M*,Q Q<-M ,QT<M* -QT<M ,Q<M*j -Q8<M QTM*,j< s-Q<M ,L",
+"W< WL<& ,HW<L ,Wa<L ,W<L. ,W8<L H<L,W. ,HLW8< W<,M <MW& ,MZ< <MZ& ,WM<j <M&",
+"W8 Z<M,j Z<&sM <dL,W W<-L ,HW<dL -W<gL ,WL<d. -W8<L W.<d,HL g<8-WL <dM,W W<",
+"-M Z<d,M -MZ< ,WM<dj -WM8< <dMZ,j Z-s<M ,L<m <Lm& <mL,B <m&aL <mL,5 <m&5L ,",
+"5L<mB amL,48 4Q,M Mm<& <Mm,T aMm,4 ,4pM <Mp& p<T,M p<&sM ,m=L =L-m =Bm,L =a",
+"-mL =5m,L ->=mL ,5m=BL ->m=aL ,Q=M -Q=M =QT,M =Q-aM p,=M =M-p p=T,M -ps=M ,",
+"L4W <m&WL ,4HWL <m&HL ,4W5L ,4W8L <mL,H5 <mL,H8 4W,M <MmW& ,4ZM Z4&,M p<W,M",
+" p<&WM Zp<,M Zp<M& =Lv, =L-v =Hv,L g=-vL v=5,L -v>=L v,5=HL -v>g=L v,=M =M-",
+"v Z,=M =MZ- p=v,M -pv=M Z=p,M =My- U< U<! U<D Ua< U<. U8< U.D< D8U< U<M U!<",
+"M V< V<a U<j 8<Uj V<j s<V U<* U+< D<U* +DU< <*U. +<U8 U<D*. U+<D8 <MU* +MU<",
+" V<* V+< <jU* +<Uj <jV* V+s< U<E <EU! UH< H<Ua <EU. UE8< U.H< H8U< UE<M <ME",
+"U! V<H H<Va UE<j U8<ME H<Vj sHV< U<d +<Ud H<Ud gU< U.<d 8<Ud UH<d. U8g< <MU",
+"d <dMU+ V<d gV< <dUj <dMU8 <dVj s<gV 4U< 4!U< U<4D U<4a U5< U<48 5DU< 5aU< ",
+"U<4M <M!4U V4< 4aV< U<4j 4U8<M V5< V4s< =U =U+ =UD =Ua =U5 =U> U5=D >U=D =U",
+"M U+=M V= V=+ =Uj =U>M V=5 s=V 4EU< 4U<!E U<4H 4UHa< UE5< 4U8<E H5U< 4UH8< ",
+"<ME4U 4UE<M! 4HV< V4Ha< 4Uj<E <ME4U8 H5V< s<V4H =Ud U+=d =UH g=U U5=d =d>U ",
+"UH=5 g>=U Ud=M =U+dM V=H V=g Ud=j >M=Ud V5=H gVs= U<N <NU! UND< UNa< <NU. U",
+"N8< U<DN. U8<DN UQ< Q!U< V<Q QaV< Q<Uj Q8U< Q<Vj sQV< <*UN UN+< U<D*N U+<DN",
+" U<*N. U+<8N D<NU*. a*NU8< Q<U* +QU< Q<V* +QV< UQ<*j U+Q8< V<Q*j s<V+Q UW< ",
+"U!W< H<UW WaU< U.W< W8U< UH<W. UH8W< W<UQ UW<Q! Z<V ZaV< W<Uj UW8Q< ZjV< VZ",
+"s< W<Ud +WU< UH<W* UWg< UW<d. U+W8< UHW<d. gU<W8 Q<Ud U+WQ< V<Z* Z<gV <djUW",
+" U+W<j Z<Vdj gV<sZ U<m U!<m D<Um a<Um 5<Um 8<Um U5<Dm U5a<m U<4Q <MmU! V<m ",
+"a<Vm pU< U8p< Vp< s<Vp =Um U+=m Um=D Ua=m U5=m >m=U =U5Dm =U>Dm =UQ U+=Q V=",
+"Q V+=Q p=U p>=U V=p Vps= U<4W 4UW<! H<Um 4UWa< 5WU< 4UW8< UH5W< UH8<m <MmUW",
+" <M!4UW V4Z< Z4Va< UWp< pU<W8 Z<Vp Vp<sZ =Uv =+vU vU=H gv=U =5vU v>=U =UvH5",
+" g=Uv> vU=Q =Uv+Q Z=V gVZ= pv=U p=Uv> VpZ= yV= ,U< U<& U<,D c<U ,.U< U8b< ,",
+"UD<. U8c< b<M <MU& V<b c<V U<,j 8<bM ,jV< Vsc< U<b* -U< ,UD<* -Uc< ,U<*. U8",
+"-< U<Db*. c-U8< <Mb* b<-M b<V* V-< ,Uj<* U<-j V<b*j s<V- ,EU< UE<& UHb< UHc",
+"< ,U<E. ,U8<E ,UH<. c<UH8 bE<M <M&bE ,HV< cHV< ,Uj<E <&jUE V<bHj s<VcH U<,d",
+" U<-d ,UH<d c<gU ,Ud<. -U8<d <d.,UH gc<U8 <dbM -U<dM ,dV< g<V- <dMbj -Uj<d ",
+"V<d,j V-gs< ,4U 4&,U 4U,D ,4cU 4U,5 4U,8 ,4U5D U5c< 4b,M <M&4b V4, V4c< 4U,",
+"j <M&b5 ,4V5 V4s, =bU =U- ,U=D c=U ,U=5 ->=U =bU5D =Uc> =bM -U=M V=b c=V ,U",
+"=j =b>M V5=b V-s= ,E4U ,4U&E 4U,H c4U,H ,4U5E ,4U8E ,4UH5 c5<UH ,4UME <ME4U",
+"& ,4VH c4V,H ,4UjE <ME4b8 V4,H5 s,V4H ,U=d =d-U ,U=H gc=U =bU5d =b>Ud =bHU5",
+" c=g>U bd=M =bM-d Vd=b gVc= =bM5d >M=bd V=bH5 c=Vgs ,NU< UN<& ,UD<N U<cN ,U",
+"<N. ,U8<N U<N,D. c<U8N UQb< Q<U& ,QV< V<cQ ,UQ<j <&jUQ V<bQj s<VcQ ,U<*N U<",
+"-N U<Db*N c-U<N U<Nb*. -U8<N ,NU<D*. -U8c<N ,UQ<* UQ-< V<bQ* V<-Q UQ<b*j -U",
+"Q8< bQ<V*j V-sQ< UWb< W<U& ,UHW< UWc< ,UW<. ,UW8< ,U.WD< cW<U8 W<bM <M&bW V",
+"<Zb VZc< ,UW<j <&jUW Zb<Vj Zc<Vs ,UW<d UW-< UH<bW* c-WU< <d.,UW -UW8< ,.UHW",
+"<d cW8gU< <dMbW -UWQ< Zb<Vd Z<V- ,UW<dj -UW<j ZbjV<d Z-Vs< 4U,m <mU& ,4UDm ",
+"U<cm ,4U5m <m&U5 U5<,Dm c5<Um 4U,Q <MmU& ,4Vm V<cm ,4pU U<p& pbV< c<Vp ,U=m",
+" -m=U =bUDm cm=U =bU5m =b>Um ,U5=Dm c=>Um ,U=Q -U=Q Vm=b =QV- pb=U =U-p =bV",
+"p V=cp 4U,W <m&UW ,4UHm c4W,U ,4U5W ,4UW8 4UH,5W c5WU< <MmbW 4bW<M& V4Z, Zc",
+"4V< pb<UW pU<W& Vp<Zb cp<VZ vb=U =U-v =bvUH =Ucv =bvU5 -vU>= =U5vD, cv=>U v",
+"b=M -vU=Q =bVv V-Z= p=bvU -pUv= Vv,p= c=yV <k <k! <kB a<k 1<k 8<k 1B<k a<8k",
+" 6M< 6!<M T<k a<6M l< l<8 l<T ls< 6*k +<k *B<k a<+k <k1* +k1< <kB1* ak*68 6",
+"M* +<6M Tk6* T<+k l<* l+< 6Tl* s6l* <kE <!kE H<k a<Hk 1E<k 8E<k Hk1< 8<Hk 6",
+"E<M <kEM! H<6M 6HMa< l<E 8<lE lH< s<lH <dk <d+k Hk6* g<k <k1d <d8k <dk1H 1<",
+"gk <d6M <dk+M HM6* 6Mg< l<d +<ld 6Hl* gl< 4k< 4!<k 4B<k a<4k 7<k 8<7k <k7B ",
+"a<7k <k4M <k!4M T<4k 4Tka< l<7 78l< 7Tl< l<7s =k =k+ =kB =ak =k7 >k= 7B=k =",
+"a>k =kM 6+=M =Tk 6a=M l= l=> l=T l=s 4E<k <kE4! H<4k 4Hka< <k7E 78<kE H<7k ",
+"7H8<k <kE4M 4kE<M! 4HkT< H<k4aM 7<lE 7l8<E 7Hl< 7slH< =kd +k=d =Hk g=k 7d=k",
+" =d>k 7H=k >kg= 6d=M =k+dM 6H=M g6=M l=d >=ld l=H gl= <kN <!kN kN<B aN<k 1N",
+"<k <N8k <kN1B 1a<kN Q<k Q!<k T<Qk a<Qk l<Q Q8l< Q<lT lQs< 6Nk* +N<k <kN*B a",
+"k*6N <kN1* 68*kN 1<Nk*B akN68* Qk6* Q<+k 6Q*Tk ak*6Q 6Ql* +Ql< l<QT* ls<+Q ",
+"W<k W!<k W<Hk a<Wk Wk1< 8<Wk 1H<Wk 1Wa<k W<6M 6WM<! Z<k a<Zk lW< W8l< lZ< s",
+"Zl< Wk6* W<+k <dkHW W<gk <dk1W <dkW8 H<k1W* g1<Wk WM6* <dk+Q 6MZ* Z<gk 6Wl*",
+" +Wl< Z6l* l<gZ <km <!km <Bkm <kam <k7m <k8m 7B<km 7a<km Q<4k <kmQ! <kTm ak",
+"mQ< l<p l8p< lTp< spl< =km +k=m km=B ak=m 7k=m >m=k 7=mkB >k=am =Qk +Q=k Qk",
+"=T Qa=k l=p p=l> lp=T lsp= W<4k <kmW! <kHm akmH< W<7k 7W8<k 7HW<k 7Wa<k <km",
+"WM <k!4WM 4kZ< Z4ka< 7Wl< lW78< l<7Z lZ<7s =kv =+vk vk=H gv=k =k7v v>=k 7v=",
+"Hk g=k7v v6=M =Qkv+ Z=k =kgZ lv= v>l= l=Z yl= ?k ?k& ?Bk ?ak ?1k ?:k 1k?B :",
+"a?k ?M ?M& ?Tk ?aM l? l?: l?T s?l ?k* ?-k k*?B -k?a 1*?k -k?: ?B1k* ?:-ak ?",
+"M* ?-M Tk?* -T?M l?* l-? ?Tl* s?l- ?kE k&?E ?Hk Hk?a 1k?E :k?E 1H?k ?k:H ?M",
+"E M&?E ?HM HM?a l?E lE?: l?H lHs? ?dk -k?d Hk?d g?k 1d?k ?k:d ?H1dk ?:gk ?d",
+"M -M?d HM?d g?M l?d ?:ld ?Hld gl? ?4k 4k?& 4k?B 4a?k 7?k ?k7: ?k7B ?k7a ?M4",
+" 4M?& 4T?M 4a?M l?7 7l?: 7l?T l?7s =k? =k- ?B=k ?a=k 7?=k Ak ?=7kB Aak =M? ",
+"?-=M ?T=k ?a=M l=? Al =Tl? Als 4k?E ?4k&E 4H?k ?H4ak 7k?E ?:7kE ?k7H ?:H7k ",
+"4M?E ?M4&E 4H?M ?HM4a lE7? l?7:E 7l?H l?H7s ?d=k =d-k ?H=k =kg? ?k7d Adk ?H",
+"7=k Agk ?d=M ?-M=d ?H=M =Mg? ?=ld Ald =Hl? Alg ?kN k&?N kN?B ak?N 1k?N :k?N",
+" ?B1kN ?:akN ?Qk Qk?& Qk?T Qa?M l?Q ?Ql: lQ?T ?Qls k*?N ?N-k ?Bk*N ?-akN ?1",
+"k*N ?:-kN k*N?B1 :-k?aN Qk?* -Q?M ?QTk* ?-QTk ?Ql* ?Ql- l?QT* l-?sQ ?Wk Wk?",
+"& Hk?W Wa?k 1W?k ?k:W ?H1Wk ?:HWk ?WM WM?& ?Zk Zk?a l?W ?:lW ?Zl l?Z: Wk?d ",
+"-k?W ?HWdk ?Wgk ?W1dk ?:W-k 1H*?Wk g?:Wk WM?d -W?M Zk?d gk?Z ?Wld ?-lW ld?Z",
+" ?Zgl ?mk km?& km?B ak?m 7k?m ?k:m ?m7kB ?:mak ?Mm Mm?& Tk?m aM?m ?pl l?:p ",
+"lp?T ls?p ?m=k -k?m ?=mkB ?-mak ?=7km Akm 7=B?mk akAm ?Q=k -Q=k ?Tm=k ?-Tkm",
+" ?pl= Alp l=?pT lsAp 4W?k ?W4k& Hk?m ?Hmak ?k7W ?:W7k ?H7Wk ?:Hkm 4W?M ?WM4",
+"& Z4?M ?Z4ak lW?p l?W:p l?7Z s?Z7l ?vk =k-v vk?H gk?v vk7? Avk ?v7Hk gvAk ?",
+"vM ?M-v =k?Z =kZ- lv? Alv ?Zlv yAl 6U< 6!U< D<k U<6a 1U< U81< U<1D Ua1< U<6",
+"M <k!UM V6< 6aV< l<U U8l< l<V Vls< 6U* U+6* U*6D Ua6* 1U6* U+1< 6U*1D 6U8D*",
+" U*6M 6U+<M V6* 6+V< 6Ul* U+l< V6l* V6s* 6EU< <kEU! U<6H 6UHa< 1EU< 6U8<E U",
+"H1< 6UH8< <kEUM 6UE<M! 6HV< V6Ha< U<lE l<U8E V<lH s<VlH U<6d <dkU+ UH6* 6Ug",
+"< U<1d <dkU8 <dk1D 1Ug< <dkUM 6U+<dM 6HV* V6g< U<ld l+<Ud V<ld l<gV U<4k <k",
+"!4U D<4k 4Ua<k 7U< U87< U<7D Ua7< 4U6<M 4U6<M! 4kV< V46a< 7Ul< 7lU8< 7V< s<",
+"7V =U6 6U=+ =Dk 6U=a =U7 =U>k 7U=D =D>k 6U=M =U6+M V=6 V6=a l=U =Ul> l=V 7V",
+"s= <kE4U 4UE<k! 4UH<k UH<4ak U<7E 7U8<E UH7< 7UH8< 4U6<ME <k4MU!E V46H< 4Hk",
+"V<a 7lU<E l<87UE V<7H 7VsH< 6U=d =U6+d 6U=H g6=U 7d=U 7>U=d 7U=H =Ug7 =U6dM",
+" 6U+=Md V6=H =kgV ld=U l=>Ud =H7V V=gl 6NU< <kNU! DN<k 6Ua<N 1NU< 6U8<N 1U<",
+"DN 1Ua<N U<6Q 6UQ<! 6QV< V6Qa< UQl< l<UQ8 lQV< s<VlQ 6NU* 6U+<N 6U*DN 6Ua*N",
+" 6U*1N 6U8*N <kN1D* a*N6U8 UQ6* 6U+Q< 6QV* V6+Q< l<UQ* l+<UQ l<VQ* s*V6Q U<",
+"6W 6UW<! D<Wk 6UWa< UW1< 6UW8< 1UHW< 1UWa< 6UWQ< <M!6UW V6Z< Z6Va< UWl< lW<",
+"U8 VlZ< lZ<Vs UW6* 6U+W< <dkWD g6UW< 6UW1* 6UW8* 1UH6W* g1UW< <dkUQ U+W6Q* ",
+"V6Z* gV6Z< lW<Ud l+WU< lZ<Vd gl<VZ U<6m <kmU! <kDm akmU< U<7m 7U8<m 7UD<m 7",
+"Ua<m <kmUQ <k!4UQ 6mV< V6ma< pUl< 7pU8< l<Vp Vp<7s 6U=m =U6+m Dk=m =Ua6m =m",
+"7U 7>U=m =U7Dm 7Ua=m 6U=Q =UQ6+ V6=Q V=6+Q 7p=U l=p>U Vpl= V=pl> <kmUW <k!4",
+"UW <kmUH UH<akm UW7< 7UW8< 7UHW< 7UWa< 6UW<Mm Q!4UW<k Z4V<k Z6aV<m 7pUW< 7U",
+"8lW< Z<7V 7ZVs< v6=U =Uv6+ vD=k g=Uv6 =U7v 7vU>= 7vU=H g7Uv= =Uv6Q =U+v6M =",
+"kVv Vv6g= =Ulv lv=>U Z=7V l=yV ?t ?t& ?tD ?ct ?t1 ?t: t1?D t:?c ?tM tM?& V?",
+" V?c l?t ?tl: V?l u? ?t* t-? t*?D t-?c ?1t* ?:t- ?t1D* ?t:c- t*?M ?Mt- V?* ",
+"V?- ?tl* l?t- l*V? u?- ?tE t&?E ?tH tc?H t1?E ?Et: ?1tH t:?H tM?E ?tM&E V?H",
+" Vc?H lE?t ?t:lE lHV? u?H ?td ?dt- tH?d g?t ?1td t:?d ?tH1d ?tg: td?M ?td-M",
+" V?d g?V ?tld l-?td ldV? u?g ?t4 ?&t4 t4?D t4?c 7t? ?:7t ?D7t 7t?c t4?M ?t4",
+"M& V?4 c4V? l?7t ?t:7l 7V? u?7 t= t=- t=D t=c t=7 At =D7t Atc t=M =Mt- t=V ",
+"V?c= l=t Alt 7Vt= Au ?Et4 ?t4&E t4?H ?tHc4 ?E7t ?t:7E ?H7t 7tH?c ?t4ME t4&?",
+"ME V4?H V?c4H 7tl?E l?:7tE ?H7V ?Hu7 t=d -=td t=H gt= ?d7t Atd =H7t Agt td=",
+"M t=-dM =HV? V=g? ldt= ltAd =Hlt Aug ?tN t&?N tD?N ?Ntc t1?N ?Nt: ?t1DN ?t:",
+"cN ?tQ ?&tQ V?Q tc?Q ?Qlt t:?Q Vl?Q u?Q ?Nt* ?Nt- ?tD*N ?ct-N ?t1*N ?t:-N t",
+"*1?DN t-:?cN t*?Q ?Qt- V*?Q ?QV- ?tQl* t-Ql? V?lQ* ?-uQ ?tW ?&tW tH?W tc?W ",
+"?1tW t:?W ?tH1W ?cWt: tW?Q ?tWQ& ?ZV ?ctZ ?tlW l?Wt: l?tZ u?Z tW?d ?Wt- ?tH",
+"W* ?Wgt ?tW1d t-W?: ?H1tW* g?t:W tQ?d t-W?Q ?dtZ ?Zgt l?Wtd l-W?t V?dlZ g?u",
+"Z ?tm ?&tm tm?D tc?m ?m7t t:?m ?tm7D ?cm7t t4?Q ?tQ4& V?m cmV? ?pt ?t:p ?pV",
+" u?p t=m ?mt- tm=D tmc= 7=tm Atm t=7Dm tcAm t=Q =Qt- =QV? ?mV- tp= Apt V=?p",
+" Aup t4?W ?tW4& tH?m ?cWt4 ?W7t 7tW?: 7tH?W 7cW?t ?tW4Q ?W&t4Q ?mtZ V?mZc ?",
+"Wtp ?pt:W tZ?p ?Zup ?vt t-?v =Htv ?vgt 7t?v Atv ?vt7H gtAv =Qtv ?vt-Q ?vV Z",
+"-t= tp?v lvAt tZl= Auy 3F !3F 3BF a3F 3F. 83F 3F.B a38F 3FK 3F!K T3F a3TF j",
+"3F j38F j3TF s3F 3(F +3F 3(FB a3+F (F3. 83+F 3F.(B +8a3F (F3K 3F+K 3(TF T3+",
+"F 3(jF j3+F Tj3(F +3sF G3 G3! GH3 Ga3 G3. G83 H3G. G3H8 G3K !KG3 GT3 TaG3 G",
+"j3 8jG3 G3Hj sG3 Gd3 +G3 HdG3 gG3 d3G. +3G8 GHd3. G8g3 dKG3 GK+3 G3Td GTg3 ",
+"G3dj +3Gj dj3GT g3sG 4F 4F! 4FB 4aF 45F 48F 5B4F 4F5a 4FK !K4F 4TF Ta4F 4jF",
+" 8j4F 4F5T s4F 4;F 4+F ;F4B 4Fa; 5;4F >F4 45;FB 4a>F ;F4K +F4K 4FT; 4F+T 4F",
+";j 4j>F ;jF4T >Fs4 4G 4G! 4GH 4Ga 4G5 4G8 G54H G54a 4GK GK4! 4GT GT4a 4Gj G",
+"84j G54T s4G 4Gd 4+G G;4H g4G G54d >G4 4GH5d >Gg4 4KG; 4K+G GT4d 4GgT G;4j ",
+"4G>j 4GT5d sGg4 3FN 3F!N 3FNB 3FaN 3FN. 3F8N 3F.NB 8a3FN Q3F !3QF T3QF a3QF",
+" j3QF 83QF QTj3F Q3sF (F3N 3F+N 3FN(B +a3FN 3F.(N +83FN N.(3BF 8a3+FN 3(QF ",
+"Q3+F QT3(F +QT3F Qj3(F +Q83F Tj3Q(F s+Q3F GW3 G3W! HWG3 G3Wa W3G. G3W8 GHW3",
+". G8HW3 GQ3 G3Q! ZG3 GaZ3 G3Wj G3Q8 GjZ3 ZGs3 WdG3 GW+3 GHWd3 GWg3 GWd3. +G",
+"W83 HWdG3. gGW83 G3Qd +3GQ GdZ3 ZGg3 dj3GQ +GQ83 ZGdj3 gZsG3 4mF mF4! mF4B ",
+"4Fam 5m4F 4F8m 45mFB amF48 4QF 4FQ! 4FTm 4FQa p4F 48pF 4TpF p4sF m;4F 4F+m ",
+"4m;FB amF4+ 45m;F 4m>F 5m;4FB >m4aF 4FQ; 4F+Q 4QT;F 4+QTF 4;pF p4>F p4T;F p",
+">4sF 4GW 4!Gm Gm4H Ga4W G54W G84W 4GH5W 4G8Hm 4GQ Q!4G Z4G 4GZa pG4 4Gp8 pG",
+"Z4 Z4sG v4G 4+vG 4GvH v4gG 4Gv5 v4>G v4GH5 gv>4G 4GvQ +G4Q v4ZG gGZ4 v4pG p",
+"4>G Zpv4G y4G #3F &3F #3FB &3aF 3F#. &38F 3F.#B 8a&3F 3F#K 3F&K #3TF &3TF #",
+"3jF j3&F Tj#3F &3sF 3(#F &3+F 3BF#( +a&3F 3F.#( +8&3F #(F.B3 8a&+3F 3FK#( +",
+"&3FK T#3(F +T&3F j#3(F &j3+F j#3T(F s+&3F G#3 G&3 H#G3 G3H& #3G. 8&G3 GH#3.",
+" G8H&3 #3GK &3GK T#G3 G3T& j#G3 G3&j GTj#3 G&s3 d#G3 +3G& GHd#3 G&g3 Gd#3. ",
+"d&3G8 Hd#G3. gG8&3 Gd#3K d&3GK GTd#3 gGT&3 dj#G3 d&jG3 GT#dj3 gsG&3 4#F 4&F",
+" #B4F a&4F 5#4F 4F5& 45#FB 48a&F #F4K &F4K T#4F 4FT& j#4F 4F&j 4T5#F 4&sF ;",
+"#4F 4F;& 4;#FB a;&4F 45;#F 4&>F 5;#4FB >&4aF 4;#FK ;&F4K 4T;#F 4+T&F ;j#4F ",
+">&4jF 4T#;jF s>4&F 4G# 4G& GH4# Ga4& 4#G5 G54& 4GH5# 4G8H& G#4K 4KG& 4#GT G",
+"T4& 4#Gj G&4j 4GT5# 4Gs& 4#G; +G4& 4GHd# 4Gg& 4G5d# 4G>& G5H4d# g>4G& 4Gd#K",
+" 4+G&K 4GTd# g4GT& 4Gjd# >G4&j dj#4GT gs4G& 3F#N 3F&N 3FN#B a&3FN 3F.#N 8&3",
+"FN .B3#FN a&38FN #3QF &3QF QT#3F Qa&3F Qj#3F &j3QF Tj#Q3F sQ&3F 3FN#( +&3FN",
+" #BF3(N a&3+FN #3FN.( 8&3+FN 3F#N.B( 3F&N+8a Q#3(F +Q&3F T#3Q(F Q&3+TF j#3Q",
+"(F +Q3&jF 3(jFQT# +Q&s3F W#G3 G3W& GHW#3 GaW&3 GW#3. G8W&3 HW#G3. H8WG&3 Q#",
+"G3 G3Q& G#Z3 G&Z3 GQj#3 GQ8&3 ZGj#3 Z&Gs3 GWd#3 d&3GW HWdG#3 gGW&3 Wd#G3. G",
+"8Wd&3 W#H3Gd. G8Wg&3 GQd#3 +GQ&3 ZGd#3 Z&Gg3 GQ#dj3 d&3GQ8 dj#ZG3 gsGZ&3 m#",
+"4F 4Fm& 4m#FB am&4F 45m#F m&F48 5m#4FB 48am&F Q#4F 4FQ& 4QT#F 4Qa&F 4#pF 4&",
+"pF p4T#F p&4sF 4m;#F m&F4+ m;#4FB 4+am&F 5m;4#F >m4&F 5B4Fm;# am&>F4 4Q;#F ",
+"4+Q&F Q;#4TF a;F4Q& p4;#F p>4&F 4T;p#F s>4p&F 4#Gm Gm4& 4GHW# 4GaW& 4G5W# 4",
+"G8W& G5H4W# G5a4W& 4#GQ GQ4& 4GZ# 4GZ& 4Gp# 4Gp& Zp4G# Zp&4G 4Gv# 4Gv& v4GH",
+"# gv4G& v4G5# v>4G& 4GHv5# v>Gg4& v4GQ# v&4GQ Zv4G# Zv&4G pv4G# pv&4G pvGZ4",
+"# 4Gy& I3 I3! DI3 aI3 I3. 8I3 I3D. D38I I3K !KI3 TI3 T3aI Ij3 83Ij D3Ij sI3",
+" I3( +I3 I3D( +3aI 3(I. +38I DI3(. +D8I3 3(IK I3+K I3T( +3TI j3I( +3Ij Ij3D",
+"( +Is3 GI3 I3G! J3 Ja3 I3G. G38I J3. J83 I3GK GI3!K JT3 TaJ3 G3Ij Ij3G8 Jj3",
+" sJ3 Id3 +3Id Jd3 gJ3 d3I. 83Id d3J. g3J8 I3dK Id3+K TdJ3 JTg3 I3dj Idj+3 d",
+"jJ3 g3sJ 4I 4I! 4DI 4aI 4I5 48I 5D4I 5a4I 4IK IK4! 4TI TI4a 4Ij 8I4j 5T4I s",
+"4I 4I; 4+I D;4I +D4I 45I; >I4 4D5I; 4D>I 4KI; 4K+I T;4I +T4I I;4j 4I>j I;j4",
+"D >Is4 4GI GI4! J4 J4a G54I G84I J45 J48 GI4K 4GI!K J4T 4TJa Gj4I 4G8Ij J4j",
+" sJ4 4Id +G4I J4d gJ4 5I4d 4G>I 4dJ5 J>4 4KId 4+GIK 4TJ; gTJ4 Id4j >I4Gj 4d",
+"Jj g4sJ I3N !3IN I3DN I3aN N.I3 IN83 DI3N. D8I3N QI3 I3Q! Q3TI Q3aI Q3Ij Q3",
+"8I Ij3QD QIs3 3(IN I3+N DI3(N +DI3N I3(N. +I83N I3(DN. D83+IN I3Q( +3QI QDI",
+"3( +QDI3 Ij3Q( +QI83 QD3Ij( sI+Q3 WI3 I3W! JW3 WaJ3 I3W. W38I W3J. W8J3 G3Q",
+"I GQI!3 ZJ3 JaZ3 W3Ij GQ8I3 Z3Jj s3ZJ W3Id +3WI WdJ3 JWg3 Id3W. +WI83 JWd3.",
+" gJW83 Q3Id +GQI3 JdZ3 g3ZJ IdjW3 +WIj3 ZJdj3 sJZg3 4Im 4!Im Dm4I am4I 45Im",
+" 8m4I 4D5Im 4D8Im 4QI Q!4I QD4I Qa4I pI4 48pI 4DpI pIs4 4mI; +m4I Im;4D 4+D",
+"Im Im;45 4I>m 4D5Im; >Dm4I Q;4I +Q4I 4QDI; 4+QTI 4Ip; p4>I pD4I; p>D4I 4WI ",
+"4!WI J4W 4WJa 5W4I W84I 4WJ5 4WJ8 GQ4I 4GQI! ZJ4 ZaJ4 4GpI pG48I Jp4 s4Jp v",
+"I4 4+vI Jv4 g4Jv 4Iv5 v4>I v4J5 v>J4 4QvI vI4+Q Z4Jv ZJg4 p4vI pvI>4 pvJ4 y",
+"J4 bI3 I&3 DIb3 cI3 I3b. b38I bDI3. 8Ic3 I3bK &3IK b3TI TIc3 b3Ij I3&j Ij3b",
+"T cIs3 I3b( b3+I bDI3( +Ic3 bI3(. I&3+8 DI3b(. c+8I3 bKI3( I&3+K bTI3( c+TI",
+"3 Ij3b( I&j+3 bT3Ij( sI+c3 bG3 b3G& Jb3 cJ3 G3b. b3G8 b3J. c3J8 G3bK I&3GK ",
+"bTJ3 JTc3 b3Gj I&jG3 bjJ3 s3cJ b3Id b3+G bdJ3 g3cJ Id3b. b+G83 Jbd3. cJ8g3 ",
+"Id3bK b+G3K JbTd3 cJTg3 Idjb3 Idj&3 Jjbd3 sJgc3 4bI 4I& bD4I c4I b54I b84I ",
+"4b5DI 48cI bK4I 4KI& bT4I 4TcI bj4I I&4j 4bT5I c4sI b;4I b+4I 4bDI; 4+cI 4b",
+"5I; 4b>I b5D4I; >Ic4 I;K4b I;&4K 4bTI; c4+TI I;j4b >I4bj 4bTI;j c>s4I 4bG b",
+"G4& J4b cJ4 b54G bG48 4bJ5 J4c5 4KbG 4bG&K 4bJT cTJ4 bG4j I&j4G 4bJj cJs4 b",
+"G4d b+4G 4bJ; cJg4 4bG5d 4b>G J4b5d c4J> 4bGdK 4b+GK J4bTd cJ4gT Idj4b >bG4",
+"j J4jbd J>sc4 I3bN &3IN bDI3N I3cN bI3N. I&38N DI3bN. c8I3N b3QI Q3I& bQDI3",
+" QIc3 Ij3bQ I&jQ3 bQDIj3 sIQc3 bI3(N I&3+N DI3b(N c+I3N I3(bN. +I3b8N 3(INb",
+"D. +I8c3N bQI3( b+QI3 QI3bT( cQ+I3 bQ3Ij( Ij3b+Q Qjb3TI( cQ+sI3 b3WI W3I& b",
+"WJ3 JWc3 bGW3. bG8W3 JbW3. cJW83 b3GQ bGQ&3 JbZ3 Z3cJ bGQj3 I&jW3 ZJbj3 sJZ",
+"c3 Id3bW b+GW3 JbWd3 cJWg3 bW3Id. Id3bW8 bWdJ3. gJ8cW3 bGQd3 b+GQ3 ZJbd3 Zc",
+"Jg3 Id3bWj Id3bQ8 JjdZb3 ZcgsJ3 bm4I Im4& 4bDIm 4Icm 4b5Im Im&48 b5D4Im c45",
+"Im bQ4I QI4& 4bQTI 4QcI 4bpI 4Ip& pb4TI pIc4 Im;4b Im&4+ 4bDIm; c4+Im 4b5Im",
+"; >I4bm Imb;4D5 c>4Im 4bQI; I;&4Q bQ;4TI c4Q+I pb4I; p>b4I 4bTpI; cp>4I bG4",
+"W WI4& 4bJm J4cW 4bG5W 4bGW8 J4b5W cJ45W bG4Q 4bGQ& J4Zb cJZ4 4bpG pbG48 pb",
+"J4 c4Jp 4bvI 4Iv& vbJ4 c4Jv vb4G5 v>b4G Jv4b5 cvJ>4 vb4GQ vI&4Q ZJ4vb cvZJ4",
+" pvb4G pvI4& Jpv4b cJy4 6F 6!F 6FB 6aF 61F 68F 1F6B 6F1a 6FK !K6F 6TF Ta6F ",
+"6jF 8j6F 6F1T s6F 6(F 6+F (B6F +a6F 1(6F 6F1+ 61(FB 6+1aF (F6K +F6K T(6F 6F",
+"+T j(6F 6F+j 6T1(F 6+sF 6G 6G! 6GH 6Ga 6G1 6G8 1G6H 1G6a 6GK GK6! 6GT GT6a ",
+"6Gj G86j 1G6T s6G 6Gd 6+G GH6d g6G 1G6d 1+6G 6G1Hd 6Gg1 Gd6K 6K+G GT6d 6GgT",
+" Gj6d +G6j 6GT1d sGg6 46F 4F6! 6F4B 4F6a 7F 78F 7BF 7aF 6F4K 6!4FK 4F6T 4T6",
+"aF 7jF 8j7F 7TF 7sF 6;F 4F6+ ;F6B 6Fa; 7;F 7>F ;F7B >F7a ;F6K 4+6FK 6FT; 4+",
+"T6F ;j7F 7j>F T;7F >F7s 4G6 6!4G 6G4H 6G4a 7G 7G8 7GH 7Ga 4K6G 4G6!K 6G4T 4",
+"GT6a 7Gj G87j 7GT 7sG 6G; 6+4G G;6H 4Gg6 7Gd 7>G G;7H g7G 6KG; 4+G6K GT6; g",
+"46GT G;7j >j7G GT7d sGg7 6FN !F6N NB6F aF6N 1F6N 8F6N 61FNB 68aFN 6QF 6FQ! ",
+"QT6F 6FQa 6F1Q 6FQ8 6Q1TF 6QsF (F6N +F6N 6(FNB 6+aFN 61(FN 6+1FN 1(F6NB 1+F",
+"6aN Q(6F 6F+Q 6QT(F 6+QTF 6Q1(F 6+Q1F 1Q(6TF s6+QF 6GW W!6G GH6W Ga6W 1G6W ",
+"G86W 6G1HW 6G8Wa 6GQ Q!6G Z6G 6GZa 1G6Q GQ68 6GZ1 Z6sG GW6d +G6W 6GHWd 6GgW",
+" 6G1Wd 6+G1W 1GH6Wd g61GW GQ6d +G6Q 6GZd gGZ6 6GQ1d 6+G1Q Z61Gd gZ6sG 6mF m",
+"F6! mF6B 6Fam 7mF 8m7F mF7B am7F 4F6Q 4Q6!F 6FTm 4Qa6F 7pF p87F pT7F sF7p m",
+";6F 6F+m 6m;FB 6+maF m;7F 7m>F 7Bm;F 7>amF 6FQ; 4+Q6F 6Q;TF 6+TmF p;7F >F7p",
+" 7pT;F 7p>sF 6Gm 6!Gm Gm6H Ga6m 7GW G87W Gm7H Ga7W 6G4Q 4GQ6! 4GZ6 Z46Ga 7p",
+"G 78pG 7ZG sG7Z v6G 6+vG 6GvH gGv6 7vG v>7G vG7H 7Ggv 6GvQ v6+GQ ZGv6 Zv6gG",
+" pv7G p>7G 7GZv y7G 69F 6&F 9F6B 6F9a 916F :6F 691FB 6a:F 9F6K &F6K 6F9T 6F",
+"T& 6F9j 6j:F 6T91F :6sF 9(6F 6F9+ 69(FB 6+9aF 691(F 6+:F 91(6FB :6+aF 69(FK",
+" 6+9FK 6T9(F 6+T9F 6j9(F :6+jF 9T(6jF s:6+F 6G9 6G& 9G6H 9G6a 691G :G6 6G91",
+"H 6G:H 6K9G 6KG& 9G6T GT6& 9G6j 6G:j 6GT9j :Gs6 9G6d 9+6G 6G9Hd 6Gg9 6G91d ",
+"6+:G 9G16Hd :Gg6 6G9dK 6+G9K 6GT9d g69GT 6Gj9d :G6+j 9GT6dj g:s6G 49F 4F6& ",
+"9F4B 4F9a 79F 7:F 9F7B :a7F 9F4K 49&FK 4F9T 49TaF 9j7F :j7F 9T7F sF7: 4F9; ",
+"4F9+ 49;FB 49+aF 9;7F >F7: 7B9;F 7:>aF 49;FK 49+FK 49T;F 49+TF 79;jF 7:>jF ",
+"7T9;F 7s:>F 49G 6G4& 9G4H 9G4a 7G9 7:G 9G7H :G7H 4K9G 49G&K 9G4T 49GT& 9G7j",
+" 7j:G 9G7T 7:sG 9G4d 9+4G 49GH; 49gG 9G7d :>7G 7G9H; 7Gg: 49GdK 49+GK 49GTd",
+" g49GT 7G9dj 7:G>j 7GT9d 7sGg: 9F6N &F6N 69FNB 6a9FN 691FN 6F:N 91F6NB :6aF",
+"N 6F9Q 6FQ& 6Q9TF 6Qa9F 6Q91F 6Q:F 9Q16TF :Q6sF 69(FN 6+9FN 9(F6NB 9+F6aN 9",
+"1(6FN :6+FN 916N(BF 6+a:FN 6Q9(F 6+Q9F 9Q(6TF 6+F9Qa 9Q(6jF :Q6+F QT1(69F s",
+"6+:QF 9G6W G&6W 6G9HW 6Ga9W 6G91W 6G:W 9G16HW :G6Wa 9G6Q GQ6& 6GZ9 6GZ& 6GQ",
+"9j 6G:Q Z691G :GZ6 6G9Wd 6+G9W 9GH6Wd g69GW 9G16Wd :G6+W 691HGWd g:6GW 6GQ9",
+"d 6+G9Q Z69Gd Z6&gG 9GQ6dj :GQ6+ 6GjZ9d Z:g6G 4F9m 6Fm& 49mFB 49amF 9m7F 7F",
+":m 7B9mF 7:amF 4F9Q 49Q&F 49QTF 49QaF 7Fp9 7F:p 7p9TF 7sp:F 49m;F 49+mF 9mF",
+"6;B amF49+ 79m;F 7:>mF 9m;7BF :>m7aF 49Q;F 49+QF 4QF9T; a;F49Q 7p9;F 7p>:F ",
+"p9;7TF :p>7sF 9G4W Gm6& 49GHm 49GWa 9G7W :G7W 7G9Hm 7:GHm 9G4Q 49GQ& 49ZG Z",
+"49Ga p97G 7G:p Z97G 7GZ: 49vG 6Gv& v69GH gv69G v97G 7G:v 7v9GH :vGg7 v69GQ ",
+"v6&GQ Zv69G Zv6G& 7pGv9 :vG7p 7Zv9G 7:yG 6I 6I! 6DI 6aI 6I1 68I 1D6I 1a6I 6",
+"IK IK6! 6TI TI6a 6Ij 8I6j 1T6I s6I 6I( 6+I DI6( +D6I 6(1I 1+6I 6D1I( 6+D1I ",
+"I(6K 6K+I 6(TI +T6I 6(Ij +I6j 6DjI( 6+sI 6GI GI6! J6 J6a 1G6I G86I J61 J68 ",
+"GI6K 6GI!K J6T 6TJa Gj6I 6G8Ij J6j sJ6 6Id +G6I J6d gJ6 1I6d 8I6d 6dJ1 J6g1",
+" 6KId 6+GIK 6TJd gTJ6 Id6j Idj6+ 6dJj g6sJ 4I6 6!4I 6D4I 6a4I 7I 7I8 7DI 7a",
+"I 4K6I 4I6!K 6T4I 4TI6a 7Ij 8I7j 7TI 7sI 6I; 6+4I D;6I aI6; 7I; 7>I D;7I >D",
+"7I 6KI; 4+I6K TI6; 4+T6I I;7j >j7I TI7; 7>sI 6G4I 4G6I! J46 4aJ6 7GI G87I 7",
+"J 7J8 4G6IK 6GK4I! 4TJ6 J46Ta Gj7I 7G8Ij 7JT 7Js 6I4d 4+G6I J6; J4g6 7Id >G",
+"7I 7Jd g7J 4Id6K I;K6+G 6TJ; gJ46T Id7j 7>GIj J;7T sJg7 6IN IN6! DI6N 6NaI ",
+"6N1I 6N8I 6D1IN 6D8IN 6QI Q!6I QD6I Qa6I 1Q6I Q86I 6QD1I 6QsI I(6N 6N+I 6DI",
+"(N 6+DIN 6I1(N 6+I1N 1D(6IN 6+N1aI 6(QI +Q6I 6QDI( 6+QTI 6QI1( 6+Q1I Ij(6QD",
+" s6I+Q 6WI 6!WI J6W 6WJa 1W6I W86I 6WJ1 6WJ8 GQ6I 6GQI! ZJ6 ZaJ6 WI6j 6GQ8I",
+" J6Z1 ZJs6 WI6d +W6I 6WJd gWJ6 6WI1d 6+W1I J61Wd gJ61W QI6d 6+GQI ZdJ6 ZJg6",
+" Idj6W 6+WIj ZJ61d sJ6gZ 6Im 6!Im Dm6I aI6m 7Im 8I7m Dm7I aI7m 6Q4I 4QI6! T",
+"I6m 4Qa6I 7pI 78pI pD7I 7psI Im6; +I6m 6DmI; 6+DIm Im7; >m7I 7DIm; 7>DIm QI",
+"6; 4+Q6I 6QDI; 6+TIm 7;pI p>7I 7pDI; 7sIp> 6W4I 4WI6! J6m 6aJm 7WI W87I 7JW",
+" J87W 4GQ6I Im!6GQ J4Z6 ZJ46a pG7I 7pG8I 7ZJ sJ7Z v6I 6+vI Jv6 g6Jv 7vI v>7",
+"I 7Jv 7vJ> 6QvI v6I+Q Z6Jv Jv6gZ pv7I 7vIp> 7vJp yJ7 b6I 6I& 9D6I c6I 6Ib1 ",
+":I6 b61DI c6:I bK6I 6KI& 6IbT 6TcI 6Ibj 6I:j b6T1I :Is6 b(6I 6Ib+ b6DI( 6+c",
+"I b61I( 6+:I 6DIb1( :c6+I b6I(K b6+IK b6TI( c6+TI b6jI( :I6+j Ij(b6T s:I6+ ",
+"b6G 6&bG J6b cJ6 6Gb1 b6:G b6J1 :J6 bK6G b6G&K b6JT cTJ6 6Gbj :Gb6j b6Jj s6",
+":J 6Gbd 6+bG b6Jd cJg6 b6G1d 6I:d J6b1d g6:J b6GdK b6+GK J6bTd cJ6gT Idjb6 ",
+":Id6j J6jbd sJ6g: 49I 6I4& 9D4I 49cI 7bI 7:I 9D7I 7cI 4K9I 49I&K 9T4I c46TI",
+" bj7I 7j:I bT7I sI7c 6Ib; 9+4I 49DI; 6Ic; b;7I :>7I 7bDI; 7Ic> 49I;K I;&6K ",
+"49TI; c6;TI 7bI;j 7:I>j 7bTI; 7sIc> b64G 4bG6& J49 J4c6 7bG :G7b 7Jb 7J: 4b",
+"G6K I&K49G 49JT cJ46T bG7j 7:Gbj J97T sJ7c 6Gb; I;&6G 49J; J4g9 bG7d :I7d J",
+"97d :Jg7 49IdK IdK49+ J49Td cJ6T; 7bGdj 7:Idj 7JbTd g7Js: bN6I 6NI& b6DIN 6",
+"IcN b61IN 6I:N 6DIb1N :c6IN 6IbQ QI6& b6QTI 6QcI b6Q1I 6Q:I 6QIb1T :cQ6I b6",
+"I(N b6+IN 9D(6IN c6+IN 6I(b1N :I6+N b(6D1IN c6+:IN b6QI( b6+QI bQ(6TI c6Q+I",
+" Ij(b6Q :QI6+ b(6Q1TI sI+c6Q 6GbW WI6& b6JW J6cW b6G1W 6W:I J6b1W J6:W 6GbQ",
+" b6GQ& J6Zb cJZ6 b6G1Q :GQb6 ZJ6b1 Z6:J b6GWd b6+WI J6bWd cJ6gW 6WIb1d :WI6",
+"+ b6WJ1d :Jg6W b6GQd b6+GQ ZJ6bd Zc6gJ b6WIdj :QI6d ZbdJ6j Z:Jg6 6Ibm Im6& ",
+"49DIm 6Icm bm7I :m7I 7bDIm cm7I 9Q4I Im&6Q 49QTI c4Q6I pb7I 7I:p 7pbTI 7Icp",
+" 49Im; Im&6+ 9Dm6I; c6m+I 7bIm; 7:I>m 9Dm7I; 7c>Im 49QI; I;&6Q 6QIbT; c6QI;",
+" 7pbI; :pI7> 7D;p9I 7cp>I 6Gbm Im&6G 49Jm J6cm bG7W :W7I J97W 7W:J 4bG6Q b6",
+"G4Q& J4Z9 Zc4J6 pb7G :pG7b 7bJp Z:7J 49vI 6Iv& vbJ6 c6Jv vb7G 7I:v 7bJv :v7",
+"J vb6GQ v6IQ& Jv6Zb cv6ZJ 7vbpG :vI7p Jp97v 7Jy: 3FL 3F!L 3FLB 3FaL FL3. 3F",
+"8L 3L.FB 8a3FL M3F !3MF M3TF M3aF j3MF M38F TMj3F M3sF (F3L 3F+L 3FL(B +a3F",
+"L 3L.(F +83FL (BL3F. 8a3+FL 3(MF M3+F TM3(F aM3+F Mj3(F +M83F Mj3T(F s+M3F ",
+"G3L !3GL H3GL a3GL 3LG. 83GL GH3L. G8H3L GM3 M3G! G3HM G3aM MjG3 G38M GTMj3",
+" GMs3 d3GL G3+L GHd3L G3gL Gd3L. +G83L Hd3GL. gG83L G3dM +3GM dM3GT GMg3 dM",
+"jG3 +GM83 GTMdj3 gsGM3 4FL !F4L LB4F aF4L 5F4L 8F4L 45FLB 48aFL 4MF MF4! TM",
+"4F 4FaM 4F5M 4F8M 4T5MF 4MsF ;F4L +F4L 4;FLB a;F4L 45;FL 4F>L 5;F4LB >F4aL ",
+"4FM; 4F+M M;F4T aM;4F M;F4j 4M>F 4T5M;F >Ms4F 4GL GL4! GH4L 4LGa 4LG5 4LG8 ",
+"4GH5L 4G8HL 4GM 4!GM GT4M Ga4M G54M G84M 4GT5M 4GsM 4LG; 4L+G 4GHdL 4GgL 4G",
+"5dL 4G>L G5H4dL g>4GL GM4d +G4M 4GTdM 4GgM 4GM5d 4G>M G5T4dM >Mg4G FL3N 3FN",
+"!L 3FNLB a3FLN 3L.FN 83FLN .BL3FN a3F8LN M3QF Q!M3F QTM3F aM3QF QMj3F Q8M3F",
+" TMjQ3F sQM3F 3FN(L +3FLN (BL3FN a3F+LN N.(3FL 83F+LN (FLBN.3 3L+N8aF QM3(F",
+" +QM3F TM3Q(F +Q3aMF Mj3Q(F Q83+MF 3(MFQTj +QMs3F W3GL W!G3L GHW3L GaW3L GW",
+"3L. G8W3L HW3GL. W83GaL G3WM GQM!3 GMZ3 ZGaM3 GQMj3 GQ8M3 ZGMj3 sZGM3 GWd3L",
+" +GW3L HWdG3L gGW3L Wd3GL. G83+WL W3HLGd. G8Wg3L dM3GQ +GQM3 ZGdM3 gZGM3 GQ",
+"Mdj3 dM3GQ8 dMjZG3 sZGgM3 mF4L 4mF!L 4mFLB amF4L 45mFL 48mFL 5mF4LB 48FamL ",
+"4FMm MmF4! MmF4T aMm4F 4MpF p48MF p4TMF sp4MF 4m;FL 4+mFL m;F4LB 4+FamL 5m;",
+"4FL >m4FL mL4B5;F amF>L4 MmF4; 4+QMF 4QTM;F aMF4+Q p4M;F >Mp4F M;Fp4T sp4>M",
+"F 4LGm 4GW!L 4GHWL 4GaWL 4G5WL 4G8WL G5H4WL amL4G8 GQ4M 4GQM! 4GZM Z4GaM 4G",
+"pM pG48M Zp4GM sZ4GM 4GvL v4+GL v4GHL gv4GL v4G5L v>4GL 4GHv5L g4Lv>G 4GvM ",
+"vM4+G Zv4GM gZ4GM pv4GM >Mv4G pvGZ4M 4GyM 3F#L 3F&L 3FL#B a&3FL 3L.#F 8&3FL",
+" #L.3BF a&38FL #3MF &3MF TM#3F aM3&F Mj#3F M&38F Mj#T3F sM&3F 3FL#( +&3FL #",
+"3(LBF a&3+FL #(F3L. 8&3+FL (FLB#3. 3F+L8a& M#3(F M&3+F M#3T(F +T3M&F j#3M(F",
+" +M3&jF 3(MFTj# M&3s+F #3GL &3GL GH#3L Ga&3L G#3L. G8&3L H#3GL. H83G&L M#G3",
+" G3M& GTM#3 GT&M3 GMj#3 G8M&3 HM#Gj3 sGM&3 Gd#3L d&3GL Hd#G3L gG&3L d#3GL. ",
+"G83d&L H#G3dL. G8&g3L dM#G3 dM&G3 GT#dM3 gMG&3 GM#dj3 dM3G&j dMGjH#3 sG&gM3",
+" #F4L &F4L 4#FLB 4a&FL 45#FL 48&FL 5B#4FL 5aF4&L M#4F 4FM& 4TM#F 4T&MF 4M5#",
+"F 48M&F 5T#4MF s4M&F 4;#FL ;&F4L ;#F4LB 4aF;&L 5;#4FL >&4FL 5#4L;FB 4a&>FL ",
+"M;#4F M;&4F 4T#M;F a;F4M& 4M#;jF >M4&F 5FM;4T# s4&>MF G#4L 4LG& 4GH#L 4Ga&L",
+" 4G5#L 4G8&L G5#4HL 4GLH5& 4#GM GM4& 4GTM# 4GTM& 4GM5# 4G8M& 4G#H5M s4GM& 4",
+"Gd#L 4+G&L G;#4HL g4G&L G5#4dL >G4&L HL5d4G# >G&g4L 4GMd# dM&4G dM#4GT g4MG",
+"& dM#4Gj >MG4& 5#dM4GT >M&s4G 3FN#L &3FLN #LN3BF &3FaLN #LN3F. &3F8LN 3LNB#",
+"F. 3F&N8aL QM#3F M&3QF TM#Q3F Qa3M&F Mj#Q3F Q83M&F TMQj#3F M&3sQF #(L3FN &3",
+"F+LN (FLB#3N 3L+Na&F 3F#LN.( 3L+N8&F (BN.3F#L 8a+F3L&N M#3Q(F +Q3M&F 3(MFQT",
+"# Q3aM+&F 3(MFQj# j3+FQ&M TjQ#3(MF M&s3+QF GW#3L G&W3L HW#G3L Wa3G&L W#3GL.",
+" W83G&L W3HLG#. HLW&G83 GQM#3 GQ&M3 ZGM#3 Z&GM3 WM#Gj3 M&3GQ8 GMjZ#3 sGMZ&3",
+" Wd#G3L G&3+WL W3HLGd# G&Wg3L W3GLd#. GW+38&L 3LH.WdG# GWg38&L GQ#dM3 dM3GQ",
+"& dM#ZG3 gMGZ&3 Q#G3dMj W38M+G& dMZjG#3 sGgZM&3 4m#FL m&F4L m#F4LB 4aFm&L 5",
+"m#4FL 48Fm&L mL4B5#F am5&4FL Mm#4F Mm&4F 4T#MmF aMF4Q& p4M#F p&4MF 4TMp#F s",
+"4Mp&F m;#4FL 4+Fm&L mL4B;#F a;4&mFL 5#4Lm;F m&F>L4 LB;F5m4# am>&4FL 4Q#M;F ",
+"M;F4Q& Q#M;4TF MmT&4+F M;#p4F p&4>MF M;p#4TF >&s4pMF 4GW#L 4G&WL Gm#4HL amL",
+"4G& G5#4WL m&L4G8 W#4LG5H HL5&4GW 4GQM# Mm&4G Z4GM# Z4&GM pG4M# pG&4M pGMZ4",
+"# Z4MpG& v4G#L v&4GL 4GHv#L v&Gg4L 4G5v#L >G4v&L 45v#GHL >&g4vGL vM4G# vM&4",
+"G vMGZ4# Z4GvM& vM4pG# >M4pG& ZGvMp4# y&4GM UI3 I3U! DIU3 U3aI I3U. U38I UD",
+"I3. U8ID3 IM3 I!M3 VI3 aIV3 U3Ij 83IM IjV3 VIs3 I3U( U3+I UDI3( U+DI3 UI3(.",
+" U+8I3 DI3U(. +DIU83 M3I( +3IM I3V( +IV3 IM3j( U+jI3 VIj3( sIV+3 UG3 G3U! J",
+"U3 UaJ3 G3U. U3G8 U3J. U8J3 U3GM IM3G! VJ3 VaJ3 U3Gj UG8M3 VjJ3 s3VJ U3Id U",
+"3+G UdJ3 JUg3 Id3U. U+G83 JUd3. gJU83 I3dM IdM+3 J3Vd g3VJ IdMj3 IdM83 JjVd",
+"3 gVJs3 4UI U!4I UD4I Ua4I U54I U84I 4U5DI 4U8aI 4IM 4!IM V4I 4aVI Uj4I 8I4",
+"M 4IV5 V4sI U;4I U+4I 4UDI; 4U+aI 4U5I; 4U>I U5D4I; >I4Ua I;4M +I4M 4IV; 4+",
+"VI IM;4j 4I>M V45I; >IV4 4UG 4!UG J4U 4UJa U54G UG48 4UJ5 4UJ8 UG4M 4UGM! J",
+"4V JaV4 UG4j 4UG8M V4J5 VJs4 UG4d U+4G 4UJ; J4gU 4UG5d 4U>G J4U5d >UJ4 Id4M",
+" IdM4+ V4J; J4gV IdM4j >MG4U J4V5d J4V> I3UN U!I3N UDI3N UaI3N UI3N. U8I3N ",
+"DI3UN. 8I3UaN U3QI IM3Q! QIV3 VQaI3 IM3Qj UQ8I3 VQIj3 sIVQ3 UI3(N U+I3N DI3",
+"U(N +I3UaN I3(UN. +I3U8N D3UNI(. +3UND8I IM3Q( U+QI3 VQI3( V+QI3 UQ3Ij( Ij3",
+"U+Q Ij3VQ( V+QsI3 U3WI UGW!3 UWJ3 JUWa3 UGW3. UG8W3 JUW3. J8UW3 U3GQ UGQ!3 ",
+"Z3VJ ZJVa3 UGQj3 UGQ83 ZJVj3 sJZV3 Id3UW U+GW3 JUWd3 gJUW3 UW3Id. Id3UW8 UW",
+"dJ3. gUWJ83 IdMW3 U+GQ3 ZJVd3 gVZJ3 Id3UWj Id3UQ8 VZdJj3 sJZgV3 Um4I Im!4U ",
+"4UDIm 4UaIm 4U5Im 4U8Im U5D4Im U8m4aI UQ4I IMm4! 4QVI V4QaI 4UpI pU48I pIV4",
+" Vps4I Im;4U 4U+Im 4UDIm; U+m4aI 4U5Im; >I4Um ImU;4D5 4Ua>Im IMm4; IMm4+ V4",
+"QI; V4+QI pU4I; >MIp4 Vp4I; V>p4I UG4W 4UGW! 4UJm J4UWa 4UG5W 4UGW8 J4U5W J",
+"48UW UG4Q 4UGQ! VZJ4 ZJ4Va 4UpG pUG48 J4Vp JpVs4 4UvI vU4+G vUJ4 Jvg4U vU4G",
+"5 v>U4G Jv4U5 J>v4U 4IvM vIM4+ J4Vv VvJg4 pvU4G >Mv4I JpVv4 J4yV UIb3 U3I& ",
+"bUDI3 UIc3 bUI3. I&3U8 UDIb3. cU8I3 b3IM I3M& bIV3 VIc3 IM3bj IM&83 VbIj3 s",
+"IVc3 bUI3( I&3U+ UDIb3( cU+I3 UI3b(. U+8I&3 3(U.bDI U+8cI3 IM3b( IM&+3 VbI3",
+"( Vc+I3 bM3Ij( IM3b+j Ij3Vb( Vc+sI3 b3UG U3G& bUJ3 JUc3 bGU3. bG8U3 JbU3. c",
+"JU83 b3GM IM&G3 VbJ3 c3VJ bGMj3 bG8M3 JjVb3 sJVc3 Id3bU b+GU3 JbUd3 cJUg3 U",
+"G3bd. I&3U8d bdUJ3. gcUJ83 IdMb3 IdM&3 VJbd3 gVJc3 IM3bdj Id3b8M VdbJj3 sJc",
+"gV3 bU4I U&4I 4bUDI 4UcI 4bU5I 4b8UI b5U4DI c4U5I bM4I IM4& 4bVI cIV4 4bM5I",
+" IM&48 V4b5I c4VsI 4bUI; I;&4U b;U4DI c4U+I b5U4I; >I4U& 45b;UDI c>4UI IM;4",
+"b IM;4& V4bI; c4V+I 4bMI;j >Mb4I I;jV4b V>c4I bG4U UG4& 4bJU cUJ4 4bGU5 4bG",
+"U8 J4bU5 cJ4U5 bG4M IM&4G JbV4 VJc4 4bGUj 4bG8M J4Vb5 sJ4Vc 4bGUd 4b+UG J4b",
+"Ud cJ4gU bG54Ud >bG4U 4bdJ5U J>c4U IdM4b IdM4& J4Vbd gV4cJ 4bMIdj >Mb4G J4b",
+"V5d J>Vc4 bUI3N I&3UN UDIb3N cUI3N UI3bN. U83I&N D3UNbI. U8Ic3N IM3bQ IM&Q3",
+" VbQI3 cQVI3 bQUIj3 IM3bQ8 Ij3VbQ cQVsI3 UI3b(N U+3I&N D3UNbI( U+Ic3N 3(U.b",
+"IN b3U+8IN UDb.3(IN UIc3+8N bQ3IM( IM3b+Q bQIV3( V+IcQ3 Qjb3IM( b3+Q8IM IjV",
+"3bQ( s+cQVI3 bGUW3 UG&W3 JbUW3 cJUW3 UG3bW. I&3UW8 bWUJ3. J8UcW3 bGQU3 IM&W",
+"3 ZJVb3 ZcJV3 IM3bWj IM3bW8 JjVZb3 ZcVsJ3 bWUId3 Id3UW& bWUJd3 gJUcW3 Wdb3U",
+"G. b3+GUW8 W3J.bdU gWJ8cU3 Id3bWM Id3UQ& VJdZb3 ZcJgV3 IdWjbM3 +WUjI&3 djJ3",
+"ZbV g3sJZcV 4bUIm Im&4U bmU4DI c4UIm b5U4Im 4U8Im& 45bmUDI 4U8cmI IMm4b IMm",
+"4& V4bQI c4VQI pb4IM pU&4I Vp4bI cpV4I 4bUIm; 4U+Im& Imb;4UD 4U+cmI Imb;4U5",
+" Im&>U4 bU4I5mD; c4U>Im 4bQIM; 4b+IMm 4bQV;I c4IV+m IM;pb4 >I4pU& pbIV4; V>",
+"4cpI 4bGUW 4UGW& J4bUW cJ4UW bG54UW bG84UW 4bWJ5U c4UJ8m 4bGUQ IM&4W ZJ4Vb ",
+"Zc4VJ pbG4U pUG4& JpV4b cpJV4 vb4UG vU&4G Jv4bU cvJ4U 4bGvU5 >I4vU& vb4J5U ",
+"J>4cvU vbM4G vIM4& VvJ4b cvVJ4 pb4vIM >I4vbM Vv4Jpb yJVc4 6kF kF6! kF6B 6Fa",
+"k 1k6F 6F8k 61kFB akF68 6MF MF6! 6FTk 6FaM l6F 68lF 6TlF sFl6 k(6F 6F+k 6k(",
+"FB akF6+ 61k(F 6+1kF 1k(6FB 6+1akF M(6F 6F+M 6Tk(F 6+TkF 6(lF 6+lF l6T(F ls",
+"6+F 6Gk 6!Gk Gk6H Gk6a 61Gk Gk68 6G1Hk 6G8Hk 6GM 6!GM GT6M Ga6M lG6 6Gl8 6G",
+"lH s6lG Gk6d +k6G 6GHdk 6Ggk 6G1dk 6+G8k 1GH6dk g61Gk GM6d +G6M 6GTdk 6GgM ",
+"6Gld 6+lG lG6Td g6lG 4kF kF4! kF4B 4Fak 7kF 8k7F kF7B ak7F 4F6M 4kM!F 4FTk ",
+"4TkaF 7lF 78lF lF7T sF7l 4Fk; 4F+k k;F4B ak;4F k;7F 7k>F 7Bk;F 7>akF 6FM; 4",
+"+kMF 4Tk;F aM;6F 7;lF >F7l 7lT;F l>7sF 4Gk 4!Gk Gk4H Ga4k 7Gk G87k Gk7H Ga7",
+"k 6G4M 4GkM! GT4k 4GTak lG7 l87G 7GlH lG7s Gk4d +G4k 4GkH; 4Ggk Gk7d 7G>k 7",
+"GHdk 7Ggk GM6; 4+G6M 4GTdk g4kGT 7Gld 7>lG 7GTld lGg7 kF6N 6!kFN 6kFNB akF6",
+"N 61kFN 68kFN 1kF6NB 68FakN 6FQk 6Qk!F 6QTkF 6QakF 6QlF l6Q8F l6QTF ls6QF 6",
+"k(FN 6+kFN k(F6NB 6+FakN 1k(6FN +kF68N 1k6(NBF 6F1+akN 6Qk(F 6+QkF Qk(6TF a",
+"kF6+Q l6Q(F l+6QF 6QTl(F s6Ql+F Gk6W 6GWk! 6GHWk 6GaWk 6G1Wk 6G8Wk 1GH6Wk G",
+"8k6Wa GQ6M 6GQM! 6GZk Z6Gak 6GlW lG6W8 Z6lG lZs6G 6GWdk 6+GWk GkH6Wd g6GWk ",
+"1GW6dk +Gk6W8 61GkHWd 6G8gkW 6GQdk 6+GWM Z6Gdk gZ6Gk lG6Qd l+G6W lZ6Gd glZ6",
+"G 4Fkm kmF6! kmF4B akm4F km7F 78kmF 7BkmF 7akmF 4FQk 4Qk!F 4QkTF aMm6F lF7p",
+" 7lp8F 7lpTF 7slpF km;4F 4+kmF 6mFk;B akF6+m 7km;F 7>mkF km;7BF >km7aF 4Qk;",
+"F 4+QkF kmF6T; akF4+Q 7lp;F l>p7F l;p7TF 7spl>F Gk4W 4GkW! 4GkHm akm4G Gk7W",
+" 7GW8k 7GHWk 7GaWk GQ4k 4GQk! 4GZk Z4kGa 7plG 7pGl8 lG7Z 7sGlZ 4Gvk v6+Gk v",
+"6GHk gv6Gk vk7G 7>Gvk 7vGHk g7vGk 6GvM v6M+G Zv6Gk Z4kgG lG7v l>G7v lvZ7G l",
+"Gy7 9k6F 6Fk& 69kFB akF6& 691kF 6k:F 91k6FB :6akF 6F9M 6FM& 6T9kF 6T&kF 69l",
+"F :6lF l69TF ls:6F 69k(F k&F6+ 9k(6FB 6+9akF 91k6(F :6+kF 916k(BF akF:6+ 6M",
+"9(F 6+M9F 9T(6MF k&F6+T l69(F l:6+F 6T9l(F s:6l+F 69Gk Gk6& 6G9Hk 6Gak& 6G9",
+"1k 6G:k 9G16Hk :G6Hk 9G6M GM6& 6GT9M 6GTk& 6Gl9 l6:G lG69H lsG:6 6G9dk dk&6",
+"G 9GH6dk g69Gk 9G16dk :G6+k 691HGkd g:6Gk 6GM9d dM&6G 9GT6dM g6M9G lG69d l:",
+"G6+ 6GTld9 gl:6G 9k4F 4Fk& 49kFB 49akF 9k7F :k7F 7B9kF 7:akF 4F9M 49M&F 49T",
+"kF 49aMF lF79 lF7: 7l9TF 7sl:F k;F49 k;&4F 49Fk;B akF49+ 79k;F 7:>kF k;F7B9",
+" :>F7ak 49M;F M;&6F k;F49T aMF49+ 7l9;F l>7:F l;97TF 7s:l>F 9G4k Gk4& 49GHk",
+" 49Gak 9G7k 7k:G 7G9Hk 7:GHk 9G4M 49GM& 49GHM 49GaM l97G 7:lG 7GTl9 7sGl: 4",
+"9Gdk dk&4G 9G;4Hk g49Gk 7G9dk 7:G>k 9G;7Hk g7:Gk 49GdM M;&6G 9GT4dk g49GM l",
+"G79d l>G7: 7G9lH; gl7:G 69kFN k&F6N 9kF6NB 6aFk&N 91k6FN :6kFN 916kNBF akF:",
+"6N 6Q9kF 6Q&kF 9QT6MF akF6Q& l69QF :Q6lF 6Q9lTF ls6:QF 9k(6FN 6+Fk&N 9k6(NB",
+"F ak6&+FN 916k(FN 6+k:FN NB1F9k6( ak:F6+N 9Q(6MF k&F6+Q QT6F9M( 6F+Q9aM 6Q9",
+"l(F l+6:QF 69l(QTF l6:Qs+F 6G9Wk 6G&Wk 9GH6Wk Gak6W& 9G16Wk :G6Wk 691HGkW 6",
+"Ga:Wk 6GQ9M 6GQk& Z69Gk Z6&Gk lG69W :GQl6 lZ69G Z:l6G 9GW6dk +Gk6W& 69HkGWd",
+" 6G&gkW 691WGkd 6+G:Wk GH1d69Wk g6G:Wk 9GQ6dM 6GQdk& 6GMZ9d Z6Gg9M 6GQld9 :",
+"G6l+W lG6Z9d Z:6glG kmF49 km&4F 49FkmB akF6m& 79kmF 7:kmF kmF7B9 :mk7aF 49Q",
+"kF Mm&6F kmF49T akF49Q 7lp9F :pl7F p9l7TF :pl7sF 49mk;F kmF49+ km6;9FB ak6m",
+";&F km;79F :mk7>F km7B9;F ak:m7>F k;F49Q k;F4Q& Tk9;4QF aM9m4+F l;97pF :p7l",
+">F l97Tp;F >F7s:pl 49GWk km&4G 9Gm4Hk 49Gakm 7G9Wk 7:GWk 9Gm7Hk 7Gk:Hm 49GW",
+"M Mm&6G Z49Gk Z4kG& 7pGl9 :pG7l 7Zl9G 7Z:lG v69Gk v6&Gk 49GvkH g4Gvk& 7v9Gk",
+" :vG7k v9G7Hk g7G:vk v6M9G v6MG& Z4Gv9M Z4Gg9M lv79G lv:7G 7Z9lvG yl7:G 6UI",
+" 6!Ik Dk6I Ua6I 1U6I U86I 6U1DI 6U8aI 6IM 6!IM V6I 6aVI lI6 68lI V6lI s6lI ",
+"6(Ik U+6I Ik(6D 6U+aI Ik(61 6U+1I 6D1Ik( 1U+6aI 6(IM +I6M 6IV( 6+VI 6Il( 6+",
+"lI Vl6I( lsI6+ 6UG 6!UG J6U 6UJa 1U6G UG68 6UJ1 6UJ8 UG6M 6UGM! J6V JaV6 6U",
+"lG lG6U8 lJ6 s6lJ UG6d U+6G 6UJd J6gU Idk61 Idk68 J61Ud gJ61U Id6M IdM6+ Vd",
+"J6 J6gV 6Ild l+G6U J6ld g6lJ 4Ik 4!Ik Dk4I aI4k 7UI U87I Dk7I Ua7I 6I4M 4Ik",
+"M! 4IV6 V46aI lI7 l87I 7VI lI7s U;6I +I4k Ik;4D ak;4I U;7I 7I>k 7UDI; 7>UaI",
+" IM6; IM;6+ 6IV; V4+6I 7Il; 7>lI V;7I 7IV> 6U4G 4UG6! J4k 4aJk 7UG UG78 7JU",
+" J87U 4UG6M Ik!4GM V4J6 J4V6a 7UlG 7UGl8 7Jl sJ7V UG6; Idk4+ 4dJk J4gk UG7d",
+" >U7G Jk7d >k7J Idk4M 4+kIdM V6J; gV4J6 7Ild l>G7U ld7J 7Jgl 6NIk IkN6! IkN",
+"6D 6UaIN IkN61 6U8IN 6D1IkN akN68I UQ6I 6UQI! 6QVI V6QaI 6QlI lI6Q8 Vl6QI l",
+"sI6Q Ik(6N 6U+IN 6D(IkN akN6+I 1U(6IN 6UN1+I 6(1UDIN 6NU+1aI 6UQI( 6U+QI V6",
+"QI( V6+QI lI6Q( l+I6Q V6QlI( sIQV6+ UG6W 6UGW! 6UJW J6WUa 6UG1W 6UGW8 J61UW",
+" J68UW UG6Q 6UGQ! J6Zk ZJ6Va 6WlI lWI68 Z6lJ lJZs6 Idk6W 6U+WI J6WUd gJ6UW ",
+"1UW6Id 6W8Idk 6UWJ1d J6Wg1U Idk6Q 6U+GQ ZJ6Vd gV6ZJ lWI6d l+W6I lJZ6d glJZ6",
+" Um6I Ikm6! Ikm4D akm4I Um7I 7U8Im 7UDIm 7UaIm QI4k IMm6! 6IVm V6maI 7plI 7",
+"pU8I 7IVp 7sIVp Ikm6; Ikm4+ 6DmIk; 4+DIkm 7UIm; 7>UIm Ikm7D; >Im7Ua Ik;4Q I",
+"Mm6+ V6mI; V6+Im 7pUI; l>I7p 7VpI; 7V>pI UG6m 4WIk! 4WJk J4kWa UG7W 7UGW8 J",
+"k7W 7JUW8 IMm6G Ik!4GQ J4Zk ZJ4ak 7WlI 7pUG8 Jp7V Jpl7s 4Ivk v6U+G v6Jk Jv6",
+"gU vU7G 7vU>G 7UJv J>k7v 6IvM v6I+M J6Vv Vv6gJ lI7v lvI7> 7Jlv 7Jyl t6I 6It",
+"& 6DtI tIc6 6It1 t6:I t61DI t:c6I 6ItM IM6& tIV6 cIV6 t6lI l6:I ltV6I u6I 6",
+"It( 6+tI t6DI( tc6+I t61I( t:6+I 6D1tI( :c6t+I t6IM( t+6IM Vt6I( t+V6I lt6I",
+"( lt+6I Vt6lI( 6+uI tG6 6Gt& tJ6 c6tJ 6Gt1 t6:G t6J1 J6t: 6GtM tG6M& VtJ6 V",
+"Jc6 l6tG t:Gl6 J6lt uJ6 6Gtd 6+tG J6td g6tJ tG61d t:G6+ tJ61d gtJ:6 tG6dM t",
+"+G6M tdVJ6 gV6tJ ltG6d t+Gl6 lJt6d gJu6 t4I 4It& 4DtI tIc4 7tI 7It: tD7I 7I",
+"tc 4ItM t4IM& tIV4 tc4VI lI7t 7:lI Vt7I u7I 4It; 4+tI t4DI; tc4+I 7It; 7It>",
+" 7tDI; t>7cI t4IM; t4+IM t4VI; t4V+I 7tlI; l>I7t 7VtI; 7>uI t4G 4Gt& tJ4 cJ",
+"t4 7tG 7:tG 7Jt tJ7c 4GtM t4GM& VJt4 tJ4Vc lG7t 7tGl: tJ7V uJ7 4Gtd 4+tG J4",
+"td g4tJ 7Gtd 7>tG td7J 7Jgt t4GdM t4+GM tJ4Vd gt4VJ 7tGld t>G7l lJ;7t g7uJ ",
+"6ItN t6I&N t6DIN tc6IN t61IN t:6IN 6D1tIN :I6tcN 6QtI tQ6I& tQV6I tcQ6I tQ6",
+"lI t:Q6I Vl6tQI 6QuI t6I(N t+6IN 6DIt(N c6It+N 6I1t(N :I6t+N 61t(DIN t6:Ic+",
+"N tQ6I( t+Q6I V6ItQ( t+Ic6Q lI6tQ( t+6:QI l6tQVI( u6+QI 6GtW tG6W& J6tW tcW",
+"J6 tG61W t:G6W tJ61W :Jt6W 6GtQ tGQ6& Z6tJ Zc6tJ tGQl6 t:G6Q lJZt6 ZJu6 tG6",
+"Wd t+G6W tJ6Wd gtJ6W 6WItd1 t+6:WI J61tWd :J6gtW tGQ6d t+G6Q tZJ6d gtZJ6 tW",
+"6lId t+6:GQ tZ6lJd ug6ZJ 4Itm t4Im& t4DIm tc4Im 7Itm t:m7I 7tDIm 7ctIm 4QtI",
+" t4QI& t4VQI tc4QI 7Itp :pI7t tp7VI 7puI t4Im; t4+Im 6Dmt;I t+Ic6m 7tIm; t>",
+"7Im 7DItm; 7cIt>m t4QI; t4+QI tQIV6; t4IcQ; tp7I; tp>7I 7VItp; u7Ip> 4GtW t",
+"4GW& J4tW tJ4cW 7GtW 7tG:W tW7J 7Jt:W 4GtQ t4GQ& ZJt4 tZ4cJ 7ptG tpG7: 7JtZ",
+" 7ZuJ v6tG tv4+G t4Jv cv6tJ tG7v :vI7t 7Jtv g7tJv tv4GQ t4+GQ Vv6tJ cvVJ6 l",
+"vt7G :vI7l lvJ7t yJu7 <e <e! <eB a<e <e. 8<e e.<B a<8e <eK <!eK T<e a<Te <j",
+"e <j8e <jTe s<e <e* +<e <e*B a<+e e*<. 8<+e *B<e. +<a8e e*<K <e+K <eT* T<+e",
+" <e*j <j+e <jeT* +<se G< G<! G<H Ga< G<. G8< G.H< H8G< G<K <KG! GT< T<Ga G<",
+"j 8<Gj H<Gj sG< f< f+< fH< gf< f<. f8< H<f. f8g< f<K +<fK fT< fTg< fj< +<fj",
+" H<fj sf< 4e 4e! 4eB 4ae 4e5 48e 4B5e 5a4e 4eK eK4! 4Te Te4a 4ej 8e4j 5T4e ",
+"s4e =e =+e =Be =ae =5e >e= 5e=B =a>e =eK +e=K =Te +T=e =je =j>e 5T=e s=e 4G",
+"< 4!G< 4He Ga4e G5< G84e H54e H84e 4KG< 4G<!K GT4e 4GTa< G<4j 4G8<j He4j 4G",
+"s< f= f=+ =Hf g=f f=5 f>= f5=H f>g= f=K f+=K =Tf gf=T =jf =jf> f5=T sf= <eN",
+" <!eN eN<B <eaN eN<. <N8e <eN.B aeN8< Q<e <eQ! T<Qe a<Qe <jQe 8<Qe <jeQT Q<",
+"se e*<N <e+N *B<eN aeN+< <e*N. +<8eN <eN*B. +<8aeN <eQ* Q<+e Q<Te* +Q<Te <j",
+"eQ* +Q<8e Q<Tej* s<+Qe G<W W!G< W<He WaG< G.W< W8G< G<HW. G8<Wa GQ< Q!G< Z<",
+"G GaZ< W<Gj Q8G< G<Zj Z<sG fW< +Wf< H<fW fWg< W<f. W8f< fHW<. f8Wg< fQ< +Qf",
+"< Zf< g<Zf W<fj Q8f< fjZ< s<Zf 4em 4!em 4Bem am4e <m5e 8m4e <mB5e aem48 4Qe",
+" Q!4e Qe4T Qa4e p<e 48pe 4Tpe p<se =em +e=m em=B ae=m 5e=m =e>m =B5em >e=am",
+" =Qe +Q=e Qe=T Qa=e p=e >ep= pe=T sep= 4We 4!We H<Gm Wa4e 5W4e W84e 4He5W 4",
+"H8We GQ4e 4GQ<! Z4e 4aZe pG< G8p< pGZ< Z4se fv= =+fv fv=H fvg= v=f5 v>f= =H",
+"fv5 g=fv> =Qf =+fQ Z=f Zfg= fp= p=f> fpZ= yf= ,<e <&e <e,B <&ae <e,. <&8e ,",
+"<e.B <&e8a <e,K <Ke& ,<Te <&Te ,<ej e&<j <je,T <&se <e,* -<e *B<,e a<-e ,<e",
+"*. 8<-e ,<e*B. -8a<e ,<e*K <e-K ,T<e* T<-e <je,* <j-e ,T<ej* -<se ,G< G<& G",
+"<,H G<,a ,.G< G<,8 ,GH<. ,G8H< ,KG< GK<& G<,T T<G& G<,j <&Gj ,GT<j ,Gs< f<,",
+" f-< ,Hf< f-g< ,<f. -8f< fH<,. f-8g< ,<fK fK-< ,Tf< f<-T ,jf< f<-j fT<,j f-",
+"s< ,4e 4e& 4B,e 4e,a 4e,5 4e,8 ,45eB ,48ae ,K4e 4Ke& 4e,T Te4& 4e,j e&4j ,4",
+"T5e ,4se =e, -=e ,e=B -a=e ,5=e -=>e =B5,e >e-=a ,e=K -e=K ,T=e =e-T ,j=e =",
+"e-j =T5,e -=se ,4G 4&,G 4G,H 4G,a 4G,5 4G,8 ,4GH5 ,4GH8 ,K4G ,4G&K 4G,T ,4G",
+"T& 4G,j <&j4G ,4GHj ,4sG f=, f-= fH=, f-g= =,f5 ->f= =Hf,5 g=f-> f,=K =Kf- ",
+"=,fT f-=T =,fj f-=j =Hjf, f-s= <e,N <Ne& ,<eNB aeN<& ,<eN. <&e8N <eN,.B ,8<",
+"aeN ,<Qe <&Qe ,QT<e ,Qa<e <je,Q <&jQe ,QT<je s<Qe& ,<e*N <e-N ,<e*BN -a<eN ",
+"<e*,N. -8<eN ,<*BeN. aeN-8< ,Q<e* Q<-e Q<e,T* -QT<e ,Q<ej* -Q8<e QT,j<e* s-",
+"Q<e G<,W W<G& ,GHW< ,GaW< ,GW<. ,G8W< G<H,W. G8<,Wa G<,Q Q<G& ,GZ< G<Z& ,GQ",
+"<j <&jGQ Z<G,j Z<&sG ,Wf< f<-W fHW,< f-Wg< fW<,. f-W8< ,HWf<. gf8-W< ,Qf< f",
+"<-Q f<Z, f-Z< fQ<,j f-Q8< Zf<,j sfZ-< 4e,m em4& <mB,e aem,4 ,45em <m&5e ,45",
+"emB ,48aem 4e,Q Qe4& ,4QTe <m&Te ,4pe 4ep& p<T,e p<&se ,m=e =e-m =Be,m =a-e",
+"m =5e,m >e-=m emB=5, =a->em ,Q=e =e-Q =QT,e =Q-Te =ep, pe-= p=T,e -ps=e 4G,",
+"W We4& ,4GHm <m&Ga ,4G5W <m&G5 4He,5W 4G8,Hm 4G,Q <m&GQ ,4Ze 4eZ& ,4pG G<p&",
+" Zp<,G Zp<G& v,f= f=-v =Hfv, g=f-v fv=,5 f>-v= fv5=H, f>-g=v =,fQ f-=Q f=Z,",
+" f-Z= p,f= f-p= fpZ=, f-y= I< I<! D<I aI< I<. 8I< D.I< 8ID< I<K <!IK TI< aI",
+"T< I<j Ij8< I<Dj sI< I<* +I< I<D* D<+I <*I. 8I+< I<*D. +D<8I <*IK +KI< I<T*",
+" TI+< <jI* I<+j I<jD* +Is< G<I G!I< J< J<a G.I< 8IG< J<. J8< GKI< I<KG! J<T",
+" T<Ja I<Gj I<jG8 J<j sJ< fI< +If< Jf< gJ< I<f. 8If< f<J. J8g< I<fK f+I<K fT",
+"J< gTJ< I<fj f8I<j fjJ< g<sJ 4I< 4!I< 4De De4a 5I< 8I4e 5D4e D84e 4KI< I<K4",
+"! De4T 4DeTa I<4j I<j48 De4j 4Dse =I =I+ =DI =aI =I5 =I> 5D=I =D>e =IK +I=K",
+" =TI +T=I =Ij >I=j 5T=I s=I G<4I I<!4G J4< 4aJ< 5IG< 4G8I< J5< 48J< I<K4G 4",
+"GKI<! 4TJ< J4Ta< I<j4G 4G8I<j 4eJj J4s< =If f+=I J= J=g f5=I =If> J=5 J>= f",
+"I=K =If+K J=T =TgJ fj=I f>=Ij J=j s=J I<N <!IN DNI< aNI< <NI. IN8< I<ND. D8",
+"<IN QI< Q!I< D<QI aIQ< IjQ< 8IQ< I<jQD QIs< <*IN +NI< I<*DN +D<IN I<*N. +I<",
+"8N D<NI*. a*N8I< I<Q* QI+< QD<I* +QDI< I<jQ* I<j+Q QD<I*j sI<+Q WI< W!I< J<",
+"W WaJ< W.I< 8IW< W<J. W8J< QIG< GQ<I! ZJ< ZaJ< I<Wj I<jW8 JjZ< ZJs< WIf< WI",
+"+< fWJ< gWJ< fWI<. f8WI< JfW<. Jf8W< QIf< fQ+I< JfZ< ZJg< fQI<j fQ8I< ZJ<fj",
+" sJ<Zf I<m <!Im Dm4e I<am Im5< I<8m I<m5D I<m5a QI4e I<mQ! QD4e I<mQa pI< 8",
+"Ip< 4Dpe pIs< =Im +I=m De=m aI=m 5I=m >m=I =D5Im >eD=m =QI +Q=I QD=I Qa=I p",
+"=I p>=I pD=I sp=I WI4e I<mW! J<m a<Jm WI5< I<mG8 5WJ< 8<Jm I<mGQ I<!4GQ J4Z",
+"< ZJ4a< G<pI pG<8I Jp< s<Jp =Iv =+vI J=v Jvg= =5vI v>=I v=J5 v>J= fQ=I =Qf+",
+"I Z=J gZJ= =Ifp fp>=I Jp= yJ= h< h<& hD< hc< h<. h8< D<h. c<h8 h<K <&hK hT<",
+" c<hT hj< 8<hj D<hj hs< h<* h-< D<h* c<h- <*h. -8h< hD<*. c-8h< <*hK -<hK T",
+"<h* h<-T <jh* h<-j hT<*j s<h- hG< G<h& hJ< cJ< G<h. G8h< h.J< J8c< G<hK hG<",
+"&K J<hT cTJ< G<hj h8G<j J<hj s<hJ hf< h<f- J<hf i< f<h. h<f8 Jf<h. i8< f<hK",
+" f-<hK h<fT iT< h<fj f-jh< Jfjh< is< h4 h4& h4D hc4 h45 h48 4Dh5 c4h5 h4K 4",
+"&hK h4T c4hT h4j 48hj 4Dhj hs4 h= h=- h=D c=h h=5 h>= h5=D c=h> h=K =Kh- h=",
+"T hc=T h=j =jh> h5=T hs= h4G 4Gh& hJ4 cJh4 4Gh5 4Gh8 J4h5 J4h8 4GhK h4G&K J",
+"4hT cJ4hT 4Ghj h48Gj J4hj h4sJ h=f f-h= J=h i= f=h5 f>h= h5J= i>= =Khf h=f-",
+"K hJ=T i=T hf=j h=jf> hJ=j is= h<N <&hN D<hN hNc< <Nh. 8<hN hD<N. c<8hN hQ<",
+" Q<h& QDh< c<hQ Q<hj Q8h< hQD<j s<hQ <*hN -<hN hD<*N c-<hN h<*N. h-8<N D<*h",
+"N. h-8c<N Q<h* h<-Q hQD<* c-Qh< hQ<*j h-Q8< QD<hj* hs-Q< hW< W<h& J<hW c<hW",
+" W<h. W8h< J<Wh. cJ<W8 GQh< hWQ<& hZ< Z<hc W<hj hW8Q< Z<hj s<hZ fWh< h<-W J",
+"fWh< iW< hfW<. hf8W< hfWJ<. W8i< h<fQ f-Qh< Z<hf iZ< hfQ<j fQ8h< hZf<j sZi<",
+" h4m 4&hm 4Dhm c4hm 5<hm 48hm h45Dm c5<hm h4Q 4Qh& 4QhT c4hQ hp4 p<h8 pDh4 ",
+"h4cp h=m -=hm hm=D hmc= =5hm >=hm h=5Dm c=h>m h=Q h-=Q hQ=D hc=Q hp= h=-p =",
+"Dhp s=hp h4W 4Wh& J4hW c4hW 4Wh5 4Wh8 J5<hW cJ5W< 4GhQ h4WQ& hZ4 h4Zc pGh4 ",
+"hp4G8 h4Jp sZh4 hv= -vh= J=hv iv= v=h5 v>h= J=hv5 v>i= =Qhv h=Q-v hZ= iZ= h",
+"=fp fp-h= Z=hp yi= 6e 6e! 6eB 6ae 6e1 68e 6B1e 1a6e 6eK eK6! 6Te Te6a 6ej 8",
+"e6j 1T6e s6e 6e* 6+e *B6e +e6a 1e6* 1+6e 6e1*B 6+e1a e*6K 6K+e Te6* +T6e ej",
+"6* +e6j 6Te1* 6+se 6G< 6!G< 6He Ga6e 1G< G86e 1H6e Ga1< 6KG< 6G<!K GT6e 6GT",
+"a< G<6j 6G8<j GT1< 6Gs< f6 f6+ f6H gf6 f61 f68 6Hf1 f6g1 f6K 6+fK f6T fTg6 ",
+"f6j 6+fj 6Hfj sf6 4e6 6!4e 4B6e 6a4e 7e 7e8 7eB 7ae 4K6e 4e6!K 6T4e 4Te6a 7",
+"ej 8e7j 7Te 7se =6e 6+=e 6e=B 6a=e 7=e >e7 =B7e 7a>e 6e=K =6+eK 6T=e =T6+e ",
+"7e=j >j7e 7e=T >e7s 6G4e 4G6<! 6H4e 4Ga6e 7G< G87e 7He Ga7e 4G6<K 6GK4e! 4G",
+"T6e 6GT4ae G<7j 7G8<j GT7e 7Gs< f=6 =+f6 f6=H f=g6 7f 7f> 7fH g7f =Kf6 f=6+",
+"K f6=T g=f6T 7fj fj7> 7fT sf7 6eN eN6! eN6B 6Nae 6N1e 6N8e 6e1NB 68eaN 6Qe ",
+"Q!6e Qe6T Qa6e 1Q6e Q86e 6Qe1T 6Qse e*6N 6N+e 6e*NB 6+eaN 6e1*N 6+e1N 1eN6*",
+"B aeN68* Qe6* +Q6e 6QeT* 6+QTe 6Qe1* 6+Q1e 1Qe6T* s6e+Q 6We 6!We He6W Wa6e ",
+"1W6e W86e 6He1W 6H8We GQ6e 6GQ<! Z6e 6aZe GQ1< 6GQ8< 6eZ1 Z6se f6W 6+fW 6Hf",
+"W gWf6 6Wf1 6Wf8 f61HW f68gW f6Q 6+fQ Zf6 g6Zf 6Wfj 6Qf8 f6Z1 s6Zf 6em 6!em",
+" 6Bem ae6m 7em 8e7m em7B ae7m 6Q4e 4Qe6! Te6m aem6Q 7pe 78pe pe7T 7pse 6e=m",
+" +e6m =B6em =a6em =m7e >m7e 7=emB 7ae>m 6Q=e =Q6+e =Q6Te =Qa6e 7ep= 7p>e 7p",
+"e=T 7sep= 6W4e 4We6! He6m aem6G 7We W87e He7W Wa7e 4GQ6e <m!6GQ 4eZ6 Z4e6a ",
+"pG7e 7pG8< 7Ze se7Z fv6 f+v6 fHv6 fvg6 7fv f>7v fv7H gf7v f6=Q =Qf6+ fvZ6 Z",
+"f6g= 7fp 7pf> 7Zf y7f ?e ?e& ?Be ?ae ?1e ?:e 1e?B :e?a ?eK e&?K ?Te Te?a ?j",
+"e :e?j 1T?e s?e ?e* ?-e *B?e -a?e 1e?* :e?- ?B1e* ?:-ae e*?K -e?K Te?* ?e-T",
+" ej?* ?e-j ?T1e* ?-se ?G ?G& ?GH ?Ga ?G1 ?:G 1G?H :G?H ?GK G&?K ?GT GT?a ?G",
+"j :G?j 1G?T s?G ?f ?f- ?fH g?f ?f1 :f? f1?H :fg? ?fK ?Kf- ?fT ?Tgf ?fj ?j:f",
+" f1?T s?f ?4e 4e?& 4e?B 4a?e 7?e 7:e ?B7e 7e?a 4e?K ?4e&K 4T?e ?T4ae 7e?j 7",
+"j:e 7e?T 7?se ?=e =e?- ?B=e =e?a 7e?= Ae ?=7eB Aae ?e=K ?-=eK =e?T ?-T=e =e",
+"?j Aje ?T7=e Ase ?G4 4G?& 4G?H 4G?a ?G7 7:?G 7G?H 7G?a 4G?K ?G4&K 4G?T ?GT4",
+"a 7G?j ?:G7j 7G?T ?G7s ?f= f-?= =H?f ?fg= 7f? Af ?H7f Agf =K?f ?f-=K =T?f ?",
+"fTg= =j?f Afj ?T7f Asf ?eN e&?N eN?B ae?N 1e?N ?N:e ?B1eN ?:aeN ?Qe Qe?& Qe",
+"?T Qa?e 1Q?e :e?Q ?Q1Te ?Qse e*?N -e?N ?Be*N ?-aeN ?1e*N ?:-eN 1e*?BN :-e?a",
+"N Qe?* ?e-Q ?QTe* ?-QTe ?Q1e* ?:Q-e 1Qe?T* s?-Qe ?GW G&?W He?W Ga?W 1G?W :G",
+"?W ?G1HW ?:GWa ?GQ GQ?& ?ZG Ze?a 1G?Q :G?Q Z1?G sG?Z ?fW f-?W fH?W ?Wgf f1?",
+"W ?W:f ?f1HW g?:fW ?fQ f-?Q ?Zf ?fZ- f1?Q ?Q:f ?jZf ?Zsf ?me em?& em?B ae?m",
+" 7e?m :e?m ?m7eB ?:mae 4Q?e ?Q4e& Te?m ?Qa4e ?pe 7e:p pe?T se?p =e?m ?e-m ?",
+"=emB ?-mae ?=7em Aem 7=e?mB aeAm =e?Q ?-Q=e ?Tm=e ?-Tem pe?= Ape ?p=Te spAe",
+" ?Gm Gm?& Gm?H Ga?m 7G?W :G?m ?G7Hm ?:GHm 4G?Q ?GQ4& Z4?G ?Z4Ga ?pG ?G:p ?G",
+"7Z sG?p ?vf -v?f fv?H gf?v 7f?v Afv ?v7fH gfAv =Q?f ?fQ-v ?fZ= g?Zfv ?pf Ap",
+"f 7f?Z yAf 6I< 6!I< 6De De6a 1I< 8I6e 1D6e D86e 6KI< I<K6! De6T 6DeTa I<6j ",
+"I<j68 De6j 6Dse 6I* +I6e De6* +D6e 1I6* +I1< 6De1* 6+D1e 6KI* 6+I<K TI6* 6+",
+"DTe I*6j I<j6+ I*j6D 6Is* G<6I I<!6G J6< 6aJ< G<1I 6G8I< J1< 68J< I<K6G 6GK",
+"I<! 6TJ< J6Ta< I<j6G 6G8I<j 6eJj J6s< f6I 6+fI Jf6 Jfg6 6If1 68fI f6J1 J1g<",
+" 6IfK f6+IK fTJ6 Jf6gT 6Ifj f68Ij f6Jj Jfs6 6I4e I<!46 6D4e 4De6a 7I< 8I7e ",
+"7De D87e I<K46 6IK4e! 4De6T 6TI4ae I<7j 7I8<j De7T 7Dse =I6 6+=I 6D=I 6a=I ",
+"=I7 7>=I 7D=I 7D>e 6I=K =I6+K 6T=I =TI6+ 7I=j 7>I=j 7T=I =I7s 4G6I< 4G6I<! ",
+"4eJ6 J46a< G<7I 7G8I< 7J< J87e 4G6I<K 6!4GI<K J46T< 4TeJ6a 7GI<j I<j7G8 J<7",
+"T s<7J f6=I =If6+ J=6 g6J= 7fI 7If> 7Jf J>7f =If6K f6+=IK J6=T J=g6T fj7I 7",
+"f>Ij =T7J 7Jsf 6NI< I<N6! 6NDe 6DeaN 1NI< 68I<N 6De1N 6D8eN QI6e 6QI<! QD6e",
+" 6QDae QI1< 6Q8I< 6QD1e sI<6Q 6NI* 6+I<N 6De*N 6+DeN 6I*1N 68I*N I<N1D* a*N",
+"68I QI6* 6+QI< 6QDI* 6+QDe I*j6Q 6Q8I* 6QDI*j sI*6Q WI6e 6WI<! 6WJ< J6Wa< W",
+"I1< 6W8I< 1WJ< J68W< 6GQI< I<!6GQ J6Z< ZJ6a< I<j6W 6W8I<j J1Z< sJ6Z< 6WfI f",
+"6+WI JWf6 Jf6gW f61WI f68WI Jf61W Jf6W8 6QfI f6Q+I JfZ6 Zf6gJ f6Q1I f6Q8I Z",
+"f6J1 sf6ZJ I<6m I<m6! De6m aem6D I<7m 7I8<m De7m 7De8m I<m6Q Im!6Qe I<m6T 6",
+"QDaem pI7e 7pI8< pD7e 7sIp< 6I=m =I6+m =D6Im =aI6m =m7I 7>I=m 7De=m 7>Dem 6",
+"Q=I =QI6+ =QD6I =Qa6I 7p=I p=I7> p=D7I s=I7p I<m6G I<!6Gm 6eJm J6ma< WI7e 7",
+"WI8< J<7W 7JW8< 6GQI<m I<6mGQ! ZJ46e Z6aJ<m 7pGI< 7G8pI< Z<7J Jp<7s v6=I =I",
+"v6+ fvJ6 J=gv6 =I7v 7vIf> 7vJ= J>=7v =Qf6I =Q+v6I Z6J= Z=Jg6 7Ifp 7fp>I Z=7",
+"J 7Jyf h? h?& h?D ?ch h?1 h:? ?Dh1 ?ch: h?K ?Kh& h?T hT?c h?j ?:hj ?Dhj hs?",
+" h?* h?- h*?D h-?c ?1h* ?:h- ?D1h* h:?c- ?Kh* ?Kh- h*?T ?-hT h*?j ?-hj ?Djh",
+"* h?s- h?G h&?G ?J ?Jc ?Gh1 ?Gh: ?J1 ?J: ?KhG ?G&hK ?JT cJ?T ?Ghj ?:Ghj ?Jj",
+" s?J ?fh h-?f ?Jf i? h1?f ?fh: J1?f i?: ?Khf ?fh-K hT?f i?T hj?f ?fjh: Jf?j",
+" i?s h?4 ?4h& ?Dh4 h4?c 7h 7h: 7hD 7hc ?Kh4 h?4&K ?Th4 ?ch4T 7hj 7:hj 7hT h",
+"s7 h=? ?-h= h?=D ?ch= 7h= Ah =D7h Ahc =Kh? h=?-K h?=T c=?hT =j7h Ahj =T7h A",
+"hs ?Gh4 ?G4h& ?J4 c4?J 7hG 7Gh: ?J7 7c?J ?G4hK h4&?GK J4?T ?Jc4T 7Ghj 7h:Gj",
+" hT7J 7Jhs ?fh= h=?f- ?J= i?= 7hf Ahf 7f?J Ai h=?fK ?f-h=K =T?J =Ti? hj7f h",
+"fAj =j?J Ais h?N ?&hN hN?D hN?c ?1hN hN?: ?D1hN h:?cN h?Q h&?Q ?QhT hQ?c ?Q",
+"h1 ?:hQ ?QDh1 hQs? ?*hN hN?- ?D*hN ?ch-N h?1*N h:?-N h1*?DN ?c-h:N h*?Q ?-h",
+"Q ?QDh* ?cQh- h?Q1* h:Q?- ?Q*h1T hs?-Q h?W h&?W ?JW hW?c ?Wh1 ?:hW J1?W ?W:",
+"J ?GhQ ?GQh& hZ? ?chZ ?Whj h:W?Q h1?Z s?hZ hW?f ?-hW Jf?W i?W ?fh1W h:W?f ?",
+"Jf1W ?:iW hQ?f ?fQh- ?fhZ i?Z ?fQh1 :fQh? hZ?f1 s?iZ h?m h&?m ?Dhm hm?c 7hm",
+" ?:hm 7Dhm hm7c ?Qh4 h?Q4& ?Thm ?cQh4 hp? h:?p hT?p s?hp ?=hm ?-hm ?Dmh= c=",
+"?hm 7=hm Ahm 7h=Dm hcAm h?=Q h=Q?- h=Q?D c=Qh? h=?p Aph hp?=D hpAs ?Ghm ?Gm",
+"h& ?Jm cJ?m 7hW 7:hW hW7J hW7c ?GQh4 ?G&h4Q h4?Z hZ?c4 hW?p hp?:G hZ7 7Zhs ",
+"hv? h?-v ?Jv i?v hv7 Ahv 7Jhv Aiv hQ?v hv?-Q ?Zhv ?Ziv ?phv hpAf 7Zhv Aiy <",
+"eL <!eL eL<B <eaL eL<. <e8L <eL.B aeL8< <Me <!Me <MTe <Mae Me<j <M8e <MeTj ",
+"<Mse e*<L <e+L *B<eL aeL+< <e*L. +<8eL <eL*B. +<8aeL <eM* <M+e <MeT* aMe+< ",
+"<Me*j +<M8e T<Mej* s<+Me G<L <LG! GLH< GLa< <LG. GL8< G<HL. G8<HL G<M G!<M ",
+"H<GM a<GM <MGj 8<GM GT<Mj G<sM f<L +<fL H<fL f<gL <Lf. 8<fL fH<L. f8<gL fM<",
+" +<fM H<fM fMg< <Mfj 8<fM fT<Mj fMs< 4eL eL4! eL4B 4Lae 4L5e 4L8e 4e5LB 48e",
+"aL 4Me 4!Me Te4M aM4e 5M4e 8M4e 4Te5M 4Mse =eL +e=L eL=B ae=L 5e=L =e>L =B5",
+"eL >e=aL =Me +M=e Te=M aM=e 5M=e =M>e =T5Me se=M 4LG< 4G<!L 4LHe 4Ga<L GL5<",
+" 4G8<L 4He5L 4H8eL G<4M 4GM<! HM4e aMe4G 5<GM 4G8<M 4HM5e s4G<M f=L f+=L fH",
+"=L =Lgf =Lf5 >Lf= =Hf5L g=f>L =Mf =+fM fT=M gf=M f5=M =Mf> =HMf5 =Msf eL<N ",
+"<eL!N <eLNB aeL<N <eLN. 8<eLN eLN<.B 8<LaeN <MQe <MeQ! <MeQT aMeQ< <MeQj Q8",
+"<Me Q<TMej s<QMe <e*LN +<eLN <eL*BN +<LaeN e*L<N. 8<L+eN NB*L<e. a<+e8LN <M",
+"eQ* +Q<Me Q<TMe* +Q<aMe Q<Mej* Q8<+Me QMejT<* +Q<seM GLW< G<W!L G<HWL Ga<WL",
+" G<WL. G8<WL W<LHe. aeLW8< W<GM GQ<M! G<ZM Z<GaM GQ<Mj GQ8<M Z<GMj sZ<GM W<",
+"fL f+W<L fHW<L gfW<L fW<L. f8W<L H<WfL. g<Wf8L W<fM fQ+<M fMZ< Zfg<M fQ<Mj ",
+"fQ8<M Zf<Mj sfZ<M 4Lem <mLe! <mLeB aem4L <mL5e 48emL 5<LemB aeL8<m Qe4M <Mm",
+"e! <MmTe aMe4Q 4Mpe p<8Me p<TMe sp<Me em=L =+emL =BemL =aemL =5emL >e=mL em",
+"L=B5 =am>eL Qe=M =Q+Me =QTMe =QaMe pe=M p=>Me p=TMe s=pMe 4LWe 4We!L 4HeWL ",
+"4WaeL 4We5L 4W8eL <mLH5e aeL4W8 WM4e <MmG! 4MZe Z4eaM G<pM pG<8M Zp<GM Z4es",
+"M =Lfv fv=+L =HfvL g=fvL fv=5L f>v=L fv5=HL f>vg=L fv=M =Qf+M =MZf g=MZf =M",
+"fp fp>=M fpZ=M =Myf <e,L <Le& ,<eLB aeL<& ,<eL. <&e8L <eL,.B ,8<aeL ,<Me Me",
+"<& <Me,T aMe<& <Me,j <M&8e ,T<Mej s<Me& ,<e*L <e-L ,<e*BL -a<eL <e*,L. -8<e",
+"L ,<*BeL. aeL-8< <Me,* <M-e ,T<Me* -T<Me ,M<ej* -M8<e <M,jTe* s-<Me ,LG< GL",
+"<& ,GH<L ,Ga<L ,G<L. ,G8<L G<L,H. <&LH8e G<,M <MG& ,GT<M <M&GT ,GM<j <M&G8 ",
+"G<M,Hj sG<,M ,<fL -<fL fH<,L f-<gL f<,L. f-8<L ,H<fL. g-<f8L ,Mf< f<-M fT<,",
+"M f-T<M fM<,j f-M8< ,HMfj< sf-<M ,L4e 4Le& ,4eLB ,4aeL ,45eL ,48eL 4eL,5B a",
+"eL,48 4e,M Me4& ,4TMe aMe,4 ,4M5e <M&5e 4Te,5M s4e,M ,e=L -e=L =Be,L =a-eL ",
+"=5e,L >e-=L ,5e=BL =a->eL ,M=e =e-M =TM,e =T-Me =M5,e >M-=e ,5T=Me s=-Me ,L",
+"4G ,4G&L ,4GHL ,4GaL ,4G5L ,4G8L ,4LH5e <&LG5a 4G,M <M&4G ,4GHM Me&4H ,4G5M",
+" <M&G5 4GT,5M s4G,M f,=L =Lf- =Hf,L g=f-L f=5,L f>-=L f5,=HL f>-g=L =,fM f-",
+"=M =HMf, g=Mf- =Mf,5 f>M-= =H,f5M sf=-M ,<eLN <&eLN <eL,NB <&LaeN <eL,N. 8<",
+"Le&N .B,L<eN a<8e,LN <Me,Q <M&Qe ,QT<Me Qa<Me& ,Q<Mej Q8<Me& QMej,T< <M&seQ",
+" <e*,LN -<eLN NB*L,<e aeL-<N N.*L,<e 8<e-LN <e,.NB*L ae-L8<N ,Q<Me* -Q<Me Q",
+"TM*,<e aMe-Q< QMej,<* Q8<-Me T*,M<jQe -Q<seM ,GW<L G<&WL G<H,WL aeLW<& G<L,",
+"W. <&LW8e WL,.G<H WLa<,G8 ,GQ<M <M&GQ Z<G,M Z<&GM G<M,Wj GQ8<M& ,GMZ<j s<MZ",
+"e& fW<,L f-W<L ,HWf<L gf<-WL ,W<fL. -W<f8L ,<fLHW. gWf8-<L fQ<,M f-Q<M Zf<,",
+"M Z-f<M ,WMfj< f8<-WM fM<Z,j Z-<sfM <mL,e <m&eL ,4LemB aeL<m& ,45emL <mL5e&",
+" 5L<m,eB a<8me&L <Mm,e <Mme& ,4TMem <M&aem p<M,e p<&Me ,4TpeM s<Mpe& =em,L ",
+"-=emL emL=B, -me=aL emL=5, -=m>eL 5m=L,eB >m=a-eL =QM,e =Q-Me Mem=T, =Te-Mm",
+" p=M,e -p=Me peT=M, s=M-pe ,4GWL <m&GL emL,4H aeL,4W <mL,G5 <mL,G8 ,L4GH5W ",
+"4G,8amL <Mm,G <MmG& Z4e,M Z4eM& pG<,M pG<M& Z4MpG, s<MpG& fv=,L -vf=L fv,=H",
+"L -vfg=L v=,f5L -v=f>L =,f5vHL >Lg=-vf =Qf,M -vMf= Z=f,M Z-=fM fp=,M fp-=M ",
+"Z=Mfp, yf-=M U<I U!I< D<Ue aIU< U.I< 8IU< I<.UD U8<De I<M <!IM V<I aIV< I<U",
+"j I<8M I<Vj V<sI I<U* +IU< I<*UD U+<De I<*U. U+<8I U<DI*. +D<U8e <MI* I<+M ",
+"I<V* +IV< I<M*j I<M+j V<I*j sI<V+ UG< U!G< J<U UaJ< U.G< G8U< U<J. U8J< GMU",
+"< I<MG! J<V JaV< G<Uj I<MG8 V<Jj VJs< fU< U+f< fUJ< J<gU U<f. U8f< JfU<. Jf",
+"8U< U<fM fU+<M Vf< g<Vf U<fj fU8<M V<fj s<Vf 4Ue 4!Ue Ue4D Ua4e U54e U84e 4",
+"Ue5D 4U8De Ue4M I<M4! V4e 4aVe Ue4j I<M48 4eV5 V4se =UI U+=I Ue=D Ua=I U5=I",
+" =U>e =U5De >eU=D =IM +I=M V=I V+=I Ue=j =I>M V5=I >eV= UG4e 4UG<! 4UJ< J4U",
+"a< G5U< 4UG8< U5J< J48U< I<M4G I<!4GM V4J< J4Va< I<MG5 4G8I<M V5J< sJ4V< =U",
+"f =+fU J=U =UgJ f5=U =Uf> J5=U =UJ> fU=M =Uf+M J=V gVJ= fU=j f>U=M =jVf Vfs",
+"= UNI< I<NU! I<NUD Ua<IN I<NU. U8<IN D<NUe. aeNU8< QIU< I<MQ! QIV< V<QaI I<",
+"MQj I<MQ8 V<QIj sI<VQ I<*UN U+<IN U<DI*N aeNU+< U<NI*. I<NU8* I<U*DN. UN+<D",
+"8e I<MQ* I<M+Q V<QI* V+<QI UQ<I*j U+QI<j I<jV*Q sIQV+< G<UW UG<W! UWJ< J<UW",
+"a UG<W. UG8W< J<UW. J8<UW GQU< I<MW! VZJ< ZJ<Va I<MWj I<MW8 ZJ<Vj sJ<VZ UWf",
+"< fU+W< JfUW< gJ<UW fUW<. fU8W< fUWJ<. J8WgU< UQf< fUQ+< Z<Vf VfZg< fUQ<j f",
+"UQ8< VfZ<j sfVZ< Um4e I<mU! I<mUD aem4U I<mU5 I<mU8 5D<Uem 4U8aem UQ4e I<Mm",
+"! 4QVe V4eQa 4Upe pU<8I pIV< Vp<sI Ue=m =U+Im =UDIm =UaIm =U5Im >eU=m U5e=D",
+"m >Im=Ua UQ=I =UQ+I Ve=Q V=+QI pU=I p=U>e =IVp V>ep= UW4e 4UWe! U<Jm J<mUa ",
+"4UW5e 4UW8e J5<UW J8<Um I<M4W I<!4WM V4Ze Z4Vae UGp< pUG8< J<Vp Jp<Vs fv=U ",
+"=Ufv+ =UJv J=gvU =Ufv5 f>Uv= J=vU5 J>=vU fU=Q =Uf+Q VfZ= J=VgZ =Ufp fpU>= V",
+"=Jp J=yV hU< U<h& U<hD hUc< U<h. U8h< hUD<. c<Uh8 hM< <Mh& Vh< c<Vh U<hj 8<",
+"hM V<hj s<Vh U<h* h<-U hUD<* c-Uh< hU<*. -U8h< U<Dh*. hc8-U< <Mh* h<-M h<V*",
+" V<h- hM<*j -Ujh< Vh<*j V-hs< UGh< G<U& hUJ< cUJ< hUG<. h8UG< J<Uh. cJ<U8 G",
+"<hM hMG<& J<Vh VJc< hMG<j h8MG< VhJ<j sJ<Vh h<fU f<-U JfUh< iU< fU<h. f-U8<",
+" hJ<fU. U8i< h<fM f-U<M V<hf iV< fUjh< f-U<j Vfh<j s<iV h4U 4Uh& 4UhD hUc4 ",
+"4Uh5 4Uh8 h4U5D c5<hU h4M 4Mh& Vh4 c4Vh 4Uhj 48hM V4h5 s4Vh h=U h-=U hU=D h",
+"c=U h5=U =Uh> h=U5D c=h>U h=M h-=M V=h h=V- h5=M >Mh= =jVh V=hs 4UhG h4UG& ",
+"hUJ4 cJ4hU h4UG5 h48UG J5<hU cJ5U< 4GhM h4MG& J4Vh Vh4cJ h4MG5 h48GM Vh4J5 ",
+"hs4VJ hf=U f-=U hJ=U i=U h=fU5 f>Uh= J=hU5 =Ui> hf=M h=Mf- h=Vf iV= h=Mf5 h",
+">Mf= J=Vh5 s=iV U<hN hU<&N hUD<N c<UhN hU<N. h8U<N U<DhN. h8Uc<N UQh< hQU<&",
+" V<hQ VhcQ< hQU<j hQ8U< VhQ<j hsVQ< hU<*N -U<hN U<Dh*N hc<-UN U<*hN. h8<-UN",
+" UDhN<*. hUc<-8N hQU<* -UQh< VhQ<* V-hQ< UQ<hj* -U<hQ8 hQ<V*j hsQV-< UWh< h",
+"WU<& J<UhW cJ<UW hWU<. hW8U< hWUJ<. cWUJ8< W<hM hWM<& Z<Vh Zc<Vh hWM<j hW8<",
+"M hZV<j hZsV< fUWh< f-UW< hJWfU< UWi< hW<fU. fU<hW8 hUJ<fW. iUW8< fUQh< f-U",
+"Q< VfZh< Z<iV fU<hWj fU<-Wj hZ<Vfj iZVs< 4Uhm h4Um& h4UDm c<mhU h4U5m h48Um",
+" U5<hmD c4Uh8m 4UhQ h4QU& V4hQ Vh4cQ pUh4 hp4U8 h4Vp cp<Vh hm=U h=-Um h=UDm",
+" c=hUm h=U5m h>=Um h5U=Dm h>Uc=m hQ=U h=Q-U =QVh c=VhQ =Uhp -pUh= V=hp cp=V",
+"h 4UhW h4WU& J<mhU cJ<Um h4WU5 h4WU8 J4Uh5W c4Uh5W 4WhM h4WM& Z4Vh hZ4Vc hp",
+"4UG pUG<& Jp<Vh cpJV< =Uhv -vUh= J=hvU =Uiv hv=U5 hv>=U hvUJ=5 iv>=U =Mhv h",
+"vM-= V=hZ Z=iV fpUh= fp-=U Jp=Vh yVi= 6ek 6!ke 6Bke ak6e <k1e 8k6e <kB1e ak",
+"e68 6Me 6!Me Tk6e aM6e l<e 68le 6Tle s6le ke6* +k6e <kBe* ake6+ ke*1< 6+e8k",
+" 6e1k*B 68eak* Me6* +M6e 6Tek* aMe6+ 6el* 6+le l<Te* ls<+e G<k G!<k H<Gk a<",
+"Gk Gk1< 8<Gk 6He1k 6H8ke G<6M 6GM<! HM6e aMe6G lG< G8l< 6Hle sGl< f6k 6+fk ",
+"6Hfk f6gk 1<fk 68fk f61Hk f68gk f6M 6+fM 6HfM f6gM lf6 f6l+ f6lH l<sf 4ke 4",
+"!ke 4Bke ak4e 7ek 8k7e ke7B ak7e 6M4e 4keM! Tk4e ake4T le7 l87e 7Tle le7s =",
+"ke +k=e ke=B ak=e 7e=k =k>e 7=ekB 7ae>k 6M=e =k+Me Tk=e =Tk+e l=e >el= le=T",
+" les= G<4k 4Gk<! Hk4e ake4G G<7k 7G8<k Hk7e 7Ga<k 4Gk<M <k!4GM 4GT<k 4GTake",
+" 7Gl< lG78< 7Hle 7sGl< =kf =+fk fk=H gf=k 7fk >k7f fk7H gk7f f6=M =kf+M fT=",
+"k g=kfT lf7 l>7f =Hlf g7lf 6Nke <kNe! <kNeB ake6N <kN1e 68ekN 1<NkeB akN68e",
+" Qk6e 6QeM! 6QeTk ake6Q 6Qle l<Q8e l<QTe ls<Qe <kNe* 6+ekN 6eNk*B akN6+e 6e",
+"1k*N <kN1+e <k1e*BN a<+k1eN 6Qek* 6+Qke Qke6T* 6+Qake l<Qe* l+<Qe 6Qel*T s<",
+"Ql+e W<Gk 6Wek! 6HeWk ake6W 6We1k 6W8ke H<k1We 6W8ake WM6e 6WMe! 6MZe Z6eak",
+" 6Wle lG<W8 Z6le lZ<sG 6Wfk f6+Wk f6HWk gf6Wk f61Wk f68Wk 1H<fkW f1Wg<k 6Wf",
+"M f6Q+k f6Zk Zf6gk f6lW lf6+W l<Zf glfZ6 ke6m <kme! <kmeB ake6m ke7m 7e8km ",
+"7ekmB 7aekm Qk4e Mem6! <kmTe ake4Q 7ple 7pel8 7pelT 7selp ke=m =k+em =kemB ",
+"=akem 7=ekm >k=em =km7eB 7am>ke Qk=e =Qk+e =QkTe =Qake lep= l>ep= l=pTe l=s",
+"pe Wk4e <kmG! <kmHe ake4W Wk7e 7We8k 7HeWk 7Wake <kmGQ <k!4GQ 4kZe Z4kae 7W",
+"le 7Wel8 le7Z 7Zels fv=k =kfv+ =Hkfv g=kfv fk7v f>k7v 7fvHk g7fvk fQ=k =Qf+",
+"k =kZf Z=kgf 7flv lfp7> 7Zlf lfy7 ?ke ke?& ke?B ak?e 1e?k ?k:e ?B1ke ?:ake ",
+"?Me Me?& Tk?e aM?e l?e ?:le ?Tle les? ke?* ?e-k ?Bke* ?-ake ?1ke* ?:-ke ke*",
+"?B1 :-k?ae Me?* ?e-M ?Tke* ?-Tke ?el* ?-le l?Te* l-?se ?Gk Gk?& Gk?H Ga?k 1",
+"G?k ?k:G ?G1Hk ?:GHk ?GM GM?& GT?M Ga?M l?G ?:lG ?GlH lGs? ?fk fk?- fk?H gk",
+"?f ?1fk fk?: ?f1Hk g?:fk ?fM f-?M fT?M gM?f lf? ?fl- lH?f lfg? 4k?e ke4& ?B",
+"4ke ?a4ke ?k7e 7k:e 7?keB ?a7ke 4M?e ?M4e& ?T4ke ?aM4e 7?le 7:le ?T7le 7sel",
+"? ?k=e =e-k ?=ekB =a?ke ?=7ke Ake 7ek?=B akAe =e?M ?-M=e =T?ke ?aM=e ?=le A",
+"le l=?Te lsAe 4G?k ?G4k& ?G4Hk ?Ga4k ?k7G ?:G7k ?G7Hk ?G7ak 4G?M ?GM4& ?GT4",
+"k ?Ga4M 7l?G l?G7: l?G7H s?G7l =k?f f-=k ?f=Hk g=k?f fk7? Afk 7f?Hk gfAk =M",
+"?f ?fM-= ?fT=k g?Mf= ?fl= Alf lf?=H glAf ke?N ke&?N ?BkeN ?akeN ?1keN ?:ekN",
+" keN?B1 :ek?aN Qk?e ?Qke& ?QTke ?Qake ?Qle ?:Qle l?QTe s?lQe ?ke*N ?-keN ke",
+"*?BN -ke?aN ke*?1N :ek?-N ke?B1*N ak:e?-N ?Qke* ?-Qke Qke?T* ?Qe-Tk l?Qe* l",
+"-?Qe leQ?T* s?Ql-e Gk?W ?GWk& ?GHWk ?GaWk ?G1Wk ?:GWk 1He?Wk ?Hk:We GQ?M ?G",
+"Qk& Zk?G ?ZGak ?GlW l?G:W lG?Z s?ZlG fk?W ?-Wfk ?fHWk g?fWk ?f1Wk :f?Wk f1H",
+"?Wk :fWg?k fQ?M ?fQ-k ?MZf g?Zfk lW?f lf?:W ?Zlf gl?Zf ke?m ?mke& ?mkeB ?am",
+"ke ?m7ke ?:mke 7ek?mB ?ak:em Me?m ?Mme& ?Tmke ?aMem le?p :pel? ?plTe s?ple ",
+"?=ekm ?-mke =ke?mB ?ae-km 7=e?mk keAm =B?m7ek Akmae ?Mm=e ?-Mem ?Qe=Tk ?Qe=",
+"ak l=?pe leAp ?pTl=e Apels Gk?m ?Gmk& ?GmHk ?Gakm ?G7Wk ?:Gkm ?Hk7We ?Gk7Wa",
+" GM?m ?GMm& ?Z4Gk ?GaMm lG?p ?pGl: ?Zl7G s?plG fk?v -vk?f ?vfHk g?vfk ?v7fk",
+" fvAk 7fH?vk Avkgf fv?M ?vMf- ?Zf=k g?vfM ?plf lfAp lv?Zf ylAf 6Ue 6!Ue Ue6",
+"D Ua6e 1U6e U86e 6Ue1D 6U8De Ue6M I<M6! V6e 6aVe lI< 8Il< V6le sIl< Ue6* U+",
+"6e Ik*6D ak*6I Ik*1< Ik*68 1Ue6D* 6D8Ik* IM6* I<M6+ 6IV* 6+Ve 6Il* +Il< lI<",
+"V* sI<l+ UG6e 6UG<! J<k a<Jk UG1< 6UG8< 1UJ< 8<Jk I<M6G I<!6GM V6J< J6Va< U",
+"Gl< lG<U8 lJ< l<sJ f6U 6Uf+ f6Jk J<gk 6Uf1 6Uf8 Jf61U Jf6U8 6UfM f6U+M Vf6 ",
+"g6Vf f6lI lf6U+ l<Vf l<gJ 6U4e 4Ue6! Dk4e ake4U 7Ue U87e Ue7D Ua7e I<M4k Ik",
+"!4Me 4kVe V4e6a 7Ule 7Uel8 7Ve se7V =Ik +I=k Dk=I aI=k 7U=I =I>k 7Ue=D 7>UD",
+"e 6I=M =Ik+M V6=I V=6+I l=I =Il> =I7V >e7V 4UG6e I<!4Gk 4kJ< J4ka< UG7e 7UG",
+"8< J<7U 7JU8< 4GkI<M 6!UG4Me J4V6e J4aV6e 7UGl< 7U8lG< l<7J lJ<7s f6=U =Uf6",
+"+ J=k =kgJ 7fU 7Uf> =U7J >kJ= =Uf6M =U+f6M =kVf J=Vg6 =Ulf lf7>U l=J 7Vsf 6",
+"NUe 6Ue!N 6UeDN 6UaeN 6Ue1N 6U8eN IkN1D< akN1I< UQ6e 6UQe! 6QVe V6eQa QIl< ",
+"lI<Q8 lI<VQ sI<lQ Ik*6N 6U+eN I<NDk* akN6I* I<N1U* I<N1U+ IkD*1<N Ua1*I<N I",
+"k*6Q 6U+Qe V6eQ* V6+Qe lI<Q* l+IQ< lIQV6* sIQl+< UW6e 6UWe! W<Jk J<kWa 6UW1",
+"e 6UW8e J1<UW J8<Wk I<M6W I<!6WM J<Zk ZJ<ak WIl< lWI8< ZJl< lJ<sZ 6UfW f6U+",
+"W Jf6UW gJ<Wk f6U1W f6UW8 J6Wf1U J6WfU8 6UfQ f6U+Q Z6Vf Vf6gZ lf6UW l+WI< V",
+"f6lZ Vf6sZ Ue6m I<mk! I<mDk akmI< Ue7m 7Ue8m 7UeDm 7Uaem I<M6m I<!4Qk 6eVm ",
+"V6eam pU7e 7pU8e 7eVp 7Vesp Ik=m =Ik+m =DkIm =aIkm 7Ue=m 7>Uem 7Dm=Ik >Dm7U",
+"e QI=k =QI+k V=6QI =QaIk lIp= l=Ip> V=plI V>e7p I<mGk I<!4Wk <kJm J<kam UW7",
+"e 7UW8e 7JUW< 7UWae 4WkI<M UG4Q<k! ZJ4<k Z4aJ<k 7pUG< 7U8lWe l<Jp Jpls< v6f",
+"U =Iv+k =kJv J=kgv fv7U 7fUv> J=k7v J>=vk =Uf6Q =U+f6Q ZJ=k J=kgZ =Ilv fpU7",
+"> Jpl= l=yJ h?t h&?t ?Dht ht?c ?th1 ?th: ?t1hD ?t:hc h?M h&?M V?h Vh?c lh? ",
+"l?h: lhV? u?h t*h? h?t- ?tDh* ?cht- ?t1h* ?t:h- h?1t*D ?cth:- h*?M ?-hM V*h",
+"? h?V- h?l* h?l- V?lh* h?u- ?tG ?&tG ?Jt tJ?c ?1tG t:?G J1?t ?t:J ?GhM ?tGM",
+"& ?JV cJV? h?lG lh?:G ?Jl u?J tf? t-?f tf?J i?t f1?t ?t:f ?Jtf1 ?ti: hM?f ?",
+"fMt- V?f i?V ?flh lf?h: ?Jlf ui? ht4 h&t4 hDt4 tch4 7ht 7th: 7Dht ht7c ?Mh4",
+" h?M4& h4V? V?hc4 7hl l:7h 7Vh u7h t=h t-h= ht=D htc= 7ht= Aht t=7hD htAc h",
+"?=M h=Mt- h=V? c=Vh? l=h Alh V=7h Auh t4?G ?tG4& h4tJ tJ4?c ?G7t 7tGh: tJ7h",
+" ?J7t: ?tG4M ?G&h4M J4V? ?JVc4 lG7h 7hl:G 7V?J ?Ju7 tf= f-t= t=J it= tf7 At",
+"f 7Jtf Ait =Mtf tf=-M V?J= t=iV tfl= lfAh ?Jl= Aiu hN?t ?t&hN ?tDhN ?chtN ?",
+"t1hN ?t:hN ht1?DN ?cth:N ?thQ ?tQh& hQV? V?hcQ hQl? lh?:Q V?lhQ h?uQ ?t*hN ",
+"t-?hN h?Dt*N t-h?cN h?1t*N t-?h:N hDt*?1N hN?ct-: ?tQh* t-Qh? V?hQ* V?-hQ l",
+"h?Q* l-h?Q lhQV?* uh-?Q ?thW ?tGW& ?WtJ ?cWtJ ?tG1W h:W?t ?Jt1W ?J:tW ?WhM ",
+"?tGQ& tZ?J hZ?tc h?lW lhW?: lJ?Z hZu? ?Wtf t-W?f ?JtfW ?tiW tf?1W tf:?W tf1",
+"?JW i?t:W ?Qtf tfQ?- tf?Z ?ZiV lhW?f lhW?- V?flZ i?uZ ?thm ?tmh& ?tmhD ?cmh",
+"t hm7t h:m7t 7htDm 7hctm ?Mhm ?Mmh& hmV? V?mhc 7htp hpl?: 7Vhp hpu? hmt= t-",
+"mh= t=hDm t=chm t=7hm htAm 7hDt=m Atmhc ht=Q t=Qh- V?mh= c=Qht hpl= hpAl l=",
+"hVp upAh t4hW ?tGm& ?mtJ ?Jmtc hW7t 7hWt: ?J7tW ?J:tm ?tG4Q ?G&t4Q h4tZ V?m",
+"cJ lW7h lhW7: tp?J hZu7 tf?v hv?t- tv?J ?vit 7htv hvAt hv7tJ itAv =Qtf hv?-",
+"M t=hZ ?viV hvl= lvAh hZl= yAui O !O OB aO O. 8O .BO 8aO OK !KO TO TaO jO j",
+"O8 jOT sO (O +O (BO +aO (O. +8O (O.B 8a+O (OK +OK T(O +TO jO( +jO T(jO s+O ",
+"EO !EO HO HaO EO. 8EO HO. H8O EKO !OEK HTO TaHO jOE 8EjO HjO sHO dO +dO HdO",
+" gO dO. 8dO dOH. g8O dKO dK+O TdO gTO djO jO8d jOTd gsO O2 !O2 2BO aO2 5O 5",
+"8O 5BO 5aO 2KO !O2K TO2 T2aO jO5 58jO 5TO s5O ;O +;O ;OB a;O 5;O >O ;O5B >O",
+"a ;OK ;O+K T;O +OT; ;jO >jO jOT; s>O EO2 EO!2 HO2 aOH2 5EO 8E5O H5O HO5a EO",
+"2K !EO2K TOH2 HTaO2 5EjO jO58E jOH5 H5sO d;O d;+O H;O g;O 5dO >Od HO5d g>O ",
+";OdK +d;OK HOT; T;gO jO5d dj>O jOH; >Ogs P P! PB aP P. 8P P.B 8Pa QP Q!P TP",
+" QaP Pj Q8P TPj sP P( +P P(B +Pa P(. +P8 .BP( +8aP QP( +QP TP( +TP Pj( +Pj ",
+"T(Pj sP+ WP W!P HP HPa WP. W8P HP. H8P WQP WPQ! ZP ZaP WjP 8PWj ZPj sZP dP ",
+"+WP HPd gP dP. 8dP H.dP gP8 QdP Qd+P ZdP gZP dPj Wj+P dPZj gsP mP mP! mPB a",
+"mP 5P 5P8 5PB 5aP QmP mPQ! TmP amTP pP p8P pTP spP ;P +mP ;PB a;P 5P; >P 5B",
+";P >Pa Q;P Q;+P T;P Tm+P p;P >Pp T;pP >Ps WmP mPW! HmP amHP 5WP W85P H5P 5a",
+"HP QmWP Q!WmP ZmP amZP pWP W8pP ZpP ZpsP vP v+P vHP gvP v5P >Pv H5vP >Pg vQ",
+"P +QvP ZvP ZvgP pvP pv>P ZPpv yP #O &O #BO a&O #O. 8&O #O.B a&8O #OK &OK T#",
+"O T&O jO# &jO T#jO s&O #(O +&O #(OB a&+O (O#. 8&+O (BO#. +8a&O (O#K &O+K #(",
+"TO +OT& #(jO +&jO jOT#( +&sO #EO &EO H#O H&O EO#. &E8O #OH. 8&HO #OEK EK&O ",
+"T#HO HOT& #EjO &EjO H#jO H&sO d#O d&O d#HO g&O #Od. 8Od& Hd#O. 8&gO #OdK &O",
+"dK d#TO T&gO d#jO jOd& dj#HO gOs& #O2 &O2 #O2B &2aO 5#O 5&O #B5O a&5O #O2K ",
+"2K&O #OT2 &OT2 5#jO jO5& T#5O 5&sO ;#O ;&O #B;O aO;& ;#5O >&O 5;#OB a&>O #O",
+";K &O;K ;#TO TO;& ;#jO &j>O ;j#TO s&>O EO#2 EO&2 #OH2 &OH2 #E5O &E5O 5#HO H",
+"O5& #O2EK &EO2K HT#O2 H&TO2 jO5#E &jE5O H5T#O sH5&O ;#dO dO;& ;#HO ;&gO d#5",
+"O d&>O H5d#O g&>O dK;#O d&;OK H;T#O gT;&O dj#5O >&djO H;j#O gs>&O P# P& P#B",
+" aP& P#. 8P& .BP# 8aP& QP# Q&P TP# TP& Pj# P&j T#Pj sP& P#( +P& #BP( +aP& #",
+"(P. +8P& P#(.B aP&+8 P#Q( Q&+P P#T( T&+P j#P( P&+j Pj#T( +Ps& WP# W&P HP# H",
+"P& P#W. 8PW& P#H. 8PH& QPW# WQP& ZP# Z&P W#Pj P&Wj PjZ# Z&sP dP# dP& H#dP g",
+"P& P#d. d&8P dP#H. 8Pg& Q#dP dPQ& dPZ# Z&gP d#Pj P&dj dPjZ# g&sP mP# m&P P#",
+"mB m&aP 5P# 5P& P#5B aP5& mPQ# QmP& mPT# m&TP pP# p&P TPp# p&sP ;P# ;P& PB;",
+"# ;&aP 5#;P >P& ;P#5B aP>& Q#;P ;PQ& T#;P ;PT& ;Pp# p&>P pT;P# >&sP mPW# Wm",
+"P& mPH# m&HP WP5# W&5P H#5P 5PH& WQmP# m&PWQ mPZ# m&ZP WPp# W&pP pPZ# ZPp& ",
+"vP# v&P HPv# v&gP 5Pv# v&>P vH5P# >&gP QPv# Q&vP vPZ# ZPv& vPp# pPv& ZpvP# ",
+"y&P CO !CO DO DaO CO. 8CO DO. D8O CKO !OCK DTO TaDO jOC 8CjO DjO sDO C(O +C",
+"O D(O +DO (OC. 8C+O (OD. +OD8 (OCK CK+O T(DO DT+O C(jO +CjO D(jO +DsO CEO C",
+"E!O HDO DaHO EOC. CE8O DOH. HOD8 COEK !EOCK DTHO HDTaO CEjO jO8CE HDjO HDsO",
+" dCO dC+O DdO gDO COd. dC8O dOD. D8gO CKdO +dCOK DOTd DTgO dCjO djC+O jODd ",
+"gOsD CO2 CO!2 DO2 D2aO 5CO 8C5O 5DO 5OD8 CO2K !C2OK T2DO DTaO2 5CjO jO58C j",
+"O5D 5DsO ;CO ;C+O D;O +OD; ;C5O >CO 5OD; >DO CK;O +;COK DOT; a;ODT ;CjO jO>",
+"C jOD; sD>O EOC2 !EOC2 DOH2 HDaO2 CE5O 58CEO HO5D H5D8O EKCO2 EK2!CO HDTO2 ",
+"DTaHO2 jO5CE 58CjOE H5DjO sH5DO ;CdO +d;CO HOD; D;gO dC5O dC>O 5ODd gD>O dK",
+";CO dK;+CO H;DTO gDT;O djC5O >jdCO H;jDO >DOgs PC PC! DP DPa PC. 8PC DP. D8",
+"P QPC PCQ! QDP DPQa PjC QC8P DPj sPD PC( +PC DP( +DP C(P. +C8P P(D. D8+P PC",
+"Q( QP+C Q(DP QD+P jCP( +CPj D(Pj +DsP WPC PCW! HPD DPWa PCW. WC8P H.DP D8HP",
+" QPWC Q!WPC ZDP DPZa WCPj PjCW8 DPZj ZDsP dPC +CdP DdP gPD PCd. 8CdP D.dP D",
+"8gP QCdP dPC+Q DdZP ZDgP dCPj dPj+C dPDj gDsP mPC P!mC DmP amDP 5PC 5C8P 5D",
+"P D85P mPQC Q!mPC TmDP amPQD pPC 8PpC pDP pDsP ;PC +C;P D;P Dm+P 5C;P >PC D",
+";5P >PD QC;P ;PC+Q DPQ; a;PQD ;PpC pP>C D;pP pD>P mPWC W!mPC DmHP amPWD WP5",
+"C 5W8PC 5DHP H5PD8 WQmPC WmPQ!C DmZP ZDamP WPpC pW8PC ZPpD sPDZp vPC +PvC v",
+"DP vDgP 5PvC vP>C 5DvP vD>P QPvC v+QPC ZPvD ZvDgP vPpC >PpvC pPvD yDP bO b&",
+"O bDO cO bO. b8O DOb. c8O bKO &ObK bTO cTO bjO jOb8 jObT scO b(O b+O D(bO c",
+"+O (Ob. +8bO bD(O. +8cO (ObK +ObK T(bO +TcO b(jO jOb+ bTj(O c+sO bEO &EbO b",
+"HO cHO EOb. 8EbO HOb. H8cO EKbO bK&EO HTbO HTcO bEjO &jEbO jObH cHsO bdO bO",
+"d& bODd gcO dOb. bO8d bHdO. c8gO dKbO d&ObK bOTd cTgO jObd d&jbO bHjdO gOsc",
+" bO2 &Ob2 DOb2 c2O b5O bO5& bO5D c5O 2KbO bK&O2 TOb2 TOc2 jOb5 &jOb5 bO5T s",
+"Oc5 b;O bO;& bOD; c;O 5;bO >bO b5D;O c>O ;ObK ;&ObK bOT; T;cO jOb; bj>O b5T",
+";O >Osc EOb2 b&EO2 HOb2 HOc2 5EbO b58EO bOH5 H5cO bKEO2 &EObK2 bHTO2 c2HTO ",
+"b5jEO b5E&jO bH5jO c5HsO d;bO d&;bO bOH; gOc; bO5d bd>O bH5dO >Ogc bd;OK bd",
+"O;&K bH;TO c;TgO b5djO >bdjO bH;jO c>gsO bP bP& bPD cP bP. b8P b.DP cP8 bQP",
+" Q&bP bTP cQP bPj Q8bP DPbj scP bP( b+P b(DP cP+ P(b. +Pb8 bPD(. +Pc8 QPb( ",
+"+QbP b(TP +QcP b(Pj +Pbj bTPj( s+cP bWP W&bP bHP cWP WPb. W8bP b.HP H8cP WQ",
+"bP bWQP& ZbP ZcP WjbP P&jbW bPZj sPZc bdP +WbP HPbd gcP b.dP 8dbP bHPd. g8c",
+"P QdbP dP&bQ bdZP gPZc dPbj dP&bj ZbdPj scgP bmP m&bP DmbP cmP b5P 5Pb8 5Db",
+"P c5P QmbP m&PbQ TmbP TmcP pbP b8pP bTpP cpP b;P +mbP D;bP c;P 5Pb; >Pb b5P",
+"D; c>P Q;bP ;P&bQ T;bP Q;cP b;pP pb>P pbD;P >Pcp WmbP m&PbW HmbP HmcP 5WbP ",
+"b5W8P H5bP H5cP bWQmP bWQm&P bmZP ZmcP bWpP pbW8P ZPpb cPZp vbP b+vP bHvP c",
+"vP b5vP vb>P vbH5P >Pcv bQvP vb+QP ZPvb cPZv pPvb >Pbpv ZpbvP ycP 0O !0O 0B",
+"O a0O 1O 18O 1OB 1aO 0OK 0O!K T0O a0TO jO1 18jO 1TO s1O 0(O +0O 0(OB a0+O 1",
+"(O 1+O (B1O +a1O (O0K 0O+K 0(TO T0+O 1(jO jO1+ T(1O 1+sO E0O E0!O H0O a0HO ",
+"1EO 8E1O 1HO 1OH8 0OEK !EO0K T0HO HTa0O 1EjO jO18E jO1H 1HsO d0O d0+O d0HO ",
+"g0O 1dO 1O8d Hd1O g1O 0OdK +d0OK d0TO T0gO jO1d djO1+ 1OTd gOs1 0O2 0O!2 0O",
+"2B 0Oa2 15O 581O 5B1O 1O5a 0O2K 2K0!O 0OT2 Ta0O2 15jO jO158 1O5T 15sO ;0O ;",
+"0+O 0B;O ;0aO 1;O >O1 ;O1B 1a>O 0O;K +;0OK ;0TO a;0TO jO1; jO>1 1OT; s1>O 0",
+"OE2 !EO02 0OH2 Ha0O2 5E1O 158EO 1OH5 1H58O EK0O2 2K0!EO HT0O2 Ta0HO2 jO15E ",
+"158jOE 1H5jO s1H5O ;0dO +d;0O ;0HO ;0gO 1O5d 1d>O 1OH; >Og1 dK;0O dK;+0O H;",
+"T0O gT;0O djO1; >j1dO 1H;jO gs>1O P0 P0! P0B aP0 1P 1P8 1PB 1aP QP0 P0Q! TP",
+"0 Q0aP 1QP Q81P 1TP sP1 P0( +P0 0BP( +0aP 1P( 1+P P(1B +P1a P0Q( QP+0 P0T( ",
+"+0TP 1(Pj +Q1P 1(TP 1+sP WP0 P0W! HP0 H0aP 1WP W81P 1HP H81P QPW0 Q!WP0 ZP0",
+" aPZ0 Wj1P 1WQ8P Z1P Z1sP dP0 +0dP H0dP gP0 1dP +W1P HP1d g1P Q0dP dP0+Q dP",
+"Z0 ZPg0 Qd1P dPj1+ 1dZP sPg1 mP0 P!m0 P0mB mPa0 1mP 8m1P 1B5P 5a1P mPQ0 Q!m",
+"P0 mPT0 amPQ0 p1P 1Pp8 1TpP p1sP ;P0 +0;P PB;0 a0;P 1;P >P1 1B;P 1a>P Q0;P ",
+";P0+Q T0;P a;PQ0 1;pP p1>P T;1P s1>P mPW0 W!mP0 mPH0 amPH0 5W1P 1W58P H51P ",
+"1Hm8P WQmP0 WmPQ!0 mPZ0 ZamP0 1WpP p1W8P p1ZP sP1Zp vP0 +Pv0 HPv0 vPg0 v1P ",
+"v1>P 1HvP g1>P QPv0 v+QP0 vPZ0 ZvPg0 pPv1 >Ppv1 ZPv1 y1P 9O 9&O 9OB 9aO 91O",
+" :O 1B9O :aO 9OK &O9K 9TO 9OT& 9jO :jO jO9T s:O 9(O 9+O (B9O +a9O 1(9O :+O ",
+"91(OB +a:O (O9K +O9K T(9O 9O+T 9(jO +j:O 9T1(O :+sO 9EO &E9O 9HO 9OH& 1E9O ",
+":EO 9O1H :HO EK9O 9&EOK HT9O 9HTaO 9EjO jO:E jO9H sO:H 9dO 9Od& Hd9O g9O 9O",
+"1d :dO 9H1dO g:O dK9O d&O9K 9OTd 9TgO jO9d dj:O 9HjdO gOs: 9O2 &O92 2B9O aO",
+"92 95O :5O 5B9O 5a:O 2K9O 9&O2K TO92 9TaO2 jO95 jO:5 9O5T :5sO 9;O 9O;& ;O9",
+"B 9Oa; 9O1; :>O 95;OB :a>O ;O9K ;&O9K 9OT; 9+T;O jO9; :j>O 95T;O >Os: EO92 ",
+"9&EO2 HO92 9HaO2 5E9O 5E:O 9OH5 H5:O 9EO2K &EO92K 9HTO2 H&O9T2 95jEO :5jEO ",
+"9H5jO :H5sO d;9O d&;9O 9OH; 9;gO 9O5d >O:d 9H5dO >Og: 9d;OK 9dO;&K 9H;TO g9",
+"T;O 95djO :>djO 9H;jO g:s>O 9P 9P& 9PB 9aP 9P1 :P 1B9P :Pa 9QP Q&9P 9TP Qa9",
+"P 9Pj :QP 1T9P s:P 9P( 9+P P(9B +P9a 9(1P :P+ 9P1(B +P:a QP9( +Q9P 9(TP +T9",
+"P 9(Pj +Q:P 9TP1( s+:P 9WP W&9P 9HP HP9a 1W9P :WP 1H9P :HP WQ9P 9WQP& Z9P 9",
+"aZP Wj9P Wj:P 9PZ1 Z:P 9dP +W9P HP9d g9P 1d9P :dP 9HP1d g:P Qd9P dP&9Q 9dZP",
+" Z9gP dP9j Qd:P Z91dP gPZ: 9mP m&9P mP9B am9P 95P :mP 9B5P 5a:P Qm9P m&P9Q ",
+"Tm9P 9QamP p9P :pP 9TpP sP:p 9;P +m9P 9B;P a;9P 1;9P >P: 95P;B :a>P Q;9P ;P",
+"&9Q T;9P a;P9Q 9;pP >P:p p9T;P s:>P Wm9P m&P9W Hm9P 9HmaP 5W9P 5W:P H59P H5",
+":P 9WQmP 9WQm&P 9mZP Z9amP 9WpP pW:P ZPp9 :PZp v9P 9+vP 9HvP v9gP 95vP :vP ",
+"v91HP >Pg: 9QvP v9+QP ZPv9 Zv9gP pPv9 pv:P Zp9vP y:P C0O C0!O D0O a0DO 1CO ",
+"8C1O 1DO 1OD8 0OCK C0O!K T0DO DTa0O 1CjO jO18C jO1D 1DsO 0(CO C0+O 0(DO D0+",
+"O C(1O +C1O D(1O 1O+D C0O(K +C0OK DT0(O +DT0O jO1C( 1+jCO 1DT(O s1+DO E0CO ",
+"C0O!E D0HO HDa0O CE1O 18CEO HD1O 1HD8O C0OEK EK0!CO HDT0O DTaH0O jO1CE 18Cj",
+"OE 1HDjO s1HDO C0dO +dC0O d0DO D0gO dC1O 1+dCO 1ODd 1DgO dKC0O dKC+0O DdT0O",
+" gDT0O djC1O 1+CdjO 1DdjO gs1DO 0OC2 C02!O 0OD2 Da0O2 5C1O 158CO 1O5D 1D58O",
+" C02OK 2K0!CO DT0O2 Ta0DO2 jO15C 158jOC 1D5jO s15DO C0;O +;C0O ;0DO a;0DO ;",
+"C1O 1C>O 1OD; 1D>O ;C0OK ;C0+OK D;T0O D;0+TO ;jC1O >j1CO 1D;jO >DOs1 C02EO ",
+"!EOC02 HD0O2 Da0HO2 15CEO 58C1EO 1H5DO H5D1aO EK2C0O E02K!CO DT0HO2 DTH0aO2",
+" 15CjOE 5E1O8jC H5D1TO 1H5sDO d;C0O d;C+0O H;D0O gD;0O 1d5CO >C1dO 1H;DO >D",
+"Og1 ;C0dKO C0;O+dK Td0D;O D;Tg0O 1dC;jO djC>O1 djO1D; gs1>DO PC0 !CP0 DP0 D",
+"0aP 1PC 1C8P 1DP D81P PCQ0 Q!PC0 Q0DP aP0QD 1CPj PjC18 QD1P 1DsP C0P( PC+0 ",
+"P0D( +0DP PC1( 1C+P 1(DP +D1P QPC0( +QPC0 QDP0( +QDP0 PjC1( 1+QPC 1QDP( sP1",
+"+D PCW0 W!PC0 H0DP aP0WD WP1C 1W8PC HP1D 1HPD8 WQPC0 WPCQ!0 DPZ0 ZDaP0 PjC1",
+"W 1W8PjC 1DZP sP1ZD PCd0 dPC+0 D0dP DPg0 1CdP 1+WPC Dd1P 1DgP dPCQ0 +QCdP0 ",
+"ZDdP0 gZDP0 dPj1C dPC1+Q Z1DdP gZ1DP PCm0 mPC!0 mPD0 amPD0 1C5P 1m8PC 5D1P ",
+"1Dm8P QmPC0 mPCQ!0 QDmP0 QDmaP0 1PpC p18PC 1DpP sP1pD PC;0 ;PC+0 D0;P a;PD0",
+" 1C;P 1P>C D;1P 1D>P ;PCQ0 +QC;P0 QD;P0 aP0QD; p1;PC >Pp1C pD1;P >Ps1D WmPC",
+"0 mPCW!0 HmDP0 HmDaP0 1W5PC 5W81PC 1HmDP H8m1DP QmPWC0 QCW0mP! ZDmP0 amPZD0",
+" p1WPC 1W8pPC Zp1DP Zp1sPD PCv0 v+PC0 DPv0 gvDP0 1PvC >Pv1C 1DvP >Pg1D vQPC",
+"0 +QPvC0 ZvDP0 vDPgZ0 pv1PC pv1>PC Zv1DP 1DyP b9O 9&bO 9DO c9O b1O :bO bO1D",
+" :cO 9ObK b9&OK bO9T 9TcO jOb1 bj:O jO9D sO:c 9(bO bO9+ D(9O 9+cO 1(bO b+:O",
+" b1D(O c+:O b9(OK b+9OK bT9(O c9+TO b1j(O :b+jO b1T(O :c+sO 9EbO b9&EO bO9H",
+" 9HcO 1EbO bE:O bO1H cH:O b9EOK 9&EbKO bH9TO c9HTO b1jEO :bjEO b1HjO :cHsO ",
+"bO9d d&Ob9 9ODd c9gO bO1d bd:O b1HdO gO:c bd9OK 9+ObdK bTd9O gc9TO b1djO :d",
+"bjO b1TdO g:scO 9Ob2 b9&O2 DO92 9Oc2 bO95 b5:O 9O5D :Oc5 b9O2K 9&ObK2 bT9O2",
+" c29TO b15jO :b5jO b1T5O :c5sO bO9; ;&Ob9 9OD; 9;cO bO1; :b>O b1;DO >O:c b;",
+"9OK 9+Ob;K bT;9O c;9TO b1;jO :>bjO b1T;O c>s:O b9EO2 9&EbO2 bH9O2 c29HO b15",
+"EO :b5EO b1H5O :cH5O 9EObK2 EOb29&K 9HObT2 9HTc2O 95EbjO b5j:EO bHO95T s:Hc",
+"5O bd9;O bd9;&O bH;9O c;9gO b1d5O :>bdO b1H;O g:c>O 9dOb;K d&b;9OK bHO9T; g",
+"9Tc;O djOb1; >bj:dO djO95D c>sg:O bP9 b9P& 9DP cP9 b1P :Pb 1DbP :cP 9QbP bQ",
+"9P& 9TbP 9QcP 9Pbj bQ:P 1TbP :csP b(9P 9+bP 9(DP 9+cP b(1P b+:P b1PD( :+cP ",
+"bQ9P( b+Q9P bTP9( cQ9+P b1QP( :Qb+P b1TP( :cQ+P 9WbP bW9P& 9HbP 9HcP 1WbP b",
+"W:P 1HbP cW:P bW9QP 9WQbP& bPZ9 cPZ9 b1WPj :WbPj b1ZP :PZc 9dbP dP&b9 Dd9P ",
+"cPg9 1dbP bd:P b1HdP :cgP bQd9P 9+QbdP Zb9dP Zcg9P dPjb1 :QdbP Zb1dP g:PZc ",
+"9mbP m&Pb9 Dm9P 9mcP 95bP b5:P 5D9P c5:P bQ9mP bQ9m&P bTm9P cQ9mP b1pP pb:P",
+" 9DpP :Pcp 9;bP ;P&b9 D;9P 9;cP 1;bP >b:P b1;DP :c>P bQ;9P 9+Qb;P bT;9P cQ;",
+"9P pb9;P :p>bP p9D;P cp:>P bW9mP bW9m&P bHm9P cW9mP b1W5P :Wb5P b1H5P :cW5P",
+" 9WQbmP QmP&bW9 Zb9mP Zc9mP pb9WP :pbWP Zpb9P cpZ:P bPv9 vb9+P 9DvP v9cP b1",
+"vP vb:P vb1HP :Pcv vb9QP b+Qv9P Zvb9P cvZ9P pvb9P :vbpP Zvb1P :cyP R R! RB ",
+"Ra R. R8 R.B R8a RM RM! RT RTa Rj R8M RTj sR R( R+ R(B R+a R(. R+8 .BR( +8R",
+"a RM( R+M RT( R+T Rj( R+j TjR( sR+ RE RE! RH RHa RE. R8E RH. RH8 RME MER! R",
+"HT HMRa RjE RE8M RHj sRH Rd R+d RHd gR Rd. R8d HdR. gR8 RdM +MRd RTd gRT Rd",
+"j +jRd HjRd gsR R2 R2! R2B Ra2 R5 R58 R5B R5a RM2 M2R! RT2 R2aM R5M 5MR8 R5",
+"T sR5 R; R+; R;B Ra; R5; >R 5;RB >Ra R;M +MR; RT; +TR; R;j >MR 5TR; s>R RE2",
+" !ER2 RH2 HaR2 R5E 58RE RH5 H5R8 MER2 RME!2 R2HM aM2RH RE5M R58ME H5RT RHs5",
+" Rd; +dR; RH; gR; R5d >Rd H5Rd g>R dMR; dM;R+ HMR; RTg; 5dRj Rd>M H;Rj gR>M",
+" RP RP! RPB RaP RP. R8P P.RB 8PRa S S! ST Sa Sj S8 STj Ss RP( R+P P(RB +PRa",
+" P(R. +PR8 RP(.B R+8aP S( S+ ST( S+T Sj( S+8 TjS( Ss+ RW RW! RHW RWa RW. RW",
+"8 R.HP H8RW SW S!W SZ SZa SWj S8W SZj SsZ RWd R+W HPRd gRW R.dP +WR8 dP.RH ",
+"RWg8 Sd S+W SZd gS Sdj S8d ZdSj gSs Rm Rm! RmB Ram R5m R8m RB5P 5aRm Sm S!m",
+" STm Sam Sp Sp8 SpT Ssp Rm; R+m RB;P +mRa 5PR; >PR ;PBR5 Ra>P S; S+m S;T Sa",
+"; Sp; S> pTS; S>s RWm W!Rm RHm HmRa R5W 5WR8 H5RW H8Rm SWm W!Sm SZm ZaSm Sp",
+"W pWS8 SZp SZsp vR vR+ vRH gvR vR5 v>R RHv5 gR>P Sv Sv+ SvZ gSv Svp S>v ZpS",
+"v yS R# R& R#B Ra& R#. R8& .BR# 8aR& RM# R&M RT# RT& Rj# R&j TjR# sR& R#( R",
+"+& #BR( +aR& #(R. +8R& R#(.B R+8a& M#R( +MR& T#R( +TR& j#R( +jR& RTj#( R+s&",
+" R#E R&E RH# RH& #ER. 8&RE H#R. H8R& M#RE REM& R#HM HMR& j#RE RE&j R#Hj RHs",
+"& Rd# Rd& HdR# gR& d#R. 8dR& RHd#. R8g& R#dM dMR& R#Td RTg& R#dj d&Rj RHjd#",
+" g&sR R#2 R&2 2BR# a&R2 R5# R5& 5BR# 5aR& M#R2 R2M& T#R2 R2T& R#5M 5MR& R#5",
+"T R5s& R;# R;& ;#RB a;R& 5;R# >R& R5;#B Ra>& R#M; M;R& R#T; T;R& R#;j R&>M ",
+"R5T;# >&sR #ER2 &ER2 H#R2 R2H& 5#RE RE5& R#H5 H5R& RM#E2 M&ER2 RHT#2 RH&T2 ",
+"R5M#E R5&ME RH5T# sRH5& d;R# d&R; R#H; R;g& R#5d Rd>& RH5d# >&gR dM;R# dM&R",
+"; RH;T# gRT;& R5dM# >MRd& RH;j# >MgR& RP# R&P P#RB aPR& P#R. 8PR& RP#.B aP&",
+"R8 S# S& ST# Sa& Sj# S8& TjS# Ss& P#R( +PR& RP#(B aP&R+ RP#(. R+8P& P#(R.B ",
+"R+8aP& S#( S+& T#S( +TS& j#S( +jS& STj#( s+S& RW# RW& R#HP HPR& W#R. W8R& R",
+"HW#. RH8W& SW# S&W SZ# SZ& WjS# W8S& ZjS# S&sZ R#dP +WR& dP#RH RWg& dP#R. d",
+"P&R8 RH#dP. gRW8& Sd# Sd& ZdS# gS& djS# 8dS& SZdj# S&gs Rm# Rm& m#RB amR& R",
+"#5P 5PR& R5m#B R5am& Sm# S&m TmS# TmS& Sp# Sp& pTS# S&sp R#;P +mR& ;P#RB a;",
+"PR& ;P#R5 Rm>& R5#;PB >PRa& S;# S;& T;S# T;S& p;S# S>& SpT;# S&s> WmR# W&Rm",
+" R#Hm HmR& R#5W 5WR& RH5W# RH5W& WmS# W&Sm ZmS# SmZ& pWS# SWp& S#Zp ZpS& vR",
+"# vR& RHv# v&gR R5v# >Rv& vRH5# >PgR& Sv# Sv& S#Zv S&gv S#pv pvS& SZpv# yS&",
+" RU RU! RD RDa RU. R8U RD. RD8 RUM U!RM VR VRa RjU U8Rj VRj sRV RU( R+U RD(",
+" R+D U(R. U+R8 D(R. +DR8 UMR( RU+M VR( V+R R(Uj U+Rj RjV( V+sR RUE U!RE RHU",
+" UHRa UER. REU8 R.UH UHR8 UMRE RUM!E VRH RHVa REUj R8UME RHVj VRsH RdU U+Rd",
+" RDd gRU R.Ud U8Rd R.Dd RDg8 RUdM R+UdM VdR gVR UdRj R+jUd RdVj sRgV RU2 U!",
+"R2 RD2 R2Ua R5U U5R8 R5D U5Ra UMR2 RUM!2 V2R RaV2 U5Rj R5U8M V5R V5sR R;U U",
+"+R; RD; UaR; U5R; >RU 5DR; >RD RUM; R+UM; V;R R+V; U;Rj Rj>U R5V; V>R UER2 ",
+"RUE!2 R2UH RHUa2 REU5 R5U8E UHR5 RH5U8 RUME2 U!MRE2 RHV2 V2RHa R5UME U58RjE",
+" RHV5 VsHR5 UdR; R+Ud; UHR; RDg; U5Rd Rd>U 5DRd >RgU dM;RU R+UdM; RHV; V;gR",
+" R5dUj >MRUd R5Vd gRV> UP UP! RDP UaP UP. U8P R.DP D8UP SU S!U SV SVa SUj S",
+"8U SVj SsV UP( U+P R(DP +DUP P(U. +PU8 RDP(. R+D8P SU( S+U SV( SV+ UjS( U+S",
+"8 VjS( VsS+ RWU R!UW RWD UWRa R.UW UWR8 R.WD H8UP SUW UWS! SZV VZSa UWSj UW",
+"S8 SjVZ SVsZ UdP U+RW HPUd gUP U.dP 8dUP RWDd. U8gP SdU U+Sd SVd gSV UdSj U",
+"8Sd SjVd SsgV RmU R!Um RDm UaRm U5P U8Rm 5DRm 5aUP SUm UmS! SVm VmSa SpU pU",
+"S8 VpS VpSs U;P U+Rm DmR; +DRm 5PU; >PU R5D;P RD>P S;U U+S; SV; V+S; pUS; S",
+">U S;Vp S>V UWRm RWUm! UHRm RHmUa U5RW R5WU8 H5UP RH8Um UWSm S!UWm VmSZ SZV",
+"am SWpU SpUW8 SZVp SZpVs vRU R+vU vRD vRgU R5vU vU>P R5vD gU>P SvU vUS+ VvS",
+" VvgS pUSv vUS> VpSv yVS Rb Rb& RbD cR Rb. Rb8 bDR. cR8 RbM bMR& VRb cRV Rb",
+"j b8Rj RbVj scR Rb( Rb+ bDR( cR+ b(R. b+R8 RbD(. R+c8 R(bM bMR+ RbV( V+cR R",
+"(bj b+Rj VRbj( s+cR RbE REU& RbH cRH bER. REb8 R.bH RHc8 REbM M&ERb RbVH VR",
+"cH REbj Rb8ME bHRj sHcR Rbd b+Rd bHRd gcR R.bd b8Rd RbHd. g8cR bMRd dM&Rb R",
+"bVd cRgV bdRj d&jRb VdRbj scgR Rb2 R2U& bDR2 cR2 Rb5 b5R8 b5RD cR5 R2bM M&2",
+"Rb RbV2 V2cR b5Rj Rb58M RbV5 c5sR Rb; b+R; b;RD cR; b5R; >Rb Rb5D; c>R bMR;",
+" M;&Rb RbV; V;cR b;Rj Rb>M V5Rb; sRc> bER2 Rb&E2 R2bH RHc2 REb5 Rb58E bHR5 ",
+"RHc5 RbME2 RbEM&2 V2RbH cRVH2 Rb5ME M&ERb5 V5RbH cR5sH bdR; Rb+d; bHR; c;gR",
+" b5Rd Rb>d RbH5d gRc> RbdM; RbdM;& VdRb; gVcR; Rb5dM >MbRd V5dRb V>gcR RbP ",
+"UP& bPRD cRP R.bP bPR8 RbDP. R8cP Sb Sb& SVb Sc Sbj Sb8 VbSj Scs R(bP bPR+ ",
+"RbDP( R+cP RbP(. Rb+8P bP(RD. cR+8P Sb( Sb+ VbS( Sc+ bjS( b+S8 SVbj( S+sc R",
+"bW bWR& bHRW cRW R.bW bWR8 RbHW. RWc8 SbW bWS& SZb ScZ bWSj bWS8 SjZb ZcSs ",
+"bWRd b+RW RbHdP cRgP RbWd. dP&U8 dP.RbH cRWg8 Sbd b+Sd ZbSd gSc bdSj b8Sd S",
+"Zbdj gsSc Rbm bmR& bmRD cRm b5Rm b8Rm Rb5Dm R5cm Sbm bmS& VmSb Scm Spb pbS8",
+" SbVp Scp bmR; b+Rm RbmD; R+cm Rb5;P Rb>P b5PRD; cR>P Sb; b+S; V;Sb Sc; pbS",
+"; S>b SpbV; Sc> bWRm RbWm& bHRm RHcm b5RW Rb5W8 RbH5W R5cW bWSm SbWm& SmZb ",
+"cmSZ SWpb SpbW8 ZpSb SZcp vRb Rbv& RbvD cvR Rbv5 >Rvb vRbH5 v>cR Svb vbS+ S",
+"bVv Scv pvSb v>Sb VvpSb ycS Rk Rk! RkB Rak R1 R18 R1B R1a RkM kMR! RTk TkRa",
+" lR lR8 lRT lsR Rk( R+k k(RB +kRa R1( R1+ 1(RB 1+Ra kMR( Rk+M R(Tk +kRT lR(",
+" l+R RTl( sRl+ RkE kER! RHk HkRa R1E RE8k R1H 1HR8 kMRE RkM!E HkRT RHTak lR",
+"E R8lE lHR sRlH Rdk +kRd HkRd gRk R1d 1+Rd 1HRd gR1 RkdM dkMR+ TkRd RTgk ld",
+"R R+ld RHld glR Rk2 k2R! k2RB R2ak R15 5kR8 RB5k 1aR5 kMR2 RkM!2 R2Tk ak2RT",
+" lR5 R5l8 R5lT l5sR R;k +kR; RBk; akR; R1; >kR RB1; R1>a RkM; k;MR+ TkR; ak",
+";RT l;R l>R RTl; sRl> kER2 RkE!2 R2Hk ak2RH RE5k R158E 1HR5 R1H5a RkME2 kME",
+"R2! RHTk2 RHTak2 R5lE lR58E RHl5 lsRH5 dkR; dk;R+ HkR; R;gk 1dR5 R1>d 1HR; ",
+"gR>k dkMR; R+dk;M RH;Tk gRTk; R5ld >Rld RHl; gRl> kP kP! kPB akP R1P 8kP RB",
+"1P 1PRa Sk S!k STk Sak Sl Sl8 SlT Ssl kP( +kP P(kB ak+P R(1P 1PR+ kP(1B akP",
+"1+ Sk( S+k TkS( +TSk Sl( l+S STl( l+Ss RWk R!Wk HkP WkRa R1W 1WR8 1HRW 1WRa",
+" SWk WkS! SZk ZkSa lWS S8lW lZS lZSs dkP +kRW dkHP gkP 1WRd 1+RW dkP1H R1gP",
+" Sdk +WSk ZkSd gSk ldS S+lW SZld glS Rmk R!km RBkm akRm R1m 1mR8 RB1m 1aRm ",
+"Skm kmS! TkSm akSm Slp lpS8 lTSp Slsp k;P +kRm kB;P k;aP 1mR; >kP k;P1B ak>",
+"P S;k +kS; TkS; akS; l;S S>l lTS; Ssl> WkRm km!RW HkRm akmRH 1WR5 R1W8m 1HR",
+"m akPH5 WkSm S!Wkm SmZk SZakm SplW SlpW8 SplZ SZpls vRk R+vk RHvk vRgk vR1 ",
+"vR>k R1vH gk>P Svk vkS+ ZkSv gkSv lvS S>lv lZSv ylS R9 R9& R9B R9a R91 :R 9",
+"1RB :Ra R9M 9MR& R9T 9TRa lR9 l:R R9lT s:R R9( R9+ 9(RB 9+Ra 91R( :R+ R91(B",
+" R+:a R(9M 9MR+ R(9T 9+RT R9l( :Rl+ lR9T( s+:R R9E REk& R9H 9HRa 91RE :RE 9",
+"HR1 :RH RE9M k&ERM 9HRT R9HT& R9lE lE:R R9lH :RlH R9d 9+Rd 9HRd gR9 9dR1 :R",
+"d R9H1d g:R 9MRd dk&RM 9TRd R9gM R9ld :Rld lHR9d gRl: R92 R2k& 92RB R29a R9",
+"5 :R5 RB95 R5:a R29M k&2RM R29T R9T&2 R9l5 l5:R 95RT s5:R R9; 9+R; RB9; 9aR",
+"; 95R; :>R R95;B :a>R 9MR; k;&RM 9TR; aM;R9 R9l; :Rl> l;R9T :>sR 9ER2 k&ER2",
+" R29H R9H&2 RE95 R5:E 9HR5 RH:5 R9ME2 R9EM&2 R9HT2 aM2R9H lR95E :R5lE lHR95",
+" :RHl5 9dR; dk&R; 9HR; R9g; 95Rd >R:d R9H1; :>gR R9dM; R9dM;& R9HT; gR9T; l",
+"dR95 l>:Rd lH;R9 g:Rl> R9P kP& RB9P 9PRa 9PR1 :RP kPB91 Ra:P S9 S9& S9T S9a",
+" Sl9 S: lTS9 S:s R(9P 9PR+ kP(9B akP9+ kP(91 R+:P 9P(R1B :R+aP S9( S9+ 9TS(",
+" 9+Sa l(S9 S:+ Sl9T( S+s: R9W 9WR& 9HRW 9WRa 9WR1 :RW R9H1W RH:W S9W 9WS& S",
+"Z9 Z9Sa S9lW S:W S9lZ S:Z 9WRd 9+RW dkP9H R9gP dkP91 R+:W 9HPR1d :RgP S9d 9",
+"+Sd Z9Sd gS9 S9ld S:d SZ9ld gS: R9m 9mR& RB9m 9aRm 95Rm :Rm R95mB Ra:m S9m ",
+"9mS& 9TSm 9aSm Sp9 S:p STp9 :pSs 9mR; 9+Rm k;P9B ak;9P k;P95 :R>P k;B95P :>",
+"Ram S9; 9+S; 9TS; 9aS; S9l; S:> Sp9T; s:S> 9WRm km&RW 9HRm km&RH 95RW R5:W ",
+"R9H1m RH:m 9WSm S9Wm& SmZ9 SZ9am SWp9 :WSp ZpS9 SZ:p vR9 R9v& R9vH vRg9 R9v",
+"1 :vR vR91H gR:v Sv9 v9S+ ZvS9 g9Sv S9lv S:v Sv9lZ y:S RUk U!Rk RDk DkRa R1",
+"U 1UR8 R1D 1URa UkRM RUkM! VRk RaVk lRU R8lU VlR VlsR UkR( RU+k R(Dk +kRD R",
+"(1U 1UR+ R(1D 1+RD RUkM( R+UkM RkV( R+Vk RUl( R+lU VRl( lRV+ UkRE RUk!E HkR",
+"D RHUak RE1U R1U8E 1URH R1HU8 RUkME U!kRME RHVk VRHak RUlE lRU8E VRlH lsVRH",
+" RUdk R+Udk DkRd RDgk 1URd R1+Ud 1DRd R1gU dkMRU R+UdkM RdVk VRgk RdlU l+RU",
+"d lRVd VlgR UkR2 RUk!2 R2Dk ak2RD 1UR5 R1U58 1DR5 R1D5a RUkM2 U!kRM2 RkV2 V",
+"2Rak R5lU lRU58 lRV5 lsVR5 RUk; R+Uk; DkR; ak;RD 1UR; R1>U 1DR; R1>D k;MRU ",
+"R+Uk;M R;Vk V+Rk; R;lU lR>U lRV; >RVl RUkE2 U!kRE2 RHUk2 RHUak2 R1U5E 1U5R8",
+"E R1HU5 1UHR5a UkMRE2 !ER2UkM V2RHk ak2VRH lRU5E R5Ul8E VlRH5 Vs5lHR dk;RU ",
+"R+Udk; RH;Dk gRUk; R1dU5 >kRUd R1HU; >kgRD RdUk;M dkR;U+M VdRk; gVRk; ldRU5",
+" l>RUd lH;VR V>lgR UPk U!kP DkP akUP 1UP U81P 1PRD Ua1P SUk U!Sk SVk VaSk S",
+"lU lUS8 SlV SVls U(kP +kUP D(kP Dk+P 1(UP U+1P R1DP( R1+DP UkS( U+Sk VkS( S",
+"kV+ SUl( lUS+ l(SV SVl+ WkUP kP!UW HkUP akPUH 1URW R1WU8 1WRD R1WUa UWSk S!",
+"UWk ZkSV SZVak SUlW SlUW8 SVlZ SlVsZ dkUP dkPU+ dkDP UPgk Ud1P dkPU8 dkP1D ",
+"1UgP UdSk S+UWk SkVd SVgk lUSd S8dlU SVld SlgV kmUP km!UP DkRm akmRD 1URm R",
+"1mU8 1DRm akPU5 UmSk S!Ukm SkVm SVakm pUSl SlpU8 SlVp SlVsp k;UP k;PU+ k;DP",
+" ak;UP U;1P 1U>P k;P1D Dk>P U;Sk S+Ukm SkV; SV+km lUS; >USl SVl; SlV> RWUkm",
+" RWUkm! RHmDk RWDakm R1WU5 1UWR8m R1HUm 1UHR8m SUWkm km!SUW SZVkm ZkVSam Sl",
+"pUW lWpS8U SlVZp VplSsZ UPvk vRU+k RDvk gvRDk R1vU >kvUP R1vD >kgUP SUvk Sv",
+"U+k vkSV VvgSk vUSl lv>SU SlVv SlyV tR tR& tRD tcR tR1 t:R R1tD :cR tRM R&t",
+"M VtR VtcR ltR :Rlt lRVt uR tR( t+R RDt( cRt+ R1t( :Rt+ tR1D( :+cR RMt( R+t",
+"M VRt( tRV+ tRl( lRt+ ltVR( uR+ tRE R&tE tHR cRtH R1tE tE:R R1tH :RtH RMtE ",
+"tRM&E VRtH tcVRH tRlE t:RlE lRtH uRH tdR R+td RHtd gtR R1td :Rtd tHR1d t:gR",
+" RdtM t+RdM tRVd VtgR lRtd t:dlR tdVlR ugR tR2 R&t2 RDt2 c2tR t5R :Rt5 R5tD",
+" cRt5 RMt2 tRM&2 tRV2 tcVR2 lRt5 t:Rl5 tRV5 uR5 t;R R+t; RDt; cRt; R1t; t>R",
+" t5RD; :Rc> R;tM t+RM; tRV; tc;VR lRt; >Rlt t5VR; u>R REt2 tR&E2 RHt2 tcRH2",
+" R5tE t:R5E RHt5 t:HR5 tRME2 M&EtR2 tHVR2 cRVtH2 t5RlE lt5:RE tH5lR RHu5 Rd",
+"t; t+Rd; RHt; t;gR R5td >Rtd tH5Rd gRt> tdRM; dM&t;R tH;VR gtVR; t5dlR t>lR",
+"d tH;lR g>uR tP tP& tPD tcP tP1 t:P 1DtP :ctP St St& StV Sct Stl S:t SVlt u",
+"S tP( t+P DPt( cPt+ 1Pt( :Pt+ tP1D( t:Pc+ St( St+ S(Vt tcS+ l(St l+St SlVt(",
+" uS+ tWR RWt& tHP cRtW R1tW :RtW 1HtP :HtP StW tWS& tZS tZSc lWSt tWS: lZSt",
+" uZS tdP R+tW HPtd gtP 1dtP :dtP tHP1d t:gP Std t+Sd SdtZ gtS ldSt t:Sd Std",
+"lZ ugS tmR Rmt& RDtm cRtm t5P :Rtm 5DtP cR:m Stm tmS& tmSV tmSc tpS tpS: Vp",
+"St upS t;P R+tm D;tP c;tP 1;tP t>P t5PD; tc>P St; t+S; t;SV S;tc l;St S>t S",
+"t;Vp u>S RWtm tWRm& RHtm tcWRm R5tW t:WR5 H5tP t:HRm SWtm StWm& tmSZ ScZtm ",
+"tWSp S:ptW SZtp SZup tvR vRt+ vRtH gRtv vRt5 >Ptv tvR1H >Pgt tvS S+tv StVv ",
+"tvgS Stlv tvS: lvVSt yuS )O !)O )BO a)O )O. 8)O )O.B a)8O )OK )O!K T)O a)TO",
+" jO) 8)jO T)jO s)O *O +*O *BO a*O *O. 8*O .B*O 8Oa* *OK *O+K T*O +OT* *jO j",
+"O8* jOT* s*O E)O E)!O H)O a)HO )OE. E)8O )OH. 8)HO )OEK !E)OK T)HO HTa)O E)",
+"jO jO8E) H)jO H)sO d*O d*+O H*O g*O *Od. d*8O *OH. 8*gO *OdK +d*OK HOT* T*g",
+"O d*jO dj*+O jOH* gOs* )O2 )O!2 )O2B )Oa2 5)O 8)5O )B5O a)5O )O2K !)2OK )OT",
+"2 Ta)O2 5)jO jO58) T)5O 5)sO ;*O ;*+O ;O*B ;*aO 5*O >*O 5O*B a*>O *O;K +;*O",
+"K ;*TO a;*TO jO5* *j>O 5OT* >Os* )OE2 !)2EO )OH2 Ha)O2 E)5O 58E)O 5)HO H58)",
+"O EK)O2 !)OEK2 HT)O2 Ta)HO2 jO5E) 58EjO) H5T)O sH5)O ;*dO +d;*O ;*HO ;*gO d",
+"*5O d*>O HO5* g*>O dK;*O dK;+*O H;T*O gT;*O dj*5O >*djO H5*jO s*Og> P) P)! ",
+"P)B aP) P). 8P) .BP) 8)aP QP) P)Q! TP) Q)aP Pj) Q)8P T)Pj sP) P* +P* P*B aP",
+"* P*. 8P* P.*B aP8* Q*P Q*+P TP* T*+P P*j 8PQ* PjT* sP* WP) P)W! HP) H)aP P",
+")W. W)8P P)H. H)8P QPW) Q!WP) ZP) aPZ) W)Pj Pj)W8 PjZ) ZPs) W*P W*+P HP* gP",
+"* W.P* 8PW* H.P* 8Pg* dPQ* +WQP* Z*P Z*gP P*Wj dPj8* P*Zj s*gP mP) P!m) P)m",
+"B mPa) 5P) 5)8P P)5B 5)aP mPQ) Q!mP) mPT) amPQ) pP) 8Pp) TPp) pPs) m*P m*+P",
+" *B;P m*aP 5P* >P* *B5P aP>* ;PQ* m*P+Q m*TP am*TP p*P p*>P TPp* s*>P mPW) ",
+"W!mP) mPH) amPH) WP5) 5W8P) H)5P H5P8) WQmP) WmPQ!) mPZ) ZamP) WPp) pW8P) p",
+"PZ) sP)Zp vP* +Pv* HPv* vPg* 5Pv* vP>* 5PH* >*gP Q*vP v+QP* vPZ* ZvPg* vPp*",
+" >Ppv* ZPp* y*P ,O ,&O ,OB ,aO ,O. ,8O .B,O 8a,O ,OK &O,K ,TO ,OT& ,jO ,O&j",
+" jO,T s,O ,*O -O ,O*B -aO *O,. -8O *B,O. 8a-O *O,K -OK ,OT* -TO ,O*j -jO *j",
+"O,T s-O ,EO &E,O ,HO ,OH& EO,. 8E,O HO,. ,OH8 EK,O ,&EOK HT,O ,HTaO jO,E &j",
+"E,O ,OHj ,HsO ,dO -dO ,OH* g-O dO,. 8d-O ,HdO. -8gO dK,O dK-O ,OTd gO-T ,Od",
+"j dj-O ,HjdO gOs- ,O2 &O,2 2B,O aO,2 ,5O ,O5& 5B,O ,O5a 2K,O ,&O2K TO,2 ,Ta",
+"O2 jO,5 &jO,5 ,O5T ,5sO ,;O -;O ;O,B a;-O ,O5* ->O ,5;OB -a>O ;O,K ;O-K ,OT",
+"; T;-O ,O;j >O-j ,5T;O >Os- EO,2 ,&EO2 HO,2 ,HaO2 5E,O ,58EO ,OH5 ,H58O ,EO",
+"2K &EO,2K ,HTO2 H&O,T2 ,5jEO ,5E&jO ,H5jO s,H5O d;,O d;-O ,OH; -;gO ,O5d -d",
+">O ,H5dO >Og- ,d;OK -d;OK ,H;TO -T;gO ,5djO ->djO ,H;jO s-g>O ,P ,P& ,PB ,a",
+"P ,P. ,8P P.,B 8P,a ,QP Q&,P ,TP Qa,P ,Pj Q8,P TP,j sP, ,P* -P *B,P -Pa ,.P",
+"* -P8 P*.,B 8P-a Q*,P -QP T*,P -TP P*,j -Pj P*j,T s-P ,WP W&,P ,HP HP,a WP,",
+". W8,P ,.HP H8,P WQ,P ,WQP& Z,P ,aZP Wj,P P&j,W ,PZj Z,sP ,dP -WP HP,d g-P ",
+",.dP W8-P ,HPd. g8-P Qd,P Qd-P ,dZP Z-P dP,j Wj-P Z*P,j gPs- ,mP m&,P mP,B ",
+"am,P ,5P 5P,8 ,B5P 5a,P Qm,P m&P,Q Tm,P ,QamP p,P ,8pP ,TpP p,sP ,;P -mP ,B",
+";P am-P 5P,; >P- ,5P*B -a>P Q;,P Q;-P T;,P Tm-P ,;pP -pP p*T,P >Ps- Wm,P m&",
+"P,W Hm,P ,HmaP 5W,P ,5W8P H5,P ,H58P ,WQmP ,WQm&P ,mZP Z&m,P ,WpP p&W,P ZPp",
+", sP,Zp v,P -vP ,HvP gP-v ,5vP >P-v v,H5P g->P ,QvP vQ-P ZPv, -PZv pPv, pv-",
+"P Zp*,P y-P C)O C)!O D)O a)DO )OC. C)8O )OD. 8)DO )OCK !CO)K T)DO DTa)O C)j",
+"O jO8C) D)jO D)sO *CO *C+O D*O +OD* CO*. *C8O *OD. DO8* CK*O +*COK DOT* a*O",
+"DT *CjO *jC+O jOD* D*sO E)CO CE)!O D)HO HDa)O C).EO 8CE)O HD)O. H8D)O CE)OK",
+" EK)!CO HDT)O DTaH)O jOCE) 8CEjO) HjD)O sHD)O *CdO +d*CO HOD* D*gO d*CO. 8d",
+"*CO H*DO. gD8*O dK*CO dK*+CO H*DTO gDT*O dj*CO 8dC*jO H*jDO s*DgO )OC2 !)2C",
+"O )OD2 Da)O2 C)5O 58C)O D)5O 5D8)O 2KC)O CKO!)2 DT)O2 Ta)DO2 jO5C) 58CjO) 5",
+"DT)O s5D)O *C;O +;*CO ;*DO a;*DO *C5O *C>O 5OD* D*>O ;*COK ;*C+OK D;T*O D;T",
+"a*O ;jC*O >*jCO 5D*jO >D*sO CE)O2 !O2CE) HD)O2 Da)HO2 5CE)O 8CE5)O H5D)O 5D",
+")H8O C)OEK2 C)!OEK2 DT)HO2 DTH)aO2 5CEjO) 5)jO8CE 5D)HjO H5Ds)O d;*CO d;*+C",
+"O H;D*O gD;*O 5d*CO >*dCO H5*DO >D*gO ;*CdKO dK+*;CO D;TH*O D;Tg*O 5dC*jO d",
+"j*>CO djO5D* gs*>DO PC) !CP) DP) D)aP C)P. PC8) P)D. D)8P PCQ) Q!PC) Q)DP a",
+"P)QD jCP) PjC8) D)Pj DPs) P*C +CP* DP* D*+P *CP. 8CP* D.P* 8PD* QCP* P*C+Q ",
+"DPQ* aP*QD PC*j P*j+C P*Dj DPs* PCW) W!PC) H)DP aP)WD WPC). W8PC) HPD). H8P",
+"D) WQPC) WPCQ!) DPZ) ZDaP) PjCW) W8CPj) ZDPj) sPDZ) WCP* dPC+* DPH* DPg* dP",
+"C*. W8*PC HP*D. gPD8* dPCQ* +WQP*C DPZ* Z*DgP dPj*C dPCQ8* Z*DPj sP*gD PCm)",
+" mPC!) mPD) amPD) PC5) 5P8C) 5)DP 5DP8) QmPC) mPCQ!) QDmP) QDmaP) PCp) p8PC",
+") DPp) sPDp) mCP* m*P+C m*DP am*DP 5CP* P*>C DP5* DP>* m*PQC +QmP*C QD;P* Q",
+"D;aP* P*pC >Pp*C DPp* sP*pD WmPC) mPCW!) HmDP) HmDaP) 5WPC) W8C5P) H5PD) aP",
+")5WD QmPWC) W)Q!mPC ZDmP) amPZD) pWPC) W8PpC) ZpDP) ZpDsP) P*vC v+P*C DPv* ",
+"gvDP* v5P*C >Pv*C vD5P* >PgD* vQP*C P*Cv+Q ZvDP* gvDZ*P pvP*C pv*>PC Zp*DP ",
+"DPy* ,bO b&,O ,DO c,O bO,. ,Ob8 DO,. ,8cO bK,O ,b&OK ,ObT ,TcO ,Obj &jO,b ,",
+"ODj c,sO b*O -bO ,OD* c-O *Ob. b8-O ,D*O. -8cO *ObK bK-O bOT* cO-T jOb* bj-",
+"O ,Dj*O sOc- bE,O ,b&EO ,ObH ,HcO ,bEO. ,8bEO ,HbO. cH8,O ,bEOK bK&,EO ,HbT",
+"O cHT,O ,jbEO b8E,jO ,HjbO s,HcO ,Obd bd-O ,ODd gOc- ,dbO. -b8dO ,DdO. c-8g",
+"O ,dbOK -bdOK ,DdTO c-TgO ,djbO -jbdO ,DdjO s-gcO bO,2 ,b&O2 DO,2 ,Oc2 ,Ob5",
+" ,5b8O ,O5D ,5cO ,bO2K bK&,O2 ,DTO2 c2T,O ,5bjO ,5b&jO ,5DjO s,5cO ,Ob; b;-",
+"O ,OD; -;cO bO5* -b>O ,5D;O >Oc- ,;bOK -b;OK ,D;TO c-T;O ,;jbO ->bjO ,D;jO ",
+"s-c>O ,bEO2 b&E,O2 ,HbO2 c2H,O ,5bEO b5E,8O ,H5bO c5H,O bKE,O2 EO,2bK& bHO,",
+"T2 ,HTc2O b5E,jO 5jbE,8O ,HOb5T c5Hs,O ,db;O -bd;O ,H;bO c-;gO ,5dbO ->bdO ",
+",5DdO c>g-O bdO,;K bd;-OK ,HObT; -T;gcO djOb5* >bd-jO djO,5D c>gs-O ,Pb ,bP",
+"& ,DP cP, ,.bP b8,P ,.DP ,8cP bQ,P ,QbP& bT,P ,QcP bP,j P&j,b DP,j cPs, bP*",
+" -Pb DPb* c-P b.P* b8-P ,DP*. c8-P Q*bP bQ-P TPb* -QcP P*bj bP-j P*j,D c-sP",
+" bW,P ,WbP& bH,P ,HcP ,WbP. ,W8bP ,HPb. cW8,P ,WbQP bWQ,P& ,DZP cPZ, ,WjbP ",
+"bW8,Pj ZbP,j sP,Zc bd,P bW-P HPb* c-gP ,dPb. -Wb8P ,DdP. c-W8P ,QdbP -WbQP ",
+"bPZ* cPZ- dPjb* -WjbP Zb*Pj s-PZc bm,P m&P,b Dm,P ,mcP b5,P ,5Pb8 5D,P ,5cP",
+" ,QbmP ,Qbm&P ,QDmP cQm,P ,Ppb pb8,P ,DpP p,cP b;,P bm-P D;,P -mcP 5Pb* >b-",
+"P ,5D;P c->P ,Q;bP -Qb;P ,QD;P c-Q;P bPp* pb-P pb*DP cP-p ,WbmP ,Wbm&P ,Hmb",
+"P cWm,P ,5WbP b5W,8P ,H5bP c5W,P bWQ,mP QmP&,Wb Zbm,P ZcP,m pbW,P ,W8pbP Zp",
+"b,P cpZ,P ,Pvb vb-P ,DvP cP-v vb5,P -v>bP vD,5P cv->P vbQ,P -vbQP Zvb,P cvZ",
+"-P pvb,P -pvbP ZpbP* c-yP 0)O 0)!O 0)OB 0)aO 1)O 8)1O )B1O a)1O )O0K !K0)O ",
+"0)TO Ta0)O 1)jO jO18) T)1O 1)sO *0O *0+O 0B*O *0aO 1*O 1O8* 1O*B 1Oa* 0O*K ",
+"+*0OK *0TO a*0TO jO1* *jO1+ 1OT* 1*sO 0)EO !E)0O 0)HO Ha0)O E)1O 18E)O H)1O",
+" 1H8)O EK0)O !0OEK) HT0)O Ta0H)O jO1E) 18EjO) 1HT)O s1H)O *0dO +d*0O *0HO *",
+"0gO d*1O 1+d*O 1OH* 1*gO dK*0O dK*+0O H*T0O gT*0O dj*1O 1+d*jO 1H*jO s*1gO ",
+")O02 0)2!O 0)2OB a0)O2 5)1O 158)O 15)OB 1a5)O 0)2OK !)O2K0 T0)O2 a0)TO2 jO1",
+"5) 158jO) 1T5)O s15)O *0;O +;*0O *B;0O a;*0O 1O5* 1*>O 1;*OB >*1aO ;*0OK ;*",
+"0+OK T;*0O T;0a*O ;jO1* >*1jO 1T;*O s*1>O 0)2EO !EO0)2 H0)O2 a0)HO2 15E)O 5",
+"8E1)O 1H5)O H5)1aO E)O2K0 0)EO2K! T0)HO2 0)HOTa2 15EjO) 5)jO18E H5)1TO 1H5s",
+")O d;*0O d;*+0O H;*0O g;*0O 1d5*O >*1dO 1H;*O g>1*O ;*0dKO dK+*;0O T;0H*O T",
+";*g0O 1d5*jO dj*>O1 ;jO1H* g>1s*O P0) !0P) )BP0 P0a) 1P) 1)8P P)1B 1)aP P0Q",
+") Q!P0) P0T) aP0Q) 1)Pj Pj)18 1)TP 1Ps) P*0 +0P* P0*B a0P* 1P* +P1* *B1P aP",
+"1* Q0P* P*0+Q T0P* aP*Q0 Q*1P P*j1+ TP1* 1Ps* P0W) W!P0) P0H) aP0H) WP1) 1W",
+"8P) 1)HP 1HP8) WQP0) WP0Q!) P0Z) ZaP0) Pj)1W 1W8Pj) 1PZ) sP1Z) W0P* dP0+* H",
+"0P* P*g0 W*1P 1+WP* HP1* 1Pg* dP0Q* +WQP*0 P*Z0 Z*Pg0 dPj1* 1+WP*j 1PZ* sP*",
+"g1 P0m) mP0!) mP0)B amP0) 1)5P 1m8P) 1mP)B 1amP) QmP0) mP0Q!) TmP0) Tm0aP) ",
+"1Pp) p18P) p1TP) sP1p) m0P* m*P+0 m*P0B am*P0 5P1* 1P>* 1m*PB >P1a* m*PQ0 +",
+"QmP*0 Tm*P0 am0TP* 1Pp* >Pp1* p*1TP sP*p1 WmP0) mP0W!) HmP0) Hm0aP) 1W5P) 5",
+"W81P) 1HmP) am)1HP QmPW0) P!m0WQ) ZmP0) amPZ0) p1WP) 1W8pP) Zp1P) Zp1sP) P*",
+"v0 v+P*0 vHP*0 gvP*0 1Pv* >Pv1* v1HP* >Pg1* vQP*0 P*0v+Q ZvP*0 gvPZ*0 pv1P*",
+" pv1>P* Zp*1P 1Py* ,9O 9&,O 9O,B ,O9a ,1O :,O 1O,B ,a:O 9O,K ,9&OK ,O9T ,T9",
+"aO ,O9j ,j:O ,O1T :,sO 9*O -9O 9O*B 9a-O ,O1* :-O ,1*OB -a:O *O9K 9O-K 9OT*",
+" 9T-O jO9* :O-j ,1T*O sO:- 9E,O ,9&EO ,O9H ,H9aO 1E,O ,E:O ,O1H ,H:O ,9EOK ",
+"9&E,OK ,H9TO 9HT,aO ,1jEO :j,EO ,1HjO s,H:O ,O9d 9d-O 9OH* -9gO ,O1d -d:O ,",
+"1HdO gO:- ,d9OK -9dOK ,Td9O -T9gO ,1djO :-djO ,1TdO g:s-O 9O,2 ,9&O2 ,9O2B ",
+",a9O2 ,O95 ,5:O ,15OB :5a,O ,9O2K 9&O,2K ,T9O2 9TO,a2 ,15jO :5j,O ,1T5O s,5",
+":O ,O9; 9;-O ,;9OB -9a;O ,O1; >O:- ,1;OB :->aO ,;9OK -9;OK ,T;9O -T9;O ,1;j",
+"O :->jO ,1T;O s-:>O ,9EO2 9&E,O2 ,H9O2 9HO,a2 ,15EO :5,EO ,1H5O :H5,O 9EO,2",
+"K EO,29&K 9HO,T2 HO,29Ta 95E,jO ,5j:EO ,HO95T :H5s,O ,d9;O -9d;O ,H;9O g-9;",
+"O ,1d5O :->dO ,1H;O g:->O 9dO,;K 9d;-OK ,HO9T; g9;-TO djO,1; ->j:dO ;jO,1H ",
+"s->g:O ,P9 ,9P& ,B9P 9a,P ,1P :P, ,B1P ,a:P 9Q,P ,Q9P& 9T,P ,Qa9P 9P,j ,Q:P",
+" 1T,P :Ps, 9P* -P9 *B9P 9a-P 1P9* :-P ,1P*B :a-P Q*9P 9Q-P TP9* 9T-P P*9j -",
+"Q:P P*j9T :-sP 9W,P ,W9P& 9H,P ,HP9a 1W,P ,W:P 1H,P ,H:P ,W9QP 9WQ,P& ,PZ9 ",
+"Z9a,P ,1WPj :WQ,P ,1ZP :PZ, 9d,P 9W-P HP9* -Pg9 1d,P -W:P ,1HdP :-gP ,Qd9P ",
+"-W9QP 9PZ* -PZ9 dPj,1 :-WPj Z9*1P :PZ- 9m,P m&P,9 ,m9PB ,am9P 95,P ,5:P ,1m",
+"PB :ma,P ,Q9mP ,Q9m&P ,Tm9P 9Tm,aP ,1pP p,:P p9T,P sP,:p 9;,P 9m-P ,;P9B -m",
+"9aP 1;,P :->P ,1;PB :-maP ,Q;9P -Q9;P ,T;9P -Tm9P 9Pp* :P-p p9*TP -ps:P ,W9",
+"mP ,W9m&P ,Hm9P 9Hm,aP ,1W5P :W5,P ,1H5P :Hm,P 9WQ,mP QmP&,W9 Z9m,P ,amZ9P ",
+"p9W,P :pW,P Zp9,P Z:p,P ,Pv9 v9-P v9H,P -vg9P ,1vP :P-v v1,HP :v-gP v9Q,P -",
+"v9QP Zv9,P Z-v9P pv9,P :v-pP Zp9P* :-yP 0)CO C0)!O 0)DO Da0)O C)1O 18C)O D)",
+"1O 1D8)O C0)OK !K)C0O DT0)O Ta0D)O jO1C) 18CjO) 1DT)O s1D)O C0*O +*C0O *0DO",
+" a*0DO *C1O 1+*CO 1OD* 1+D*O *C0OK *C0+OK D*T0O D*0+TO *jC1O 1+C*jO 1D*jO s",
+"*1DO C0)EO !E)C0O HD0)O Da0H)O 1CE)O 8CE1)O 1HD)O H8)1DO EK)C0O 0)EOCK! DT0",
+"H)O 0)HODTa 1CEjO) C)8O1jE Hj)1DO 1HDs)O d*C0O d*C+0O H*D0O gD*0O 1d*CO 8dC",
+"1*O 1H*DO g1D*O *C0dKO C0dO+*K Td0D*O D*Tg0O 1dC*jO dj1*+CO djO1D* g1Ds*O C",
+"02)O !)2C0O D0)O2 a0)DO2 15C)O 58C1)O 1D5)O 5D)1aO CKO0)2 0)C2!KO T0)DO2 0)",
+"TODa2 15CjO) 5)jO18C 5D)1TO 1D5s)O ;*C0O ;*C+0O D;*0O D;0a*O 1;*CO >*1CO 1D",
+";*O >D*1O *C0;OK C0;O+*K T;0D*O a;D*T0O 1;C*jO *jC>O1 ;jO1D* s*1>DO CEO0)2 ",
+"0)C2!EO D0)HO2 0)HODa2 5CE1)O 5E1O8C) H5)1DO 5OD81H) 0)C2EKO C)!OE02K 0)HOD",
+"T2 DaHO0)T2 5)jO1CE 5j1EC)8O H)Dj15O 15s)HDO ;*Cd0O C0;O+d* D;0H*O D;*g0O 5",
+"dC1*O 1d*>CO 1HO5D* g1*>DO C0;OdK* dK+*C0;O T;H*D0O D*g0T;O dj1;*CO dj>*1CO",
+" jOH;1D* >Dgs1*O C0P) PC0!) P0D) aP0D) PC1) 1P8C) 1)DP 1DP8) QPC0) PC0Q!) Q",
+"DP0) QD0aP) PjC1) Q8C1P) 1QDP) sP1D) *CP0 P*C+0 D0P* aP*D0 1CP* 1+P*C DP1* ",
+"aP*1D P*CQ0 +QCP*0 QD*P0 aP0QD* P*j1C P*C1+Q P*j1D sP*1D WPC0) PC0W!) HPD0)",
+" WD0aP) 1WPC) W8C1P) 1HPD) aP)1WD QPCW0) QCW0P)! ZDP0) aP0ZD) 1WCPj) QC8P1W",
+") Z1DP) Z1DsP) dPC*0 +WCP*0 HP*D0 gPD*0 1W*PC P*C1+W 1HPD* g1PD* QdCP*0 QCd",
+"P+*0 Z*DP0 gPDZ*0 dPC1Q* WC*j1+P Z1*DP sPDZ1* mPC0) PC0m)! DmP0) Dm0aP) 1mP",
+"C) 8mC1P) 1DmP) am)1DP mPCQ0) P!m0QC) Tm0DP) amDPQ0) p1PC) 1P8pC) pD1P) pD1",
+"sP) m*PC0 +mCP*0 Dm*P0 am0DP* 1m*PC >P1*C 1DmP* >PD1* Q;CP*0 QCm*+P0 ;P0QD*",
+" m*DP+Q0 p*1PC p*1>PC pD*1P sP1pD* mPCW0) P!m0WC) Dm0HP) amHPD0) 5WC1P) W)8",
+"P1mC 1H)5DP H)8m1DP QCW0mP) !Cm)QPW0 DmPZ0) amZPD0) 1WPpC) 18pCWP) pDPZ1) s",
+"1pDZP) vP*C0 P*Cv+0 vDP*0 gP*vD0 v1P*C v1*>PC v1DP* >D*g1P P*CvQ0 P*vC+Q0 v",
+"DPZ*0 gDZ*vP0 v1Pp*C >*v1pPC Z1PpD* y*1DP b9,O ,b9&O ,O9D ,9cO ,Ob1 ,b:O ,O",
+"1D c,:O ,b9OK b9&,OK ,D9TO c9T,O ,1bjO :bj,O ,1DjO s,O:c bO9* b9-O 9OD* -9c",
+"O bO1* -b:O ,1D*O :Oc- b*9OK -b9OK bT*9O c-9TO b1*jO :-bjO b1T*O s-:cO ,b9E",
+"O b9&,EO ,H9bO c9H,O ,1bEO :b,EO ,1HbO :cH,O b9E,OK b9,&EKO bH9,TO ,H9cTO b",
+"1E,jO ,jb:EO ,1ObHj :cHs,O ,db9O -b9dO ,Dd9O c-9gO ,1dbO :-bdO ,1DdO g:c-O ",
+"9dOb*K bd9-OK ,DO9Td -T9gcO djOb1* -jb:dO djO,1D s-cg:O ,b9O2 b9&,O2 ,D9O2 ",
+"c29,O ,1b5O :b5,O ,1D5O :c5,O b9O,2K bO,29&K 9DO,T2 ,T9c2O b15,jO ,5b:jO ,1",
+"Ob5T :c5s,O ,;b9O -b9;O ,D;9O c-9;O ,1;bO :->bO ,1D;O c>:-O 9;Ob*K b;9-OK ,",
+"DO9T; -T9c;O ;jOb1* -jb:>O ;jO,1D c>:s-O b9E,O2 EO,2b9& 9HO,D2 ,H9c2O b1E,5",
+"O ,5b:EO ,1ObH5 c5,:HO EO,2b9K 9&,KEOb2 HO,2bT9 ,9c2HTO 5E9O,jb ,b:EjO5 ,O1",
+"Hb5T sHc5:,O bd9,;O bd9-;O ,HO9D; g-9c;O ,1Ob5d ->b:dO ,1ObH; c>-g:O ,Obd9;",
+"K b9-OdK; ,OH;bT9 gTc;-9O ,O1db;j >j:d-bO 1H,;bTO >Og:s-c ,b9P ,P9b& 9D,P ,",
+"Pc9 b1,P ,P:b 1D,P :,cP ,Qb9P bQ9,P& ,QD9P cQ9,P ,1QbP :Qb,P ,1QDP sP,:c 9P",
+"b* bP-9 DP9* c9-P 1Pb* :b-P ,1DP* c-:P bQ*9P -Qb9P bTP9* c-Q9P P*jb1 :-QbP ",
+"P*j9D s-P:c ,Wb9P bW9,P& ,HP9D cW9,P ,1WbP :Wb,P ,1HbP :cW,P bW9,QP WQP&,b9",
+" Zb9,P Zc9,P b1W,Pj ,Wj:Pb Zb1,P Z:c,P ,dPb9 -Wb9P ,Dd9P c-W9P ,1dbP :-WbP ",
+",1DdP g:Pc- 9QdbP* bQd-P9 Zb*9P Z-c9P b1WP*j :Wb-Pj Zb1P* Z:-cP ,mb9P bm9,P",
+"& ,Dm9P cm9,P ,1mbP :mb,P ,1D5P :cm,P bQ9,mP QmP&,b9 9Dm,TP ,TmcP9 pb9,P :p",
+"b,P p9D,P cp:,P ,;Pb9 -mb9P ,D;9P c-m9P ,1;bP :-mbP ,1D;P c>P:- 9Q;bP* bQ;-",
+"P9 9QD,;P cm9-TP pb*9P -p:bP p9DP* cp-:P bW9,mP WmbP,9& 9Hm,DP ,HmcP9 b1W,5",
+"P ,5W:Pb b1H,5P :H,c5P QmbP,W9 ,bP&WQ9m ,DmZ9P cm9Z,P ,1WpbP pbW:P, Z9PpD, ",
+"Z:Pcp, vb9,P -vb9P v9D,P cv-9P vb1,P :v-bP v1D,P :vc-P bQ*v9P vb9-QP Z9PvD,",
+" Z-9cvP pbPv1, -pb:vP ZbPp9* y:c-P R) R)! R)B Ra) R). R8) .BR) 8aR) RM) M)R",
+"! RT) R)aM Rj) R)8M TjR) sR) R* R+* R*B Ra* R*. R8* R.*B 8*Ra R*M +MR* RT* ",
+"+TR* R*j +jR* T*Rj sR* RE) !ER) RH) HaR) E)R. 8ER) H)R. R)H8 MER) RME!) R)H",
+"M aM)RH jER) R8ME) R)Hj RHs) Rd* +dR* RH* gR* d*R. 8dR* R.H* R8g* dMR* dM*R",
+"+ HMR* RTg* djR* R+jd* H*Rj s*gR R)2 !)R2 2BR) a)R2 R5) 58R) 5BR) R)5a M)R2",
+" RM)!2 T)R2 aM)R2 R)5M R58M) R)5T R5s) R;* +;R* *BR; a;R* R5* >R* *BR5 Ra>*",
+" M;R* M;*R+ T;R* aM;R* 5MR* R*>M 5TR* >Rs* E)R2 RE)!2 H)R2 RHa)2 5ER) R58E)",
+" R)H5 RH58) RME)2 ME)R2! RHT)2 RH)aM2 R5ME) 5MER8) RH5T) sRH5) d;R* R+d;* H",
+";R* R;g* 5dR* Rd>* H5R* >*gR dM;R* R+dM;* RH;T* gRT;* R5dM* >MRd* RH5T* >Mg",
+"R* RP) P)R! P)RB R)aP P)R. R)8P RP).B aP)R8 S) S!) ST) Sa) Sj) S8) TjS) Ss)",
+" R*P +PR* RP*B aPR* R.P* 8PR* P*.RB aP*R8 S* S+* S*T Sa* S*j S8* T*Sj Ss* R",
+"W) W!R) R)HP R)Wa W)R. R)W8 RHW). RH8W) SW) W!S) SZ) ZaS) WjS) W8S) ZjS) s)",
+"SZ RW* +WR* HPR* RWg* R.W* W8R* RH*W. gRW8* Sd* +WS* SZ* gS* W*Sj W8S* SjZ*",
+" s*gS Rm) m)R! m)RB R)am R)5P R)8m R5m)B R5am) Sm) m)S! TmS) amS) Sp) p8S) ",
+"pTS) s)Sp Rm* +mR* *BRm amR* 5PR* Rm>* R5*mB >PRa* S;* +mS* TmS* amS* Sp* S",
+">* STp* s*S> WmR) RWm!) R)Hm RHma) R)5W R5W8) RH5W) RH8m) WmS) S!Wm) ZmS) S",
+"Zam) pWS) SpW8) S)Zp SZps) vR* R+v* RHv* g*vR R5v* >*vR vRH5* >PgR* Sv* v+S",
+"* ZvS* S*gv pvS* v>S* ZpS* yS* ,R ,R& ,RB ,Ra ,R. ,R8 RB,. R8,a ,RM R&,M ,R",
+"T RT,a ,Rj R8,M RT,j sR, ,R* -R *B,R -Ra ,.R* -R8 ,R*.B R8-a R*,M -RM R*,T ",
+"-RT R*,j -Rj ,RT*j s-R ,RE ,ER& ,RH RH,a RE,. ,ER8 ,.RH RH,8 RM,E M&E,R RH,",
+"T ,RHT& ,ERj ,R8ME RH,j ,RsH ,Rd -Rd RH,d g-R ,.Rd R8-d ,RHd. g8-R Rd,M Rd-",
+"M RT,d -RgM Rd,j Rd-j ,RHdj gRs- ,R2 ,2R& RB,2 ,2Ra ,R5 R5,8 RB,5 R5,a RM,2",
+" M&2,R ,2RT ,RT&2 R5,M ,R58M R5,T ,Rs5 ,R; -R; RB,; Ra-; R5,; ->R ,R5*B -a>",
+"R R;,M R;-M RT,; RT-; R;,j -R>M ,R5T; ->sR RE,2 ,R&E2 ,2RH ,RH&2 ,ER5 ,R58E",
+" RH,5 ,RH5a ,RME2 ,REM&2 ,RHT2 aM2,RH ,R5ME M&E,R5 ,RH5T sR,H5 Rd,; Rd-; RH",
+",; g;-R R5,d -d>R ,RH5d ->gR ,RdM; -RdM; ,RHT; -RTg; ,R5dM >M-Rd ,RH;j s-Rg",
+"> ,RP R&,P RB,P Ra,P RP,. R8,P ,RP.B ,R8aP S, S&, S,T Sa, S,j S8, ,TSj Ss, ",
+"R*,P -RP P*B,R Ra-P P*.,R R8-P ,R.P*B -R8aP S*, S- ,TS* S-T ,jS* S-8 S*T,j ",
+"S-s ,RW R&,W RH,W RW,a ,.RW RW,8 ,RHW. ,RHW8 S,W ,WS& SZ, Z&S, ,WSj ,WS8 Sj",
+"Z, s,SZ RW,d -RW ,RHW* -RgP ,RWd. RW-8 dP.,RH -RWg8 Sd, S-W Z*S, gS- ,dSj -",
+"WS8 SZ*,j s-gS ,Rm R&,m RB,m Ra,m R5,m R8,m ,R5mB ,R5am S,m ,mS& ,TSm ,aSm ",
+"Sp, p&S, STp, s,Sp Rm,; -Rm ,Rm*B Ra-m ,R5m* -R>P m*B,R5 >P-Ra S;, S-m ,TS;",
+" -TS; p*S, S-p Sp*,T s-S> RW,m ,RWm& RH,m ,RHam R5,W ,R5W8 ,RH5W ,RH8m ,WSm",
+" S&W,m SmZ, SZ&,m SWp, Sp&,W ZpS, Ss,Zp vR, -vR ,RvH gR-v ,Rv5 v>-R vR,H5 -",
+"vRg> Sv, S-v ZvS, SvZ- pvS, Sv-p Sv,Zp y-S RU) U!R) RD) R)Ua U)R. R)U8 D)R.",
+" R)D8 UMR) RUM!) VR) RaV) R)Uj R8UM) RjV) VRs) R*U U+R* RD* UaR* R.U* U8R* ",
+"R.D* D8R* RUM* R+UM* V*R R+V* U*Rj R+jU* R*Vj V*sR UER) RUE!) R)UH RHUa) RU",
+"E). R8UE) RHU). RH8U) RUME) U!MRE) RHV) VRHa) RjUE) U8ERj) VRHj) VsHR) UdR*",
+" R+Ud* UHR* RDg* RdU*. R8dU* RH*U. gRU8* dM*RU R+UdM* RHV* V*gR RdjU* U8dR*",
+"j VdR*j s*VgR U)R2 RU)!2 D)R2 RDa)2 R)U5 R5U8) R)5D R5D8) RUM)2 U!MR)2 R)V2",
+" V2Ra) R5UM) U58Rj) R5V) Vs5R) U;R* R+U;* D;R* R+D;* U5R* R*>U 5DR* RD>* M;",
+"*RU R+UM;* R;V* V+R;* R5*Uj >MRU* R5V* >RV* RUE)2 U!ER)2 RHU)2 UH)Ra2 R5UE)",
+" U5ER8) RH5U) RH)U5a UMER)2 !ER)UM2 V2RH) RHaV2) U5ERj) REU85M) V5RH) sRHV5",
+") RdU;* U+dR;* RH;U* gRU;* R5dU* >RUd* RH5U* g>RU* RdUM;* dMR;U+* VdR;* gVR",
+";* U5dR*j Rdj>U* V5dR* V>gR* UP) P)U! R)DP U)aP P)U. U)8P RDP). RD8P) SU) U",
+"!S) SV) VaS) UjS) U8S) VjS) s)SV UP* +PU* DPR* aPU* U.P* 8PU* RD*P. aP*U8 S",
+"*U U+S* SV* V+S* U*Sj U8S* SjV* s*SV R)UW RWU!) R)WD RWDa) RWU). RW8U) RWD)",
+". RWD8) UWS) S!UW) S)VZ SZVa) SUWj) S8UW) SZVj) SsZV) UWR* R+WU* HPU* UPg* ",
+"RW*U. RW8U* RWD*. gUP8* UWS* S+UW* Z*SV S*gV SdU*j S8dU* SZ*Vj Ss*gV R)Um R",
+"mU!) R)Dm RDma) U)5P R8mU) R5Dm) RD8m) UmS) S!Um) S)Vm SVam) S)pU SpU8) S)V",
+"p SspV) UmR* R+mU* DmR* am*RD 5PU* UP>* R5Dm* >PUD* UmS* S+Um* VmS* SV+m* p",
+"US* >US* S*Vp S*V> RWUm) UW)Rm! RHmU) am)RWD R5WU) R5)UW8 R5WD) aP)UH5 SUWm",
+") UWmS!) SZVm) VZmSa) SpUW) pUWS8) SZpV) VpZSs) R*vU vRU+* RDv* gvRU* vRU5*",
+" >PUv* vRD5* >PgU* vUS* SvU+* S*Vv VvgS* Sp*vU S>vU* VvpS* SVy* ,Rb R&,U ,R",
+"D cR, ,.Rb Rb,8 ,.RD ,Rc8 Rb,M ,RbM& V,R V,cR Rb,j ,R8bM ,RVj cRs, Rb* -Rb ",
+"R*,D c-R R.b* Rb-8 ,RD*. c8-R bMR* Rb-M ,RV* V-R b*Rj Rb-j V*R,j sRV- ,ERb ",
+",Rb&E Rb,H ,RcH ,RbE. ,R8bE ,RHb. cRH,8 ,RbME ,RbM&E ,RVH cRV,H ,RjbE ,Rb&j",
+"E V,RHj s,VRH Rb,d Rb-d RD,d c-gR ,Rdb. -Rb8d ,RDd. c-Rg8 ,RdbM -RbdM ,RVd ",
+"gRV- ,Rdbj -Rjbd Vd,Rj V-gsR ,2Rb ,Rb&2 ,2RD ,Rc2 Rb,5 ,R5b8 R5,D ,Rc5 ,RbM",
+"2 ,RbM&2 ,RV2 cRV,2 ,R5bM Rb5,8M ,RV5 s,VR5 Rb,; Rb-; RD,; -Rc; b5R* >R-U ,",
+"R5D; ->cR ,R;bM -RbM; ,RV; V;-R ,R;bj >M-Rb V5*,R -RV> ,RbE2 R&E,U2 ,RHb2 c",
+"RH,2 ,R5bE ,REU5& ,RHb5 cR5,H RbE,M2 bER2,M& V,RH2 V,HcR2 ,REb5M ,ER5b8M V5",
+",RH s,HcR5 ,Rdb; -Rbd; ,RHb; c-Rg; ,R5bd ->Rbd ,R5Dd c>Rg- Rbd,M; Rbd-M; Vd",
+",R; V-gR; Rb5,dM -Rb>Md V5d,R V->gR ,UP U&,P RD,P ,RcP ,.UP U8,P ,RDP. cR8,",
+"P Sb, ,US& SV, Sc, ,USj ,US8 SjV, s,Sc bPR* -UP ,RDP* -RcP ,UP*. U8-P P*.,R",
+"D c-R8P Sb* S-b V*Sb Sc- b*Sj -US8 SV*,j s-Sc Rb,W ,RWU& RW,D ,RcW ,RWb. ,R",
+"Wb8 ,RWD. cRW,8 ,USW SbW,& ZbS, S,Zc SbW,j Sb8,W SZb,j Ss,Zc bWR* Rb-W ,RWD",
+"d -RcW ,UdP. -RWb8 dP.,RD c-RW8 ,USd -USd ZbS* Z-Sc Sbd,j S-bW8 SZb*j gScs-",
+" Rb,m ,RmU& RD,m ,Rcm U5,P ,R8bm ,R5Dm cR5,m ,USm Sbm,& VmS, cmS, pbS, Spb,",
+"8 S,Vp S,cp bmR* Rb-m ,RDm* -Rcm ,U5;P -U>P R5D,;P c>R-m ,US; -US; V;S, S;V",
+"- pbS* Sb-p Vp*Sb cpS- ,RWbm RW&,Um ,RHbm cRW,m ,R5bW Rb5,W8 ,R5WD cR5,W Sb",
+"W,m ,UWS&m SZb,m ScZ,m Spb,W S8WpU, Vp,SZ ScpZ, ,Rvb vR-U ,RvD cR-v vRb,5 -",
+"vR>b vRD,5 cvR-> vbS* Sb-v S,Vv cvS- Svbp* -pUSv Vv,Sp Scy- Rk) k)R! k)RB R",
+")ak R1) R)8k 1)RB R)1a kMR) RkM!) R)Tk ak)RT lR) R8l) RTl) l)sR R*k +kR* Rk",
+"*B akR* R1* 1+R* *BR1 1aR* RkM* k*MR+ TkR* ak*RT l*R R+l* RTl* sRl* kER) Rk",
+"E!) R)Hk ak)RH 1ER) R18E) R)1H R1H8) RkME) kMER)! RHTk) RHTak) REl) lR8E) R",
+"Hl) lsRH) dkR* dk*R+ HkR* R*gk 1dR* R1+d* 1HR* R1g* dkMR* R+dk*M RH*Tk gRTk",
+"* Rdl* l+Rd* RHl* gRl* k)R2 Rk)!2 Rk)2B ak)R2 R)5k R158) R15)B R1a5) RkM)2 ",
+"kM)R2! RTk)2 RT)ak2 R5l) lR58) lR5T) lsR5) k;R* k;*R+ k;*RB ak;R* 1;R* R1>*",
+" R1;*B >kRa* k;MR* R+kM;* RT;k* RT;ak* R5l* >Rl* l;RT* l>sR* RkE)2 kE)R2! R",
+"Hk)2 RH)ak2 R15E) 5kER8) R1H5) ak)RH5 kMER)2 !ER)kM2 Hk)RT2 akHMR)2 lR5E) R",
+"58lE) lHR5) sR5lH) dk;R* R+dk;* RH;k* gRk;* R1d5* >kRd* R1H5* >kgR* RdkM;* ",
+"dkR;+M* Hk;RT* RT;gk* ldR5* l>Rd* lH;R* gl>R* kP) k!P) P)kB a)kP R)1P 8)kP ",
+"kP)1B akP1) Sk) k)S! TkS) akS) Sl) l)S8 STl) l)Ss kP* k*+P *BkP kPa* 1PR* k",
+"P8* kP*1B akP1* S*k +kS* TkS* akS* l*S S+l* lTS* l*Ss R)Wk kP)W! H)kP akPH)",
+" R)1W R1W8) R1HW) R1Wa) WkS) S!Wk) S)Zk SZak) SWl) Sl8W) l)SZ SslZ) WkR* dk",
+"P+* kPH* kPg* 1WR* dkP8* kP*1H gR1W* WkS* S+Wk* ZkS* S*gk Sdl* S8dl* SZl* l",
+"*gS R)km km)R! km)RB akmR) R)1m R1m8) R1m)B akP5) kmS) S!km) STkm) Sakm) l)",
+"Sp Slp8) SlpT) Sslp) kmR* km*R+ km*RB akmR* 1mR* kP>* kP*5B >kPa* kmS* S+km",
+"* S;Tk* Sa;k* Spl* l*S> Sp*lT Ss*l> km)RW RW)km! RHmk) ak)RHm R1W5) km)RW8 ",
+"R1Hm) ak)R5W SWkm) km)S!W SZkm) ZkmSa) SlpW) lWpS8) SZpl) lZpSs) R*vk vR+k*",
+" vRHk* gvRk* R1v* >kvR* vR1H* >kgP* vkS* Sv+k* SZ*vk gSvk* l*Sv lv>S* lvZS*",
+" l*yS ,R9 R&,k RB,k R9,a ,R1 :R, RB,1 ,R:a R9,M ,R9M& R9,T ,RT9a l,R :Rl, ,",
+"RlT sRl, R9* -R9 *BR9 R9-a R*,1 :-R ,R1*B :a-R 9MR* R9-M 9TR* R9-T ,Rl* l-R",
+" l*R,T sRl- ,ER9 k&E,R R9,H ,RH9a ,ER1 ,R:E R1,H ,R:H ,R9ME ,R9M&E ,RH9T R9",
+"H,aM ,RlE :R,lE ,RlH :RHl, R9,d R9-d 9HR* -Rg9 R1,d -R:d ,R1H* :-gR ,Rd9M -",
+"R9dM ,RT9d -RTg9 ,Rld -Rld lH*,R gRl- ,2R9 k&2,R ,R92B ,Ra92 R9,5 ,R:5 ,R15",
+"B :R5,a ,R9M2 ,R9M&2 ,RT92 ak2,RT ,Rl5 :R5l, l,R5T ls,R5 R9,; R9-; ,R;9B -R",
+"9a; R1,; ->:R ,R1;B :-R>a ,R;9M -R9M; ,RT9; -RT9; ,Rl; -Rl> l;,RT s-Rl> ,R9",
+"E2 ,REk&2 ,RH92 ak2,RH ,R15E :R5,E ,R1H5 :RH,5 R9E,M2 k&,MRE2 ,R29HM ,2RH9a",
+"M l,R5E l,5:RE lH,R5 s,5:RH ,Rd9; -R9d; ,RH9; g-R9; ,R15d :-R>d ,R1H; g:R->",
+" R9d,M; R9d-M; R9H,T; -R;g9M ld,R5 l->Rd lH;,R gl->R ,kP k&,P ,BkP ak,P R1,",
+"P ,R:P ,R1PB :Ra,P S9, ,kS& ,TS9 ,aS9 l,S S:, lTS, l,Ss 9PR* -kP kP*,B ak-P",
+" kP*,1 -R:P k*B,1P :-RaP S9* S-9 9TS* -TS9 S9l* l-S S9*lT s-S: R9,W kP&,W H",
+"k,P akP,H R1,W ,R:W ,R1HP :RH,W ,WS9 S9W,& Z9S, SZ9,a S,lW :WS, SZl, S,Z: 9",
+"WR* R9-W dkP,H -kgP dkP,1 -R:W ,1HdkP g:R-W ,dS9 -WS9 Z9S* g9S- Sdl, lWS- l",
+"Z*S9 gSl- R9,m km&,R ,Rm9B akm,R R1,m ,R:m ,R1mB :Rm,a ,kSm S9m,& S9T,m S9a",
+",m Spl, S,:p Sp9,T Ss,:p 9mR* R9-m k;P,B -Rm9a k;P,1 -R:m k;B,1P :-Ram ,kS;",
+" -kS; S9;,T S-9Tm S;l, S>l- Sp9T* l-pSs ,RW9m ,RWkm& ,RH9m ,RHakm ,R15W :RW",
+",5 ,R1Hm :RH,m S9W,m km&S,W SZ9,m SamZk, Sp9,W S:p,W lZ,Sp S:Zp, ,Rv9 vR-k ",
+"vR9,H -vRg9 ,Rv1 :R-v vR1,H :vRg- v9S* S9-v Sv9Z* gS-v9 l,Sv S-lv lv,SZ l-y",
+"S UkR) RUk!) R)Dk ak)RD R)1U R1U8) R)1D R1D8) RUkM) U!kRM) RkV) VRak) RUl) ",
+"lRU8) VRl) lsVR) RUk* R+Uk* DkR* ak*RD 1UR* R1+U* 1DR* R1+D* k*MRU R+Uk*M R",
+"*Vk V+Rk* R*lU l+RU* lRV* s*VlR RUkE) U!kRE) RHUk) RHUak) R1UE) 1UER8) R1HU",
+") R1)UH8 UkMRE) !ER)UkM VRHk) ak)VRH lRUE) R8UlE) VlRH) Vs)lHR dk*RU R+Udk*",
+" RH*Dk gRUk* R1dU* 1UdR8* R1HU* gR1U* RdUk*M dkR*U+M VdRk* gVRk* ldRU* R8dl",
+"*U lH*VR glVR* RUk)2 U!kR)2 RDk)2 RD)ak2 R1U5) 1U5R8) R1D5) ak)R5D UkMR)2 !",
+")k2RUM V2Rk) ak)V2R lRU5) R5Ul8) VlR5) V5Rls) k;*RU R+Uk;* RD;k* RD;ak* R1;",
+"U* >kRU* R1D5* >kDR* R;Uk*M k;R*U+M V;Rk* ak;V*R l;RU* l>RU* l;VR* V>lR* Uk",
+"ER)2 !ER)Uk2 Hk)RD2 R)UHak2 1UER5) RE1U58) R1)UH5 R)1HU5a E)R2UkM U!RME)k2 ",
+"RHkV2) akV2RH) R5UlE) RUlE58) V5RlH) lRV5sH) RdUk;* dkR;U+* Hk;RD* RD;gk* 1",
+"UdR5* R1d>U* 1UHR5* >D*gR1 dkR;U*M U+R*k;dM RH;V*k gRkV;* R5dl*U >RUld* lHR",
+"V5* glRV>* U)kP kP)U! D)kP akPU) 1)UP 1UP8) R1DP) 1UaP) UkS) S!Uk) VkS) SVa",
+"k) SUl) SlU8) l)SV SlVs) kPU* kP*U+ kPD* akPU* UP1* kP*U8 kP*1D aP*1U U*Sk ",
+"S+Uk* SkV* SV+k* lUS* S8*lU SVl* Ss*Vl kP)UW UW)kP! RWDk) ak)RWD R1WU) kP)U",
+"W8 R1WD) aP)1UH SUWk) UWkS!) SZVk) ZkVSa) SlUW) lWUS8) SlVZ) lZVSs) dkPU* U",
+"+WkP* dkPD* gUPk* R1WU* 1U+RW* R1WD* g1UP* SdkU* U+WS*k SZ*Vk gSVk* lW*SU S",
+"+UlW* lZ*SV glSV* km)UP Um)kP! RDmk) ak)RDm R1mU) km)U8P R1Dm) ak)U5P SUkm)",
+" km)S!U SVkm) VmkSa) SlpU) pUlS8) SlVp) VplSs) km*UP U+mkP* km*RD R+Dkm* kP",
+"*U5 >kPU* kP*5D >kDP* S;Uk* km*S+U SV;k* S+kVm* Sp*lU S>lU* Vp*Sl S>Vl* RWU",
+"km) k!m)RWU km)RWD akRmUH) kP)U5W R)1WU8m kP)UH5 1HRmU8) km)SUW WmS)U!k Zkm",
+"SV) akVmSZ) lWUSp) SplWU8) lZSVp) SlVpsZ) vRUk* kP*vU+ vRDk* gR*vDk vR1U* >",
+"P*v1U vR1D* >D*vR1 SvUk* vU+S*k VvSk* gSkVv* lvSU* S>Ulv* lvVS* ylVS* tR, ,",
+"Rt& ,RtD t,cR ,Rt1 t,:R R1,D :,cR ,RtM tRM,& tRV, tcV,R tRl, t:Rl, lRV, uR,",
+" t*R t-R RDt* cRt- R1t* :Rt- t*R1D c-:R R*tM tR-M tRV* -RVt lRt* -Rlt t*VlR",
+" u-R ,RtE tR&,E ,RtH tcR,H tR1,E t:R,E tHR,1 t:H,R tRM,E M&EtR, tHV,R cRVtH",
+", ltR,E lt,:RE ltH,R ,RuH ,Rtd -Rtd RHt* gRt- tdR,1 t:d-R tH*R1 g:Rt- tdR,M",
+" t-RdM tH*VR V-gtR ltd,R l-tRd tH*lR g-uR ,Rt2 tR&,2 tRD,2 tcR,2 ,Rt5 t:R,5",
+" t5R,D tc5,R tRM,2 M&2tR, VtR,2 Vt,cR2 t5Rl, lt5:R, t5V,R ,Ru5 ,Rt; -Rt; t;",
+"R,D tc;-R R5t* -Rt> t5*RD c>Rt- t;R,M t-RM; t;V,R V-tR; t5*lR l-t>R t5VR* -",
+">uR tR,E2 ,R&tE2 tHR,2 cR,tH2 t5R,E :R,t5E tH5,R tH,cR5 ,RMtE2 M&tE,R2 V,Rt",
+"H2 V2tc,RH l,Rt5E lRt5:,E tHRV5, uRH,5 tdR,; t-Rd; tH;,R gt-R; t5d,R t>-Rd ",
+"tH5R* gt>-R ,Rdt;M -Rdt;M tHRV;, gtRV-; t5Rld, t>Rl-d tHRl;, u->gR tP, ,Pt&",
+" ,DtP t,cP ,1tP t,:P tP1,D t:Pc, St, t&S, VtS, S,tc l,St S,t: SVl, uS, tP* ",
+"t-P DPt* c-tP 1Pt* :-tP tP*1D t-P:c St* S-t t*SV StV- l*St Stl- St*Vl u-S ,",
+"RtW tWR,& ,HtP tcW,R tWR,1 t:W,R tHP,1 t:H,P S,tW StW,& S,tZ ScZt, Stl,W S:",
+"t,W lZ,St SZu, ,dtP -RtW HPt* gPt- tW*R1 t-W:R tHP1* gtP:- tWS* Sdt- S*tZ S",
+"-gt Stdl* l-StW tZ*Sl gSu- ,Rtm tmR,& tmR,D tcm,R ,5tP t:m,R t5P,D tc5,P tm",
+"S, Stm,& SV,tm Sct,m S,tp S:pt, Vp,St Spu, ,;tP -Rtm tm*RD t-mcR 5Pt* >Pt- ",
+"t5PD* t>Pc- tmS* S;t- St;V* V-mSt S*tp tpS- tp*SV S-up tWR,m ,RWtm& tHm,R t",
+"H,cRm t5W,R t5,:RW tH5,P tH,:Rm StW,m tWmS&, tZS,m tZmSc, tpS,W tpWS:, tZpS",
+", uZ,Sp vRt* tP-v tvR,H cvRt- tvR,1 :vRt- tH5P* :vRc- S*tv tvS- Vv,St V-vSt",
+" lvtS* l-vSt Vv,Sl y-uS X X! XB aX X. 8X X.B 8Xa XK XK! TX TXa Xj 8Xj TXj s",
+"X X( +X X(B +Xa X(. +X8 .BX( +8aX X(K +XK TX( +TX Xj( +Xj T(Xj sX+ GX GX! H",
+"X GaX GX. G8X HX. H8X GXK XKG! GTX TXGa GjX 8XGj HXj sGX dX +GX HXd gX dX. ",
+"8dX H.dX gX8 dXK GK+X TdX gXT dXj Gj+X dXHj gsX X2 X2! X2B aX2 5X 5X8 5XB 5",
+"aX X2K 2KX! TX2 T2aX 5Xj 58Xj 5TX sX5 X; +X; X;B aX; 5X; >X 5BX; >Xa X;K +K",
+"X; TX; T;+X X;j >Xj T;5X >Xs GX2 X2G! HX2 G2aX G5X 5XG8 H5X 5aHX X2GK GX2!K",
+" G2TX aX2GT 5XGj G58Xj 5THX G5sX G;X G;+X HX; gX; 5dX >XG 5dHX >Xg GKX; dXK",
+"+; TXG; TXg; dj5X Gj>X Td5X gs>X XP XP! XPB aXP XP. 8XP P.XB aX8P QX QX! QX",
+"T QaX QXj Q8X XjTP sXQ XP( +XP P(XB aX+P P(X. 8X+P XP(.B aXP+8 QX( +QX Q(TX",
+" Qa+X Q(Xj Q8+X Xj(TP +QsX Y Y! YH Ya Y. Y8 YH. Y8H YQ YQ! YZ YZa Yj Y8Q YZ",
+"j sY Yd Y+ YHd gY Yd. Y+8 HdY. gY8 YQd Y+Q YZd gYZ Yjd Y+j ZdYj sYg Xm Xm! ",
+"XmB aXm 5Xm 8Xm 5BXm aX5P QXm Q!Xm TXm aXTm pX pX8 pXT spX Xm; +Xm XB;P aX+",
+"m X;5P >Xm Xm;5B aX>P QX; QX+m TXQ; TX+m pX; >Xp TXp; sp>X Ym Ym! YHm Yam Y",
+"5 Y58 Y5H Y5a YQm Q!Ym YZm ZaYm Yp Yp8 YpZ sYp Yv Yv+ YvH gYv Yv5 Y> vHY5 Y",
+">g YvQ v+YQ YZv YZgv Ypv Y>p ZpYv yY X# X& X#B aX& X#. 8X& .BX# 8aX& X#K X&",
+"K TX# TX& Xj# X&j T#Xj sX& X#( +X& #BX( +aX& #(X. +8X& X#(.B aX&+8 #(XK +KX",
+"& X#T( T&+X j#X( X&+j Xj#T( +Xs& GX# G&X HX# HX& X#G. 8XG& X#H. 8XH& X#GK G",
+"KX& G#TX TXG& G#Xj X&Gj H#Xj G&sX dX# dX& H#dX gX& X#d. d&8X dX#H. 8Xg& X#d",
+"K dKX& T#dX TXg& d#Xj X&dj dXjH# g&sX X#2 X&2 2BX# X2a& 5X# 5X& X#5B aX5& 2",
+"KX# &2XK X#T2 T2X& 5#Xj Xj5& 5#TX 5Xs& X;# X;& ;#XB X&a; 5#X; >X& X;#5B aX>",
+"& ;#XK XK;& T#X; X;T& X#;j X&>j X;jT# >&sX X#G2 G2X& X#H2 H2X& G#5X 5XG& H#",
+"5X 5XH& GX#2K X&2GK GTX#2 GT&X2 Xj#G5 X&jG5 G5TX# sX5G& G#X; X;G& H#X; X;g&",
+" 5#dX G&>X H5Xd# >&gX dX#;K dX&;K GT;X# gXT;& dXj5# >XG&j X;jH# >Xgs& XP# X",
+"&P P#XB X&aP P#X. X&8P XP#.B aXP8& QX# QX& Q#TX TXQ& Q#Xj 8XQ& Xj#TP QXs& P",
+"#X( X&+P XP#(B aXP+& XP#(. X&P+8 P#(X.B +X8aP& X#Q( Q&+X QXT#( +QXT& Xj#Q( ",
+"X&j+Q TX#Pj( sX+Q& Y# Y& YH# Ya& Y#. Y8& H#Y. H8Y& YQ# Y&Q YZ# YZ& Yj# Y&j ",
+"ZjY# sY& Yd# Y+& HdY# gY& d#Y. 8dY& YHd#. g8Y& QdY# +QY& ZdY# Y&gZ djY# +jY",
+"& YZdj# Y&gs Xm# Xm& m#XB X&am 5#Xm Xm5& Xm#5B aXm5& Q#Xm XmQ& T#Xm XmT& pX",
+"# pX& TXp# p&sX X#;P X&+m Xm;#B aXm;& Xm;5# Xm>& 5X#;PB >Xam& Q#X; X;Q& QX;",
+"T# aX;Q& X;p# p&>X pXT;# >Xps& Ym# Y&m HmY# HmY& Y5# Y5& H5Y# H5Y& QmY# Q&Y",
+"m ZmY# YmZ& Yp# Yp& Y#Zp Y&sp Yv# Yv& vHY# Y&gv v5Y# Y>& YvH5# Y&g> vQY# YQ",
+"v& Y#Zv ZvY& Y#pv pvY& YZvp# yY& IX IX! DX DXa IX. 8IX DX. D8X IXK I!XK DXT",
+" aITX IjX Ij8X DXj sIX IX( +IX DX( +DX X(I. 8I+X X(D. D8+X X(IK IX+K D(TX D",
+"X+T I(Xj Ij+X D(Xj +DsX GIX IXG! JX JaX IXG. GI8X JX. J8X IXGK GIX!K JTX TX",
+"Ja GIXj IjXG8 JjX sJX IdX Id+X JdX gJX I.dX Id8X dXJ. J8gX IXdK IdX+K TdJX ",
+"JTgX dXIj Idj+X dXJj gXsJ IX2 I!X2 DX2 I2aX 5IX 8I5X 5DX D85X X2IK IX2!K I2",
+"TX aX2TI Ij5X IjX58 DX5T 5DsX I;X I;+X DX; D;+X I;5X >XI D;5X >XD IKX; I;X+",
+"K TXD; aX;TI X;Ij Ij>X X;Dj sI>X IXG2 GIX!2 JX2 aXJ2 GI5X G58IX J5X 5aJX GI",
+"X2K IX2GK! TXJ2 JTaX2 IjXG5 G58IjX 5TJX J5sX dXI; IdX+; J;X J;gX Id5X Id>X ",
+"5dJX J>X IdX;K +GIX;K TXJ; gJTX; Idj5X >IjdX X;Jj >XsJ IP IP! DXP aIP IP. 8",
+"IP D.IP 8IDP QIX Q!IP QDX DXQa IPj 8IQX DjQX sIP IP( +IP D(IP DX+P P(I. 8I+",
+"P IP(D. +DX8P Q(IP QI+X Q(DX QD+X I(Pj IP+j IPjD( +IsP YI YI! YJ YJa YI. Y8",
+"I YJ. YJ8 YQI QIY! YZJ ZJYa YjI Q8YI YJj sYJ YId Y+I YJd gYJ IdY. +IY8 JdY.",
+" Y8gJ QIYd +QYI YdZJ YZgJ IdYj +IYj YdJj sJgY ImX I!Xm DXm aXDm 5IP 8I5P DX",
+"5P 8XDm ImQX ImXQ! DmQX aXmQD pIX 8IpX pDX pDsX I;P Im+X I;DP DX+m I;5P >PI",
+" I;P5D DX>P I;QX I;P+Q DXQ; aX;QD I;pX pI>X DXp; sI>P YIm ImY! YJm JmYa Y5I",
+" 5IY8 YJ5 J5Y8 QIYm YQIm! JmYZ YZJam YpI pIY8 JpY JpsY YvI vIY+ JvY JvgY vI",
+"Y5 Y>I Y5Jv Y>J YQvI Yv+QI YZJv gYZJv pIYv pIY> JvYp yJY bX bX& bXD cX bX. ",
+"b8X b.DX cX8 bXK bKX& bTX cXT bXj 8Xbj DXbj scX bX( b+X b(DX cX+ X(b. +Xb8 ",
+"bXD(. +Xc8 X(bK bK+X b(TX +TcX b(Xj +Xbj bTXj( s+cX bGX G&bX JbX cJX GXb. G",
+"8bX bXJ. J8cX GXbK I&KGX bTJX JTcX GjbX I&jGX bXJj cJsX bdX +GbX bdJX gcX b",
+".dX 8dbX JbdX. g8cX bKdX dX&bK TdbX gTcX dXbj IdjX& JjbdX scgX bX2 b2X& b2D",
+"X cX2 b5X 5Xb8 5DbX c5X X2bK I&2XK b2TX TXc2 5Xbj I&j5X 5TbX c5sX bX; +Xb; ",
+"DXb; cX; 5Xb; >Xb b5XD; c>X bKX; I;&XK TXb; TXc; X;bj bX>j X;jbT sc>X GXb2 ",
+"I&2GX bXJ2 JXc2 G5bX bG58X b5JX J5cX bGX2K bG2X&K JbTX2 cJTX2 bG5Xj bG5X&j ",
+"J5bTX sJc5X G;bX I;&dX bXJ; c;gX 5dbX bG>X J5bdX gc>X bG;XK IdKX;& J;bTX cJ",
+";TX dXjb5 >XbGj J;jbX J>scX bXP IP& DXbP cXP b.IP 8IbP IP.bD 8IcP bQX Q&bX ",
+"QDbX cQX QXbj Q8bX IPjbT cQsX b(IP +IbP IP(bD +IcP IP(b. IP&+8 DX(bP. cX+8P",
+" b(QX +QbX bQXD( +QcX IPjb( IP&+j Ij(bTP sIPc+ Yb Yb& YJb Yc Yb. Yb8 JbY. Y",
+"c8 YbQ bQY& YZb YcZ Ybj bQY8 ZbYj sYc Ybd Yb+ JbYd Ycg bdY. b+Y8 YJbd. Y8gc",
+" bQYd b+YQ YdZb ZcgY bdYj b+Yj YZbdj gsYc bXm XmI& DXbm cXm 5IbP 8Xbm b5XDm",
+" 5IcP QXbm Im&QX TXbm QXcm pbX b8pX bTpX cpX I;bP +Xbm I;PbD +Xcm I;Pb5 bX>",
+"P 5DXb;P cX>P QXb; I;PQ& I;PbT QXc; bXp; pb>X pbXD; >Xcp Ybm bmY& JmYb Ycm ",
+"Yb5 b5Y8 J5Yb Yc5 bQYm YbQm& YmZb cmYZ Ypb pbY8 YbJp Ycp Yvb vbY+ YbJv Ycv ",
+"vbY5 Y>b YJ5vb Yc> YQvb Yvb+Q ZvYb YZcv pvYb p>Yb JpYvb yYc X0 X0! X0B aX0 ",
+"1X 1X8 1XB 1aX X0K !KX0 TX0 T0aX 1Xj 18Xj 1TX sX1 X0( +X0 0BX( +0aX 1X( 1+X",
+" X(1B +X1a 0(XK X0+K X0T( +0TX 1(Xj +j1X 1(TX 1+sX GX0 X0G! HX0 G0aX 1GX G8",
+"1X 1HX Ga1X X0GK GX0!K G0TX aX0GT Gj1X 1G8Xj GT1X 1GsX dX0 +0dX H0dX gX0 1d",
+"X +G1X HX1d g1X X0dK dX0+K T0dX TXg0 dj1X dXj1+ Td1X sXg1 X02 !0X2 2BX0 X2a",
+"0 1X5 158X 1B5X 5a1X 2KX0 X02!K X0T2 aX0T2 15Xj 1X58j 5T1X 1Xs5 X;0 +0X; ;0",
+"XB a0X; 1X; >X1 1BX; 1a>X ;0XK X;0+K T0X; aX;T0 Xj1; 1X>j TX1; s1>X X0G2 GX",
+"0!2 X0H2 aX0G2 G51X 1G58X H51X 1Ga5X GX02K X02GK! GTX02 GT0aX2 1G5Xj G581Xj",
+" 1GT5X sX1G5 G0X; dX0+; H0X; X;g0 G;1X 1G>X HX1; g1>X dX0;K +G0X;K GT;X0 gX",
+"T;0 dXj1; >X1Gj X;j1H >Xgs1 XP0 X!P0 P0XB XPa0 1XP 8X1P XP1B aX1P QX0 X0Q! ",
+"Q0TX Q0aX 1QX Q81X QX1T 1QsX P0X( XP+0 XP0(B aXP+0 XP1( +X1P 1XP(B 1+XaP X0",
+"Q( +0QX QXT0( +QXT0 1(QX +Q1X 1QXT( sX1+Q Y0 Y0! YH0 Ya0 Y1 Y18 Y1H Y1a YQ0",
+" Q!Y0 YZ0 ZaY0 Y1Q 1QY8 YZ1 sY1 Yd0 Y+0 HdY0 gY0 Y1d Y1+ 1HYd gY1 QdY0 +QY0",
+" ZdY0 g0YZ 1QYd 1+Yj YdZ1 g1sY Xm0 X!m0 m0XB a0Xm 1Xm 8X1m 1BXm aX1m Q0Xm X",
+"m0Q! T0Xm aXmQ0 pX1 1Xp8 1TpX s1pX X0;P +0Xm Xm;0B aXm+0 Xm1; 1X>P 1Xm;B >X",
+"1am Q0X; +QXm0 QX;T0 aX;Q0 1Xp; p1>X pX1T; >Xps1 Ym0 m0Y! HmY0 amY0 Y15 1mY",
+"8 1HY5 1aY5 QmY0 YQm!0 ZmY0 YZam0 Yp1 p1Y8 ZpY1 Y1sp Yv0 v+Y0 vHY0 g0Yv Yv1",
+" Y>1 YHv1 g1Y> vQY0 Yv+Q0 Y0Zv gYZv0 pvY1 p>Y1 ZvY1 yY1 9X 9X& 9XB 9aX 9X1 ",
+":X 1B9X :Xa 9XK 9KX& 9TX TX9a 9Xj :Xj 1T9X s:X 9X( 9+X X(9B +X9a 9(1X :X+ 9",
+"X1(B +X:a X(9K 9K+X 9(TX +T9X 9(Xj +X:j 9TX1( s+:X 9GX G&9X 9HX Ga9X 1G9X :",
+"GX 1H9X :HX GX9K X&K9G GT9X 9GTaX Gj9X Gj:X HX9j :GsX 9dX +G9X HX9d g9X 1d9",
+"X :dX 9HX1d g:X 9KdX dX&9K Td9X 9TgX dX9j dX:j dXj9H s:gX 9X2 92X& X29B 92a",
+"X 95X :X5 9B5X 5a:X X29K X&29K 92TX 9TX&2 5X9j 5X:j 5T9X s5:X 9X; +X9; 9BX;",
+" aX9; 1X9; >X: 95X;B :a>X 9KX; X;&9K TX9; aX;9T X;9j >j:X X;j9T s:>X GX92 X",
+"&29G 92HX 9GaX2 G59X G5:X H59X H5:X 9GX2K 9G2X&K 9GTX2 aX29GT 9G5Xj :G5Xj 9",
+"G5TX :HXs5 G;9X dX&9; HX9; 9Xg; 5d9X :G>X 9H5dX >Xg: 9G;XK d&K9X; 9GTX; g9X",
+"T; dXj95 :>GXj X;j9H g:Xs> 9XP X&9P XP9B aX9P 1X9P :XP 9X1PB aX:P 9QX Q&9X ",
+"QX9T Qa9X 1Q9X :QX 9QX1T :QsX XP9( +X9P 9XP(B 9+XaP 9X1P( +X:P 1X(9PB :X+aP",
+" 9(QX +Q9X 9QXT( 9+QTX 9QX1( +Q:X Xj(9TP :QXs+ Y9 Y9& Y9H Y9a Y91 Y: 9HY1 Y",
+":H Y9Q 9QY& YZ9 Z9Ya Y9j Y:Q Z9Y1 sY: Y9d Y9+ 9HYd gY9 9dY1 Y:+ Y91Hd Y:g 9",
+"QYd 9+YQ YdZ9 YZg9 9dYj :QY+ YZ91d gYZ: 9Xm X&9m 9BXm aX9m 1X9m :Xm 95XmB a",
+"X:m QX9m Xm&9Q TX9m aXm9Q p9X :pX 9TpX sX:p Xm9; +X9m 9Xm;B aXm9+ 95X;P :X>",
+"P X;B95P :Xm>a QX9; X;&9Q 9QXT; aX;9Q 9Xp; >X:p p9XT; :pXs> Y9m 9mY& 9HYm 9",
+"aYm Y95 Y:5 9HY5 :HY5 9QYm Y9Qm& YmZ9 YZ9am Yp9 Y:p ZpY9 YpZ: Yv9 v9Y+ YHv9",
+" Yvg9 v9Y1 Y:v Yv91H gY:v YQv9 Yv9+Q ZvY9 gY9Zv pvY9 Yp:v Yp9Zv yY: IX0 I!X",
+"0 DX0 D0aX 1IX 8I1X 1DX D81X X0IK IX0!K D0TX aX0TI Ij1X IjX18 DX1T 1DsX X0I",
+"( IX+0 X0D( +0DX IX1( +I1X 1(DX +D1X IX0(K +IX0K DXT0( +DXT0 IjX1( 1+IXj 1D",
+"XT( sI1+X IXG0 GIX!0 JX0 aXJ0 GI1X 1G8IX J1X 1aJX GIX0K IX0GK! TXJ0 JTaX0 I",
+"jX1G 1G8IjX 1TJX J1sX I0dX IdX+0 dXJ0 JXg0 Id1X 1+GIX 1dJX J1gX IdX0K +I0dX",
+"K JTdX0 gJTX0 Idj1X 1+IdXj J1TdX sJg1X X0I2 IX0!2 X0D2 aX0I2 5I1X 1I58X 5D1",
+"X 1DX5a IX02K X02IK! DXT02 TI0aX2 IjX15 5I81Xj 1DX5T sI15X I0X; I;X+0 D0X; ",
+"aX;D0 I;1X 1I>X DX1; 1D>X I;X0K +I0X;K DX;T0 aX0TI; I;j1X >I1Xj X;j1D >Xs1D",
+" GIX02 IX0G2! X0J2 JaX02 1G5IX G581IX 1XJ5 J158X IX0G2K I!X2G0K JTX02 aX0JT",
+"2 1G5IjX Ij1XG58 J15TX sJ15X IdX;0 +GIX;0 X;J0 gJX;0 1G;IX >I1dX 1XJ; J1>X ",
+"dX0I;K Id+X;0K J;TX0 gXTJ;0 1IdX;j Idj>X1 J1;TX J>s1X IP0 I!P0 D0IP a0IP 1I",
+"P 8I1P DX1P aI1P Q0IP IP0Q! Q0DX QDXa0 QI1X IPj18 QD1X 1IsP P0I( +0IP IP0D(",
+" +DXP0 1(IP +I1P 1DXP( 1+DIP IP0Q( +QIX0 QDX0( +QDX0 IPj1( IPj1+ 1QDX( sIP1",
+"+ YI0 I0Y! YJ0 JaY0 Y1I 1IY8 YJ1 J1Y8 QIY0 YQI!0 Y0ZJ YZJa0 1QYI Y1Q8I ZJY1",
+" Y1sJ IdY0 +IY0 JdY0 g0YJ 1IYd 1+YI YdJ1 YJg1 YQId0 Y+QI0 YZJd0 gYZJ0 Y1QId",
+" Y1+QI YZ1Jd gY1sJ I0Xm ImX!0 D0Xm aXmD0 5I1P 1Im8X DX1m aXm1D ImXQ0 QI0Xm!",
+" QDXm0 aX0TIm 1IpX pI81X 1DpX sIPp1 I0;P I;P+0 I;PD0 a;PI0 I;1P 1I>P I;P1D ",
+">XD1m I;PQ0 Im0+QX I;PT0 aX0QD; pI1X; >Xp1I pDX1; sIP>1 ImY0 YIm!0 Y0Jm YJa",
+"m0 1IY5 Y158I J1Y5 YJ15a YQIm0 Im0YQ! YZJm0 ZJmYa0 pIY1 Yp18I Y1Jp JpsY1 Y0",
+"vI Yv+I0 Y0Jv gYJv0 vIY1 >IY1 Y1Jv Y1J> YvQI0 vIQY+0 YZvJ0 JvZgY0 Yv1pI Y>p",
+"1I JpYv1 YJy1 bX9 I&9X 9DX cX9 b1X :IX 1DbX :cX bK9X I&K9X 9TbX 9TcX 9Xbj b",
+"X:j 1TbX :csX b(9X 9+bX 9(DX 9+cX b(1X b+:X b1XD( :+cX bX9(K b+X9K bTX9( cX",
+"9+T b1Xj( :I+Xj b1TX( :cXs+ 9GbX bG9X& J9X J9cX 1GbX bG:X b1JX :JX bG9XK bG",
+"9X&K 9TJX cJ9TX b1GXj :GbXj 9XJj sX:J 9dbX dX&9I 9dJX cXg9 1dbX bd:X J91dX ",
+"gX:J bdX9K IdK9+X J9TdX gJ9TX Idj9X :IdXj J9jdX g:XsJ b29X I&29X 92DX 9Xc2 ",
+"95bX b5:X 5D9X c5:X bX92K 9I2X&K bTX92 cX9T2 b1X5j :I5Xj b1T5X :cXs5 9Xb; I",
+";&9X DX9; 9Xc; 1Xb; :I>X b1XD; :c>X bX;9K I;K9+X bTX9; cX;9T I;j9X :>IXj X;",
+"j9D c>Xs: bG9X2 bG9X&2 9XJ2 cJ9X2 b1G5X :Gb5X 95JX J5:X 9G2bXK bK9GX&2 J9TX",
+"2 J9TcX2 9G5bXj bG5:Xj J95TX :Js5X bG;9X 9+GbX; 9XJ; cJ;9X b1GX; :>GbX J95d",
+"X >X:J IdK9X; X;G&9IK J9;TX cXTJ9; b1GX;j >Ij:dX J9;Xj :J>sX 9IP I&9P DX9P ",
+"9IcP 1IbP :IP b1XDP cX:P 9QbX IP&9Q QD9X 9QcX 1QbX bQ:X IPj9D :IsP 9(IP +I9",
+"P 9DXP( cX9+P b1XP( +I:P b1DIP( :cX+P bQX9( b+Q9X 9QDX( cQX9+ IPj9( :QI+X I",
+"P(b1T sIP:+ Yb9 9IY& YJ9 Yc9 Yb1 Y:b J9Y1 Y:J bQY9 Yb9Q& ZJY9 Y9Zc b1Yj :QY",
+"b ZbY1 Z:Yc bdY9 b+Y9 YdJ9 g9Yc b1Yd :IY+ YJ91d gY:J Yb9Qd Yb+9Q YZb9d gY9Z",
+"c Yb1Qd Y:b+Q YZb1d sY:gJ 9Xbm Im&9X DX9m 9Xcm 1Xbm bX:m b1XDm cX:m bQX9m 9",
+"QIXm& bTX9m cQX9m b1pX pb:X 9DpX :Xcp I;9P I;P9+ I;P9D cXm9+ I;Pb1 :I>P 95D",
+"I;P c>X:m I;P9Q 9+QI;P I;P9T cQX9; pbX9; :pI>X p9DX; cpX:> bmY9 Yb9m& JmY9 ",
+"cmY9 b1Y5 :IY5 J9Y5 Y5:J Yb9Qm Im&Y9Q YZb9m YcZ9m pbY9 Yb:p Y9Jp cpY: vbY9 ",
+"Yvb9+ Y9Jv Y9cv vbY1 Yb:v Jv9Y1 :JY> Yvb9Q Y9QvI& Jv9YZ YcvZ9 Ypbv9 :vIYp J",
+"p9Yv Y:yJ RX RX! RXB RaX RX. R8X X.RB 8XRa XM XM! RTX aXM RjX 8XM TXRj sRX ",
+"RX( R+X X(RB +XRa X(R. +XR8 RX(.B R+8aX XM( +XM R(TX +XRT R(Xj +XRj XM(Tj R",
+"+sX RG RG! RGH RGa RG. RG8 R.HX G8RH RGM R!GM RGT GTRa RGj G8Rj GTRj sRG RG",
+"d R+G HXRd gRG R.dX +GR8 dX.RH RGg8 dXM +MRG GTRd gXM GjRd +GRj dXMHj sRgX ",
+"RX2 X2R! X2RB R2aX R5X 5XR8 RB5X 5XRa XM2 M!X2 R2TX X2aM 5XM 8X5M 5XRT R5sX",
+" R;X +XR; RBX; aXR; 5XR; >XR X;BR5 Ra>X XM; X;+M TXR; XMa; X;Rj >XM XM;5T s",
+"R>X RG2 G2R! R2HX R2Ga RG5 G5R8 G5RH G5Ra R2GM XM2G! R2GT aXMG2 G5Rj RG58M ",
+"G5RT RGs5 RG; +GR; G;RH RGg; G5Rd >RG RG5H; gR>X GMR; dXM+; GTR; XMg; G;Rj ",
+"RG>M dXMH5 gX>M RXP XPR! XPRB RXaP XPR. RX8P RXP.B aXPR8 SX S!X STX SaX SXj",
+" S8X TXSj SsX XPR( RX+P RXP(B aXPR+ RXP(. R+8XP XP(R.B R+8aXP SX( S+X TXS( ",
+"+TSX XjS( +XS8 STXj( S+sX YR YR! YRH YaR YR. Y8R RHY. RHY8 SY SY! SZY SYa S",
+"Yj SY8 YjSZ sYS YRd Y+R RHYd gYR RdY. R+Y8 YRHd. Y8gR SYd SY+ YZSd gSY YjSd",
+" Y+S8 SZYdj sYgS RmX R!Xm RBXm aXRm 5XRm 8XRm XmBR5 aXmR5 SXm XmS! TXSm aXS",
+"m SpX pXS8 STpX sXSp XmR; +XRm Xm;RB aXmR+ Xm;R5 Rm>X R5X;PB >XRam S;X +XS;",
+" TXS; aXS; pXS; S>X SpTX; >XSs YRm RmY! RHYm RaYm Y5R R5Y8 RHY5 R5Ya SYm Ym",
+"S! SmYZ SmYa YpS S8Yp SZYp YpSs YvR vRY+ YHvR YvgR vRY5 Y>R YvRH5 gRY> SvY ",
+"YvS+ YZSv SvgY YpSv S>Y SZpYv yYS RX# R&X X#RB aXR& X#R. 8XR& RX#.B aX&R8 X",
+"M# XM& R#TX TXR& R#Xj X&Rj XM#Tj R&sX X#R( +XR& RX#(B aX&R+ RX#(. R+8X& X#(",
+"R.B R+8aX& M#X( X&+M XM#T( aXM+& XM#j( XM&+j RT#Xj( sX+R& RG# RG& R#HX GaR&",
+" G#R. G8R& RGH#. RG8H& R#GM GMR& R#GT GTR& R#Gj G&Rj RGTj# RGs& R#dX +GR& d",
+"X#RH RGg& dX#R. dX&R8 RH#dX. gRG8& d#XM XMd& dXMH# XMg& dXMj# dXM&j dX#RHj ",
+"gsRG& X#R2 R2X& RX#2B aX&R2 R#5X 5XR& R5X#B R5aX& M#X2 X2M& XM#T2 aXM&2 5#X",
+"M XM5& R5TX# sX5R& R#X; X;R& X;#RB aX;R& X;#R5 R&>X R5#X;B >XRa& X#M; M;X& ",
+"XM;T# aXM;& XM;5# XM>& X;#R5T >XsR& G#R2 R2G& RGH#2 RGa&2 R#G5 G5R& RG5H# R",
+"G5H& XM#G2 XM&G2 RGT#2 XM&H2 RG5M# XM&G5 RG5T# sRG5& R#G; G;R& RG;H# gRG;& ",
+"RG5d# RG>& dX#RH5 >XgR& dXM;# dXM;& XM;H# gXM;& dXM5# >XMG& dX#R5T >XgM& XP",
+"R# RXP& RXP#B aXPR& RXP#. X&PR8 XP#R.B R8aX&P SX# S&X TXS# TXS& XjS# 8XS& S",
+"TXj# S&sX RXP#( X&PR+ XP#R(B R+aX&P XP#R(. R+8X&P .BR(XP# aXR&+P8 X#S( +XS&",
+" STX#( S+TX& SXj#( S+8X& Xj#ST( Ss+X& YR# Y&R RHY# RHY& R#Y. R8Y& YRH#. Y8R",
+"H& SY# SY& S#YZ YZS& S#Yj Y8S& SZYj# S&sY RdY# R+Y& YRHd# Y&gR YRd#. Y+R8& ",
+"RHdY#. gYR8& YdS# Y+S& SZYd# S&gY SYdj# SY+&j YZjSd# gSsY& R#Xm XmR& Xm#RB ",
+"aXmR& Xm#R5 Xm&R5 R5#XmB R5aXm& XmS# XmS& STXm# SaXm& S#pX pXS& SpTX# Sp&sX",
+" Xm;R# Xm&R+ Rm#X;B RamX;& R5X;P# >XRm& 5#XmR;B aXm>R& X;S# X;S& S;TX# Sa;X",
+"& SpX;# S&>X pXTS;# S>sX& RmY# RmY& YRHm# YaRm& R5Y# R5Y& Y5RH# Y5aR& YmS# ",
+"SmY& SZYm# SZ&Ym S#Yp S&Yp SZpY# Yp&Ss Y#vR vRY& YvRH# gYvR& YvR5# >RY& vRH",
+"Y5# Y>gR& S#Yv YvS& YZvS# Sv&gY SvpY# S&Y> YpZSv# SYy& [ [! [D [a [. [8 [D.",
+" [8D [M [!M V[ V[a [j [8M V[j [s [( [+ [D( [+D [(. [+8 D([. +D[8 [M( [+M V[",
+"( V[+ [j( [+j V([j [s+ [G [!G [J [Ja [G. [8G [J. J8[ [GM GM[! VJ[ [aVJ [jG ",
+"G8[j Jj[ [sJ [d [+G [Jd g[ [d. [8d J.[d g[8 [dM +G[M V[d g[V [dj +G[j [dJj ",
+"g[s [2 [!2 [D2 [a2 [5 [58 [5D [5a [M2 M2[! V[2 V2[a [5M 5M[8 V[5 [s5 [; [+;",
+" [;D [a; [5; [> 5D[; [>D [;M +M[; V[; [+V; [;j [>M [5V; V>[ [G2 G2[! [J2 J2",
+"[a [5G G5[8 J5[ [5J8 GM[2 [!GM2 V2[J VJ[a2 G5[j [5G8M V[J5 J5[s [d; +G[; J;",
+"[ g[; [5d [>G [5J; g[> GM[; [+GM; V[J; V;g[ G;[j [d>M [5Vd V>g[ [P [!P [DP ",
+"[aP [P. [8P DP[. D8[P S[ S[! SV[ S[a S[j S[8 [jSV [sS [P( [+P DP[( +D[P P([",
+". +P[8 [DP(. [+D8P S[( S[+ S(V[ V[S+ S([j [+S8 SV[j( S+[s [Y [Y! YJ[ Ya[ [Y",
+". Y8[ Y.[J [JY8 S[Y S![Y ] ]a Yj[ Y8S[ ]j ]s [Yd Y+[ [dYJ g[Y Y.[d [+Y8 YJ[",
+"d. Y8g[ S[d Y+S[ ]d ]g [dYj [+Yj ]jd ]gs [m [m! [mD [am [5m [8m 5D[m 5a[m S",
+"[m S![m V[m [aVm [p [p8 [pV [ps [m; [+m Dm[; +D[m 5P[; [>m [5D;P [a>P S[; [",
+"+S; V[S; [+Vm [p; S>[ V;[p [pV> [Ym Ym[! Jm[ [aJm Y5[ [5Y8 [JY5 [5Ya [mSY S",
+"[Ym! ]m ]am [pY Y8[p ]p ]ps [v [v+ [vJ g[v [v5 Y>[ J5[v Y>g[ [vS S+[v ]v ]g",
+"v [pv [pY> ]pv ]y [b [& [bD [c [b. [8b bD[. [c8 [bM [&M V[b [cV [jb [&j Vb[",
+"j [sc [b( [+b bD[( [c+ b([. b+[8 [bD(. c+[8 bM[( b+[M [bV( V+[c bj[( b+[j V",
+"[bj( [+sc [bG [&G [Jb [cJ bG[. bG[8 [bJ. J8[c bG[M GM[& JbV[ VJ[c bG[j G&[j",
+" Jb[j [csJ [db [d& Jb[d g[c bd[. b8[d [Jbd. [8gc bd[M dM[& Vb[d [cgV bd[j d",
+"&[j Jj[bd gs[c [b2 [&2 bD[2 [c2 [5b [5& b5[D [c5 bM[2 M&[2 [bV2 V2[c b5[j 5",
+"M[& Vb[5 c5[s [;b [;& b;[D [c; b5[; [>b [5bD; [>c bM[; M;[& Vb[; V[c; b;[j ",
+"[&>M V[5b; c>[s bG[2 G&[2 [bJ2 c2[J bG[5 G5[& Jb[5 J5[c [bGM2 [&GM2 VJ[b2 [",
+"cJV2 [5bGM [5&GM J5V[b [sJc5 bG[; G;[& Jb[; c;g[ b5[d >b[d J5[bd c>g[ [dbM;",
+" [d&M; J;V[b g[Vc; [5dbM [>bGM J;[bj J>V[c [bP [&P bP[D [cP bP[. b8[P [bDP.",
+" [8cP S[b S[& V[Sb Sc[ [jSb [8Sb SV[bj [sSc bP[( b+[P [bDP( [+cP [bP(. [+b8",
+"P bPD[(. [c+8P [bS( [+Sb SV[b( S+[c S[bj( S[+b8 V[jSb( [scS+ Yb[ Y&[ [JYb Y",
+"c[ [bY. [8Yb YJ[b. Y8[c SYb YbS& ]b ]c YjSb YbS8 ]jb ]sc [dYb [+Yb YJ[bd Yc",
+"g[ Yb[d. Yb+[8 [JdYb. g[Yc8 YbSd YbS+ ]bd ]gc S[dbj S[8bd bd]j gs]c [mb [m&",
+" bm[D [cm b5[m b8[m [5bDm [5cm [mSb [mS& Vb[m cmS[ [pb [p& pbV[ cp[ bm[; b+",
+"[m [mbD; [+cm [5b;P [&>P b5P[;D >P[c [;Sb [;S& SV;[b S;[c [;pb Sb[> [pVb; [",
+">Sc [mYb [mY& Jb[m Jm[c [5Yb [5Y& YJ5[b Y5[c SmYb S[&Ym ]bm ]cm SbYp Y&[p ]",
+"pb ]pc [vb [v& vb[J cv[ [5vb Yb[> [vJb5 [>Yc Sb[v S&[v ]vb ]cv pb[v SbY> pv",
+"]b ]yc kX kX! kXB akX R1X 8kX RB1X 1XRa kXM M!kX TkX akTX lX lX8 lXT lsX kX",
+"( +kX X(kB ak+X R(1X 1XR+ kX(1B akX1+ k(XM kX+M T(kX Tk+X lX( l+X TXl( sXl+",
+" RGk R!Gk HkX GkRa R1G 1GR8 1GRH 1GRa kXGM kXMG! GkRT akXGT lGR RGl8 lHX sR",
+"lG dkX +kRG dkHX gkX 1GRd 1+RG dkX1H R1gX kXdM dkX+M dkTX TkgX ldX R+lG HXl",
+"d glX kX2 X!k2 X2kB k2aX 5kX 8k5X 5BkX ak5X k2XM kXM!2 T2kX akXT2 lX5 5Xl8 ",
+"5TlX l5sX kX; k;+X kBX; kXa; 1XR; >kX kX;1B ak>X XMk; kX;+M kXT; akXT; lX; ",
+"l>X TXl; >Xls R2Gk kX2G! H2kX akXG2 1GR5 R1G58 5kHX akXG5 kXMG2 Gk2XM! RGTk",
+"2 ak2RGT RGl5 lGR58 H5lX lsGR5 GkR; dkX+; kXH; kXg; 1GR; R1>G dkXH5 gk>X dk",
+"XM; +GkXM; dkXT; gkXT; RGl; lG>X HXl; >Xgl kXP X!kP XPkB kXaP kX1P kX8P kXP",
+"1B akX1P SkX kXS! TkSX akSX lXS S8lX STlX lXSs XPk( kX+P kXP(B akX+P kXP1( ",
+"R1+XP 1X(kPB 1+XakP kXS( +kSX STkX( S+TkX SXl( S+lX SlTX( Ssl+X Yk Yk! YkH ",
+"Yak Y1R Y8k R1YH R1Ya SYk S!Yk YZk YkSa lY lY8 lYZ lYs Ykd Y+k HkYd gYk R1Y",
+"d R1Y+ Y1RHd Y1gR YkSd YkS+ YdZk SYgk lYd lY+ YZld glY kXm X!km kBXm kXam 1",
+"XRm kX8m kXm1B akX1m kXSm kXmS! kXTm SakXm lXp l8pX lTpX splX Xmk; kX+m kXm",
+";B akX+m kXm1; kX>P kXB1;P >kXam kXS; S+kXm S;TkX Sa;kX S;lX lXS> lXpT; l>X",
+"Ss Ykm kmY! HkYm akYm Y5k 5kY8 H5Yk 5aYk SmYk SYkm! YmZk SYakm lYp lpY8 lZY",
+"p lsYp Yvk vkY+ YHvk Yvgk vRY1 Y>k Yv1RH >kgY YkSv SY+vk ZvYk gYkSv lYv lY>",
+" YZlv ylY R9X kX& RB9X 9XRa 9XR1 :RX kXB91 Ra:X 9XM XMk& 9XRT aX9M lX9 l:X ",
+"9TlX s:lX R(9X 9XR+ kX(9B akX9+ kX(91 R+:X 9X(R1B :R+aX 9(XM +X9M R9TX( aXM",
+"9+ 9Xl( :Xl+ lX9T( lsX:+ R9G 9GR& 9GRH 9GRa 9GR1 :RG R9G1H RG:H 9MRG kX&GM ",
+"9GRT aXM9G R9lG :RlG 9HlX :RsG 9GRd 9+RG dkX9H R9gX dkX91 R+:G 9HXR1d :RgX ",
+"dX9M dkXM& dkX9T 9XgM 9dlX :dlX lHX9d lXg: R29X k2X& kX29B akX92 9XR5 R5:X ",
+"R95XB :R5aX 92XM kX&M2 R9TX2 aXM92 95lX l5:X lX95T lsX:5 9XR; X;k& kX;9B ak",
+"X9; kX;95 :R>X k;B95X :>RaX XM9; kX;M& kX;9T aXM9; 9Xl; l:>X lX;9T l>Xs: R2",
+"9G kX&G2 R9GH2 kX&H2 9GR5 RG:5 R9GH5 :RGH5 R9GM2 kX2GM& R9GT2 aX29GM lGR95 ",
+":RGl5 lHX95 :RGs5 9GR; dkX;& kX;9H gR9G; dkX95 >R:G 9G5RH; g:R>X dXM9; kX;d",
+"M& XM;9H g9XM; lG;R9 l>G:R lHX9; glX:> kX9P X&kP kXP9B akX9P kXP91 kX:P 9X1",
+"kPB :RaXP S9X 9XS& 9TSX 9aSX S9lX S:X Sl9TX sXS: kXP9( kX&+P 9X(kPB 9+XakP ",
+"9X1kP( :R+XP kX9P1(B akX:P+ 9XS( 9+SX S9TX( S9+TX Sl9X( :XS+ lXTS9( S:s+X Y",
+"9R Yk& R9YH R9Ya R9Y1 Y:R Y9R1H :RYa SY9 Y9S& YZS9 Y9Sa lY9 lY: Y9lZ S:sY R",
+"9Yd R9Y+ Y9RHd Y9gR Y9R1d :RY+ R9HY1d gRY: Y9Sd Y9S+ SZ9Yd SYg9 Y9ld l+Y: l",
+"YZ9d Y:gl 9XRm Xmk& kXm9B akX9m kXm95 Rm:X kXB95P :RmaX 9XSm S9Xm& S9TXm S9",
+"aXm p9lX lX:p Sp9TX :pXSs kXm9; kXm9+ kXB9;P kX&a;P 95Xk;P :>RXm 1;9PkXB :X",
+"a>kP 9XS; S9+Xm S9;TX S9aX; Sp9X; >XS: S9TlX; S:>sX R9Ym kmY& Y9RHm Y9aRm R",
+"9Y5 :RY5 Y95RH Y:RH5 SmY9 SY9m& SZ9Ym SY9am S9Yp YpS: Yp9lZ lYs:p vRY9 vkY&",
+" Yv9RH gY9vR Yv9R1 >kY: Y9HvR1 :vRgY YvS9 Sv9Y+ Sv9YZ gS9Yv Y9lv Y:lv lYvZ9",
+" lYy: [k [!k [Dk [ak [1 [18 [1D [1a [kM kM[! V[k Vk[a [l [l8 [lV [sl [k( [+",
+"k Dk[( +D[k [1( [1+ 1D[( 1+[a kM[( +k[M [kV( Vk[+ [l( [l+ l(V[ l+[s [Gk Gk[",
+"! Jk[ [aJk [1G 1G[8 J1[ [1J8 Gk[M [!GkM V[Jk JkV[a [lG [8lG lJ[ lJ[s [dk +G",
+"[k [dJk g[k [1d 1+[d [dJ1 g[1 dk[M [+GkM Vk[d V[gk [ld [+lG V[ld gl[ [k2 k2",
+"[! Dk[2 ak[2 [15 5k[8 1D[5 1a[5 kM[2 [!kM2 [kV2 V[ak2 [l5 l5[8 V5[l [5ls [;",
+"k +k[; Dk[; ak[; [1; [>1 1D[; [a>k k;[M [+kM; Vk[; V[+k; [l; [>l V[l; l>[s ",
+"Gk[2 [!Gk2 [kJ2 Jk[a2 1G[5 [1G58 [1J5 J1[5a [GkM2 GkM[!2 JkV[2 V[aJk2 [5lG ",
+"[lG58 J5[l [slJ5 Gk[; [+Gk; [;Jk [;gk 1G[; [d>k [1J; >kg[ [dkM; +Gk[;M Jk;V",
+"[ g[Vk; [5ld lG[> J;[l [>gl [kP kP[! Dk[P ak[P [1P 1P[8 1D[P 1a[P S[k [!Sk ",
+"SkV[ Sk[a [lS S8[l SV[l [lSs kP[( +k[P [DkP( [+DkP 1P[( 1+[P [1DP( [1+DP [k",
+"S( Sk[+ SV[k( SV+[k l(S[ S[l+ SlV[( [slS+ Yk[ [!Yk YJk JkYa Y1[ [1Y8 J1Yk J",
+"8Yk YkS[ S[Yk! ]k ]ak lY[ Y8[l ]l ]ls [dYk [+Yk YdJk YJgk [dY1 [1Y+ YJ1[d Y",
+"1g[ Sk[d S[+Yk ]dk ]gk S[ld Y+[l ]ld ]lg [mk km[! Dk[m ak[m [1m 1m[8 1D[m 1",
+"a[m Sk[m S[km! Vk[m S[akm [pl lp[8 [lVp ls[p km[; +k[m [mDk; [+mDk 1m[; [1>",
+"P [1mD; [>1Dm Sk[; S[+km SV;[k S[ak; l;[p l>[p [plV; V>[Sl [mYk Yk[m! JmYk ",
+"YJkam [1Y5 Y1[8m J5Yk YJ58k S[Ykm YkmS[! ]km ak]m [plY [plY8 ]lp ls]p [vk [",
+"+vk YkJv gk[v [v1 >k[v J1[v g1[v vkS[ [vS+k ]vk gv]k lv[ [>lY ]lv ]yl [t [t",
+"& [tD [ct [t1 [: tD[1 [:c [tM tM[& V[t V[tc [lt [:l V[lt u[ [t( t+[ [Dt( t+",
+"[c t([1 [:+ [t1D( [+:c [Mt( tM[+ t(V[ V[t+ l([t l+[: [lVt( u[+ tG[ [&tG tJ[",
+" [ctJ [1tG [:G [tJ1 :J[ [GtM tG[M& V[tJ tJV[c tG[l lG[: [ltJ uJ[ td[ [+tG [",
+"Jtd g[t [1td [:d td[J1 g[: tM[d t+[GM V[td V[gt td[l ld[: lJ[td ug[ [t2 t2[",
+"& [Dt2 c2[t t5[ [:5 tD[5 t5[c [Mt2 [tM&2 V2[t [cVt2 t5[l [5l: V[t5 u[5 t;[ ",
+"[+t; tD[; t;[c [1t; t>[ t5[D; c>[: tM[; t+[M; V[t; [c;Vt t;[l l>[: [l;Vt u[",
+"> [Gt2 tG[&2 t2[J tJ[c2 [5tG [5:G [Jt5 J5[: tG[M2 [&MtG2 tJV[2 [cVtJ2 tG5[l",
+" [:lG5 lJ[t5 J5u[ [dt; t+[G; [Jt; t;g[ [5td tG[> tJ5[d t>g[ tG;[M tGM[;& tJ",
+";V[ g[tV; [ldt5 [:dl> lJ;[t g[u> tP[ [&tP [DtP tP[c [1tP [:P tP[1D :P[c St[",
+" [tS& V[St [cSt [lSt S:[ SlV[t u[S [Pt( [+tP tP[D( tcP[+ tP[1( [+:P [1DtP( ",
+"[:c+P S([t t+S[ StV[( St+[c Stl[( S+[: [lVSt( S[u+ tY tY& tYJ tYc tY1 tY: Y",
+"1tJ :JtY tYS S&tY ]t ]tc lYt tYS: ]lt ]u tYd tY+ YJtd gtY Y1td t+Y: tYJ1d Y",
+":g[ SdtY S+tY ]td ]gt ldtY l+tY lt]d ]ug tm[ [&tm tD[m tm[c [1tm [:m t5[Dm ",
+":m[c tmS[ S[&tm V[tm [cmSt tp[ [p: V[tp up[ [mt; [+tm tm[D; [cmt+ t5[;P >P[",
+": tmD[1; [:mc> t;S[ St+[m St;V[ Sc;[t t;[p [pt> tp[V; S>u[ tYm Y&tm YJtm tm",
+"Yc tY5 t5Y: YJt5 t5Yc tmSY tYSm& ]tm tc]m tpY Y:tp ]pt ]up tYv t+[v tJ[v tv",
+"g[ t5[v tY> [v1tJ Yct> St[v [v&St ]tv gt]v tYlv tYS> lv]t ]yu Xe Xe! XeB aX",
+"e Xe. 8Xe e.XB aX8e XeK X!eK TXe aXTe Xje Xj8e XjTe sXe X* +Xe X*B aX* X*. ",
+"8X* X.*B aX8* X*K +KX* TX* TX+e X*j X*+j XjT* sX* GXe XeG! HXe aXHe XeG. GX",
+"8e XeH. 8XHe XeGK GXe!K TXHe aXeGT GXej XjeG8 XjHe HXse fX f+X fHX gfX fX. ",
+"f8X HXf. f8gX fXK +XfK fTX fTgX fjX +Xfj HXfj sfX Xe2 X!e2 e2XB X2ae 5Xe 8X",
+"5e Xe5B aX5e e2XK Xe2!K XeT2 aXeT2 Xj5e Xje58 TX5e 5Xse X;e X;+e *BX; X;ae ",
+"5X* >Xe *B5X aX>e XKe; X;e+K X;Te aX;Te Xj5* X*>j TX5* sX>e XeG2 GXe!2 XeH2",
+" aXeG2 GX5e G58Xe 5XHe G5aXe GXe2K Xe2GK! GTXe2 GTXae2 XjeG5 G58Xje G5TXe s",
+"X5He fX; +Xf; HXf; fXg; f5X f>X H5fX gf>X X;fK f+X;K TXf; fTXg; 5Xfj fj>X 5",
+"TfX >Xsf eP eP! ePB aeP eP. 8eP P.eB ae8P QXe Q!eP TeP aXQe ePj 8XQe ejTP s",
+"eP X*P +eP *BeP ae+P X.P* 8e+P X*P.B aX*8P QX* QX+e TXQ* Te+P XjQ* 8XQ* X*j",
+"TP +esP Ye Ye! YHe Yae Ye. Y8e HeY. H8Ye YQe QeY! YZe ZeYa Yje Q8Ye ZeYj sY",
+"e Yf Yf+ YfH gYf Yf. Yf8 fHY. Y8gf YfQ fQY+ ZfY ZfgY Yfj fQY8 YjZf sYf Xme ",
+"X!em XBem Xmae 5eP 8e5P 5BeP ae5P XmQe XmeQ! XmTe aXmQe pXe 8Xpe TXpe pXse ",
+"Xm* Xm+e *BXm Xma* Xm5* >eP Xm*5B ae>P XmQ* Xm*+Q XmT* aXmQ* pX* pX>e TXp* ",
+"se>P Yem emY! HeYm aeYm Y5e 5eY8 H5Ye 5aYe QeYm YQem! YmZe YZaem Ype peY8 Z",
+"eYp seYp Yfv fvY+ YHfv Yfgv Yf5 Y>f YHf5 f>gY fQYv Yfv+Q YvZf gYZfv fpY fpY",
+"> ZfYp yYf ,X ,X& ,XB ,aX ,X. ,8X X.,B 8X,a ,XK ,KX& ,TX TX,a ,Xj 8X,j TX,j",
+" sX, ,X* -X *B,X -Xa ,.X* -X8 X*.,B 8X-a ,KX* -XK T*,X -TX X*,j -Xj X*j,T s",
+"-X ,GX G&,X ,HX Ga,X GX,. G8,X ,.HX H8,X GX,K X&K,G GT,X ,GTaX Gj,X X&j,G H",
+"X,j ,GsX fX, f-X ,HfX g-X ,Xf. -Xf8 fHX,. g8-X ,XfK fK-X ,TfX -TgX ,Xfj -Xf",
+"j fTX,j gXs- ,X2 ,2X& X2,B ,2aX ,5X 5X,8 ,B5X 5a,X X2,K X&2,K ,2TX ,TX&2 5X",
+",j X&j,5 5T,X ,5sX ,X; -X; ,BX; aX-; 5X,; >X- ,5X*B -a>X ,KX; X;-K TX,; TX-",
+"; X;,j -j>X X;j,T >Xs- GX,2 X&2,G ,2HX ,GaX2 G5,X ,G58X H5,X ,G5aX ,GX2K ,G",
+"2X&K ,GTX2 aX2,GT ,G5Xj ,G5X&j ,G5TX sX,G5 ,Xf; f;-X HX,; g;-X ,5fX f->X f5",
+"H,X g->X fX;,K f-X;K fTX,; f-TX; f5X,j f>-Xj f5T,X s-Xf> ,XP eP& ,BeP aX,P ",
+",.eP 8X,P eP.,B aeP,8 ,QX Q&,X QX,T Qa,X QX,j Q8,X ePj,T ,QsX X*,P -XP X*P,",
+"B aX-P X*P,. 8X-P ,X.P*B -X8aP Q*,X -QX ,QXT* Qa-X X*j,Q Q8-X ,TXP*j -QsX Y",
+", Y&e Y,H Ya, Y,. Y8, ,HY. ,HY8 Y,Q ,QY& YZ, ZeY& Yj, ,QY8 Z,Yj sY, Yf, Y- ",
+"fHY, Y-g f,Y. Y-8 YfH,. Y8g- fQY, Y-Q Y,Zf Y-Z fjY, Y-j YZ,fj sY- ,Xm X&,m ",
+",BXm aX,m 5X,m 8X,m ,5XmB aXm,5 QX,m Xm&,Q TX,m aXm,Q pX, ,8pX ,TpX pXs, Xm",
+",; -Xm Xm*,B aX-m Xm*,5 -X>P X;B,5P >X-am QX,; QX-m Xm*,T TX-m ,Xp* -pX pX*",
+",T sX-p Y,m ,mY& ,HYm ,aYm Y5, ,5Y8 ,HY5 ,5Ya ,QYm Y&Q,m YmZ, YZ&,m Yp, peY",
+"& ZpY, s,Yp Yv, Y-v YHv, -vgY f5Y, Y-> Yf5,H g-Y> YQv, -QYv ZvY, YZ-v Y,fp ",
+"Y-p fpZY, yY- IXe I!Xe DXe aXDe XeI. IX8e XeD. 8XDe XeIK IXe!K TXDe aXeTI I",
+"Xej IjX8e XjDe DXse I*X I*+X DX* DX+e I.X* I*8X D.X* 8XD* IKX* I*X+K TXD* a",
+"X*TI X*Ij I*j+X X*Dj DXs* IXGe GIXe! JXe aXJe GIXe. G8IXe XeJ. 8XJe GIXeK I",
+"XeGK! TXJe JTaXe IjXGe G8IXje XjJe JXse fIX +IfX JfX JfgX IXf. 8IfX fXJ. JX",
+"f8 IXfK f+IXK JXfT JfTgX IjfX f8IXj JXfj JfsX XeI2 IXe!2 XeD2 aXeI2 IX5e 5I",
+"8Xe DX5e 5DX8e IXe2K Xe2IK! DXTe2 DXTae2 IjX5e 5I8Xje 5DXTe sI5Xe X;I* I;X+",
+"e X;De aX;De I*5X I*>X DX5* DX>e I;XeK +IXe;K DX;Te DX;+Te I;jX* >IjX* X;jD",
+"e sI*>X GIXe2 IXeG2! XeJ2 JaXe2 G5IXe 5IXG8e 5XJe J58Xe IXeG2K I!X2GeK JTXe",
+"2 aXeJT2 G5IXje 8eGj5IX J5TXe sJ5Xe I;fX f+IX; fXJ; JfXg; 5IfX fI>X JXf5 Jf",
+">X fIX;K I;Xf+K JfTX; fTXgJ; f5IXj f>IXj Jf5TX J>sfX IPe I!eP DeP aeDP I.eP",
+" IP8e D.eP 8eDP IPQe IPeQ! DXQe aePQD ePIj IPj8e ePDj DesP IP* IP+e IPD* De",
+"+P I.P* IP8* IP*D. aP*8I IPQ* IP*+Q DXQ* aX*QD P*Ij IP*+j IP*Dj IPs* YIe Ie",
+"Y! YJe JaYe IeY. 8IYe JeY. YeJ8 QIYe YQIe! ZeYJ YZJae IjYe Y8QIe YeJj YJse ",
+"YfI f+YI YJf YJgf fIY. YIf8 Y.Jf JfY8 YIfQ Yf+QI YJZf gYZJf YIfj Yf8QI JfYj",
+" YJsf emIP ImXe! XmDe aXmDe IP5e 5IP8e De5P aeP5D ImXQe QIXem! QDXem QDXaem",
+" IPpe pI8eP DXpe sIPpe XmI* Im*+X XmD* aXmD* IP5* IP>e IP*5D De>P Im*QX +QI",
+"Xm* Im*TX +QDXm* IPp* >XpI* DXp* sIP>e ImYe YIem! YeJm YJaem 5IYe Y58Ie YeJ",
+"5 YJ58e YQIem ImeYQ! YZJem ZJeYam YIpe Yp8Ie peYJ JpsYe vIYf Yfv+I YfJv gYJ",
+"fv YIf5 >IYf JfY5 YJf> YfvQI fvQY+I YZvJf ZfJgYv pIYf fpY>I YJfp YJyf hX hX",
+"& hDX hcX hX. h8X DXh. cXh8 hXK X&hK hTX cXhT hjX 8Xhj DXhj hsX hX* h-X DXh",
+"* c-X X*h. -Xh8 hDX*. c8-X X*hK hK-X TXh* -TcX X*hj -Xhj hTX*j sXh- hGX G&h",
+"X hJX cXhJ GXh. G8hX JXh. hXJ8 GXhK hGX&K JThX cJThX GjhX h8GXj hXJj sXhJ h",
+"fX -Xhf hXJf iX fXh. hXf8 JfXh. i8X fXhK f-XhK hXfT iTX hXfj f-jhX JfjhX is",
+"X hX2 X&h2 DXh2 h2cX h5X 5Xh8 5DhX cXh5 X2hK hX&2K TXh2 cXTh2 5Xhj h58Xj 5T",
+"hX sXh5 h;X -Xh; DXh; cXh; 5Xh; h>X h5DX; hc>X X;hK -X;hK TXh; c-XT; X;hj h",
+"j>X h5TX; >Xhs GXh2 hGX&2 JXh2 cJXh2 G5hX h5G8X hXJ5 cJ5hX hGX2K X&2hGK hJT",
+"X2 hJTcX2 h5GXj X&jh5G hJ5TX hsJ5X fXh; f-Xh; hXJ; iX; hXf5 hf>X Jf5hX i>X ",
+"hfX;K hf;-XK hJ;TX TXi; hf5Xj h>fXj J;jhX >Xis hP hP& hPD hcP hP. h8P DPh. ",
+"cPh8 hQX QXh& hTP cQhP hPj Q8hP DPhj hsP hP* h-P DPh* c-hP P*h. -Ph8 hPD*. ",
+"c-X8P QXh* -QhP TPh* -QcX P*hj -Phj hTP*j hPs- hY hY& hYJ Ych hY. hY8 h.YJ ",
+"h8Yc hYQ Y&hQ hZY YchZ hYj Y8hQ YZhj hsY hYf Y-h YJhf iY h.Yf h8Y- hYJf. iY",
+"8 YfhQ hQY- ZfhY iZY Yfhj hjY- hYjZf isY hmX Xmh& DXhm cXhm h5P 5Ph8 5DhP c",
+"5hP QXhm hQXm& TXhm cQXhm hpX pXh8 pDhP hPcp h;P -Xhm D;hP c;hP 5Ph; h>P h5",
+"PD; hc>P QXh; -QXhm T;hP c-QXm pXh; >Xhp hpDX; >Phs hYm Y&hm YJhm hmYc hY5 ",
+"Y5h8 YJh5 h5Yc YQhm hYQm& YZhm hZYcm hpY h8Yp hYJp sYhp hvY Y-hv JvhY iYv Y",
+"fh5 h>Y hY5Jv iY> YvhQ hvY-Q YZhv YZiv hYfp Y-hp JpfhY yiY Xe0 X!e0 e0XB Xe",
+"a0 1Xe 8X1e Xe1B aX1e e0XK Xe0!K XeT0 aXeT0 Xj1e Xje18 TX1e 1Xse X*0 +0X* X",
+"0*B a0X* 1X* +X1e *B1X aX1* *0XK X*0+K T0X* aX*T0 Xj1* X*j1+ TX1* 1Xs* XeG0",
+" GXe!0 XeH0 aXeG0 GX1e 1G8Xe HX1e 1GaXe GXe0K Xe0GK! GTXe0 GTXae0 Xje1G 1G8",
+"Xje 1GTXe sX1He fX0 +Xf0 HXf0 fXg0 f1X 1+fX 1HfX f1gX X0fK f+X0K TXf0 fTXg0",
+" 1Xfj f1+Xj 1TfX f1sX e0X2 Xe0!2 Xe02B aXe02 5X1e 1X58e 1X5eB 1aX5e Xe02K e",
+"02XK! TXe02 TX0ae2 Xje15 5X81ej 1TX5e sX15e X0e; X;e+0 X;e0B aX;e0 5X1* 1X>",
+"e 1X;*B >X1ae X;e0K +X0e;K TX;e0 aX0Te; X;j1e >X1ej 1TX5* sX*>1 GXe02 Xe0G2",
+"! HXe02 HX0ae2 1G5Xe G581Xe 1HX5e H5X1ae Xe0G2K 2Ke!GX0 TX0He2 aXHeT02 1G5X",
+"je 8eGj1X5 H5X1Te 1HXse5 X;f0 f+X;0 fHX;0 gfX;0 1Xf5 f1>X f1H5X f>g1X fX;0K",
+" X;0f+K fTX;0 gX;fT0 f15Xj f>1Xj f1T5X sf>1X eP0 P!e0 P0eB a0eP 1eP 8e1P 1B",
+"eP ae1P Q0eP eP0Q! T0eP aePQ0 QX1e ePj18 Te1P 1esP X0P* +0eP X*P0B aX*P0 X*",
+"1P +e1P 1X*PB aX*1P Q0X* +QXe0 QX*T0 aX*Q0 QX1* ePj1+ 1QXT* sX*1Q Ye0 e0Y! ",
+"HeY0 aeY0 Y1e 1eY8 1HYe 1aYe QeY0 YQe!0 Y0Ze YZae0 1QYe Y1Q8e ZeY1 Y1se Yf0",
+" f+Y0 fHY0 g0Yf Yf1 f1Y+ YHf1 Yfg1 Y0fQ Yf+Q0 Y0Zf gYZf0 f1Yj Yf1+Q Y1Zf Y1",
+"sf X0em Xme!0 Xme0B aXme0 5e1P 1Xm8e 1XmeB aXm1e XmeQ0 QX0em! TXme0 aX0Tem ",
+"1Xpe pX18e pX1Te sePp1 X0m* Xm*+0 Xm*0B aXm*0 Xm1* 1e>P Xm*1B >eP1a Xm*Q0 X",
+"m0+Qe Xm*T0 aX0Qe; 1Xp* >Xp1e pX*1T sX*p1 emY0 Yem!0 YHem0 Yaem0 1eY5 Y158e",
+" Y1H5e Y1a5e YQem0 em0YQ! YZem0 ZemYa0 peY1 Yp18e YZ1pe sYp1e Y0fv Yfv+0 Yf",
+"vH0 gYfv0 fvY1 Y1f> Yf1vH gY1f> YfvQ0 fvQY+0 YZvf0 ZfvgY0 Y1fp fpY>1 fpZY1 ",
+"Yfy1 ,X9 X&9e ,B9X 9a,X ,1X :Xe ,B1X ,a:X ,K9X X&K9e 9T,X ,TX9a 9X,j ,X:j 1",
+"T,X :Xse 9X* -X9 *B9X 9a-X 1X9* :-X ,1X*B :a-X 9KX* 9X-K TX9* 9T-X X*9j -j:",
+"X X*j9T :-sX 9G,X ,G9X& 9H,X ,Ga9X 1G,X ,G:X 1H,X ,H:X ,G9XK ,G9X&K ,GT9X 9",
+"GT,aX ,1GXj :GX,j ,1GTX sX,:G f9X -Xf9 9HfX f9gX ,1fX :fX f91HX gX:f 9XfK f",
+"-9XK 9TfX f-T9X 9Xfj fj:X f9T1X sX:f ,29X X&29e ,X92B ,aX92 95,X ,5:X ,1X5B",
+" :X5,a ,X92K 9X2e&K ,TX92 aX29Te ,1X5j :X5,j ,1T5X sX,:5 9X,; 9X-; ,X;9B -X",
+"9a; 1X,; :->X ,1X;B :-X>a ,X;9K -X9;K ,TX9; -TX9; X;j,1 :-X>j ,1TX; s-X:> ,",
+"G9X2 ,G9X&2 ,HX92 aX29He ,1G5X :G5,X ,1H5X :HX,5 9G2,XK X&9eG2K ,G29TX ,2GT",
+"9aX 9G5,Xj ,G5:Xj 9G5,TX sX5:He 9Xf; f-9X; f9HX; gf9X; 95fX >X:f f95HX g:Xf",
+"> f9X;K -X;f9K f9TX; f9;-TX f95Xj :f>Xj f95TX sf:>X 9eP e&9P 9BeP ae9P 1X,P",
+" :eP ,1XPB ae:P 9Q,X eP&9Q Te9P aeP9Q 1Q,X ,Q:X ePj9T :esP X*9P 9X-P 9X*PB ",
+"-X9aP ,1XP* -X:P X*B,1P :-XaP QX9* 9Q-X 9QXT* -QX9T X*j9Q -Q:X 9TXP*j s-X:Q",
+" Y9e 9eY& ,HY9 ,aY9 Y1, Y:e ,1YH :HY, ,QY9 Y9Qe& Z9Y, YZ9,a ,1Yj :QY, Z1Y, ",
+"seY: Yf9 Y-9 YHf9 g9Y- f9Y1 Y:f Yf91H gY:f fQY9 -QY9 Y9Zf Y9Z- f9Yj Yj:f Zf",
+"9Y1 Y:sf 9X,m Xm&9e ,Xm9B aXm9e 1X,m ,X:m ,1XmB :Xm,a ,QX9m 9QXem& ,TX9m 9Q",
+"a,Xm ,1pX pX:e p9X,T :pXse Xm9* 9X-m Xm*9B -Xm9a Xm*,1 :e>P XmB,1; :-Xam Xm",
+"*9Q -QX9m Xm*9T -TX9m 9Xp* :X-p p9XT* -pXs: ,mY9 Y9em& Y9H,m Y9a,m ,1Y5 :eY",
+"5 Y95,H Y:H,5 Y9Q,m em&Y9Q YZ9,m Y9mZe& p9Y, Y,:p Yp9Ze sY:pe fvY9 Y9-v Yf9",
+"vH gY9-v f9Y5 :fY> Yf9H5 Y:gf> Yf9vQ Y-v9Q Zf9Yv Y-Zv9 Y9fp fpY: fp9YZ Y:yf",
+" XeI0 IXe!0 XeD0 aXeD0 IX1e 1I8Xe DX1e 1DX8e IXe0K Xe0IK! DXTe0 DXTae0 IjX1",
+"e 1I8Xje 1DXTe sI1Xe I0X* I*X+0 D0X* aX*D0 I*1X 1+IX* DX1* aX*1D I*X0K +I0X",
+"*K DX*T0 aX0TI* I*j1X 1+IX*j X*j1D sI*1X GIXe0 IXeG0! XeJ0 JaXe0 1GIXe G8I1",
+"Xe 1XJe J18Xe IXeG0K I!XKGe0 JTXe0 aXeJT0 1GIXje 8eGj1IX J1TXe sJ1Xe IXf0 f",
+"+IX0 fXJ0 JfXg0 1IfX f1+IX JXf1 Jf1gX fIX0K +IXf0K JfTX0 fTXgJ0 f1IXj 1+Ifj",
+"X Jf1TX sfJ1X IXe02 Xe0I2! DXe02 DX0ae2 1I5Xe 5I81Xe 1DX5e 5DX1ae Xe0I2K I!",
+"X2e0K TX0De2 aXDeT02 1I5Xje 8X5e1Ij 5DX1Te 1DXse5 I;Xe0 +IXe;0 DX;e0 aX0De;",
+" 1I;X* >I1X* 1DX5* >XD1e X;0I*K +KI;X*0 I;0TX* X;De+T0 1I;X*j I*j>X1 1DXe;j",
+" >I1sX* IXeG02 I!X2Ge0 JXe02 aXeJ02 G5I1Xe 8X5e1GI J15Xe 1aXJ5e IXG0e2K IXG",
+"02Ke! TXeJ02 aXJeT02 Ij1XG5e GX8e15Ij 1TXJ5e J15sXe fIX;0 I;Xf+0 JfX;0 gfXJ",
+";0 f15IX f>1IX Jf15X J>f1X I;Xf0K I;fX+0K fTXJ;0 X;g0JfT I;jf1X f1I>Xj J1Xf",
+"5T sf1J>X I0eP IPe!0 D0eP aePD0 IP1e 1IP8e De1P aeP1D IPeQ0 QI0eP! QDXe0 aX",
+"0QDe IPj1e Q8I1eP ePj1D sIP1e I0P* IP*+0 IP*D0 aP*I0 IP1* IP*1+ IP*1D aP*1I",
+" IP*Q0 IP0+Qe IP*T0 aX0QD* IP*1Q 1+QIP* IP*1T sIP1* IeY0 YIe!0 JeY0 YJae0 1",
+"IYe Y18Ie YeJ1 YJ18e YQIe0 QIeY0! YZJe0 ZJeYa0 Y1QIe 1QIY8e YZ1Je sYJ1e fIY",
+"0 Yf+I0 Y0Jf gYJf0 YIf1 Yf1+I JfY1 gY1Jf YfQI0 fQIY+0 YJfZ0 ZfJgY0 Yf1QI Y1",
+"IfQ8 Zf1YJ sYfJ1 ImXe0 em0IP! DXme0 aX0Dem 1ImeP 8Im1eP 1DXem 1DXaem QIXem0",
+" ImQXe0! Im0TeP aXQeIm0 pI1eP 1IPpe8 pDX1e sX1pDe Im*X0 Im0+eP Xm*D0 aX0Im*",
+" Im*1X >eP1I Xm*1D >eD1P Im0QX* Im+XQe0 Im0TX* XmD*+Q0 pI*1X >I1pX* pDX1* >",
+"I1seP YIem0 ImeY0! YJem0 JmeYa0 Y15Ie 1ImY8e YJ15e Y1eJ8m ImeYQ0 QmY0Ie! Ze",
+"mYJ0 aeJmYZ0 Yp1Ie pI8Y1e JpY1e sY1Jpe YfvI0 fvIY+0 YJfv0 JvfgY0 Yf1vI Y>f1",
+"I Jv1Yf Y>Jf1 fQIYv0 YQvIf+0 JvYZf0 gJZfYv0 fpY1I Y>1fpI JpfY1 yJYf1 h9X 9X",
+"h& 9DhX h9cX h1X h:X 1DhX :Xhc 9XhK h9X&K 9ThX cX9hT 9Xhj :Xhj 1ThX sXh: 9X",
+"h* h9-X DX9* c9-X 1Xh* :Xh- h1DX* c-:X h9X*K -X9hK hT9X* c-X9T h1X*j h:-Xj ",
+"h1TX* s-Xh: 9GhX h9GX& hXJ9 cJ9hX 1GhX hG:X hXJ1 :XhJ h9GXK X&Kh9G J9ThX hJ",
+"9cXT h1GXj h:GXj J9jhX hsJ:X hXf9 f-9hX JXf9 i9X hXf1 :Xhf Jf91X i:X f9XhK ",
+"hf9-XK Jf9TX 9TiX f9jhX :fhXj Jf9Xj s:iX 9Xh2 h9X&2 h9DX2 cX9h2 95hX :Xh5 h",
+"15DX h:c5X h9X2K X&2h9K hT9X2 hT9cX2 h15Xj h:5Xj h1T5X hs:5X 9Xh; -X9h; h;9",
+"DX c-X9; 1Xh; >Xh: h1;DX c>Xh: h;9XK h;9-XK hT;9X cX9hT; h1;Xj h>:Xj h1TX; ",
+"hs>:X h9GX2 X&2h9G J9Xh2 hJ9cX2 h1G5X h:G5X J95hX :Jh5X 9GXh2K X&h29GK hTXJ",
+"92 h9cXJT2 9G5hjX h5G:Xj J9Xh5T :J5hsX f9Xh; hf9-X; Jf9X; 9Xi; f95hX h>:fX ",
+"Jf95X >Xi: h;Xf9K h9-Xf;K J9XhT; i9;TX f9Xh;j :fXh>j J9Xf5T is:>X hP9 9Ph& ",
+"9DhP h9cP h1P h:P 1DhP :chP 9QhP hQ9X& 9ThP cQXh9 9Phj :QhP 1ThP s:hP 9Ph* ",
+"h9-P hP9D* c-X9P 1Ph* :-hP h1PD* h:Pc- hQ9X* -QXh9 hTP9* c-Q9X h1QX* h:Q-X ",
+"h1TP* hsP:- hY9 h9Y& Y9hJ Y9hc hY1 Y:h YJh1 hY:J Y9hQ hY9Q& Y9hZ hZYc9 Y9hj",
+" hQY: YZh1 Y:hZ Y9hf Y9h- JfY9 iY9 Yfh1 hY:f hY1Jf iY: hYf9Q Y-h9Q Zf9hY YZ",
+"i9 hY1fQ Y:hfQ hZ1Yf sYi: 9Xhm hm9X& hm9DX cXmh9 95hP :Xhm h1mDX h:mcX hQ9X",
+"m Xm&hQ9 hTm9X cX9hTm p9hP hP:p hp9DX cpXh: 9;hP -Xmh9 h;P9D c-X9m 1;hP >Ph",
+": h1;DP h>P:c hQ;9X -Q9h;P hT;9P cQ9-Xm hp9X; -pXh: p9DX* cp-:X Y9hm hY9m& ",
+"hYJ9m Ych9m Y9h5 h5Y: hY1J5 Y:Jh5 hY9Qm hQ9Y&m hZY9m Yc9hZm h1Yp Y:hp Jp9hY",
+" hZ:Yp Y9hv hvY-9 Jv9hY Yvi9 Yvh1 Y:hv hv1YJ Y:iv hvY9Q Y-9hvQ hZvY9 iZYv9 ",
+"fp9hY hv:Yp JpfY9 yYi: Re Re! ReB Rae Re. R8e e.RB 8eRa ReM R!Me RTe TeRa R",
+"ej 8MRe TeRj sRe Re* R+e *BRe +eRa R.X* +eR8 X*.RB aX*R8 XM* +MRe TXR* +TRe",
+" X*Rj +eRj XM*Tj R+se RGe GeR! RHe GaRe GeR. G8Re R.He H8Re GMRe XM!Ge GTRe",
+" aXMHe GjRe RG8Me HeRj RGse fR fR+ fRH gfR fR. fR8 RHf. f8gR fRM R+fM fRT f",
+"RgM fRj R+fj RHfj sfR Re2 e2R! e2RB R2ae R5e 5eR8 RB5e 5aRe R2Me XM2e! R2Te",
+" aXMe2 5MRe R5e8M 5TRe R5se Re; +eR; RBe; aeR; 5XR* >eR R5e*B Ra>e MeR; XM;",
+"+e TeR; aXMe; XM5* Re>M XM*5T sR>e GeR2 RGe!2 R2He RGae2 G5Re RG58e H5Re RG",
+"5ae XM2Ge RG2Me! RGTe2 aX2HMe RG5Me G5MR8e RG5Te sRG5e fR; R+f; RHf; g;fR f",
+"R5 f>R RHf5 gRf> R;fM fR+M; RTf; fRTg; R5fM fR>M R5fT sRf> ReP R!eP RBeP aP",
+"Re R.eP 8PRe eP.RB aePR8 Se Se! SeT Sae Sej S8e TeSj Sse ePR* +PRe X*PRB aX",
+"*RP X*PR. R+e8P Re.P*B R8eaP* Se* S+e TXS* +TSe X*Sj +eS8 SeT*j S+se YRe Re",
+"Y! RHYe RaYe ReY. R8Ye YRHe. Y8RHe SYe YeS! SZe YaSe YjSe Y8Se SjZe seSZ Yf",
+"R fRY+ YHfR YfgR Y.fR fRY8 YfRH. gYfR8 Sf Sf+ SfZ gSf Sfj Sf8 fjSZ sfS Rem ",
+"R!em RBem aeRm 5eRm 8eRm R5emB aemR5 Sem emS! TeSm aeSm Spe peS8 STpe seSp ",
+"XmR* +eRm Xm*RB aXmR* Xm*R5 Re>P XmBR5* >eRam Se; +eS; TeS; aeS; pXS* S>e S",
+"peT; >eSs ReYm YRem! HeRm YaRem R5Ye Y5R8e Y5RHe Y5aRe YeSm SYem! SmZe SZea",
+"m SeYp SpeY8 ZpSe SseYp fvR f+vR fHvR fvgR fRY5 fRY> Yf5RH f>RgY Sfv fvS+ Z",
+"fSv gfSv Sfp Sf> SZfp yfS ,RX Re& RB,X Ra,X ,.Re R8,X ,RX.B ,R8aX ,XM X&,M ",
+"RT,X TeR& Re,j 8X,M ,RTXj ,RsX R*,X -RX X*B,R Ra-X X*.,R R8-X ,R.X*B -R8aX ",
+"X*,M -XM XM*,T RT-X XM*,j Re-j ,RTX*j -RsX ,RG R&,G RG,H RG,a ,.RG RG,8 ,RG",
+"H. ,RGH8 RG,M XM&,G RG,T aXM,G RG,j e&jRG ,RGHj ,RsG fR, f-R ,RfH f-gR ,Rf.",
+" -Rf8 fRH,. f-Rg8 ,RfM -RfM ,RfT -RfT ,Rfj -Rfj fRT,j f-sR ,2Re R2e& ,RX2B ",
+",RaX2 R5,X 5eR& ,R5XB ,R5aX ,2XM XM&,2 ,RTX2 aXM,2 5X,M XM&,5 ,R5TX sX,R5 R",
+"e,; Re-; ,R;XB -RaX; ,R5X; -R>X X;B,R5 >X-Ra XM,; XM-; XM;,T -RTX; XM;,5 -X",
+">M ,RTX;j s-R>X ,2RG ,RG&2 ,RGH2 ,RGa2 RG,5 ,RG5& ,RGH5 ,RG5a ,RGM2 X&2,GM ",
+",RGT2 aX2,GM ,RG5M ,G5XM& ,RG5T sRG,5 ,Rf; f;-R fRH,; f-Rg; ,Rf5 ->fR fR5,H",
+" f>Rg- fRM,; f-RM; fRT,; f-RT; fR5,M f>R-M fR5,T sfR-> Re,P ePR& ePB,R aeP,",
+"R eP.,R eP&R8 ,R.ePB ,R8aeP Se, Se& ,TSe ,aSe ,XSj ,8Se SeT,j Ses, X*P,R Re",
+"-P ,RXP*B -RaeP ,RXP*. -R8eP ePR*,.B aeP-R8 ,XS* S-X SeT,* -TSe Se*,j -XS8 ",
+"X*jS,T sXS- Y,R ,RY& ,RYH ,RYa ,RY. ,RY8 Y,RH. Y8,RH SY, Y&Se YZS, YaS, YjS",
+", Y8S, SZe,j SYs, fRY, Y-R YfR,H gRY- YfR,. -RY8 fRHY,. Y-gR8 Sf, Sf- S,Zf ",
+"Y-gS fjS, S8Y- SfZ,j S-sY Re,m emR& ,RmXB aXm,R ,R5Xm em&R5 XmB,R5 ,R5aXm ,",
+"XSm emS& SeT,m Sae,m pXS, peS& Spe,T Ssep& Xm*,R Re-m XmB,R; -RmaX ,R5Xm* >",
+"X-Rm Xm,;R5B >Xa-Rm ,XS; -XS; Se;,T S-TXm Spe,; >XS- S;TpX, -pXSs ,RYm Y&R,",
+"m Y,RHm Ya,Rm ,RY5 Y5&,R Y5,RH Y5a,R SmY, SY&,m SZe,m SZem& S,Yp Yp&Se Yp,S",
+"Z sY,Sp vRY, fR-v Yv,RH -vRgY Yf5,R -RY> Y5HvR, Y->gR YvS, SvY- Sv,Zf gSf-v",
+" S,fp Y-S> SfpZ, Sfy- [e [!e [De [ae [e. [8e De[. D8[e [Me Me[! V[e [aVe [j",
+"e 8M[e [jVe [se [* [+e [*D [a* [*. [8* D*[. D8[* [*M +M[* V[* [+Ve [*j +e[j",
+" [jV* [s* [Ge Ge[! [Je Je[a Ge[. G8[e [eJ. Je[8 GM[e [!GMe [JVe VJ[ae Gj[e ",
+"[8GMe Je[j [Jse [f [f+ [fJ g[f [f. [f8 J.[f J8[f [fM [+fM Vf[ Vfg[ [fj [+fj",
+" Jj[f sf[ [e2 e2[! De[2 ae[2 [5e 5e[8 5D[e 5a[e Me[2 [!Me2 [eV2 V[ae2 5M[e ",
+"[58Me [5Ve [5se [;e +e[; De[; ae[; [5* [>e 5D[* [a>e Me[; [+Me; [;Ve V[+e; ",
+"5M[* [*>M [5V* >e[s Ge[2 [!Ge2 [eJ2 [Jae2 G5[e [5G8e Je[5 J5[8e [GMe2 Me2[!",
+"G VJ[e2 [JaVe2 [5GMe G5M[8e J5V[e [sJ5e [f; f+[; J;[f [;gf [f5 [>f J5[f f>g",
+"[ [;fM [f+M; V;[f Vfg[; [5fM >M[f V[f5 [>sf [eP eP[! De[P ae[P eP[. 8e[P [D",
+"eP. [8DeP S[e [!Se SVe VeSa [jSe [8Se SjVe SVse [*P +e[P DP[* aP[* P*[. 8P[",
+"* [*DP. [8*DP S[* [+Se V[S* V+Se [jS* [8S* SVe*j s*S[ [Ye Ye[! Ye[J Ye[a [e",
+"Y. Ye[8 YJ[e. YJ8[e [YSe S[Ye! ]e ]ae Ye[j S[8Ye ]je ]se [fY Y+[f YJ[f [fgY",
+" Y.[f Y8[f YJf[. g[Yf8 Sf[ S+[f ]f ]gf Yj[f S8[f ]fj ]sf [me em[! De[m ae[m",
+" 5e[m 8e[m [5Dem [5aem [mSe S[em! VmSe SVeam [pe [8pe SeVp se[p [m* +e[m Dm",
+"[* am[* 5P[* [m>e [5*Dm [>Dem [mS* S[+em VeS; SV+em [p* >e[p V*[p SV>e Ye[m",
+" [Yem! Je[m Ya[em Ye[5 Y5[8e YJ5[e Y5[ae S[Yem [YmSe! ]em ae]m [Ype [pY8e ]",
+"pe sp]e [vf [+fv [fJv gf[v Y5[f f>[v [vJf5 [>fgY [vSf [vfS+ ]fv gf]v fp[ [>",
+"Sf ]pf ]yf [h [h& [hD [ch [h. h8[ [Dh. h8[c hM[ [&hM Vh[ [cVh hj[ [8hM V[hj",
+" hs[ [h* [- hD[* [-c h.[* [-8 [hD*. [8c- [*hM [-M [hV* V-[ [*hj [-j Vh[*j [",
+"s- [hG hG[& hJ[ hJ[c [Gh. hG[8 h.[J [Jh8 [GhM [hGM& V[hJ VhJ[c hG[j h8[GM [",
+"Jhj hJ[s [fh [-f hJ[f i[ h.[f h8[f [fJh. i[8 hM[f fM[- [fVh iV[ hj[f fj[- V",
+"f[hj i[s [h2 h2[& [Dh2 h2[c h5[ [5h8 hD[5 h5[c [Mh2 [h&M2 h2V[ Vh[c2 [5hM h",
+"5[8M V[h5 h5[s h;[ [-; hD[; h;[c [5h; h>[ h5[D; c>[- [;hM [;-M V[h; V;[- [;",
+"hj >M[- Vh5[; [sh> [Gh2 [hG&2 h2[J [cJh2 hG[5 h5[G8 [Jh5 [c5hJ [hGM2 [&GhM2",
+" VhJ[2 [cJVh2 h5[GM h5G[&j Vh5[J hs[J5 h;[f [;f- [Jh; i[; h5[f f>[- [f5hJ i",
+"[> [fhM; [-fM; Vf[h; V[i; [f5hM [-jf> Vf5[h V>i[ hP[ [&hP [DhP hP[c [Ph. [8",
+"hP [hDP. [ch8P Sh Sh& ShV Shc Shj Sh8 SVhj hsS [*hP [-P [hDP* cP[- [h*P. [8",
+"-P [*DhP. [-c8P Sh* Sh- S*Vh V-Sh S*hj h8S- ShV*j S-hs hY[ [hY& [JhY [chY h",
+".[Y [hY8 hYJ[. hY8[c ShY S&hY ]h ]hc SYhj SYh8 ]hj ]hs [fhY Y-[ hYJ[f i[Y h",
+"Y[f. Y8[- [fJhY. Y8i[ Shf Y-Sh ]hf ]i hjSf h8Sf hf]j ]is hm[ [&hm hD[m hm[c",
+" [5hm [8hm h5[Dm [c5hm Shm S&hm SVhm hmSc hp[ h8[p VpSh Schp [mh; [-m hm[D;",
+" cm[- h5[m* >P[- h5D[m* [-mc> Sh; hmS- SVh; h;Sc h;[p h>S [p*Vh Sch> [Yhm h",
+"Y[m& [Jhm [cmhY [hY5 hY5[8 hY5[J Yc5[h SYhm ShYm& ]hm hc]m hY[p [p&hY ]ph h",
+"p]s hv[ [-v hJ[v i[v h5[v [-Y> hv[J5 Y>i[ hvS S-hv ]hv ]iv Sfhp Sfh> hp]f ]",
+"yi Rek R!ke RBke akRe R1e 1eR8 RB1e 1aRe XMke kXMe! TkRe akXTe lXe R8le RTl",
+"e sRle kX* +kRe *BkX kXa* 1XR* 1+Re kX*1B akX1* XMk* kX*+M kXT* akXT* lX* R",
+"+le TXl* sXl* GkRe kX!Ge HkRe akXHe 1GRe R1G8e 1HRe R1Gae kXMGe RGkMe! RGTk",
+"e RGTake RGle lGR8e RHle lsGRe fRk R+fk RHfk fRgk fR1 R1f8 R1fH fRg1 kXfM f",
+"R+kM RTfk fRTgk lfR fRl+ fRlH lXsf R2ke kX2e! kX2eB akXe2 1eR5 R1e58 R1e5B ",
+"akX5e kXMe2 XM2ke! RTek2 ak2RTe R5le lX58e lX5Te lsX5e keR; kX;+e kX;*B akX",
+"e; 1eR; R1>e kX*5B >kXae kX;Me +kXMe; kX;Te kX;aMe Rel; lX>e lX;Te l>Xse kX",
+"2Ge RG2ke! RHek2 ak2RHe R1G5e G5kR8e R1H5e RG5ake RGkMe2 M!kXGe2 kX2HMe akR",
+"eGT2 lGR5e RG5le8 lHX5e sX5lHe R;fk fR+k; fRHk; gfRk; R1f5 fR>k fR1H5 f>Rg1",
+" fRkM; kX;fM+ fRTk; fT;gkX fRl; >Xlf lfRH5 glf>X keP k!eP kBeP keaP 1PRe ke",
+"8P keP1B ake1P Sek keS! TkSe akSe leS S8le lTSe leSs X*kP ke+P kX*PB akXP* ",
+"kX*1P kX*8P kXB1P* R1+aeP kXS* +kSe SeTk* S+eTk Sel* S+le lX*ST Ssel+ Yke k",
+"eY! HkYe akYe R1Ye 8kYe Y1RHe Y1aRe YkSe SYke! ZkSe SZeak lYe Y8le SZle les",
+"Y Yfk fkY+ YHfk Yfgk fRY1 f8Yk Yf1RH gY1fR Sfk fkS+ YkZf gkSf lYf l+Sf ZflY",
+" gSlf keRm kXme! kXmeB akXem 1eRm kXm8e keP5B ake5P keSm Sekm! SeTkm Saekm ",
+"Sple Spel8 SpelT Sselp Xmk* kXm+e kXm*B akXm* kXm1* ke>P kXB1m* >keaP keS; ",
+"S+ekm Se;Tk Saek; Sel; leS> Se;lT S>els keYm Ykem! YkHem Yakem 5kYe Y5k8e Y",
+"5kHe Y5ake SYkem YkmSe! SZekm SamZke leYp lYp8e lYZpe lYspe fvYk Yfkv+ Yfkv",
+"H gYkfv f5Yk Yf>k Yf5Hk Y>kgf fkSv Sfv+k ZfkSv gSfvk Sflv S>lf lYfZp lYyf ,",
+"kX 9eR& RB9e 9aRe R1,X :Re ,R1XB Ra:e 9X,M kX&,M 9TRe akX,T lX, :Rle ,TlX s",
+"Xl, 9XR* -kX kX*,B ak-X kX*,1 -R:X k*B,1X :-RaX XM9* 9X-M kX*,T Tk-X ,Xl* l",
+"-X lX*,T lXs- R9,G kX&,G 9HRe akX,G R1,G ,R:G ,R1HX RH:e ,RG9M ,GkXM& ,RG9T",
+" ,GTakX ,RlG :RGle ,HlX sX,lG fR9 -Rf9 R9fH fRg9 ,Rf1 :fR fR91H gR:f R9fM f",
+"-R9M R9fT f-R9T fRl, lX:f lfR,H g-lX ,2kX kX&,2 ,kX2B akX,2 95Re R5:e ,5kXB",
+" :Re5a ,kXM2 kX2Me& ,TkX2 ak2,TX ,5lX :Rel5 lX,5T sX,l5 9eR; kX-; kX;,B -kX",
+"a; kX;,1 :R>e kXB,1; :>Rae kX;,M -kXM; kX;,T -TkX; ,Xl; >Xl- lX;,T l-Xs> ,R",
+"G92 ke2RG& ,HkX2 ak2,RG ,R1G5 :RG,5 ,H5kX :RH5e kX2,GM XMk&,G2 kX2,GT aX9M,",
+"G2 lG,R5 :R5lG, lHX,5 sX5lG, R9f; f-R9; fR9H; fR9g; R9f5 :Rf> fR9H5 :fRg> f",
+"R9M; f9;-XM fR9T; fR;-Tk lfR,5 lf:>X fR95T gl->X 9PRe ePk& keP,B akX,P keP,",
+"1 Re:P kXB,1P :ReaP S9e 9eS& 9TSe 9aSe S9le S:e S9elT seS: kX*,P kX-P kXB9P",
+"* -kXaP ,1XkP* :-ReP X*9PR1B :Xa-kP 9XS* -kSe S9eT* S-9TX S9el* lXS- S9TlX*",
+" l-SsX Yk, ,kY& ,HYk ,aYk ,RY1 :RY, Y1,RH Y:R,H Y9Se SY9e& Z9Se SZ9ae lY, l",
+"eY: YZl, l,sY fRY9 Y-k Yf9RH gkY- Yf9R1 Yk:f Y9HfR1 Y:gfR Sf9 S9Y- S9Zf g9S",
+"f l,Sf lY- lYfZ9 sYl- 9eRm kXme& kXm,B akX,m kXm,1 Re:m kXB,1m :Ream 9eSm S",
+"9em& S9eTm S9aem p9Se Se:p Sp9Te S:esp kXm,; kX-m kXB,;P -kXam ,R1Xm* :-RXm",
+" Xm9*R1B :Ra>eP 9eS; S-9Xm S9eT; S9ae; Sp9X* >eS: S9Tle; -pXls ,kYm Yk&,m Y",
+"k,Hm Yak,m ,5Yk Y:R,5 Y5k,H Y5a,k SY9,m SemYk& SZ9em S9mYa, l,Yp lY:pe lY,Z",
+"p lYsp, vRf9 Yk-v Yvk,H Y-kgv Yf9R5 >kY- Y9HfR5 :vRgf fvS9 Sf-v9 Sf9Zv gSfv",
+"9 S9fp Y-lv fp9SZ lYy- [ke ke[! Dk[e ak[e [1e 1e[8 1D[e 1a[e ke[M [!kMe [kV",
+"e V[ake [le [8le V[le le[s [*k +k[* Dk[* ak[* [1* 1+[* 1D[* 1a[* k*[M [+kMe",
+" Vk[* V[+ke [l* [+le V[l* l*[s Gk[e [!Gke [kJe Jk[ae 1G[e [1G8e Je[1 J1[8e ",
+"[GkMe keM[!G JkV[e V[aJke [Gle [lG8e [Jle [slJe [fk [+fk Jk[f gk[f [f1 [1f8",
+" J1[f g1[f [kfM [f+kM fkV[ Vfg[k lf[ l+[f [lVf g[lf ke[2 [!ke2 [Dke2 [ake2 ",
+"1e[5 [158e [15De [1a5e [kMe2 keM[!2 V[ke2 [akVe2 [5le [l58e [lV5e [sl5e ke[",
+"; [+ke; [;Dke [a;ke 1e[; [1>e [1;De [>1De [;kMe ke;[+M V[;ke Vek[a; [5l* >e",
+"[l [l;Ve V>[le [Gke2 ke2[!G Jk[e2 [aeJk2 [1G5e G5k[8e J1[5e J1e[5a keM[G2 k",
+"e[!GM2 V[eJk2 akVe[J2 [lG5e [5Gle8 lJ[5e lJ5[se [;fk [f+k; [fJk; g[fk; [1f5",
+" >k[f [f1J5 J>k[f [fkM; [+kfM; Vf[k; g[kVf; l;[f [>lf Vf5[l J>l[f ke[P keP[",
+"! keDP [akeP 1e[P [18eP [1DeP [1aeP [kSe S[ke! SkVe SVeak S[le S[8le SVle [",
+"slSe kP[* [+keP [*DkP [a*kP 1P[* [1+eP [1*DP [1aP* Sk[* S[+ke SVek* SV+ke S",
+"[l* [l+Se [l*SV [s*Sl [kYe Yk[e! YeJk YJkae Ye[1 Y1[8e YJ1[e YJ8ke S[Yke Yk",
+"[Se! ]ke ak]e [Yle lY[8e ]le ls]e Yk[f Yfk[+ JfYk gYk[f Y1[f [f1Y+ [f1YJ g[",
+"1Yf fkS[ Sf[+k ]fk gf]k [lSf lYf[+ ]lf gl]f ke[m [mke! [mDke [amke 1e[m [1m",
+"8e [1mDe [1aem S[kem [mkSe! SVekm SakVem le[p [pl8e [plVe [psle km[* [+mke ",
+"[m*Dk [amk* 1m[* [>1em [1mD* >kDeP S[;ke S+k[m* SVek; S+kVem l*[p [p*l> [p*",
+"Vl V>eSl Yk[em [meYk! YJkem YaeJkm Y1[5e Y1e[8m YJ5ke Y1e[5a Yk[Sem ke[mSY!",
+" ke]m ]akem [plYe lY8[pe le]p ]lpse fk[v [vf+k [vJfk g[vfk f1[v [v1f> [v1Jf",
+" J>kYf [vfSk Sf+[vk fv]k ]gfvk [plf fp[l> lf]p yl]f ht[ [&ht hD[t ht[c h1[ ",
+"[:h hD[1 [ch: [thM ht[M& V[ht Vh[tc lh[ lh[: [lVh u[h t*[ [-t tD[* [ct- [1t",
+"* [:- t*[1D :c[- tM[* [t-M V[t* V[t- t*[l l-[ lhV[* u[- [htG tG[h& [Jht tJ[",
+"hc hG[1 [h:G [Jh1 hJ[: tG[hM [h&tGM tJV[h Vh[tJc [hlG [:lhG hJ[l hJu[ tf[ [",
+"-tf [ftJ i[t h1[f :f[ [f1tJ i[: [tfM [-tfM V[tf V[it [ltf [:lf lJh[f ui[ h2",
+"[t ht[&2 ht[D2 [cht2 [ht5 h5[: t5[hD [:hc5 ht[M2 hM&[t2 Vh[t2 [ctVh2 h5[l [",
+":lh5 lhV[5 h5u[ [ht; t;[- t;[hD [-tc; [1h; [:h> t5[D* [:-c> t;[hM [-tM; Vh;",
+"[t V-[t; h;[l [>l- lh;V[ h>u[ tG[h2 [h&tG2 tJ[h2 [chtJ2 tG5[h [:hG5 tJ5[h :",
+"J[h5 [h2tGM hG[&tM2 Vh[tJ2 h2tJ[cV lh[G5 lhG[:5 lJh[5 uh5[J t;[f [-tf; tJ;[",
+"f t;i[ t5[f [>tf tf5[J t>i[ tf[M; tfM[-; tfV[; iV[t; lh;[f l-[f> Vf5[t i[u>",
+" htP h&tP hDtP tchP tPh1 hP[: htP1D [:hcP Sht S&ht VhSt htSc Shl Sh: SlVh u",
+"hS t*hP hPt- tP*hD [-tcP tP*h1 :P[- tPD[1* [:-cP S*ht St[- St*Vh V-[St l*Sh",
+" Shl- ShlV* Shu- tYh Y&ht tJhY htYc h1tY hY[: hY1tJ tY:hJ tYSh ShtY& ]ht ht",
+"]c lYh Y:Sh ]lh ]uh tYf tY- YJtf itY Y1tf Y:tf tYfJ1 tYi: Sft tYS- ]tf ]it ",
+"Shlf tYl- lf]h ui] tmhP tm[h& tm[hD [cmht t5hP hm[: t5PhD [:mhc hmSt Shtm& ",
+"VhmSt Shctm tpSh S:hp hplSV hpu[ t;hP tm[- tm[D* [-mtc t5[m* ht>P t5Dh;P [:",
+"-cm h;St [-mSt Sh;Vt V-[tm l;Sh S:h> [p*Vt h>uS hmtY tYhm& tJmhY tYchm h5tY",
+" [:mhY tY5hJ [:mhJ ShtYm tYmSh& ht]m ]htcm hplY [p:hY hp]l ]puh tYhv Y-tv h",
+"v[tJ tYiv h1[v tYh> [v1hJ tYi> tvSh [-vSt hv]t ]tiv hvlY h>lY lv]h ]yui n n",
+"! nB an n. 8n n.B 8na nK n!K Tn Tna nj 8nj Tnj sn n( +n n(B +na n(. +n8 .Bn",
+"( +8an n(K +nK Tn( +Tn nj( +nj T(nj sn+ nE n!E Hn Hna nE. 8nE Hn. H8n nEK E",
+"Kn! HnT HTan njE 8Enj Hnj snH dn +nd Hnd gn dn. 8dn H.dn gn8 dnK +Kdn Tdn g",
+"nT dnj dn+j dnHj gsn 4n 4n! 4nB 4an 5n 48n 5nB 5an 4nK n!4K 4Tn Tn4a 4jn 8n",
+"4j 5Tn s4n ;n 4+n ;nB a;n 5n; >n 5B;n >na ;nK 4K+n T;n +n4T ;nj >nj T;5n >n",
+"s 4nE n!4E 4Hn Hn4a 5nE 4E8n H5n Hn48 nE4K 4nE!K Hn4T 4HTan 4Enj njE48 Hn4j",
+" 4Hsn 4dn +n4d H;n g4n 5dn >nd 5dHn >ng 4Kdn dnK4+ T;Hn 4Tgn dn4j dn>j Td5n",
+" gs>n Pn n!P PnB aPn Pn. 8Pn n.PB aP8n Qn Qn! QnT Qan Qnj Q8n PjTn sPn Pn( ",
+"+Pn n(PB aP+n n(P. 8P+n Pn(.B aPn+8 Qn( +Qn Q(Tn Qa+n Q(nj Q8+n Pj(Tn +Qsn ",
+"Wn Wn! HPn Wan Wn. W8n H.Wn W8Hn WnQ Q!Wn Zn Zna Wnj Q8Wn Znj sZn Wnd +Wn d",
+"PHn gPn W.dn W8+n dP.Hn W8gn Qdn Wn+Q Znd gZn dnWj Wn+j dnZj gnsZ o o! oB o",
+"a o5 o8 o5B o8a oQ o!Q oT oTa op op8 opT os o; o+ o;B o+a o5; o> 5;oB o>a o",
+"Q; o+Q oT; o+T op; o>p pTo; os> oW o!W oH oHa o5W o8W oH5 oH8 oWQ Q!oW oZ o",
+"Za opW pWo8 oZp osZ ov ov+ ovH go ov5 o>v vHo5 go> ovQ v+oQ oZv goZ opv pvo",
+"> opZv yo n# &n n#B an& n#. 8n& .Bn# 8a&n n#K &nK Tn# T&n nj# &nj T#nj sn& ",
+"n#( +n& #Bn( +a&n #(n. +8&n n#(.B an&+8 #(nK +K&n n#T( T&+n j#n( &n+j nj#T(",
+" +ns& n#E &nE Hn# H&n #En. 8E&n n#H. 8nH& EKn# nK&E H#Tn T&Hn j#nE &Enj H#n",
+"j H&sn dn# d&n H#dn gn& n#d. d&8n dn#H. 8ng& n#dK dK&n T#dn T&gn d#nj &ndj ",
+"dnjH# g&sn 4n# 4&n n#4B an4& 5n# 5&n n#5B an5& n#4K 4K&n 4#Tn Tn4& 4#nj &n4",
+"j 5#Tn 4&sn ;n# ;&n nB;# ;&an 5#;n >n& ;n#5B an>& n#;K ;K&n T#;n ;&Tn ;#nj ",
+"&n>j ;njT# >&sn n#4E 4E&n 4#Hn Hn4& n#5E 5E&n H#5n 5&Hn 4n#EK &nE4K 4HTn# 4",
+"H&Tn nj#4E &nj4E 4Hjn# snH4& 4#dn dn4& H#;n 4&gn 5#dn d&>n H5nd# >&gn dn#4K",
+" d&n4K 4Tdn# g4T&n dnj4# >nd&j ;njH# >ngs& Pn# P&n n#PB P&an n#P. P&8n Pn#.",
+"B aP&8n Qn# Q&n Q#Tn T&Qn Q#nj 8nQ& Pj#Tn Q&sn n#P( P&+n Pn#(B aP&+n Pn#(. ",
+"P&n+8 n#(P.B +P8an& n#Q( Q&+n QnT#( +QnT& Pj#n( P&j+n TP#nj( sP+&n Wn# W&n ",
+"H#Wn W&Hn n#W. 8nW& HPn#. H8P&n W#Qn Q&Wn Zn# Z&n W#nj &nWj njZ# Z&sn W#dn ",
+"W&+n dP#Hn W&gn dP#n. dP&8n HP#dn. gP8&n Q#dn d&Qn dnZ# Z&gn dPjn# dP&nj Zn",
+"dj# Z&ngs o# o& o#B oa& o5# o8& 5Bo# 5ao& oQ# o&Q oT# oT& op# op& pTo# os& ",
+"o;# o+& ;#oB a;o& 5;o# o>& o5;#B >&oa Q;o# +Qo& T;o# +To& p;o# p>o& opT;# o",
+"&s> oW# o&W oH# oH& 5Wo# 5Wo& H5o# H5o& WQo# W&oQ oZ# oZ& pWo# oWp& Z#op Z&",
+"os ov# ov& vHo# go& v5o# v>o& ovH5# o&g> vQo# oQv& Z#ov Z&go o#pv pvo& oZpv",
+"# yo& nC n!C Dn Dna nC. 8nC Dn. D8n nCK CKn! DnT DTan njC 8Cnj Dnj snD nC( ",
+"+nC Dn( +Dn C(n. +C8n n(D. D8+n CKn( nC+K D(Tn Dn+T jCn( +Cnj D(nj +Dsn nCE",
+" !CnE HnD HDan CEn. nC8E H.Dn D8Hn EKnC n!CEK HDTn HnDTa jCnE njC8E DnHj Hn",
+"sD dnC +Cdn Ddn gnD nCd. 8Cdn D.dn D8gn nCdK dnC+K TdDn DngT dCnj dnj+C dnD",
+"j gDsn 4nC n!4C 4Dn Dn4a 5nC 4C8n 5Dn D85n nC4K 4nC!K Dn4T 4DTan 4Cnj njC48",
+" Dn4j 4Dsn ;nC 4C+n D;n +n4D 5C;n >nC D;5n >nD nC;K ;nC+K T;Dn a;nDT ;Cnj n",
+"j>C ;nDj >Dsn nC4E 4nC!E Hn4D 4HDan nC5E 48nCE 5DHn 4H8Dn 4nCEK n!C4EK 4HDT",
+"n HnD4Ta njC4E 48CnjE 4HjDn snH4D 4Cdn dnC4+ D;Hn 4Dgn 5Cdn dn>C Dd5n >Dgn ",
+"dnC4K 4+CdnK 4DdTn g4DTn dnj4C >ndjC dnj4D >ngsD PnC PCn! DPn aPDn nCP. Pn8",
+"C PnD. 8PDn QnC n!QC QDn DnQa QCnj QC8n DjQn QDsn nCP( Pn+C PnD( DP+n PnC(.",
+" +P8nC DPn(. +DP8n nCQ( +CQn Q(Dn QD+n PjCn( +Qn8C QDnj( sP+Dn WnC n!WC WDn",
+" DnWa nCW. WC8n W.Dn D8Wn WCQn WnQ!C ZnD DnZa WCnj W8nQC DnZj sDZn WCdn +CW",
+"n DdWn WDgn dPCn. +Wn8C WDnd. gPD8n QCdn +WnQC DdZn gDZn dPjnC +WnjC ZnDdj ",
+"gZnsD oC o!C oD oDa o5C o8C oD5 oD8 oQC Q!oC oDQ QDoa opC p8oC opD osD o;C ",
+"o+C oD; o+D 5;oC o>C 5Do; o>D Q;oC +QoC QDo; +QoD p;oC >Cop o;pD oDs> oWC W",
+"!oC oHD WDoa 5WoC W8oC H5oD H8oD WQoC o!WQC oZD ZDoa pWoC opW8C oDZp oDsZ o",
+"vC v+oC ovD goD v5oC >Cov o5vD oDg> vQoC ov+QC oDZv oDgZ oCpv o>pvC pvoD yo",
+"D bn bn& bnD cn bn. b8n b.Dn cn8 bnK bK&n bTn cnT bnj 8nbj Dnbj scn bn( b+n",
+" b(Dn cn+ n(b. +nb8 bnD(. +nc8 n(bK bK+n b(Tn +Tcn b(nj +nbj bTnj( s+cn bnE",
+" bE&n bHn cnH nEb. bE8n b.Hn H8cn nEbK &nEbK HnbT HncT bEnj &njbE Hnbj sHcn",
+" bdn +nbd Hnbd gcn b.dn 8dbn bHnd. g8cn bKdn d&nbK Tdbn gTcn dnbj d&nbj dnj",
+"bH gnsc 4bn bn4& bn4D c4n b5n bn48 5Dbn c5n 4Kbn &nK4b bn4T 4Tcn bn4j &nj4b",
+" 5Tbn c4sn b;n bn4+ D;bn c;n 5nb; >nb b5nD; c>n bK;n ;&nbK T;bn T;cn ;nbj b",
+"n>j ;njbT sc>n 4Ebn &nE4b bn4H 4Hcn bE5n 4b8nE H5bn H5cn 4bnEK 4bE&nK 4bHTn",
+" c4HTn 4bjnE &nE4bj 4bHnj c5nsH bn4d d&n4b H;bn c4gn 5dbn bd>n bH5dn gc>n 4",
+"bdnK d&Kb;n 4bTdn c;ngT dnj4b >nbdj ;njbH c>ngs bPn P&bn DPbn cPn Pnb. 8Pbn",
+" bPDn. 8Pcn bQn Q&bn QDbn cQn Qnbj Q8bn bQnDj cQsn Pnb( +Pbn bPDn( +Pcn bPn",
+"(. b+P8n DP(bn. cP+8n b(Qn +Qbn bQnD( +Qcn bQnj( b+Q8n Pj(bTn cQns+ bWn W&b",
+"n HPbn cWn b.Wn W8bn bHPn. W8cn WnbQ bWnQ& Zbn Zcn Wnbj &njbW bnZj snZc Wnb",
+"d +Wbn bHPdn cWgn bWnd. b+W8n dP.bHn cWng8 Qdbn d&nbQ bdZn gnZc dPjbn b+Wnj",
+" Zbndj Zcngs ob ob& obD oc ob5 ob8 b5oD oc5 obQ bQo& obT ocQ opb pbo8 pboD ",
+"osc ob; ob+ b;oD oc+ b5o; o>b ob5D; oc> bQo; b+oQ bTo; o+cQ o;pb p>ob opbD;",
+" c>os obW bWo& obH ocH b5oW bWo8 bHo5 oHc5 bWoQ obWQ& oZb ocZ oWpb opbW8 op",
+"Zb Zcos ovb vbo+ vboH goc o5vb v>ob ovbH5 c>go oQvb ovb+Q ovZb Zcgo pvob o>",
+"bpv oZbpv yoc 6n 6!n 6nB 6an 1n 68n 1nB 1an 6nK n!6K 6Tn Tn6a 6jn 8n6j 1Tn ",
+"s6n 6n( 6+n n(6B +n6a 1n( 1+n n(1B +n1a n(6K 6K+n 6(Tn +n6T 6(nj +n6j 1(Tn ",
+"6+sn 6nE n!6E 6Hn Hn6a 1nE 6E8n 1Hn H81n nE6K 6!nEK Hn6T 6HTan 6Enj njE68 H",
+"n6j 6Hsn 6dn +n6d Hn6d g6n 1dn +n1d Hn1d g1n 6Kdn dnK6+ Tn6d 6Tgn dn6j dnj6",
+"+ Td1n s6gn 46n 4n6! 6n4B 46an 7n 78n 7Bn 7an 6n4K 6!4nK 46Tn 4T6an 7nj 8n7",
+"j 7Tn 7sn 6;n +n6; 6B;n an6; 7;n >n7 ;n7B 7a>n 6K;n ;nK6+ Tn6; a;n6T ;n7j 7",
+"n>j T;7n >n7s 6n4E 6!4nE 46Hn 4H6an 7nE 8n7E 7Hn H87n 46nEK 4nE6!K 4H6Tn 6H",
+"T4an nj7E 78njE Hn7T 7Hsn dn6; 4+6dn Hn6; 6;gn 7dn 7d>n H;7n g7n dnK6; 4+6d",
+"nK 4Td6n g46Tn dn7j 7>dnj Td7n gn7s 6P 6P! 6PB 6aP 6P1 68P 6B1P 1a6P 6QP Q!",
+"6P 6TP Qa6P 6Pj Q86P 1T6P s6P 6P( 6+P P(6B +P6a 6(1P 1+6P 6P1(B 6+P1a 6(Qn ",
+"+Q6P 6(TP +T6P 6(Pj +Q1n 6TP1( 6+sP 6WP 6!Wn 6HP HP6a 1Wn W86P 1H6P H86P Wn",
+"6Q 6WQn! Z6P 6aZn Wn6j 6W8Qn Z1n Z6sP 6dP +W6P HP6d g6P 1d6P +W1n 6HP1d 68g",
+"P Qd6P 6+WQn 6dZn Z6gP Qd1n dPj6+ 1dZn s6gP o6 o!6 o6B oa6 7o 7o8 7oB 7oa o",
+"6Q 6Qo! oT6 6Qoa 7op o87p 7oT os7 o6; o+6 6;oB 6+oa 7o; o>7 o;7B 7ao> 6Qo; ",
+"6+oQ 6To; 6+oT 7;op 7po> 7;oT o>7s o6W 6Wo! oH6 6Hoa 7oW o87W 7oH oH7a 6WoQ",
+" o!6WQ oZ6 oaZ6 op7W 7opW8 7Zo os7Z ov6 v6o+ v6oH go6 7vo o>7v ov7H go7 oQv",
+"6 ov6+Q ovZ6 g6oZ op7v 7p>ov oZ7v yo7 9n 6&n 9nB 9an 9n1 :n 1B9n :na 9nK 6K",
+"&n 9Tn T&9n 9nj :nj 1T9n s:n 9n( 9+n n(9B +n9a 9(1n :n+ 9n1(B +n:a n(9K 9K+",
+"n 9(Tn +T9n 9(nj +n:j 9Tn1( s+:n 9nE 6E&n 9Hn H&9n 9E1n :nE 1H9n :Hn nE9K &",
+"nE6K Hn9T 6H&Tn 9Enj nj:E Hn9j :Hsn 9dn +n9d Hn9d g9n 1d9n :dn 9Hn1d g:n 9K",
+"dn d&n6K Td9n 9Tgn dn9j dn:j dnj9H gns: 49n 9n4& 4B9n 9n4a 79n 7:n 9n7B :n7",
+"a 4K9n &nK49 9n4T 49Tan 9n7j 7j:n 9T7n 7:sn 9;n 9n4+ 9B;n a;9n 9;7n >n: 7B9",
+";n :a>n 9K;n ;&n6K T;9n a;n9T ;n9j >j:n 7T9;n s:>n 4E9n &nE49 9n4H 49Han 9n",
+"7E 7E:n 9H7n :n7H 49nEK 49E&nK 49HTn 9Hn4T& 79njE 7:njE 7H9Tn 7:Hsn 9n4d d&",
+"n49 H;9n 49gn 9d7n :d>n 7H9dn >ng: 49dnK d&K9;n 49Tdn g49Tn 7d9nj 7:dnj 7Td",
+"9n g:n7s 6P9 6P& 6B9P 9a6P 1P9n :P6 6P19B 6a:P 9Qn Q&6P 9T6P Qa9n 9P6j :Qn ",
+"6TP9j :Qsn 6(9P 9+6P 6P9(B 6+P9a 6P19( 6+:P 1P(9nB :P6+a 9(Qn +Q9n 6TP9( 6+",
+"T9P 6Pj9( +Q:n Pj(9Tn :Qns+ 9Wn W&6P 9H6P HP6& 1W9n :Wn 6HP91 6H:P Wn9Q 6W&",
+"Qn Z9n 6PZ& Wn9j Wn:Q 9nZ1 Z:n 9d6P +W9n 6HP9d 6Pg9 6dP91 6d:P 1HP9dn :Wgn ",
+"Qd9n dP&6Q 9dZn Z9gn dPj9n Qd:n Z9n1d gnZ: o9 o9& o9B o9a 7o9 o: 7Bo9 o:a o",
+"9Q 6Qo& o9T 6To& op9 o:p o97T os: o9; o9+ 9;oB 9+oa 7;o9 o:> 7o9;B oa:> 9Qo",
+"; 9+oQ 9To; 9+oT o;p9 o>:p 7oT9; s:o> o9W 6Wo& o9H 6Ho& o97W o:W o97H o:H 9",
+"WoQ o9WQ& oZ9 o9Z& oWp9 op:W Z97o Z:o ov9 v6o& v9oH go9 o97v :vo 7oHv9 go: ",
+"oQv9 ov9+Q ovZ9 g9oZ pvo9 op:v oZ97v yo: 6nC n!6C 6Dn Dn6a 1nC 6C8n 1Dn D81",
+"n nC6K 6!nCK Dn6T 6DTan 6Cnj njC68 Dn6j 6Dsn nC6( 6C+n 6(Dn +n6D nC1( 1C+n ",
+"1(Dn +D1n 6nC(K 6+nCK 6DTn( 6+DTn njC6( 6+jnC 6Djn( sn+6D nC6E 6!nCE Hn6D 6",
+"HDan nC1E 68nCE Hn1D 6H8Dn 6nCEK n!C6EK 6HDTn HnD6Ta njC6E 68CnjE 6HjDn snH",
+"6D 6Cdn dnC6+ Dn6d 6Dgn 1Cdn 68dnC Dd1n 1Dgn dnC6K 6+CdnK 6DdTn g6DTn dnj6C",
+" dnC6+j dnj6D gs6Dn 6n4C 6!4nC 46Dn 4D6an 7nC 8n7C 7Dn D87n 46nCK 4nC6!K 4D",
+"T6n 6DT4an nj7C 78njC Dn7T 7Dsn 6C;n ;nC6+ Dn6; a;n6D ;n7C 7n>C D;7n 7D>n ;",
+"nC6K 6+C;nK 6D;Tn +Dn6T; ;nj7C 7>jnC 7DT;n 7s>Dn 46nCE 4nC6!E 4H6Dn 6HD4an ",
+"nC7E 78nCE Hn7D 7HD8n 6nC4EK 4n6!EKC 6HD4Tn 46anHDT 7njCE njC78E 7HDTn 7sHD",
+"n dnC6; 4+6dnC 4Dd6n g46Dn dn7C 7>dnC Dd7n 7Dgn 6dC;nK dn6;+CK Ddn6T; 6D;gn",
+"T 7dnjC >nj7dC 7DdTn g7sDn 6PC PC6! 6DP DP6a 6C1P 6C8P 1D6P D86P 6CQn 6QP!C",
+" QD6P 6QDaP 6CPj 6Q8PC QD1n 6DsP PC6( 6C+P 6(DP +D6P 6P1C( 6+P1C 6DP1( 6+D1",
+"P 6QPC( 6+QPC 6QDP( 6+QDP 6PjC( 6+PjC 6DPj( s6P+D 6CWn 6WP!C HP6D 6HPDa 1CW",
+"n 6W8PC WD1n 6H8DP 6WQPC WnC6Q! 6DZn Z6DaP 6WjPC PjC6W8 1DZn Z1nsD 6CdP 6+W",
+"PC Dd6P 6DgP 6dP1C 68dPC 6Dd1P g6P1D 6QdPC dPC6+Q Z6DdP gZ6DP dPj6C dPC6+j ",
+"Z1nDd Z1ngD o6C 6!oC oD6 6Doa 7oC 7Co8 7oD oD7a 6QoC o!6QC 6QoD oD6Qa 7Cop ",
+"7op8C op7D 7Dos 6;oC 6+oC 6Do; 6+oD o;7C >C7o 7;oD 7Do> o6Q;C o+6QC oD6Q; o",
+"+D6Q 7op;C 7p>oC 7oDp; os7>D 6WoC o!6WC 6HoD oH6Da oW7C 7oW8C oH7D 7oHD8 o6",
+"WQC 6WQo!C oDZ6 oZ6Da 7opWC op87WC 7DoZ osZ7D oCv6 ov6+C v6oD oDg6 7Cov 7vo",
+">C ov7D 7Dgo ov6QC v6Qo+C Zv6oD goZ6D 7vopC o>p7vC 7vDoZ 7oyD b6n 6&bn 9Dn ",
+"c6n b1n :nb 1Dbn :cn bK9n &nKb6 6Tbn 6Tcn 6jbn bn:j 1Tbn :csn b(9n 6+bn 9(D",
+"n 6+cn b(1n b+:n b1nD( :+cn b6n(K b6+nK b6Tn( c6+Tn b6jn( :nb+j b1Tn( :cns+",
+" bE9n &nEb6 6Hbn 6Hcn bE1n bn:E 1Hbn cn:H b6nEK b6E&nK b6HTn c6HTn b6jnE :n",
+"bjE b6Hnj :cnsH 6dbn d&nb6 Dd9n c6gn 1dbn bd:n b1Hdn :cgn b6dnK dnKb6+ b6Td",
+"n gc6Tn dnjb6 :dnbj dnj9D g:nsc bn49 4b6&n 9n4D 49cn 7bn :n7b bn7D 7cn 4b6n",
+"K 4b6&nK 4bT9n c46Tn bn7j 7:bnj bT7n sn7c 6;bn ;&nb6 D;9n 6;cn b;7n 7b>n 7b",
+"D;n >n7c b6;nK ;nKb6+ b6T;n c6;Tn 7b;nj 7>bnj 7bT;n c>n7s 4b6nE 4b6&nE 4bH9",
+"n c46Hn bn7E 7:bnE bH7n cn7H bnE49K 4Eb6&nK bHn49T 49HcnT 7bnjE :nj7bE 7bHT",
+"n 7csHn 4bd9n b6d;&n 49Ddn c6;gn bd7n 7:dbn 7bHdn gn7c dnKb6; dn4&b6K bTn49",
+"d c4Tg9n 7bdnj 7bj:dn 7bTdn g7csn b6P 6&bP 6DbP c6P 6Pb1 b6:P b6P1D c6:P 6Q",
+"bP b6QP& 6TbP 6QcP 6Pbj bQ:n b6T1P c6sP b(6P 6+bP b6PD( 6+cP b6P1( :Pb6+ b6",
+"(1DP :cP6+ b6QP( b6+Qn b6TP( c6Q+P b6Pj( :Qnb+ Pj(b6T :cQ+n 6WbP b6WP& 6HbP",
+" 6HcP 1Wbn bW:n b6H1P cW:n b6WQn 6W&bQn b6Zn c6Zn b6WPj :WnbQ b1Zn :cZn 6db",
+"P dP&b6 b6HdP c6gP b6d1P :Wnb+ 6HPb1d g:Pc6 b6QdP b6QdP& Zb6dP Zc6gP dPjb6 ",
+":Qdbn Zb1dn Z:ngc ob6 b6o& o9D oc6 7ob o:b ob7D 7co b6oQ ob6Q& b6oT o9cQ op",
+"7b ob:p ob7T os7c b6o; b6o+ 9Do; o9c; 7;ob 7bo> 7obD; c>o: ob6Q; ob+6Q obT6",
+"; oc6+Q 7obp; o:p>b 7obT; os:c> b6oW ob6W& b6oH o9cW ob7W ob:W ob7H 7Hoc ob",
+"6WQ b6Wo&Q obZ6 Z6oc 7obpW o:pbW 7boZ oc7Z vbo9 ovb6+ v9oD g6oc ov7b ob:v 7",
+"vboH 7cgo ovb6Q obQv6& oZbv6 cv6oZ 7vbop :vopb 7Zbov 7cyo Rn Rn! RnB Ran Rn",
+". R8n n.RB 8nRa Mn Mn! RTn aMn Rjn 8Mn TnRj sRn Rn( R+n n(RB +nRa n(R. +nR8",
+" Rn(.B R+8an Mn( +Mn R(Tn +nRT R(nj +nRj Mn(Tj R+sn RnE n!RE RHn HnRa nER. ",
+"RE8n R.Hn HnR8 MnE MEn! HMn aMHn REnj 8EMn HnRj RHsn Rdn +nRd HnRd gRn R.dn",
+" 8nRd dn.RH R8gn dMn dM+n TnRd gMn dnRj dM8n dMnHj sRgn R4 R4! R4B R4a R45 ",
+"R48 RB5n 48Ra R4M 4!Mn R4T 4TRa R4j 48Rj 4TR5 sR4 R4; R4+ RB;n 4+Ra 5nR; >n",
+"R ;nBR5 R4>a M;n 4MR+ 4TR; 4+RT 4jR; >Mn M;n5T sR>n R4E 4!RE R4H 4HRa RE5n ",
+"RE48 4HR5 4HR8 RE4M MnE4! 4HRT aMn4H RE4j R48ME 4HRj R4sH R4d 4+Rd 4HRd gR4",
+" 4dR5 R4>d R4H5d gR>n 4MRd dMn4+ 4TRd R4gM 4dRj dM>n dMnH5 gM>n RPn n!RP Pn",
+"RB RPan PnR. RP8n RPn.B aPnR8 Sn S!n STn San Snj S8n TnSj Ssn PnR( RP+n RPn",
+"(B aPnR+ RPn(. R+8Pn Pn(R.B R+8aPn Sn( S+n TnS( +TSn njS( +nS8 STnj( S+sn R",
+"Wn R!Wn HnRW WnRa R.Wn WnR8 RHWn. RH8Wn SWn WnS! SZn ZnSa WnSj W8Sn SjZn sn",
+"SZ WnRd +nRW RHWdn RWgn dP.Rn R+W8n RHWdn. gRW8n Sdn +WSn ZnSd gSn dnSj 8dS",
+"n SZdnj gnSs oR o!R oRB oaR oR5 o8R R5oB R5oa So So! SoT Soa Sop So8 oTSp o",
+"sS oR; o+R R;oB R+oa R5o; o>R oR5;B >Roa So; So+ oTS; o+Sa opS; S>o SpTo; o",
+"sS> oRW RWo! oHR RHoa R5oW RWo8 RHo5 RHo8 SoW o!SW oZS SaoZ SWop SWo8 SpoZ ",
+"oZSs ovR vRo+ vRoH goR o5vR vRo> ovRH5 gRo> Svo ovS+ oZSv goS opSv o>Sv SZp",
+"ov yoS Rn# R&n n#RB anR& n#R. 8nR& Rn#.B an&R8 Mn# M&n R#Tn TnR& R#nj M&8n ",
+"Mn#Tj R&sn n#R( +nR& Rn#(B an&R+ Rn#(. R+8&n n#(R.B R+8an& n#M( M&+n Mn#T( ",
+"aMn+& Mn#j( M&n+j RT#nj( sn+R& n#RE RE&n R#Hn HnR& Rn#E. &nER8 RHn#. RH8&n ",
+"n#ME ME&n H#Mn M&Hn Mn#jE M&n8E RHjn# snHR& R#dn dnR& dn#RH R&gn dn#R. d&nR",
+"8 RH#dn. gR8&n d#Mn M&dn dMnH# M&gn dMnj# dM&8n dM#Hnj gsR&n R4# R4& 4#RB 4",
+"aR& R#5n 48R& R45#B R48a& R#4M 4MR& R#4T 4TR& R#4j 4&Rj R4T5# R4s& R#;n 4+R",
+"& ;n#RB a;nR& ;n#R5 R4>& R5#;nB >nRa& M#;n ;&Mn M;nT# aM;&n M;n5# M&>n M;#5",
+"Tn >Mns& 4#RE RE4& R#4H 4HR& R45#E R48&E R4H5# R4H5& Mn#4E M&n4E R4HT# M&n4",
+"H R4j#E M&n5E R4Hj# sR4H& R#4d 4dR& R4Hd# R4g& R4d5# >nRd& dn#RH5 >ngR& dMn",
+"4# dM&R4 M;nH# gR4T& dMn5# >Mnd& dM#H5n >Mg&n PnR# RP&n RPn#B aP&Rn RPn#. P",
+"&nR8 Pn#R.B R8aP&n Sn# S&n TnS# T&Sn njS# 8nS& STnj# S&sn RPn#( P&nR+ Pn#R(",
+"B R+aP&n Pn#R(. R+8P&n .BR(Pn# aP8nR+& n#S( +nS& STn#( S+T&n Snj#( S+8&n nj",
+"#ST( Ss+&n R#Wn WnR& RHWn# RH&Wn RWn#. RW8&n Hn#RW. H8nRW& WnS# W&Sn S#Zn Z",
+"nS& SWnj# S8W&n SZnj# SZ&sn dP#Rn dP&Rn RHWdn# gRW&n RW#dn. RW8d&n dPHnR#. ",
+"RW8gn& dnS# d&Sn SZdn# S&gn Sdnj# S8d&n ZnjSd# gSs&n oR# o&R R#oB Rao& R5o#",
+" R5o& oR5#B o8Ra& So# So& S#oT oTS& S#op opS& SpTo# S&os R;o# R+o& oR;#B o+",
+"Ra& oR5;# >Ro& R5;o#B o>Ra& o;S# o+S& S;To# Sa;o& Sp;o# S&o> opTS;# os>S& R",
+"Wo# RWo& RHo# RHo& oR5W# o8RW& oHR5# oH8R& oWS# SWo& S#oZ S&oZ SpWo# Sp&oW ",
+"SZpo# osZS& o#vR vRo& ovRH# o&gR ovR5# o>vR& vR5oH# go>R& S#ov ovS& SvoZ# S",
+"&go Svop# Sv&o> oZpSv# Soy& Un Un! RDn Uan Un. U8n R.Dn D8Un UnM U!Mn Vn Vn",
+"a Unj 8MUn Vnj snV Un( U+n R(Dn +DUn n(U. +nU8 RDn(. R+D8n U(Mn +MUn Vn( V+",
+"n U(nj +nUj njV( V+sn UnE n!UE UHn HnUa nEU. UE8n U.Hn H8Un UEMn MnEU! VnH ",
+"HnVa UEnj U8nME HnVj sHVn Udn +nUd HnUd gUn U.dn 8dUn RDdn. U8gn dMUn dMnU+",
+" Vdn gVn dnUj dMnU8 dnVj sngV R4U 4!Un R4D 4URa U5n 4UR8 4DR5 4DR8 Un4M Mn!",
+"4U V4R R4Va 4URj R48Uj V5n V4sR U;n 4UR+ 4DR; 4+RD 5nU; >nU R4D5; R4>D M;Un",
+" M;nU+ V;n R4V+ ;nUj Un>M 5nV; V>n RE4U R4U!E 4URH R4HUa UE5n R48UE H5Un R4",
+"HU8 MnE4U 4UEMn! R4VH V4RHa R4jUE MnE4U8 H5Vn snV4H 4URd R4+Ud 4DRd R4gU 5d",
+"Un Ud>n R4D5d gU>n dMn4U 4U+dMn R4Vd V4gR dMnU5 >MnUd 5dVn >ngV UPn n!UP DP",
+"Un aPUn PnU. 8PUn RDPn. RD8Pn SUn UnS! SVn VnSa UnSj U8Sn SjVn snSV PnU( +P",
+"Un RDPn( R+DPn UPn(. U+P8n DP(Un. +DPU8n UnS( U+Sn S(Vn VnS+ SUnj( S+U8n SV",
+"nj( SV+sn UWn U!Wn HPUn WaUn U.Wn W8Un RWDn. RWD8n UWSn S!UWn ZnV ZaVn WnUj",
+" S8UWn ZjVn VZsn WnUd +WUn RWDdn UWgn UWnd. U+W8n dP.UHn gUP8n UdSn S+UWn V",
+"dZn SVgn SdUnj S8dUn SVdnj gVnSs oU oU! oUD oUa oU5 oU8 R5oD RDo8 SoU S!oU ",
+"oV oVa opU oUS8 oVp oVs oU; oU+ RDo; R+oD U5o; o>U oU5D; >RoD oUS; oUS+ oV;",
+" oV+ o;pU oUS> V;op oV> oUW UWo! oUH UHoa U5oW UWo8 UHo5 UHo8 SWoU oUWS! oV",
+"Z VZoa oWpU opUW8 VpoZ sZoV ovU vUo+ vRoD goU o5vU v>oU ovUH5 gUo> oUSv Svo",
+"U+ oVv goV pvoU o>USv opVv yoV Rbn U&n bnRD cRn R.bn bnR8 RbDn. R8cn bMn M&",
+"bn Vnb cnV bnRj 8Mbn bnVj cRsn R(bn bnR+ RbDn( R+cn Rbn(. Rb+8n bn(RD. cR+8",
+"n b(Mn +Mbn bnV( V+cn Rbjn( &njU+ Vnbj( snVc+ REbn UE&n bnRH RHcn RbnE. Rb8",
+"nE RbHn. cRH8n bEMn M&nbE bHVn cHVn RbjnE &njUE VnbHj snVcH bnRd d&Un RbHdn",
+" cRgn Rbdn. d&nU8 dn.RbH gcR8n dMbn dM&bn bdVn cngV dMnbj dMnb8 Vdnbj gVnsc",
+" R4b 4bR& 4bRD cR4 4bR5 4bR8 R4b5D R4c5 4MRb M&n4b R4Vb V4cR 4bRj M&nb5 b5V",
+"n cRs4 4bR; 4bR+ R4bD; R4c; R4b5; R4>b b5nRD; cR>n M;bn M;&bn b;Vn V;cn M;n",
+"b5 bM>n V5nb; cnV> RE4b R4b&E 4bRH R4cH R4b5E R4b8E R4bH5 cR4H5 R4bME M&ER4",
+"b V4RbH cR4VH R4bjE M&Eb5n V5nbH cR4sH 4bRd d&n4U R4bH; cRg4 R4b5d >nbRd 4b",
+"HR5d c>Rg4 dMn4b R4bdM& V4dRb gV4cR dMnb5 >Mbdn V5dbn V>ngc UPbn P&Un RbDPn",
+" UPcn RbPn. Rb8Pn bPnRD. cR8Pn Sbn bnS& VnSb Scn bnSj b8Sn SVbnj snSc RbPn(",
+" Rb+Pn bPnRD( cR+Pn UP(bn. U+Pb8n R(bPDn. U+Pcn8 bnS( b+Sn SVbn( cnS+ Sbnj(",
+" Sb+8n VnjSb( Scs+n bnRW W&Un RbHWn RWcn RbWn. RbW8n Rb.WDn cRW8n bWSn SbW&",
+"n ZnSb ZnSc SbWnj Sb8Wn SZbnj ZcnSs RbWdn dP&Un bWnRDd cRWgn dn.RbW b+nRW8 ",
+"R.bHWnd cW8gUn bdSn Sb+Wn SZbdn gnSc Sbdnj Sb8dn SbjVdn gScsn obR oU& RboD ",
+"ocR Rbo5 Rbo8 obR5D oUc5 Sob obS& oVb Sco opSb obS8 obVp osSc Rbo; Rbo+ obR",
+"D; oUc; obR5; >Rob Rb5oD; cRo> obS; obS+ V;ob S+oc Spbo; Sbo> oVpb; ocS> Rb",
+"oW UWo& RboH oUcW obR5W ob8RW obHR5 ocRH5 SWob oU&SW SboZ ZcoV SpboW Sb8oW ",
+"oVZpb oVsZc vRob vUo& ovbRH gRoc ovbR5 o>bvR ob5vRD cvRo> ovSb Svbo+ obVv S",
+"cgo Svbop S>bov oVvpb Scyo q q! qB qa q1 q8 q1B q8a qM q!M qT qTa lq q8l qT",
+"l sq q( q+ q(B q+a q1( q+1 1(qB 1+qa qM( q+M qT( q+T lq( l+q l(qT sq+ qE q!",
+"E qH qHa q1E q8E qH1 qH8 qME MEq! qHT HMqa lqE lEq8 lHq sqH qd q+d qHd gq q",
+"d1 q8d 1Hqd gq1 qdM +Mqd qTd gqT ldq q+ld qHld glq q4 q!4 q4B qa4 7q 7q8 7q",
+"B 7qa q4M 4Mq! qT4 4Tqa 7lq q87l 7qT sq7 q; q+4 q;B qa; 7q; q> 7Bq; q>a q;M",
+" 4+qM qT; 4+qT l;q q>l qTl; sq> q4E 4Eq! qH4 4Hqa 7qE 7Eq8 7qH qH7a 4MqE q!",
+"4ME 4HqT qH4aM lE7q 7lq8E 7qlH 7Hsq qd4 4+qd qH; gq4 7qd q>d qH7d gq7 4dqM ",
+"q+4dM 4Tqd qTg4 7qld ldq> qHl; sqg7 qP q!P qPB qaP q1P q8P 1PqB 1aqP Sq Sq!",
+" SqT Sqa Slq Sq8 qTSl sqS qP( q+P P(qB +Pqa 1Pq( 1+qP q1P(B q+1aP Sq( Sq+ S",
+"(qT q+Sa l(Sq Sql+ SlqT( S+sq qW qW! qHW qWa qW1 qW8 1HqW 1Wqa SqW S!qW Zq ",
+"Zqa lWq qWS8 Zql sqZ qWd q+W HPqd gqW 1Wqd 1+qW qH1dP qWg1 Sqd q+Sd Zqd gqZ",
+" Sqld q+lW ldZq sqgS oq oq! oqB oqa 7oq oq8 7Boq oq7a Soq S!oq oqT oqSa r r",
+"8 rT rs oq; oq+ oBq; q+oa q;7o q>o 7oq;B oaq> Sq; oqS+ qTS; q+oT r; r> r;T ",
+"rs> oqW o!qW oqH qHoa 7qW qWo8 oq7H qHo8 qWSo SqWo! Zqo oaZq rW rW8 rZ rZs ",
+"vq vq+ vqH goq vq7 vq> 7Hvq vqg7 vqS S+vq Zqv Zqgo rv rv> rZv yr q9 q& q9B ",
+"qa9 q91 :q 91qB :qa q9M q&M qT9 qT& lq9 :ql l9qT sq: q9( q+9 9(qB 9+qa 91q(",
+" :q+ q91(B :+qa 9Mq( 9+qM 9Tq( 9+qT q9l( l+:q qTl9( q+s: q9E q&E qH9 qH& 91",
+"qE :qE 9Hq1 :qH 9MqE M&qE 9HqT HMq& q9lE lE:q l9qH lH:q qd9 qd& 9Hqd gq9 9d",
+"q1 :qd qH91d gq: 9dqM dMq& 9Tqd qTg9 l9qd ld:q lHq9d g:sq q49 q&4 49qB 49qa",
+" 7q9 :q7 q97B 7a:q 49qM 4Mq& 49qT 4Tq& l97q 7l:q 79qT :q7s q;9 q;& 9;qB 9aq",
+"; 79q; q>: 7q9;B qa:> 9Mq; M;q& 9Tq; T;q& l9q; :ql> 7qT9; s:q> 49qE 4&qE 49",
+"qH 4Hq& q97E 7E:q 79qH 7H:q q49ME q&4ME qH49T qH&4T 7lq9E :ql7E 7qHl9 :qH7s",
+" 49qd 4dq& 9Hq; q;g9 79qd 7d:q 7qH9d g:q> qd49M qd&4M qH;9T gq49T 7qdl9 q>l",
+":d 7qT9d glq7: q9P q&P 9PqB 9aqP 9Pq1 :qP q91PB qa:P Sq9 Sq& qTS9 qTS& lqS9",
+" S:q Slq9T S:sq 9Pq( 9+qP q9P(B q+9aP q91P( q+:P 9P1q(B :q+aP q9S( q+S9 Sq9",
+"T( Sq+9T Slq9( S+:q qTlS9( sq:S+ qW9 qW& 9HqW 9Wqa 9Wq1 :qW qH91W qH:W qWS9",
+" qWS& Zq9 Zq& l9qW lW:q lqZ9 Zq: 9Wqd 9+qW qH9dP qWg9 qW19d q+:W 9HPqd1 gP:",
+"q qdS9 qdS& qdZ9 g9Zq Sqdl9 Sd:q Zql9d S:gq oq9 oq& q9oB qao9 o97q o:q 7oq9",
+"B oa:q So9 oqS& oTS9 o9Sa r9 r: r9T rs: q;o9 q+o9 oq9;B oq+9a 7oq9; q>o: o9",
+";7qB o:q>a o9S; o9S+ Sq;9T Sqa9; r;9 r:> 9Tr; s:r> qWo9 qWo& qHo9 qHo& 79qW",
+" 7W:q 7oHq9 oq:H SWo9 Sq&oW S9oZ oqZ& r9W r:W rZ9 rZ: vq9 vq& qHv9 g9vq v97",
+"q :vq vq79H :vgq S9vq S&vq Z9vq Sog9 rv9 r:v Zvr9 yr: qU q!U qD qDa q1U q8U",
+" qD1 qD8 qUM U!qM Vq Vqa lqU lUq8 Vql sqV qU( q+U qD( q+D 1Uq( 1Uq+ 1Dq( 1+",
+"qD UMq( U+qM Vq( Vq+ qUl( lUq+ l(Vq l+Vq qUE U!qE qHU UHqa 1UqE U8qE 1UqH U",
+"Hq8 UMqE q!UME VqH VHqa qUlE q8lUE lHVq qHVs qdU U+qd qDd gqU 1Uqd U8qd 1Dq",
+"d qDg1 UdqM q+UdM Vqd gqV lUqd l+qUd ldVq gVsq q4U 4Uq! qD4 4Uqa 7qU q87U 7",
+"qD qD7a 4UqM q!4UM Vq4 qaV4 lq7U 7lqU8 7Vq 7Vsq q;U 4Uq+ qD; 4+qD q;7U q>U ",
+"q;7D q>D U;qM q+4UM Vq; q+V4 lUq; lq>U l;Vq V>q 4UqE q!4UE 4UqH qH4Ua qU7E ",
+"7qU8E qH7U 7qHU8 q4UME 4UMq!E qHV4 Vq4Ha 7lqUE q8l7UE 7HVq sq7VH 4Uqd q+4Ud",
+" 4Dqd qDg4 qd7U >Uqd qD7d gUq> qd4UM 4U+qdM qHV; g4Vq 7qdlU q>lUd 7dVq 7Vgq",
+" qUP UPq! qDP UaqP 1UqP U8qP 1DqP D8qP SqU q!SU VqS SaVq lUSq SUq8 SlVq VqS",
+"s UPq( U+qP DPq( +DqP q1UP( q+1UP qD1P( q+D1P qUS( SUq+ S(Vq S+Vq SlqU( Sq+",
+"lU SlVq( Vq+Ss qWU UWq! qWD UWqa 1UqW UWq8 1WqD WDq8 SUqW SqUW! ZqV qaVZ lU",
+"qW Sq8UW lZVq sZVq UWqd U+qW WDqd qWgU qW1Ud q+W1U qWD1d gq1UW SUqd Sq+UW S",
+"dVq gVZq SqdlU Sq8Ud VqdlZ glqSV oqU q!oU oqD qDoa 7oU o87U oq7D oU7a oUSq ",
+"SqUo! oVq oaVq rU rU8 rV rVs q;oU q+oU q;oD q+oD 7;oU 7Uo> 7oUD; oDq> SUq; ",
+"Sq+oU S;Vq o+Vq r;U r>U rV; rV> qWoU oqUW! qHoU oqHUa oU7W 7oUW8 oU7H 7oUH8",
+" SqUoW oUWSq! oVZq oVZqa rUW UWr8 rZV sZrV vqU q+vU vqD gUvq 7Uvq vUq> 7Dvq",
+" 7ogU vUSq vqSU+ Vvq oVgq rvU v>rU rVv yrV tq tq& tqD cq tq1 :qt t1qD cq: t",
+"qM tMq& Vqt cqV ltq lt:q ltVq uq tq( tq+ t(qD cq+ q1t( t+:q tq1D( q+:c qMt(",
+" tMq+ t(Vq t+Vq l(tq tql+ Vqlt( uq+ tqE tEq& tqH cqH q1tE tE:q t1qH tH:q qM",
+"tE tqM&E tHVq qHVc lEtq :qltE tqlH uqH tqd q+td qHtd gqt t1qd td:q tqH1d g:",
+"cq tMqd tq+dM tdVq gVcq tqld :qdlt Vqdlt uqg tq4 q&t4 qDt4 cq4 7tq :q7t 7Dt",
+"q 7cq q4tM tq4M& t4Vq c4Vq 7ltq 7tl:q Vq7t uq7 tq; q+t4 qDt; cq; 7qt; t>q t",
+"q;7D cq> tMq; tq+4M t;Vq c;Vq tql; ltq> Vq;7t uq> q4tE tq4&E qHt4 qHc4 tE7q",
+" 7tq:E 7qtH 7Hcq tq4ME q&Mt4E tqHV4 cqV4H 7tlqE :ql7tE 7tHVq 7quH qdt4 tq+4",
+"d qHt; g4cq 7qtd tdq> 7tHqd t>gq tqd4M t4Mqd& Vqdt4 cq;gV 7tdlq t>qld 7Vdtq",
+" gqu7 tqP q&tP qDtP cqP q1tP tP:q tq1DP :Pcq Stq S&tq VqSt Scq Sqlt :qSt Sl",
+"Vtq uqS qPt( q+tP tqDP( q+cP tq1P( tq+:P qD1tP( cq:+P S(tq tqS+ StqV( S+cq ",
+"Stlq( St+:q VqlSt( Squ+ tqW q&tW qHtW cqW t1qW tW:q tqH1W :Wcq tWSq Sq&tW t",
+"Zq Zqc tqlW :qWSt ltZq uZq qWtd q+tW tqHdP gPcq tqW1d :qWt+ tW1qDd cqWg: Sd",
+"tq St+qW tdZq Scgq Stdlq S:dtq tZqld gquZ ot ot& otD otc ot7 ot: 7Dot ot7c ",
+"otS S&ot oVt otSc rt rt: rVt ur ot; ot+ oDt; t+oc 7ot; t>o ot7D; oct> S;ot ",
+"S+ot t;oV S;cq rt; rt> t;rV ur> otW o&tW otH tHoc 7otW tWo: 7otH tHo: tWSo ",
+"otSW& tZo octZ rtW t:rW rZt urZ tvo t+vq tHvq got 7tvq ot:v otH7v t>go Stvq",
+" ot+Sv Zqtv tZgo rtv tvr: tZrv ury <n n!< <nB a<n <n. 8<n n.<B a<8n <nK <Kn",
+"! T<n a<Tn <jn <j8n <jTn s<n n* +<n n*B an* n*. 8n* n.*B an8* n*K +Kn* Tn* ",
+"T<+n n*j <j+n njT* sn* <nE <En! H<n a<Hn nE<. <n8E <nH. 8<Hn nE<K n!<EK T<H",
+"n H<Tan <Enj <jn8E <jHn H<sn <dn <d+n Hn* g<n <.dn <d8n H.n* 8<gn dKn* <dn+",
+"K TnH* T<gn dn<j <dj+n n*Hj s<gn 4<n n!4< <n4B 4<an 5<n 8<5n <n5B a<5n <n4K",
+" 4<n!K 4<Tn 4Ta<n <j5n <jn48 T<5n 5<sn =n =+n =Bn =an =5n >n= 5n=B =a>n =nK",
+" +n=K =Tn +T=n =jn =j>n 5T=n s=n <n4E 4<n!E 4<Hn 4Ha<n <n5E 48<nE 5<Hn 4H8<",
+"n 4<nEK n!<4EK 4HT<n H<T4an <jn4E 48<njE 4Hj<n s<H5n =dn +n=d =Hn g=n 5d=n ",
+"=d>n H5=n >ng= dn=K =+dnK Hn=T gn=T dn=j >n=dj Hn=j gns= <P <P! <PB a<P <P.",
+" 8<P P.<B a<8P Q<P Q!<P T<P a<Qn <Pj 8<Qn <jTP s<P <P* +<P *B<P a<+P <.P* 8",
+"<+P <P*.B aP*8< Qn* Q<+P TnQ* T<+P P*<j 8nQ* <PjT* +<sP W<P W!<P H<P a<HP W",
+".<P 8<Wn H.<P 8<HP Q<Wn <P!WQ Z<P a<Zn <PWj <PjW8 <PZj Z<sP Wn* W<+P WnH* g",
+"<P W.n* 8nW* H<Pd. 8<gP QnW* +W<Qn Zn* Z<gP dP<j <dj+P n*Zj s<gP o< o!< o<B",
+" oa< o5< o8< 5<oB 5ao< oQ< Q<o! oT< Qao< op< p<o8 p<oT os< o= o=+ o=B =ao o",
+"=5 o>= o5=B =ao> =Qo o+=Q =To o+=T p=o p=o> op=T s=o oW< W<o! oH< H<oa 5Wo<",
+" W8o< H5o< H8o< W<oQ o!WQ< oZ< oaZ< oWp< opW8< opZ< s<oZ ov= v=o+ =Ho go= =",
+"5ov v>o= =5oH o>g= ov=Q ov=+Q Z=o Z=go ovp= o>pv= p=oZ yo= ,n ,n& ,nB ,an ,",
+"n. ,8n n.,B 8n,a ,nK ,K&n ,Tn T&,n ,nj 8n,j Tn,j sn, ,n* -n *B,n -na ,.n* -",
+"n8 n*.,B 8n-a ,Kn* -nK T*,n -Tn n*,j -nj n*j,T s-n ,nE ,E&n ,Hn H&,n nE,. ,",
+"E8n ,.Hn H8,n nE,K <&EnK Hn,T ,HnT& ,Enj <&jnE Hn,j ,Hsn ,dn -nd Hn,d g-n ,",
+".dn 8d-n ,Hnd. g8-n ,Kdn dn-K Td,n -Tgn dn,j dn-j dnj,H gns- ,4n 4&,n 4B,n ",
+"4a,n ,5n 48,n ,B5n 5a,n 4n,K <&K4n 4T,n ,4Tan 4j,n <&j5n 5T,n ,4sn =n, -=n ",
+",n=B -n=a ,5=n >n- =B5,n -a>n ,n=K =K-n ,T=n -n=T ,n=j -n=j =T5,n >ns- 4n,E",
+" <&E4n 4H,n ,4Han ,E5n ,48nE H5,n ,4H8n ,4nEK ,4E&nK ,4HTn 4H&,Tn ,4jnE <jE",
+"5&n ,4Hnj sn,4H ,d=n =d-n ,H=n -=gn 5d,n -d>n =H5,n g->n =dn,K -=dnK =HT,n ",
+"g=-Tn =jd,n >n-dj =Hj,n s-ng= ,P< <P& ,B<P a<,P ,.<P 8<,P <P.,B <P&8a ,Qn Q",
+"&,n Qn,T Qa,n Qn,j Q8,n <Pj,T ,Qsn P*,n -P< <P*,B a<-P <P*,. 8<-P ,P.n*B -P",
+"8a< Q*,n -Qn ,QnT* Qa-n <Pj,* Q8-n ,TPn*j -Qsn ,Wn W&,n H<,P Wa,n ,.Wn W8,n",
+" ,HP<. <P&H8 Wn,Q <P&WQ Zn, ,aZn Wn,j <P&Wj ,nZj Zns, Wn,d -Wn ,HP<d -Wgn ,",
+"Wnd. W8-n <d.,HP -Wng8 Qd,n Wn-Q ,dZn Z-n <dj,P Wn-j Zn*,j snZ- o, o&< o,B ",
+"oa, o,5 o8, ,5oB ,5oa o,Q ,Qo& oT, ,Qoa op, p<o& p,oT os, o=, o- =Bo, o-a =",
+"5o, o-> o=5,B ->oa o,=Q o-Q o,=T o-T o,p= o-p p=o,T os- o,W ,Wo& oH, ,Hoa ,",
+"5oW ,Wo8 ,Ho5 ,Ho8 ,WoQ o&W,Q oZ, oaZ, oWp, op&,W opZ, s,oZ ov, o-v o,=H go",
+"- o5v, -vo> ov,H5 g-o> oQv, -Qov ovZ, Z-o pvo, op-v oZ,p= yo- <nC <Cn! D<n ",
+"a<Dn nC<. <n8C <nD. 8<Dn nC<K n!<CK T<Dn D<aTn <Cnj <jn8C <jDn D<sn n*C +Cn",
+"* Dn* D<+n *Cn. 8Cn* D.n* 8nD* *CnK n*C+K TnD* an*DT nC*j n*j+C n*Dj Dns* n",
+"C<E n!<CE D<Hn H<Dan <nCE. 8<nCE H<Dn. H8<Dn <nCEK <CEn!K H<DTn D<aHnT <jnC",
+"E 8<CnjE H<jDn s<HDn <Cdn <dn+C DnH* D<gn <dnC. 8<dnC Hn*D. g<D8n <dnCK +<C",
+"dnK Hn*DT g<TDn <djnC <dC+nj <djDn sn*gD <n4C 4<n!C 4<Dn 4Da<n <n5C 48<nC D",
+"<5n 4D8<n 4<nCK n!<4CK 4DT<n D<a4Tn <jn4C 48<njC 4Dj<n s<D5n =nC +n=C =Dn +",
+"D=n 5n=C =n>C 5D=n =D>n nC=K =+nCK Dn=T =D+Tn nj=C >n=jC Dn=j sn=D 4<nCE n!",
+"<4CE 4HD<n H<D4an 5<nCE 8<C5nE H5<Dn 5D<H8n <nC4EK EK<!4nC H<D4Tn a<Hn4DT 5",
+"<CnjE <j5n8CE 5D<Hnj H5<snD dn=C =+dnC Hn=D gn=D =5dnC >n=dC =H5Dn g=>Dn =d",
+"nCK dnC=+K =HDTn g=DTn =jdnC =jd>nC =HjDn s=gDn <PC <!PC D<P a<DP PC<. 8C<P",
+" D.<P 8<DP QC<P <PCQ! D<Qn QD<aP <CPj <Pj8C <PDj D<sP <CP* +C<P <PD* D<+P <",
+"P*C. +<P8C D<P*. +D<8P QCn* +Q<PC DnQ* an*QD <Pj*C <Pj+C <PjD* s<P+D WC<P <",
+"PCW! D<HP H<PDa <PCW. W8<PC H<PD. H8<DP <PCWQ Q<CWn! D<Zn Z<DaP <PjWC <jCW8",
+"n Z<DPj s<PZD WCn* +W<PC DnW* D<gP Wn*C. W8n*C WDn*. g<PD8 Wn*QC <dC+Qn DnZ",
+"* Zn*gD <djPC <dC+Pj Zn*Dj s<PgD o<C <Co! oD< D<oa 5<oC 8<oC 5Do< D8o< Q<oC",
+" o!Q<C QDo< oDQa< oCp< op8<C p<oD oDs< o=C =Co+ =Do o+=D o5=C >Co= =5oD =Do",
+"> oQ=C o=+QC oD=Q o+D=Q =Cop o>p=C op=D =Dos W<oC o!W<C H<oD oHDa< o5W<C o8",
+"W<C oH5D< oH8D< oWQ<C W<Qo!C oDZ< oZDa< opW<C p<Wo8C Zp<oD osZD< =Cov ov=+C",
+" ov=D =Dgo ov=5C o>v=C ovD=5 go>=D ov=QC =Qvo+C =DoZ goZ=D p=ovC p=vo>C p=D",
+"oZ =Dyo ,nb <&bn ,Dn c<n ,.bn b8,n ,.Dn ,8cn ,Kbn <&Kbn bT,n ,Tcn bn,j <&jb",
+"n Dn,j c<sn bn* -nb Dnb* c-n b.n* b8-n ,Dn*. c8-n bKn* bn-K Tnb* -Tcn n*bj ",
+"bn-j n*j,D c-sn ,Ebn <&Ebn bH,n ,Hcn ,nbE. ,8nbE ,Hnb. c<H8n ,nbEK b<E&nK ,",
+"HnbT c<HTn ,njbE <&Ebnj ,Hnbj sn,cH bd,n bd-n Hnb* c-gn ,dnb. -nb8d ,Ddn. c",
+"-ng8 ,dnbK -nbdK ,DdTn c-ngT <djbn -njbd dnj,D s-ngc 4b,n ,4b&n 4D,n ,4cn b",
+"5,n ,48bn 5D,n ,5cn ,4bnK ,4b&nK ,4DTn c4T,n ,4jbn 4b8,nj ,4Dnj sn,c4 =bn -",
+"n=b ,D=n c=n b5=n =b>n =b5Dn >nc= bn=K =b-nK bT=n cn=T bn=j >n-bj =bT5n snc",
+"= ,4bnE ,4b&nE ,4Hbn c4H,n ,5nbE <&Eb5n ,H5bn c5<Hn 4bE,nK <&bn4EK 4bH,Tn ,",
+"4HcnT <jEb5n &n4jb<E 4bH,nj s<Hc5n bd=n =b-dn bH=n gnc= =b5dn >n-bd =bH5n c",
+"=g>n =bdnK -nd=bK =bHTn c=gTn =bjdn >nd=bj =bHnj s=cgn b<P <&bP D<,P c<P b.",
+"<P 8<bP ,DP<. 8<cP bQ,n <P&bQ QD,n ,Qcn <Pbj <P&bj <Pj,D c<sP <Pb* b<-P ,DP",
+"n* -Pc< b<P*. -Pb8< P*.,Dn c-P8< Qnb* bQ-n ,QDn* -Qcn <Pjb* -Qnb8 ,QDn*j s-",
+"Pc< bW,n <P&bW H<bP ,Wcn ,Wnb. ,W8bn ,WDn. cW<8P ,WnbQ W<&bQn ,DZn c<Zn <Pj",
+"bW bW8<Pj Zb<Pj Zc<sP Wnb* bW-n ,WDdn c<gP bWn*. -Wnb8 <d.,DP c-W8n ,Qdbn -",
+"WnbQ bnZ* c-Zn <djbP -Wnbj Zbn*j Z-nsc ob< b<o& oD, oc< ,5ob ,8ob ,5oD o8c<",
+" ,Qob obQ<& ,QoD oTc< pbo, opb,8 pDo, s<oc =bo o-b ob=D oc- =5ob =bo> =bo5D",
+" c>o- ob=Q -Qob ob=T =Qoc op=b ob-p p=boD ocs= ,Wob obW<& ,Hob oHc< ob5,W o",
+"b8,W obH,5 ocH,5 obW,Q bW<o&Q obZ< Z<oc opb,W obWp<& oZbp< oscZ< ov=b ob-v ",
+"ob=H c=go ovb=5 o-v>b ovD,5 cv=o> ovb=Q o-vbQ =boZ ocZ- p=bov o-pvb Z=bop o",
+"cy- 6<n n!6< <n6B 6<an 1<n 8<1n <n1B a<1n <n6K 6!<nK 6<Tn 6Ta<n <j1n <jn68 ",
+"T<1n 1<sn 6*n +n6* 6n*B an6* 1n* +<1n *B1n an1* 6Kn* n*K6+ Tn6* an*6T n*6j ",
+"n*j6+ Tn1* 6*sn <n6E 6!<nE 6<Hn 6Ha<n <n1E 68<nE H<1n 6H8<n 6<nEK n!<6EK 6H",
+"T<n H<T6an <jn6E 68<njE 6Hj<n s<H1n dn6* <dn6+ Hn6* 6*gn <d1n 68dn* Hn1* 1<",
+"gn <dn6K 6+<dnK 6H*Tn g6Tn* <dj1n 68dn*j n*j6H sn*g6 6<4n 6!4<n 46<nB 4a6<n",
+" 7<n 8<7n <n7B a<7n 46<nK 4<n6!K 4T6<n 6T<4an <j7n 78<nj T<7n 7<sn =6n 6+=n",
+" 6n=B 6a=n 7=n 7=>n =n7B =n7a 6n=K =6+nK 6T=n =T6+n 7n=j 7>=nj =n7T 7=sn 46",
+"<nE 4<n6!E 4H6<n 6H<4an <n7E 78<nE H<7n 7H8<n 6<n4EK 4<6!nEK 6H<4Tn a<Hn4T6",
+" 7<njE <jn78E 7HT<n 7sH<n 6d=n =6+dn 6H=n =6gn =n7d 7>=dn =n7H 7=gn =6dnK d",
+"nK=6+ =H6Tn g=6Tn 7=dnj >n=7dj 7Td=n g7s=n 6P< 6!<P 6B<P a<6P 1<P 8<6P 1B<P",
+" a<1P Q<6P <P!6Q T<6P 6Qa<P Q<1P <Pj68 T<1P 6Ps< 6P* +<6P *B6P aP6* 1P6* +<",
+"1P 6P*1B aP*68 Qn6* 6+Q<P TP6* aP*6Q Qn1* <Pj6+ P*j6T 6Ps* W<6P <P!6W H<6P ",
+"6HPa< W<1P 6W8<P H<1P 6H8<P 6WQ<P 6WQ<P! 6PZ< Z6a<P <Pj6W 6W8<Pj 1<Zn s<PZ6",
+" Wn6* 6+W<P HP6* 6Pg< Wn1* 6W8P* 6HP1* 1<gP 6W*Qn +Wn6Q* 6PZ* Z6*gP <dj6P 6",
+"+W<Pj 1nZ* s<Pg6 o6< 6!o< 6<oB 6ao< 7o< 7<o8 o<7B 7<oa 6Qo< o!6Q< 6To< oT6a",
+"< p<7o 7op8< 7<oT 7os< o=6 =6o+ o6=B =6oa 7o= 7=o> =B7o 7o=a o6=Q o=6+Q =6o",
+"T o+T=6 7op= 7o=p> 7o=T 7os= 6Wo< o!6W< 6Ho< oH6a< oW7< 7oW8< 7<oH 7oH8< o6",
+"WQ< 6WQo!< o6Z< oZ6a< 7opW< op87W< Z<7o osZ7< v6o= ov=6+ =6oH o=g6 ov7= 7o=",
+"v> 7o=H 7og= ov=6Q =Qvo+6 o=Z6 goZ=6 7o=pv o>p7v= 7oZ= 7oy= ?n ?&n ?Bn ?an ",
+"?1n ?:n 1n?B :n?a ?nK &n?K ?Tn T&?n ?jn :n?j 1T?n s?n ?n* ?-n n*?B -n?a 1n?",
+"* :-n ?B1n* :a-n n*?K ?K-n Tn?* -n?T n*?j -n?j ?T1n* ?-sn ?nE &n?E ?Hn H&?n",
+" 1n?E ?E:n 1H?n :n?H nE?K ?&nEK Hn?T ?HTan nj?E ?:njE Hn?j ?Hsn ?dn -n?d Hn",
+"?d g?n 1d?n :n?d ?H1dn ?:gn dn?K ?-dnK Td?n ?Tgn dn?j ?:dnj ?Hjdn gns? ?4n ",
+"4&?n 4n?B 4a?n 7?n :n7? ?n7B ?n7a 4n?K ?4&nK 4T?n ?T4an 7n?j ?:7nj ?n7T 7?s",
+"n ?=n -n?= ?B=n =n?a =n7? An ?=7nB Aan ?n=K ?-=nK =n?T ?-T=n =n?j Ajn ?T7=n",
+" Asn 4n?E ?4&nE 4H?n ?H4an 7n?E ?:7nE ?n7H ?:H7n ?4nEK &nE?4K ?H4Tn 4H&?Tn ",
+"?j7nE 7:n?jE ?H7Tn s?7Hn =n?d ?-=dn =n?H ?=gn ?n7d Adn ?H7=n Agn ?=dnK -=n?",
+"dK ?Td=n g?=Tn ?d7nj dnAj ?Hj=n gsAn ?P ?P& ?PB ?aP ?P1 ?:P 1P?B :P?a ?QP Q",
+"&?P ?TP Qa?P ?Pj :Q?P 1T?P s?P ?P* ?-P P*?B -P?a 1P?* :-?P ?P1*B ?:P-a Qn?*",
+" -Q?P TP?* -T?P P*?j -Q:n ?TP1* ?-sP ?WP W&?P ?HP HP?a 1W?P :W?P 1H?P :H?P ",
+"Wn?Q ?WQP& ?ZP Z&?P Wn?j ?:WQn Z1?P sP?Z ?dP -W?P HP?d g?P 1d?P :d?P ?HP1d ",
+"?:gP Qd?P ?-WQn Zn?d gP?Z dP?j ?:QdP ?Z1dP gPs? o? o?& o?B o?a o?7 o:? 7Bo?",
+" ?ao: o?Q o&?Q o?T oT?a ?po o:?p 7o?T s?o o?= o-? =Bo? =ao? 7o?= Ao 7o=?B A",
+"oa =Qo? ?Qo- =To? ?To- p=o? Aop o?Tp= Aos o?W o&?W o?H oH?a 7o?W ?Wo: 7o?H ",
+"?Ho: oW?Q o?WQ& ?Zo ?aoZ op?W o:?pW o?7Z os?Z ?vo o-?v =Ho? go? o?7v Aov o?",
+"H7v Aog ov?Q o-?vQ o?Z= ?Zgo op?v opAv ?Zo7v yAo <n6C 6!<nC 6<Dn 6Da<n <n1C",
+" 68<nC D<1n 6D8<n 6<nCK n!<6CK 6DT<n D<a6Tn <jn6C 68<njC 6Dj<n s<D1n 6Cn* n",
+"*C6+ Dn6* an*6D 1Cn* 68*nC Dn1* an*1D n*C6K 6+Cn*K 6D*Tn +Dn6T* n*j6C <jC1+",
+"n n*j6D sn*6D 6<nCE n!<6CE 6HD<n H<D6an 1<nCE 8<C1nE 1H<Dn H8<1Dn <nC6EK EK",
+"<!6nC H<D6Tn a<Hn6DT 1<CnjE <j1n8CE H<j1Dn 1H<snD <dn6C 6+<dnC 6H*Dn g6Dn* ",
+"1<dnC <dC1+n 1HnD* g1<Dn 6dCn*K <d+n6CK Ddn6T* 6D*gnT <jC1dn <d6j+nC 6Ddn*j",
+" s<Dg1n 46<nC 4<n6!C 4D6<n 6D<4an <n7C 78<nC D<7n 7D8<n 6<n4CK 4<6!nCK 6D<4",
+"Tn a<Dn4T6 7<njC <jn78C 7DT<n 7sD<n 6n=C =6+nC 6D=n =D6+n 7n=C 7>=nC =n7D 7",
+">D=n =6nCK 6+n=CK =D6Tn 6+D=Tn 7=njC >nj7=C =D7Tn s=7Dn 6<n4CE 4<6!nCE 6H<4",
+"Dn a<Hn4D6 7<nCE 8<n7CE 7HD<n H8<7Dn 6<4nEKC 6n4CEK<! T<Hn4D6 46T<HDan <jn7",
+"CE <j7n8CE H<j7Dn 7HDs<n =6dnC dnC=6+ =H6Dn g=6Dn 7=dnC >n=7dC 7Dd=n g7=Dn ",
+"dnC=6K dn=C6+K 6Dd=Tn g6D=Tn =jn7dC >j7d=nC 7Hn=Dj s=Dg7n 6C<P <PC6! D<6P 6",
+"DPa< 1C<P 68P<C D<1P 6D8<P <PC6Q 6QC<P! 6QD<P QD<6aP <Pj6C <PC6Q8 <Pj6D s<P",
+"6D 6CP* 6+P<C DP6* aP*6D 6P*1C 68P*C 6DP1* 6D8P* 6Q*PC <PC6+Q 6QDP* 6QDaP* ",
+"P*j6C <PC6+j P*j6D sP*6D <PC6W 6WC<P! 6HPD< WD<6aP 1W<PC <PC6W8 1H<DP H8<6D",
+"P 6WQ<PC QC<P6W! Z6D<P 6DPZ<a <PC6Wj <PWj68C Z1<DP s<DZ1n 6W*PC <dC6+P 6HPD",
+"* g6PD< 1Wn*C <dC68P 1WDn* g1<DP <PC6Qd 6C+WQn* Z6*DP Z6Dg<P <dC6Pj dP<j6+C",
+" Z1nD* s<Dg6P 6<oC o!6<C 6Do< oD6a< o<7C 7o8<C 7<oD 7oD8< o6Q<C 6Q<o!C oD6Q",
+"< 6QDoa< 7op<C o8<7pC 7oDp< os7D< o6=C o=6+C =6oD o+D=6 =C7o 7o=>C 7o=D o>D",
+"7= o=6QC =Q6o+C =QDo6 o+6=QD 7o=pC p=7o>C p=D7o s=o7D o6W<C 6W<o!C oH6D< 6W",
+"Doa< 7oW<C o8<7WC 7oHD< 7H<oD8 6WQo<C Q!oW6<C oZ6D< oD6Z<a op<7WC 78p<oWC 7",
+"ZoD< 7ZDos< ov=6C v=6o+C ovD=6 go=6D 7o=vC o>=7vC 7vDo= go7=D =Q6ovC =6o+vQ",
+"C Z=o6D Z=6goD p=o7vC >C7vp=o 7Z=oD yo7=D ?bn bn?& ?Dn ?cn b1?n ?b:n 1D?n :",
+"n?c bn?K ?b&nK bT?n cn?T bn?j ?:bnj Dn?j sn?c bn?* ?b-n Dn?* cn?- 1nb* :b-n",
+" ?D1n* c-:n ?bn*K ?-bnK ?DTn* ?-Tcn ?jbn* ?-jbn ?Djn* s-n?c bn?E ?b&nE bH?n",
+" cn?H ?b1nE ?:bnE ?Hb1n ?:Hcn ?bnEK &nE?bK ?HbTn ?cHTn ?jbnE :nb?jE ?Hjbn s",
+"?cHn bd?n ?-bdn Dd?n gn?c ?d1bn ?:dbn ?Dd1n g:n?c ?dbnK -nb?dK ?DdTn g?cTn ",
+"?djbn ?db-nj ?Ddnj g?scn 4b?n ?4b&n 4D?n ?4cn ?n7b ?:7bn ?n7D cn7? ?4bnK &n",
+"K?4b ?D4Tn ?c4Tn ?j7bn 7:b?jn ?D7Tn s?7cn ?b=n ?-=bn =n?D cn?= =n7b Abn ?D7",
+"=n Acn ?=nbK =bn?-K =bT?n c=?Tn =b7nj bnAj ?Dj=n scAn ?4bnE &nE?4b ?H4bn ?c",
+"4Hn 7?bnE 7bn?:E ?H7bn 7c?Hn 4bn?EK &n?E4bK 4bH?Tn c4H?Tn 7bn?jE 7j?E:nb ?H",
+"n7bT 7cHs?n ?=dbn =b-?dn ?Dd=n c=?gn ?d7bn bdAn ?D7dn gcAn =bn?dK =d-n?bK ?",
+"Hn=bT g?Tc=n ?dn=bj Adnbj ?Hn=bj Agnsc ?Pb bP?& ?DP ?cP b1?P ?b:P 1D?P :c?P",
+" bQ?P ?QbP& bT?P cQ?P bP?j ?:QbP DP?j sP?c bP?* ?b-P DP?* c-?P ?Pb1* ?:P-b ",
+"?DP1* ?cP:- ?QbP* ?-QbP ?QDP* ?cQ-P ?Pjb* ?-Pbj ?DP*j s?Pc- bW?P ?WbP& bH?P",
+" cW?P ?Wb1P ?:WbP ?HPb1 ?cW:P ?WbQn bWn?Q& Zb?P ?PZc ?WjbP ?Wb:Qn ?Zb1P s?Z",
+"cP bd?P ?-WbP Dd?P gP?c ?dPb1 ?:dbP ?Dd1P g?P:c ?QdbP ?Wb-Qn ?ZbdP g?ZcP ?d",
+"Pbj ?Wb-Pj ?DdPj g?scP o?b ?bo& o?D oc? 7bo? ob?: 7o?D ?co: ob?Q o?bQ& ob?T",
+" ?Qoc ob?p o:?pb op?D ocs? =bo? ob?- =Do? ?co- 7o=b Aob o?D7= Aoc o?=bQ o-?",
+"bQ o?D=Q oc?=Q p=bo? opAb ?pDo= osAc ob?W o?bW& ob?H ?Hoc ?W7ob o:?bW o?H7b",
+" o:H?c o?bWQ obW?Q& ?DoZ oc?Z ?pobW ?pbo:W ?Zo7b s?oZc ob?v o-?vb ov?D ocg?",
+" 7vbo? ovAb ?vD7o goAc ?vobQ ?vbo-Q ?Zo=b go?Zc ?pvob Aopvb ?pvoD yoAc R< R",
+"<! R<B Ra< R<. R8< <.RB 8<Ra R<M R!<M RT< T<Ra R<j 8<Rj T<Rj sR< R<* R+< *B",
+"R< +<Ra R.n* +<R8 n*.RB an*R8 Mn* +MR< T<R* +TR< <jR* +<Rj Mn*Tj R+s< R<E <",
+"ER! RH< H<Ra <ER. RE8< R.H< H8R< RE<M <MER! H<RT aMnH< RE<j R8<ME H<Rj RHs<",
+" R<d +<Rd H<Rd gR< R.<d 8<Rd RH<d. R8g< <MRd <dMR+ T<Rd RTg< <dRj <dMR8 <dj",
+"RH sRg< R4< 4!R< 4<RB 4aR< R5< 48R< RB5< 5aR< 4MR< <M!R4 4TR< aMn4< 4jR< R4",
+"8<M 5TR< R4s< =R =R+ =RB =Ra =R5 =R> R5=B >R=a =RM R+=M =RT R+=T =Rj =R>M R",
+"5=T s=R 4<RE R4<!E 4HR< R4Ha< RE5< R48<E H5R< R4H8< <MER4 R4E<M! R4HT< 4HMR",
+"a< R4j<E <MER48 R4H<j sR4H< =Rd R+=d =RH g=R R5=d =d>R RH=5 g>=R Rd=M =R+dM",
+" RH=T gR=T Rd=j >M=Rd RH=j gs=R R<P R!<P RB<P aPR< R.<P 8PR< <P.RB R8<aP S<",
+" S<! S<T Sa< S<j S8< T<Sj Ss< <PR* +PR< <P*RB aP*R< <P*R. R+<8P R<.P*B R8<a",
+"P* S<* S+< T<S* +TS< <jS* +<S8 S<T*j S+s< RW< R!W< H<RW WaR< R.W< W8R< RH<W",
+". RH8W< S<W W<S! SZ< Z<Sa W<Sj W8S< SjZ< s<SZ W<Rd +WR< RH<W* RWg< RW<d. R+",
+"W8< <P.RH* gR<W8 S<d +WS< Z<Sd gS< <dSj 8<Sd SZ<dj g<Ss oR< R<o! R<oB Rao< ",
+"R5o< R8o< oR5<B o8Ra< So< o!S< oTS< oaS< Sp< o8S< STp< s<So =Ro o+=R oR=B o",
+"a=R oR=5 =Ro> o=5RB o>=Ra S= S=+ S=T S=a S=p S>= Sp=T s=S RWo< o!RW< RHo< o",
+"HRa< 5WR< o8RW< oHR5< oH8R< oWS< S<Wo! S<oZ SZ<oa SWp< Sp<W8 ZpS< osZS< =Rv",
+" =+vR oH=R =Rgo =5vR v>=R =RvH5 g=Ro> S=v v=S+ S=Z gS= p=Sv v>S= SZp= y=S ,",
+"R< R<& RB,n Ra,n ,.R< R8,n ,R<.B ,R8a< ,Mn <MR& RT,n T<R& R<,j 8M,n ,RT<j ,",
+"Rs< R*,n -R< n*B,R Ra-n n*.,R R8-n ,R.n*B -R8a< M*,n -Mn Mn*,T RT-n Mn*,j R",
+"<-j ,RTn*j -Rs< ,ER< RE<& RH,n H<R& ,R<E. ,R8<E ,RH<. ,RH8< ,EMn <M&RE HM,n",
+" aMn,H ,Rj<E <&jRE ,RH<j sn,RH R<,d R<-d ,RH<d -Rg< ,Rd<. -R8<d <d.,RH g-R8",
+"< dM,n dM-n dMn,H -Mgn <dj,R -Rj<d ,RH<dj s-Rg< ,R4 R&,4 RB,4 R4,a R4,5 R4,",
+"8 ,R45B ,R45a R4,M <M&R4 R4,T aMn,4 R4,j <M&R5 ,R45T ,Rs4 =R, =R- ,R=B -R=a",
+" ,R=5 ->=R =R5,B >n-Ra ,R=M -R=M ,R=T -R=T ,R=j -R=j =RT,5 =Rs- ,ER4 ,R4&E ",
+"R4,H ,R4H& ,R45E ,R48E ,R4H5 ,R4H8 ,R4ME <MER4& ,R4HM ,4HaMn ,R4jE <MER5& ,",
+"R4Hj sR4,H ,R=d =d-R ,R=H g-=R =R5,d >n-Rd =RH,5 g=R-> =Rd,M =R-dM =RH,T g=",
+"R-T =Rj,d >M-dn =RH,j s=Rg- R<,P <PR& <PB,R <P&Ra <P.,R <P&R8 ,R.<PB R8<,aP",
+" S<, S<& ,TS< ,aS< ,nSj ,8S< S<T,j S<s, <P*,R R<-P ,R<P*B -Ra<P ,R<P*. -R8<",
+"P <PR*,.B R8<-Pa ,nS* S-< S<T,* -TS< S<*,j -nS8 n*jS,T s<S- RW,n W<R& ,RHW<",
+" <P&RH ,RW<. ,RW8< <P.,RH RH8<P& ,WS< W<S& Z<S, Z<S& S<W,j S8<,W SZ<,j Ss<Z",
+"& ,RW<d RW-n RH<,dP -RWg< <d.,RW -RW8< ,.RHWn* -R8g<P ,dS< -WS< SZ<,d g<S- ",
+"S<d,j S-W8< SdjZn, gS-s< o,R ,Ro& ,RoB ,Roa ,Ro5 ,Ro8 o,R5B o8,Ra So, o&S< ",
+"oTS, oaS, opS, o8S, Sp<,T s,So o,=R o-R o=,RB -Roa o=5,R -Ro> o,5=RB o->Ra ",
+"S=, S-o S,=T =TS- S,p= o-S> S=p,T S-s= ,RoW o&R,W ,RoH oH&,R o,R5W o8,RW oH",
+",R5 oH8,R SWo, S<&oW S,oZ oZ&S< Sp<,W Sp<W& oZ,Sp os,SZ vRo, =R-v ov,RH gRo",
+"- ov,R5 o-v>R =R5oH, go->R ovS, Svo- S,Z= S-go Sv,p= o-pSv S=Zp, S-yo R<U R",
+"!U< RD< UaR< R.U< U8R< R.D< D8R< <MUn <M!Un V<R RaV< U<Rj R8<Uj R<Vj V<sR U",
+"n* U+R< D<R* +DR< U.n* 8nU* RD<*. an*U8 MnU* Mn*U+ Vn* R+V< n*Uj Mn*U8 n*Vj",
+" Vns* REU< R<U!E UHR< RH<Ua R<UE. R8<UE RH<U. RH8U< <MEUn U<EMn! RHV< V<RHa",
+" R<jUE <MEU8n V<RHj s<VRH U<Rd R+<Ud HnU* RDg< R<dU. R8<Ud RD<d. gR<U8 <dMU",
+"n U+<dMn R<Vd V<gR <djUn U+<dnj V<dRj gV<sR 4UR< R4U<! 4DR< R4Da< U5R< R48U",
+"< 5DR< R4D8< R4U<M R4U<M! R4V< V4Ra< R4jU< 4U8R<j R5V< s<VR4 =RU R+=U =RD R",
+"+=D R5=U =U>n R5=D >R=D Un=M =RU+M V=R V+=R Rj=U >M=Un V5=R >nV= R4U<E 4UER",
+"<! R4HU< 4UHRa< R5<UE R4EU8< RH5U< 4UHR8< R4U<ME <MUn4E! V4RH< R4HV<a <MEU5",
+"n RE48U<j V5<RH s<HV5n Rd=U =RU+d RH=U gR=U =RU5d >nU=d =RHU5 g=R>U =RUdM d",
+"Mn=U+ Vd=R =RgV =RjUd >nd=Uj V=RH5 V>ng= U<P U!<P D<UP a<UP U.<P 8<UP RD<P.",
+" RD8<P S<U U<S! SV< V<Sa U<Sj U8S< SjV< SVs< <PU* +<UP RD<P* aP*U< U<P*. U+",
+"<8P <P.RD* U8<aP* U<S* U+S< V<S* V+S< S<U*j S+<U8 SV<*j Ss<V+ UWR< RW<U! H<",
+"UP RWDa< RW<U. RW8U< RWD<. RWD8< UWS< S<UW! Z<SV SZ<Va S<UWj S8<UW SZ<Vj Ss",
+"<VZ WnU* R+WU< RWD<d U<gP UWn*. UW8n* <d.RWD gU<8P U<Sd S+<UW V<Sd SVg< S<d",
+"Uj S8<Ud SV<dj gS<Vs oU< U<o! RDo< Uao< U5o< U8o< oU5D< oU8D< oUS< S<Uo! oV",
+"< V<oa pUS< Sp<U8 S<Vp s<oV =Uo o+=U oU=D oU=a =5oU =Uo> =RDo5 o>U=D S=U S+",
+"=U S=V =aoV Sp=U =US> VpS= oVs= UWo< oUW<! UHo< oUHa< oU5W< oU8W< oUH5< oUH",
+"8< S<UoW oUWS<! Z<oV oVZa< Sp<UW S8WpU< oVZp< oVsZ< ov=U ovU=+ oU=H =Ugo ov",
+"U=5 o>Uv= =Rv5D goU>= =USv S=vU+ oVZ= V=go p=USv S>=vU oVvp= S=yV ,Un b<R& ",
+"RD,n cR< ,.Un b8R< ,RD<. R8c< bM,n <M&Rb Vn, V<cR b<Rj <&jRb ,nVj cRs< b<R*",
+" -Un ,RDn* -Rc< ,Un*. U8-n n*.,RD c-R8< Mnb* bM-n ,nV* V-n Mn*bj Un-j Vn*,j",
+" snV- ,EUn ,Un&E bHR< RHc< ,UnE. ,U8nE ,UHn. cR<H8 ,UnME <MEU&n ,HVn cR<VH ",
+",UnjE <MERb8 Vn,Hj snV,H b<Rd Ud-n ,RD<d cRg< ,Udn. -Un8d <d.,RD cR<g8 <dMR",
+"b -UndM ,dVn gnV- <djRb -Undj Vdn,j V-ngs R4,U ,R4U& R4,D ,Rc4 b5R< ,R4b8 ,",
+"R45D R5c< ,R4bM ,4UM&n ,RV4 cR4V< ,R4bj ,4U&nj ,5Vn snV,4 =Rb -R=b ,R=D c=R",
+" Rb=5 -U>n =Rb5D =Rc> Rb=M =R-bM Vn=b =RV- Rb=j >M-bn V=R,5 >nV- ,R4bE <&ER",
+"4b ,R4bH cR4,H ,U5nE <&ERb5 ,UH5n cR5H< <MER4b <MR&4bE V4,RH cRHV4, <MERb5 ",
+"R4,jb8E V5n,H s<HcR4 Rb=d =R-bd Rb=H gc=R =Rb5d >n-Ud =RbH5 c=Rg> =RbdM =bd",
+"-Mn V=R,H c=VgR =Rbdj >Md=Rb =RbHj c=Rgs bPR< <PU& ,RD<P R<cP ,UP<. <P&U8 <",
+"P.,RD cR<8P Sb< b<S& V<Sb Sc< b<Sj b8S< SV<,j s<Sc ,UPn* U<-P b<PRD* c-R<P ",
+"<P.Rb* -UP8< <Pb*RD. c<8-UP b<S* -US< SV<b* S<V- Sb<*j S-b8< SbjVn* V-nSs b",
+"WR< <P&UW ,RWD< RWc< ,UWn. ,UW8n <P.,UH cRW8< bWS< Sb<W& ZbS< S<Zc Sb<Wj Sb",
+"8W< SZb<j Sc<sZ ,UWdn UW-n RWD,dn c-RW< <d.,UP -UW8n RW,D<d. cR8-Wn b<Sd S-",
+"bW< SZb<d g<Sc Sb<dj Sb8<d SbjZn* V-nsZ oU, ,Uo& ,RoD oUc< ,Uo5 ,Uo8 oU,5D ",
+"ocR,5 obS< Sb<o& oV, S<oc pbS< Spb8< o,Vp s,oV ob=R o-U =RboD =Roc =Rbo5 ->",
+"oU ob5=RD oc->R S=b =bS- =boV Sc= Sp=b =bS> oV,p= Scs= ,UoW oU&,W ,UoH ocR,",
+"H oU,5W oU8,W oUH,5 cR5W< Sb<oW S<WoU& Z,oV oV,Zc SpbW< SbWo8, oV,Zp oVsZ, ",
+"vR=b oU-v ovU,H =Rcv ovU,5 o-Uv> ob5=RH cv=>R =bSv o-USv SZ=b Z=Sc S=bpv o-",
+"pvU oVvp, Scy= q< q!< q<B qa< q1< q8< 1<qB 1aq< q<M <Mq! qT< T<qa l<q q8l< ",
+"qTl< sq< q* q+< q*B qa* q*1 q8* 1*qB 1aq* q*M +<qM qT* +Tq* l*q q+l< qTl* s",
+"q* q<E <Eq! qH< H<qa 1<qE 8<qE 1Hq< H8q< <MqE q!<ME H<qT qHTa< q<lE l<q8E q",
+"Hl< qHs< qd< +<qd qH* gq< 1<qd 8<qd 1Hq* q8g< <dqM q+<dM HMq* qTg< qdl< l+q",
+"<d qHl* l<gq q4< 4<q! 4<qB 4aq< 7q< 7<q8 q<7B 7<qa 4Mq< q!4<M 4Tq< qT4a< 7q",
+"l< 7lq8< 7<qT 7qs< q= q=+ q=B q=a q=7 q>= =B7q =aq> q=M q+=M q=T q+=T l=q q",
+">l= 7q=T sq= 4<qE q!4<E 4Hq< qH4a< q<7E 7q8<E 7<qH 7qH8< q4<ME <MEq!4 qH4T<",
+" 4HMqa< 7lq<E l<87qE 7qHl< sq7H< q=d =+qd q=H gq= 7dq= >=qd 7q=H g=q> qd=M ",
+"q=+dM qH=T =Tgq ldq= q>l=d lHq= l=gq q<P <Pq! <PqB a<qP 1<qP 8<qP q1<PB q8a",
+"<P Sq< q!S< qTS< qaS< l<S S8l< lTS< l<Ss q*P +<qP P*qB aPq* 1Pq* 8Pq* q*1PB",
+" q8*aP Sq* q+S< qTS* qaS* Sql* S+l< Sq*lT s*Sq qW< W<q! H<qW Waq< 1Wq< W8q<",
+" qH1W< qH8W< qWS< SqW<! Zq< qaZ< S<lW Sq8W< l<Zq s<Zq qW* +Wq* HPq* qWg< 1W",
+"q* W8q* qH*1W gq1W< qWS* Sq+W< Zq* g<Zq S<ld Sq8W* l*Zq l<gS oq< o<q! q<oB ",
+"o<qa 7<oq o<q8 7oq<B 7oaq< oqS< Sq<o! o<qT Sqao< r< r8< rT< rs< q=o o+q= =B",
+"oq oq=a 7oq= q=o> 7o=qB q>o=a S=q S+q= Sq=T Sq=a r= r>= r=T rs= o<qW oqW<! ",
+"o<qH oqHa< 7<qW 7qW8< 7oHq< 7qWa< SqWo< oqWS<! oqZ< Zqoa< rW< W8r< rZ< sZr<",
+" vq= q+v= =Hvq g=vq q=7v v>q= vq7=H vq>g= vqS= vq=S+ Zq= S=gq rv= v>r= rZ= ",
+"yr= ?q ?q& ?qB ?qa ?q1 :q? q1?B ?a:q ?qM q&?M ?qT qT?a l?q l?:q qTl? s?q ?q",
+"* -q ?Bq* -qa ?1q* -q: ?q1*B qa:- q*?M -qM q*?T -qT ?ql* l-q ?qTl* sq- ?qE ",
+"?Eq& ?qH qH?a q1?E ?E:q ?1qH ?H:q qM?E ?qM&E qH?T ?qHT& lE?q :ql?E ?qlH ?Hs",
+"q ?qd -qd qH?d g?q ?1qd ?d:q ?qH1d g:-q qd?M qd-M qT?d gM-q ?qld ld-q l?Hqd",
+" gql- ?q4 ?4q& q4?B ?4qa ?q7 7?:q 7B?q 7q?a q4?M ?q4M& ?4qT ?qT4a 7l?q ?q7l",
+": 7q?T ?q7s q=? -q= =B?q =a-q 7?q= Aq ?q7=B Aqa ?q=M =M-q ?q=T =T-q l?q= Al",
+"q l=?qT Aqs q4?E ?q4&E ?4qH ?qH4a ?E7q ?q7:E 7q?H :qH7? ?q4ME q&4?ME ?qH4T ",
+"?H4qT& ?q7lE l?7:qE l?H7q s?q7H ?dq= qd-= ?q=H g=-q 7q?d Aqd q=H7? Aqg ?qd=",
+"M -q=dM q=H?T -qTg= l=?qd ldAq l=H?q glAq ?qP q&?P qP?B qa?P q1?P ?P:q ?q1P",
+"B ?qa:P S? S?& S?T S?a S?l S?: ?TSl s?S q*?P -qP ?qP*B qa-P ?q1P* :P-q q*1?",
+"PB -q:aP S?* S?- S*?T ?TS- l*S? S?l- S?lT* S-s? ?qW q&?W qH?W qW?a ?1qW ?W:",
+"q ?qH1W :qH?W S?W S&?W S?Z ?aZq lWS? ?WS: l?Zq ?Zsq qW?d -qW ?qHW* gP-q ?qW",
+"1d :W-q ?H1qW* -qWg: S?d ?WS- ?dZq g?S ldS? lW-q S?Zld s?gS o?q o&?q ?Boq o",
+"q?a 7o?q o?:q ?q7oB o:?qa S?o S&o? ?TSo ?aSo r? r?: r?T r?s q=o? o-q o?q=B ",
+"oa-q ?q7o= Aoq q=7o?B oqAa S?= o-S? =TS? =aS? r?= Ar =Tr? Ars oq?W ?qWo& oq",
+"?H o?Hqa 7q?W o:?qW o?H7q o:H?q ?WSo S?oW& o?Zq S?Zoa r?W ?:rW r?Z s?rZ ?vq",
+" -qv ?Hvq ?vgq ?q7v Aqv ?vq7H goAq S?v S-?v S=?Z S?go r?v Arv ?Zrv Ary qU< ",
+"U<q! qD< Uaq< 1Uq< U8q< 1Dq< D8q< U<qM q!U<M Vq< qaV< qUl< l<qU8 l<Vq s<Vq ",
+"q*U U+q* qD* Uaq* 1Uq* U8q* 1Dq* D8q* U*qM q+U<M Vq* q+V< lUq* l+qU< l*Vq s",
+"*Vq U<qE q!U<E UHq< qHUa< q1U<E q8U<E qH1U< qH8U< qU<ME <MEq!U qHV< VqHa< l",
+"<qUE q8Ul<E VqlH< sqVH< U<qd q+U<d UHq* qDg< qd1U< q8dU< qH*1U gq1U< qdU<M ",
+"<dMq+U qHV* g<Vq l<dqU l<Uq8d Vqdl< glqV< 4Uq< q!4U< 4Dq< qD4a< qU7< 7qU8< ",
+"7<qD 7qD8< q4U<M <M!q4U q4V< Vq4a< 7lqU< l<q7U8 V<7q sq7V< q=U q+=U q=D q+=",
+"D 7q=U =Uq> 7q=D =Dq> qU=M q=U+M V=q =aVq lq=U q>l=U Vql= V=sq q4U<E 4U<q!E",
+" qH4U< 4UHqa< 7qU<E q8<7UE 7qHU< 7U<qH8 <MEq4U <Mq!4UE Vq4H< qH4V<a l<q7UE ",
+"lUq87<E 7VqH< 7VHsq< qd=U q=U+d qH=U =Ugq 7qd=U q>=Ud q=H7U q>Dg= q=UdM q+U",
+"=Md =HVq V=gq l=qUd l=Uq>d V=qlH V>qg= U<qP q!U<P D<qP qDa<P U<1P q8U<P qD1",
+"<P qD8<P qUS< SqU<! S<Vq SqaV< lUS< Sq8U< SVl< Ss<Vq UPq* q+U<P DPq* q+D<P ",
+"q*1UP q8*UP qD*1P qD8P* SUq* Sq+U< S*Vq Vq+S< Sq*lU Sq8U* Vq*Sl sq*SV UWq< ",
+"qWU<! WDq< qWDa< qW1U< qW8U< qWD1< qWD8< SqUW< qWUS<! Z<Vq ZqVa< lWqU< S8Ul",
+"W< lZ<Vq sqZV< UWq* q+WU< WDq* gqUW< qW*1U qW8U* qWD1* g1U<P SqdU< S+UqW* Z",
+"*Vq gqZV< S<dlU S+UlW< Zq*Vl glSV< qUo< oqU<! o<qD oqDa< 7<oU 7oU8< 7oUD< 7",
+"oUa< SqUo< oqUS<! V<oq oVqa< rU< U8r< rV< s<rV oq=U q=oU+ oq=D q=Do+ 7o=U q",
+">o=U q=D7o q>Do= Sq=U S=qU+ VqS= oV+q= r=U =Ur> rV= s=rV oqUW< qW<oU! oqHU<",
+" oU<qWa 7oUW< 7U<qW8 7oUH< 7U<oH8 oqUS<W S!oqUW< oVZq< ZqaoV< UWr< rU8W< Z<",
+"rV rZVs< =Uvq vq=U+ =Dvq vqDg= vq7=U vq>=U vqD7= vq>=D vq=SU S=Uvq+ V=Zq Vv",
+"qg= =Urv rv>=U Z=rV y=rV ?qt q&?t ?qD cq? ?1tq ?t:q ?1qD :q?c tq?M ?qtM& V?",
+"q V?cq ?qlt ?t:lq l?Vq u?q tq* -qt qDt* cq- t1q* :qt- ?qD1* :c-q tMq* -Mtq ",
+"t*Vq V-q tql* lt-q V?lq* uq- ?Etq ?qt&E tq?H ?Hcq ?qt1E ?t:qE ?qHt1 cq?:H ?",
+"qtME tq&?ME ?HVq cq?VH l?qtE l?t:qE V?lqH ?quH tq?d td-q qHt* cqg? ?qdt1 -q",
+"t:d ?qD1d cq-g: ?qdtM -qtdM ?dVq V?gq l?dtq l-qtd V?dlq g?uq t4?q ?qt4& ?4q",
+"D c4?q ?q7t ?q7t: 7q?D ?q7c ?qt4M tq4?M& V4?q cq?V4 ?q7lt :ql7t? ?q7V ?qu7 ",
+"t=q -qt= ?q=D cq= q=7t Aqt q=D7t Aqc tq=M -qt=M Vqt= V=cq ltq= ltAq V=q7t A",
+"uq ?qt4E t4&?qE ?qHt4 cq?4H ?q7tE :q?7tE 7tH?q 7cq?H tq4?ME M&?Etq4 V?q4H V",
+"?4cqH l?q7tE lE7t:q? 7V?qH u?q7H tdq= -qt=d tq=H t=gq 7tdq= tqAd t=H7q gqAt",
+" t=qdM t=d-qM V?dq= cq=gV l=tqd Aqdlt V?d7q uqAg ?tP ?&tP tP?D ?Pcq ?1tP t:",
+"?P ?qD1P cq?:P S?t S&?t S?V S?c l?St ?tS: SlV? u?S t*?P ?Pt- ?qDP* cP-q ?tP",
+"1* -qt:P ?D1tP* cq-:P S*?t St-q S*V? cqS- St*l? l-qSt S?Vl* S?u- tq?W ?qWt&",
+" tH?P ?Wcq ?qWt1 :qW?t ?qW1D cqW?: ?WSt S?tW& tZS? Sc?Z l?WSt S?:tW S?Zlt S",
+"?uZ td?P tW-q ?qWDd ?tgP ?td1P -qWt: ?H1tdP cq-:W ?dSt -qWSt ?dSV S?gt S?dl",
+"t -qWlt V?dSl g?uS ot? o&?t ?Dot ?cot o?7t ?to: ot?7D ot:?c otS? ot?S& oV? ",
+"ocS? r?t ?tr: r?V ur? t=o ot- =Dot oct= 7ot= Aot t=o7D otAc S=t t=S- oVt= t",
+"=Sc rt= Art t=rV Aru ?Wot ot?W& ?Hot otc?H ot?7W ot:?W otH7? ot:?H ot?SW S?",
+"Wot& oV?Z oV?Zc ?trW r?t:W ?ZrV r?uZ ot?v o-tv =Hot t=go ?vq7t tvAo otH7= g",
+"oAt tvS? ot-Sv tZS= ?vSc ?vrt rtAv ?vrV yAur Xn n!X XnB aXn Xn. 8Xn n.XB aX",
+"8n XnK XKn! TXn aXTn Xjn Xj8n XjTn sXn Xn( +Xn n(XB aX+n n(X. 8X+n Xn(.B aX",
+"n+8 n(XK Xn+K XnT( TX+n X(nj Xj+n XjnT( +Xsn Gn Gn! GnH Gan Gn. G8n G.Hn H8",
+"Gn GnK n!GK GTn TnGa Gnj 8nGj HnGj sGn Gnd +Gn dXHn gXn G.dn G8+n dX.Hn G8g",
+"n GKdn GK+n TdGn GTgn dnGj Gn+j dXjHn sGgn 4X 4X! 4XB 4aX 4X5 48X 4B5X 5a4X",
+" 4XK XK4! 4TX TX4a 4Xj 8X4j 5T4X s4X 4X; 4+X 4BX; +X4a X;5n >X4 X;B5n 4a>X ",
+"4KX; 4K+X T;4X +T4X X;4j 4X>j X;j4T s4>X 4GX 4!Gn 4HX Ga4X G5n G84X H54X H8",
+"4X 4KGn 4GX!K GT4X 4GTaX Gn4j 4G8Xj HX4j 4GsX 4dX +G4X HX4d g4X 5d4X >nG 4H",
+"X5d g4>X 4KdX 4+GXK Td4X 4TgX dX4j Gn>j dXj4H s4gX XPn XPn! PnXB XPan PnX. ",
+"XP8n XPn.B aXP8n QXn n!QX TXQn aXQn XjQn 8XQn XjnTP QXsn PnX( XP+n XPn(B aX",
+"P+n XPn(. +X8Pn Pn(X.B +X8aPn XnQ( QX+n QXnT( +QXTn XjnQ( +QX8n QXTnj( sX+Q",
+"n Yn Yn! YHn Yan Yn. Y8n HnY. H8Yn YQn QnY! YZn ZnYa Yjn Q8Yn ZnYj sYn Ydn ",
+"Y+n HnYd gYn dnY. +nY8 YHdn. Y8gn QdYn +QYn YdZn YZgn dnYj +nYj YZdnj gnsY ",
+"oX o!X oXB oaX o5X o8X 5XoB 5aoX oQX QXo! oTX QaoX opX pXo8 pXoT osX oX; o+",
+"X X;oB +Xoa 5Xo; o>X o5X;B oa>X QXo; +QoX TXo; +ToX o;pX op>X opTX; >Xos oY",
+" oY! oYH Yao Y5o Y8o oHY5 oHY8 oYQ YQo! oZY YaoZ Ypo opY8 oZYp sYo Yvo Y+o ",
+"oHYv goY ovY5 Y>o YvoH5 Y>go YQov YQo+ YvoZ oZgY opYv o>Yp YZvop yoY Xn# X&",
+"n n#XB X&an n#X. X&8n Xn#.B aXn8& n#XK XK&n XnT# X&Tn X#nj &nXj XjnT# X&sn ",
+"n#X( X&+n Xn#(B aXn+& Xn#(. X&n+8 n#(X.B +X8an& Xn#(K X&n+K TXn#( +TX&n Xjn",
+"#( X&j+n TX#nj( sX+&n Gn# G&n G#Hn H&Gn n#G. 8nG& GnH#. G8nH& n#GK GK&n G#T",
+"n T&Gn G#nj &nGj GTnj# G&sn G#dn G&+n dX#Hn G&gn dX#n. dX&8n HX#dn. gX8&n d",
+"X#nK dX&nK GTnd# gXT&n dXjn# dX&nj dX#Hnj gsX&n 4X# 4X& X#4B aX4& 4#5X 5X4&",
+" 4X5#B 48Xa& X#4K 4KX& 4#TX TX4& 4#Xj X&4j 4TX5# 4Xs& 4#X; +X4& X;#4B aX;4&",
+" X;#5n 4X>& 5X#;nB >X4a& X;#4K X;&4K 4TX;# X;&4T X;j4# >X4&j X;#5Tn >Xs4& 4",
+"#Gn G&4X 4#HX HX4& G#5n 5&Gn 4HX5# 4H8X& 4GX#K 4G&XK 4GTX# 4GTX& 4GjX# X&j4",
+"G 4HXj# s4GX& 4#dX dX4& 4HXd# 4Xg& 4dX5# G&>n dX#H5n >Xg4& 4dX#K dX&4K 4TdX",
+"# g4XT& dXj4# >nG&j dX#4Hj >nsG& PnX# XP&n XPn#B aXP&n XPn#. X&P8n Pn#X.B 8",
+"XaP&n XnQ# X&Qn QXnT# QaX&n XjnQ# X&jQn QXTnj# sXQ&n XPn#( X&P+n Pn#X(B +Xa",
+"P&n Pn#X(. +X8P&n .BX(Pn# aX+P8n& QXn#( +QX&n TX#Qn( QX&+Tn QX#nj( +QX&nj Q",
+"#TnXj( +QXsn& Yn# Y&n HnY# H&Yn n#Y. 8nY& YHn#. Y8H&n QnY# Q&Yn Y#Zn ZnY& n",
+"jY# &nYj YZnj# Y&sn dnY# +nY& YHdn# Y&gn Ydn#. Y+8&n dn#YH. gY8&n YQdn# Y+Q",
+"&n YZdn# gYZ&n Yjdn# Y+j&n ZndYj# sYg&n oX# o&X X#oB aXo& 5Xo# 5Xo& o5X#B o",
+"8aX& QXo# QXo& TXo# TXo& o#pX pXo& opTX# o&sX X;o# +Xo& oX;#B o+aX& o5X;# o",
+"&>X X;#o5B o>aX& oQX;# o+QX& oTX;# o+TX& opX;# o>pX& pX;oT# os>X& oY# Y&o Y",
+"#oH oHY& o5Y# o8Y& Y5oH# Y5ao& oQY# YQo& Y#oZ Y&oZ Y#op opY& YpoZ# Y&os Y#o",
+"v ovY& YvoH# Y&go Yvo5# Y&o> ovHY5# goY>& YvoQ# Yv&oQ YZvo# goZY& Ypov# Yp&",
+"o> oZvYp# Y&yo In In! DXn aIn In. 8In D.In 8IDn InK IKn! TIn aITn Inj Ij8n ",
+"InDj sIn In( +In D(In DX+n n(I. 8I+n In(D. +DX8n n(IK +KIn T(In TI+n I(nj I",
+"n+j InjD( +Isn GnI G!In Jn Jna G.In 8IGn Jn. J8n GKIn InKG! JnT TnJa InGj I",
+"njG8 Jnj sJn Idn Gn+I Jnd gJn I.dn Id8n dnJ. J8gn dKIn Idn+K TdJn gTJn dnIj",
+" Idn+j dnJj gnsJ 4IX 4!In 4DX DX4a 5In 8I4X 5D4X D84X 4KIn InK4! DX4T 4DXTa",
+" In4j Inj48 DX4j 4DsX I;n +I4X D;4X +D4X I;5n >nI I;n5D 4D>X IK;n I;n+K I;T",
+"n a;nTI ;nIj In>j I;n5T sI>n Gn4I In!4G J4X 4aJn 5IGn 4G8In J5n 48Jn InK4G ",
+"4GKIn! 4TJn J4TaX Inj4G 4G8Inj 4XJj J4sX Id4X Idn4+ J;n J4gX Id5n Gn>I 5dJn",
+" J>n Idn4K IdK4+X T;Jn gJ4TX Idn4j >nGIj ;nJj >nsJ IPn n!IP IPDn IPan PnI. ",
+"IP8n IPnD. D8XPn QIn Q!In DXQn aIQn IjQn 8IQn IPjDn QIsn PnI( IP+n IPnD( +D",
+"XPn IPn(. +IP8n DP(In. D8P+In Q(In QI+n QDXn( +QDIn IPjn( IPj+n IP(Dnj sIP+",
+"n YIn InY! YJn JnYa InY. 8IYn Y.Jn JnY8 QIYn YQIn! ZJn ZaJn InYj Y8QIn JnYj",
+" YJsn IdYn +IYn YdJn YJgn IdnY. Y+8In YJdn. gYJ8n IdQn Y+QIn ZdJn ZJgn YjId",
+"n Y+jIn YJjdn sJngY oI oI! oDI oaI oI5 o8I 5DoI 5aoI oIQ QIo! oTI QaoI opI ",
+"pIo8 pDoI osI oI; o+I DXo; +DoI 5Io; o>I oD5I; oD>X QIo; +QoI TIo; +ToI o;p",
+"I p>oI opDI; sIo> oYI YIo! oJ oJa oIY5 oIY8 oJ5 oJ8 YQoI oYQI! oJZ oaZJ oIY",
+"p Y8opI oJp oJs ovI oIY+ oJv goJ o5vI oIY> J5ov oJ> oQvI Y+oQI JvoZ gZoJ pv",
+"oI o>IYp opJv yoJ bXn I&n DXbn cXn b.In 8Ibn In.bD 8Icn bKIn IK&n TIbn TIcn",
+" Inbj &nIj InjbT cXsn b(In +Ibn In(bD +Icn In(b. I&n+8 DX(bn. cX+8n In(bK I",
+"&n+K bTXn( cX+Tn Injb( I&n+j Ij(bTn sInc+ bGn G&bn Jnb cJn b.Gn G8bn bnJ. J",
+"8cn bKGn I&nGK bTJn cTJn Gnbj I&nGj bnJj cJsn Gnbd +Gbn bdJn cJgn Idnb. Idn",
+"b8 Jnbd. cJng8 IdnbK Idn&K JnbTd cJngT Idnbj Idn&j Jnjbd sJngc 4bX bX4& bX4",
+"D c4X b54X b84X 4bX5D 48cX 4KbX I&n4K bT4X 4TcX bX4j I&n4j 4bT5X c4sX b;4X ",
+"b+4X I;nbD 4+cX I;nb5 4b>X 5DXb;n c4>X I;nbK I;&nK I;nbT c4X+T I;nbj >Xb4j ",
+"4bTX;j c>Xs4 bG4X I&n4G 4bJn J4cX G5bn I&nG5 b5Jn J5cn 4bGXK InK4G& J4bTX c",
+"J4TX 4bGXj 4bGX&j J4jbX sJ4cX bd4X Idn4& b;Jn c4gX Idnb5 bG>n J5nbd cJ>n 4b",
+"dXK IdK;&n J;nbT cJ;Tn dXj4b >nbGj J;nbj J>nsc IPbn P&In IPnbD IPcn IPnb. I",
+"P&8n bPDIn. cX8Pn QIbn I&Qn bQXDn QIcn IPjbn IP&nj bTPInj sIPcn IPnb( IP&+n",
+" bPDIn( cX+Pn bP(In. +IPb8n IPbnD(. +IPcn8 bQXn( I&n+Q IP(bTn cQX+n IP(bnj ",
+"b+QInj InbjQD( sI+cQn Ybn bnY& JnYb Ycn bnY. b8Yn YJbn. cnY8 bQYn YbQ&n ZnY",
+"b ZnYc bnYj Yb8Qn YZbnj snYc bdYn b+Yn YJbdn gnYc Ybdn. Yb+8n JndYb. Ycg8n ",
+"YbQdn Yb+Qn YZbdn ZcngY Ybjdn Yb+nj YbdJnj sYcgn obI oI& bXoD ocI b5oI b8oI",
+" ob5DX o8cX bQoI QIo& bToI oTcX pboI pIo& opbDX sIoc bXo; b+oI obDI; o+cX o",
+"b5I; ob>X b5XoD; >Xoc obQI; ob+QI obTI; oc+QI opbI; o>bpI ob;pDX osc>X Ybo ",
+"obY& oJb Yco obY5 obY8 J5ob Y5oc YQob YboQ& YboZ ZcoJ opYb Ypbo8 obJp osYc ",
+"ovYb obY+ obJv Ycgo Yvbo5 Ybo> oJvb5 ocY> YvboQ Ybo+Q oJZvb ocZgY Ypbov Y>b",
+"op oJpvb Ycyo 6X 6X! 6XB 6aX 6X1 68X 6B1X 1a6X 6XK XK6! 6TX TX6a 6Xj 8X6j 1",
+"T6X s6X 6X( 6+X X(6B +X6a 6(1X 1+6X 6X1(B 6+X1a X(6K 6K+X 6(TX +T6X 6(Xj +X",
+"6j 6TX1( 6+sX 6GX 6!Gn 6HX Ga6X 1Gn G86X 1H6X Ga1n 6KGn 6GX!K GT6X 6GTaX Gn",
+"6j 6G8Xj GT1n 6GsX 6dX +G6X HX6d g6X 1d6X +G1n 6HX1d 68gX 6KdX 6+GXK Td6X 6",
+"TgX dX6j dXj6+ dXj6H s6gX 4X6 6!4X 4B6X 6a4X 7X 7X8 7XB 7aX 4K6X 4X6!K 6T4X",
+" 4TX6a 7Xj 8X7j 7TX 7sX 6X; 6+4X 6BX; aX6; 7X; >X7 X;7B 7a>X 6KX; 4+X6K TX6",
+"; aX;6T X;7j >j7X TX7; >X7s 6G4X 4G6n! 6H4X 4Ga6X 7GX G87X 7HX Ga7X 4G6XK 6",
+"GK4X! 4GT6X 6GT4aX Gn7j 7G8Xj GT7X 7GsX 6d4X 4+G6X HX6; 4Xg6 7dX 7G>X HX7d ",
+"g7X 4dX6K X;K6+G 4Td6X g4X6T dX7j 7>GXj Td7X gX7s 6XP XP6! XP6B aX6P 1X6P 8",
+"X6P 6X1PB 68XaP 6QX Q!6X QX6T Qa6X 1Q6X Q86X 6QX1T 6QsX XP6( +X6P 6XP(B 6+X",
+"aP 6X1P( 6+X1P 1X(6PB 1+X6aP 6(QX +Q6X 6QXT( 6+QTX 6QX1( 6+Q1X Xj(6TP s6X+Q",
+" Y6 Y6! Y6H Y6a Y61 Y68 6HY1 6HY8 Y6Q 6QY! YZ6 Z6Ya Y6j 6QY8 Z6Y1 sY6 Y6d Y",
+"6+ 6HYd gY6 6dY1 6+Y1 Y61Hd Y6g1 6QYd 6+YQ YdZ6 YZg6 6dYj 6+Yj YZ61d g6sY o",
+"6X 6Xo! 6XoB 6aoX 7oX o87X oX7B oa7X 6QoX o!6QX 6ToX oT6aX 7pX 78pX oT7X 7o",
+"sX 6Xo; 6+oX o6X;B o+6aX oX7; 7o>X 7oX;B 7oa>X QX6; o+6QX oT6X; o+T6X 7;pX ",
+"7p>X 7oTX; os7>X Y6o o!Y6 oHY6 oaY6 7Y 7Y8 7YH 7Ya o6YQ Y6oQ! Y6oZ YZ6oa 7Y",
+"p Y87p 7ZY sY7 Yv6 o+Y6 YHv6 Yvg6 7Yv Y>7 7HYv g7Y YQv6 Yv6+Q ZvY6 gY6oZ 7v",
+"Yp 7pY> YZ7v y7Y 6X9 6X& 6B9X 9a6X 1X9n :X6 6X19B 6a:X 6K9X 6KX& 9T6X TX6& ",
+"9X6j 6X:j 6TX9j :Xs6 6(9X 9+6X 6X9(B 6+X9a 6X19( 6+:X 1X(9nB :X6+a 6X9(K 6+",
+"X9K 6TX9( 6+T9X 6Xj9( :X6+j Xj(9Tn s:X6+ 9Gn G&6X 9H6X Ga9n 1G9n :Gn 6HX91 ",
+"6H:X 9KGn 6G&XK GT9n 6GTX& Gn9j Gn:j 6HX9j :Gsn 9d6X +G9n 6HX9d 6Xg9 6dX91 ",
+"6d:X 1HX9dn :Ggn 6dX9K dX&6K 6Td9X g6X9T dXj9n :Gn+j 9GTdnj g:Xs6 49X 6X4& ",
+"4B9X 9a4X 7X9 7:X 9X7B :X7a 4K9X 49X&K 9T4X 49TaX 9X7j 7j:X 9T7X 7:sX 9X6; ",
+"9+4X 49X;B aX;49 9X7; 7:>X 7X9;B 7:X>a 49X;K X;&6K 49TX; X;&6T 7X9;j 7:X>j ",
+"7TX9; 7sX:> 9G4X 49GX& 9H4X 49GaX 9G7X :G7X 9H7X :H7X 49GXK X&K49G 49GTX 6G",
+"T4X& 7G9Xj 7:GXj 7GT9X 7sG:X 9d4X dX&49 49HdX 49gX 9d7X :G>n 7HX9d 7:gX 49d",
+"XK dXK49+ 49TdX g49TX 7dX9j 7:dXj 7Td9X g7Xs: 9X6P X&6P 6XP9B 6aX9P 6X19P 6",
+"X:P 9X16PB :X6aP 9Q6X QX6& 6QX9T 6Qa9X 6QX9j 6Q:X 9TX6Pj :QXs6 6XP9( 6+X9P ",
+"9X(6PB 9+X6aP 9X16P( :X6+P 6(9X1PB 6+X:Pa 6QX9( 6+Q9X 6Q(9TX 9+Q6TX Xj(9Qn ",
+":QX6+ 6(QX9T1 sX+:Qn Y69 Y6& 6HY9 6HY& 9nY1 Y:6 Y691H :HY6 6QY9 6QY& Z6Y9 Z",
+"6Y& 6jY9 :QY6 YZ69j s6Y: 6dY9 6+Y9 Y69Hd Y6g9 Y691d :dY6 9HnY1d g6Y: Y69Qd ",
+"Y6+9Q YZ69d gY6Z9 Y6j9d Y:6+Q Y9dZ1n sY:g6 o9X 6Xo& 9XoB 9aoX o97X o:X 7o9X",
+"B oa:X 9QoX o9QX& 9ToX o9TaX p97X 7X:p 7oT9X sXo: 9Xo; 9+oX o9X;B o9+aX 7o9",
+"X; >Xo: o9;7XB o:>aX o9QX; o9+QX o9TX; o9+TX 7pX9; o:p>X 7T;p9X os:>X Y9o o",
+"9Y& oHY9 o9Ya 7Y9 Y:o 7HY9 Yao: YQo9 Y6&oQ Y9oZ oZ9Ya Y97p Ypo: Y97Z Y:7Z o",
+"vY9 o9Y+ Yv69H Y9go Y97v :v7Y 7Yv9H Y:go Yv69Q Yv6Q& oZ9Yv go9YZ Yp97v Y:op",
+"v 7ZYv9 Y:yo 6IX 6!In 6DX DX6a 1In 8I6X 1D6X D86X 6KIn InK6! DX6T 6DXTa In6",
+"j Inj68 DX6j 6DsX 6(In +I6X 6(DX +D6X 1(In +I1n 6DX1( 6+D1X In(6K 6+IXK 6DX",
+"T( 6+DTX Inj6( Inj6+ 6DXj( sIn6+ Gn6I In!6G J6X 6aJn Gn1I 6G8In J1n 68Jn In",
+"K6G 6GKIn! 6TJn J6TaX Inj6G 6G8Inj 6XJj J6sX Id6X Idn6+ 6dJn J6gX Id1n Idn6",
+"8 1dJn J1gn Idn6K IdK6+X J6TdX gJ6TX Idn6j 6+GInj J6jdX sJ6gX 6I4X In!46 6D",
+"4X 4DX6a 7IX 8I7X 7DX D87X InK46 6IK4X! 4DX6T 6TI4aX In7j 7I8Xj DX7T 7DsX I",
+";6X I;n6+ DX6; aX;6D I;7X 7I>X DX7; 7D>X I;n6K I;K6+X I;n6T 6+D4TX 7IX;j 7>",
+"IXj 7DXT; 7sI>X 4G6In 4G6In! 4XJ6 J46aX Gn7I 7G8In 7JX J87X 4G6InK 6!4GInK ",
+"J46TX 4TXJ6a 7GIXj Inj7G8 Jn7T sX7J Idn6; 6+GI;n 6XJ; gJ46X Id7X 7>GIn J;7X",
+" >X7J IdK6X; Id4X6+K J6;TX J4Tg6X 7IdXj >Ij7dX 7JTdX J>n7s 6IP 6!IP DX6P aI",
+"6P 1I6P 8I6P 6DX1P 6D8IP QI6X 6QIn! QD6X 6QDaX QI1n IPj68 IPj6D 6IsP 6(IP +",
+"I6P 6DXP( 6+DIP 6IP1( 6+I1P IP(1Dn 1+D6IP 6QIX( 6+QIP 6QDX( 6+QDX IPj6( IPj",
+"6+ IP(6Dj sIP6+ Y6I 6IY! YJ6 J6Ya 6IY1 68YI J6Y1 J6Y8 6QYI Y6QI! ZJY6 YZ6Ja",
+" 6IYj Y68QI J6Yj YJs6 6IYd 6+YI YdJ6 YJg6 Y61Id Y6+1I YJ61d gY6J1 Y6QId Y6+",
+"QI YZ6Jd gY6ZJ Y6jId Y6+Ij YJ6dj sY6gJ oI6 6Io! 6DoI 6aoI 7oI o87I oD7I oa7",
+"I 6QoI oIQ6! 6ToI oTI6a op7I 7oIp8 oT7I 7osI 6Io; 6+oI oD6I; o+D6I 7;oI 7Io",
+"> 7oDI; o>D7I oIQ6; o+I6Q oTI6; o+T6I 7oIp; o>I7p 7oTI; osI7> oIY6 Y6oI! oJ",
+"6 oaJ6 7YI 7IY8 7Jo Y87J Y6oQI oIQY6! Z6oJ oJZ6a 7IYp 7Yp8I oJ7Z 7JsY v6oI ",
+"Yv6+I Y6Jv g6oJ 7IYv 7IY> 7voJ 7Jgo Yv6QI Y6Qo+I oJZv6 goJZ6 7vIYp Y>7pI oJ",
+"p7v 7Jyo b6X 6&bX 6DbX c6X 6Xb1 :In b6X1D c6:X bK6X I&n6K 6TbX 6TcX 6Xbj In",
+":j Inj9D :Isn b(6X 6+bX b6XD( 6+cX b6X1( +I:n b6(1DX :cX6+ b6X(K b6+XK b6TX",
+"( c6X+T Inj9( :In+j In(b1T sIn:+ 6GbX I&n6G J9n J6cX 1Gbn bG:n b1Jn :Jn b6G",
+"XK I&K9Gn 9TJn cJ6TX Inj9G :Gnbj 9nJj sn:J 6dbX Idn6& 9dJn c6gX Idnb1 Id:n ",
+"J9n1d gn:J Idn9K IdK6X& J9nTd c6XgT Idn9j :Idnj J9ndj :Jngs b64X I&n49 9D4X",
+" 49cX 7bX :I7X bX7D 7cX 4bX6K I&K49X 4bT6X c4X6T bX7j 7:IXj bT7X sX7c 6Xb; ",
+"I;&6X I;n9D 6Xc; bX7; 7b>X 7bXD; >X7c I;n9K I;K6X& I;n9T c6XT; 7bX;j 7>bXj ",
+"7bTX; 7cXs> 4bG6X 49GI&n 49Jn cJ46X bG7X 7:GbX J97X 7X:J InK49G 4KbG6X& J49",
+"TX c4TJ9n 7bGXj 7bj:Gn 7JbTX 7Js:X Idn49 49+Idn 9;Jn cJ6X; bd7X 7:IdX 7JbdX",
+" >n:J IdK49X dX4&b6K J9;Tn c4Tg6X 7bdXj >Ij:Gn 7bTdX J>ns: 6IbP IP6& b6XDP ",
+"6IcP b6X1P 6I:P 6DXb1P :cX6P 6QbX IP&6Q b6QDX 6QcX IPjb6 QI:n b6TIPj sIP:n ",
+"b6XP( IP&6+ IP(9Dn c6X+P IP(b1n :IP6+ b(6X1DP :I+c6P b6QX( b6+QX IP(b6T c6Q",
+"+X IP(b6j :QI+n 6XbjQD( sI+:Qn Yb6 b6Y& J6Yb Yc6 b6Y1 :IY6 YJ6b1 Y6:J b6YQ ",
+"Yb6Q& ZbY6 Y6Zc b6Yj Y:b6Q YZb6j s6Yc b6Yd b6Y+ YJ6bd g6Yc Yb61d Y:b6+ YbdJ",
+"1n Y:Jg6 Yb6Qd Yb6+Q YZb6d Yc6gZ Yb6dj Yb6+j YbdZ1n sYcg6 o9I 6Io& 9DoI o9c",
+"X ob7I o:I 7obDX 7Ioc 9QoI o9IQ& 9ToI oc6QI pb7X op:I 7obTI sIo: 9Io; 9+oI ",
+"o9DI; oc6+I 7obI; :Io> 7D;o9I o:Ic> o9IQ; o9+QI o9TI; c6QX; 7pbX; o:Ip> 7b;",
+"oTI os:>I obY6 Ybo6& oJ9 Y6oc 7Yb Ybo: Yb7J Yc7 Ybo6Q Y6QoI& Z9oJ oJ9Zc Yb7",
+"p o:IYp Yb7Z Yc7Z vbY6 Yvb6+ o9Jv g9oJ Yb7v 7>Yb oJ97v Ycg7 Yvb6Q YbQo9+ oJ",
+"9Zv oJ9gZ 7Ybpv :vIop oJpv9 Ycy7 RXn n!RX XnRB RXan XnR. RX8n RXn.B aXnR8 X",
+"Mn n!XM XMTn XMan MnXj XM8n XMnTj XMsn XnR( RX+n RXn(B aXnR+ RXn(. R+8Xn Xn",
+"(R.B R+8aXn X(Mn XM+n XMnT( aXM+n XMnj( R+jXn RTXnj( sX+Mn RGn R!Gn GnRH Gn",
+"Ra R.Gn GnR8 RGHn. RG8Hn GMn G!Mn GnRT aMGn GnRj 8MGn RGTnj RGsn GnRd +nRG ",
+"RGHdn RGgn dX.Rn R+G8n RGHdn. gRG8n dMGn GM+n dXMHn GMgn dXMnj dXM8n RGTdnj",
+" gsRGn R4X 4!RX RB4X 4XRa 4XR5 4XR8 R45XB R48aX 4XM 4!XM 4XRT aX4M 4XRj 8X4",
+"M R4T5X R4sX 4XR; 4XR+ X;BR4 aX;R4 R45X; R4>X R45X;B >XR4a X;4M +X4M XM;4T ",
+"aXM4+ XM;4j 4X>M R4TX;j >XsR4 R4G 4!RG 4GRH 4GRa 4GR5 4GR8 R4GH5 R4GH8 4MRG",
+" R4GM! 4GRT aXM4G 4GRj R4G8M R4GHj R4sG 4GRd 4+RG R4GH; R4gX R4G5d R4>G 4HX",
+"R5d >XgR4 dX4M dXM4+ dXM4H 4XgM dXM4j GM>n R4HdXj >Xg4M XPRn RXPn! RXPnB aX",
+"PRn RXPn. R8XPn XPnR.B R8XaPn SXn n!SX TXSn aXSn XjSn 8XSn STXnj SXsn RXPn(",
+" R+XPn XPnR(B R+XaPn XPnR(. +XPR8n .BR(XPn aX+PR8n XnS( +XSn STXn( S+TXn SX",
+"nj( S+8Xn XjnST( Ss+Xn YRn RnY! RHYn RaYn RnY. R8Yn YRHn. Y8RHn SYn YnS! Zn",
+"SY SnYa SnYj SnY8 SZYnj SYsn RdYn R+Yn YRHdn YRgn YRdn. Y+R8n dn.YRH gYR8n ",
+"YdSn SnY+ SZYdn SYgn SYdnj SY+8n YZnSdj gSsYn oRX RXo! RXoB RaoX R5oX R8oX ",
+"oR5XB o8RaX SoX o!SX SXoT SXoa pXSo SXo8 SpToX sXSo R;oX R+oX oRX;B o+RaX o",
+"R5X; oR>X X;BoR5 o>RaX oXS; SXo+ S;ToX Sa;oX SpXo; So>X opTS;X os>SX oYR YR",
+"o! YRoH YRoa oRY5 YRo8 Y5oRH Y5aoR SoY S!oY SYoZ YaSo SoYp Y8So SZpoY SosY ",
+"vRoY YRo+ YvoRH oYgR YvoR5 >RoY ovRY5H goY>R YvSo Y+So YZvSo SogY SvoYp SoY",
+"> YpoSvZ SoyY XnR# RX&n RXn#B aXnR& RXn#. X&nR8 Xn#R.B R8aX&n X#Mn MnX& XMn",
+"T# aXM&n XMnj# XM&8n RTXnj# sX&Mn RXn#( X&nR+ Xn#R(B R+aX&n Xn#R(. R+8X&n .",
+"BR(Xn# aXR&+n8 XMn#( XM&+n TX#Mn( +TXM&n Mn#Xj( +XM&nj XMTnj#( XM&sn+ R#Gn ",
+"GnR& RGHn# RGa&n RGn#. RG8&n Gn#RH. G8nRH& G#Mn M&Gn RGTn# aMnG& RGjn# M&nG",
+"8 XM#Hnj sRG&n dX#Rn dX&Rn RGHdn# gRG&n RG#dn. RG8d&n dXHnR#. RG8gn& dXMn# ",
+"dXM&n dX#HMn gXM&n dM#Gnj XM&dnj dXHjMn# sX&gMn R#4X 4XR& R4X#B R4aX& R45X#",
+" R48X& 4X#R5B 4aXR5& 4#XM XM4& R4TX# aXM4& R4jX# XM&48 XM#5Tn sR4X& X;#R4 X",
+";&R4 R4#X;B R4aX;& R45X;# >XR4& 5#X;R4B R4a>X& XM;4# XM;4& XM#T;n XM&a;n XM",
+"#;nj >XM4& X;Rj4T# sX&>Mn R#4G 4GR& R4GH# R4GH& R4G5# R4G5& R4#H5X 4G8RH& R",
+"4GM# XM&4G R4GT# XM&4H R4Gj# M&nG5 XM#4Hj sR4G& R4Gd# dX&R4 dX#R4H gR4G& dn",
+"#RG5 >nGR& H#5nRG; >X&gR4 dXM4# dXM4& dX#R4T g4XM& dX#R4j >MG&n dX4MH5# sX&",
+"gR4 RXPn# X&PRn XPnR#B RaXP&n XPnR#. R8XP&n .BP#RXn aXR&8Pn XnS# X&Sn STXn#",
+" SaX&n SXnj# S8X&n XjnST# SsX&n XPnR#( R+XP&n XPRn#B( aXR&+Pn #(P.RXn 8X+PR",
+"&n XnR(.BP# anR&8X+P SXn#( S+X&n TXnS#( +TXS&n XjnS#( X&jS+n XjSnT#( S+Xsn&",
+" RnY# R&Yn YRHn# YaR&n YRn#. Y8R&n RHnY#. RH8Y&n YnS# SnY& SZYn# SZ&Yn SYnj",
+"# SY8&n YjnSZ# sYS&n YRdn# Y+R&n dn#YRH gYR&n dn#YR. d&nY8R dnY#RH. gR8Y&n ",
+"SYdn# SY+&n YZnSd# gSY&n YjnSd# S+nY&j dnYjSZ# sY&gSn RXo# R&oX oRX#B oaRX&",
+" oR5X# o8RX& R5Xo#B R5ao&X oXS# SXo& oTXS# oT&SX SpXo# Sp&oX oTXSp# osSX& o",
+"RX;# o+RX& X;#oRB aX;o&R X;#oR5 o>RX& X;o#R5B oaR>X& S;Xo# S;&oX oTXS;# S+X",
+"oT& opXS;# S>oX& X;S#opT S>Xos& oRY# YRo& oYRH# YaoR& Y5oR# Y5&oR oHRY5# Y5",
+"RoH& S#oY Y&So oZYS# oZ&SY YpoS# Yp&So oZSYp# sYoS& YvoR# Yv&oR oHRYv# goYR",
+"& ovRY5# Y>oR& YRoHv5# Y>Rgo& SvoY# Sv&oY oZYSv# goSY& YpoSv# S>Yo& SZYpov#",
+" yoYS& [n [!n [Dn [an [n. [8n Dn[. D8[n [Mn Mn[! V[n [aVn [jn 8M[n [jVn [sn",
+" [n( [+n Dn[( +D[n n([. +n[8 [Dn(. [+D8n Mn[( +M[n [nV( [+Vn nj[( +n[j V[nj",
+"( [+sn [Gn Gn[! Jn[ [aJn Gn[. G8[n [nJ. [8Jn GM[n [!GMn JnV JaVn Gn[j [8GMn",
+" VnJj Jn[s [dn +G[n [dJn g[n dn[. 8d[n Jn[d. [8gn dM[n [+GMn VdJn JngV dn[j",
+" [+jGn JnVdj gn[s [4 [4! [4D [4a [45 [48 4D[5 4D[8 [4M 4M[! V[4 [aV4 [4j 48",
+"[j [4V5 [s4 [4; [4+ 4D[; 4+[a 5n[; [>4 [45D; [a>n 4M[; 4+[M [4V; [4V+ 4j[; ",
+"[4>M V[4;j >n[s [4G 4G[! J4[ [aJ4 4G[5 4G[8 [4J5 [4J8 4G[M [4GM! V[J4 J4V[a",
+" 4G[j [48GM V5Jn J4[s [4d 4+[d [4J; g[4 4d[5 [d>n J4[5d >ng[ 4d[M [4+GM V;J",
+"n V[g4 4d[j [>4GM J4[dj g4[s [Pn n![P DP[n aP[n Pn[. 8P[n [DPn. [8DPn S[n [",
+"!Sn VnS[ Sn[a Sn[j Sn[8 SV[nj S[sn Pn[( +P[n [DPn( [+DPn [Pn(. [+8Pn DPn[(.",
+" +DP[8n [nS( Sn[+ SV[n( SV+[n S[nj( S[+8n VnjS[( [sS+n [Yn Yn[! [YJn Yn[a [",
+"nY. Yn[8 YJ[n. YJ8[n Sn[Y S[Yn! ]n ]an Yn[j S[8Yn ]jn ]sn Yn[d Yn[+ YJ[dn [",
+"Ygn [Ydn. Y+[8n [YdJn. g[Y8n Sn[d S[+Yn ]dn ]gn S[dnj S[8dn dn]j gs]n o[ o[",
+"! o[D o[a o[5 o[8 [5oD [5oa o[S S!o[ oV[ Sao[ [po S8o[ [poV os[ o[; o[+ [;o",
+"D [+oD o5[; [>o o[5D; oD[> S;o[ S+o[ V;o[ V[o+ [;op o[S> oVp[; [>oV o[Y o![",
+"Y oJ[ Yao[ Y5o[ Y8o[ J5o[ J8o[ SYo[ o[YS! ]o ]oa o[Yp [poY8 ]op ]os [vo Y+o",
+"[ [voJ go[ [5ov o[Y> oJ[v5 [>go o[Sv [voS+ ]ov ]og op[v [pvo> op]v ]yo [bn ",
+"[&n bn[D [cn bn[. b8[n [bDn. [8cn bM[n M&[n [bVn V[cn bn[j &n[j V[bnj sn[c ",
+"bn[( b+[n [bDn( [+cn [bn(. [+b8n bnD[(. [c+8n [bMn( [+bMn V[bn( [cV+n [jbn(",
+" [+jbn [jbVn( [sc+n bG[n G&[n [bJn Jn[c [bGn. [8bGn Jn[b. [cJ8n GMbn [&GMn ",
+"JbVn VJcn [jbGn [&jGn JnVbj [sJcn bd[n d&[n Jn[bd gn[c [dbn. [8dbn [dbJn. g",
+"[c8n [dbMn [d&Mn JnVbd gVn[c [djbn [d&nj Jnb[dj g[scn [4b [4& 4b[D [c4 4b[5",
+" 4b[8 [4b5D [4c5 4b[M 4M[& Vb[4 V[c4 4b[j 4&[j V[4b5 s4[c 4b[; 4b[+ [4bD; [",
+"4c; [4b5; [&>n b5n[;D >n[c [4bM; [4+bM V[4b; [c4V+ [4jb; [>4bM V4b[;j V>[c4",
+" 4b[G 4G[& Jb[4 J4[c [4bG5 [48bG J4[b5 [c4J5 [4bGM [4&GM J4V[b [c4VJ [4jbG ",
+"[4&Gj J4[bj [s4cJ 4b[d 4d[& J4[bd g4[c [4db5 [>4bG J4b[5d J>n[c [4dbM [4dM&",
+" J;Vbn g[4Vc [4dbj >MbGn J4b[dj J>Vcn bP[n P&[n [bDPn [Pcn [bPn. [8bPn bPD[",
+"n. [c8Pn [bSn Sn[& SV[bn cnS[ S[bnj S[8bn V[nSbj [scSn [bPn( [+bPn bPD[n( [",
+"c+Pn bPn[(. b+P[8n bD[(Pn. [+8cPn S[bn( S[+bn V[nSb( Sc[+n [jnSb( Sbn[+j nj",
+"V(S[b Sc+[sn [bYn Yn[& YJ[bn [Ycn Yb[n. Yb8[n Jn[Yb. Yc[8n SnYb S[&Yn ]bn ]",
+"cn SYbnj SYb8n bn]j sc]n Yb[dn Yb+[n Jn[Ybd g[Ycn [dnYb. Ybn[8d dnJ.Yb[ Yc8",
+"g[n S[dbn S[d&n bd]n gc]n Sbn[dj SbnY+j ]jnbd ]cngs o[b o[& [boD oc[ [5ob [",
+"5o& o[b5D c5o[ Sbo[ S&o[ V[ob o[Sc ob[p o&[p oVp[b [poc [;ob [+ob o[bD; c;o",
+"[ o[b5; ob[> [5boD; [>oc S[;ob o[+Sb oV[b; oV+[c [pob; [p&o> [pboV; oV>[c Y",
+"bo[ Y&o[ [Job o[Yc Ybo[5 o[8Yb oJ[b5 oJ8[c YbSo o[&SY ]ob ]oc [poYb [p&oY o",
+"p]b os]c ob[v o&[v oJ[vb ocg[ [vob5 [v&o> [vboJ5 oJ>[c [voSb [v&So ov]b go]",
+"c [pvob [pvo& ]opvb yo]c qX q!X qXB qaX q1X q8X 1XqB 1aqX qXM XMq! qTX TXqa",
+" lXq q8lX qTlX sqX qX( q+X X(qB +Xqa 1Xq( 1+qX q1X(B q+1aX XMq( +XqM TXq( +",
+"TqX qXl( q+lX lXqT( q+sX qG qG! qGH qGa qG1 qG8 1GqH 1Gqa qGM GMq! qGT GTqa",
+" lGq q8lG qGlH sqG qGd q+G HXqd gqG 1Gqd 1+qG qG1Hd qGg1 GMqd +GqM GTqd qGg",
+"M qGld q+lG lGqTd lGgq q4X 4Xq! 4XqB 4aqX 7qX q87X qX7B qa7X 4XqM q!4XM 4Tq",
+"X qT4aX lX7 l87X 7TlX lX7s q;X 4+qX X;qB aXq; q;7X q>X 7qX;B qa>X XMq; q+4X",
+"M TXq; q+T4X 7Xl; lXq> 7qTX; >Xsq qG4 4Gq! 4GqH 4Gqa 7qG q87G qG7H qG7a 4Gq",
+"M qG4M! 4GqT qGT4a 7qlG 7qGl8 7HlX 7qsG qG; 4+qG G;qH qGg4 qG7d q>G 7qGH; >",
+"Xgq GMq; q+G4M GTq; gq4GT 7dlX lGq> 7qGTd lXg7 qXP XPq! XPqB aXqP 1XqP 8XqP",
+" q1XPB q8aXP SqX q!SX SXqT SXqa SqlX SXq8 SlqTX SqsX XPq( +XqP qXP(B q+aXP ",
+"q1XP( q+1XP 1XPq(B 1+XqaP qXS( SXq+ SqTX( Sq+TX SlqX( Sq+lX lXTSq( sqS+X Yq",
+" Yq! YqH Yqa Yq1 Yq8 qHY1 qHY8 YqS S!Yq ZqY SaYq lYq S8Yq ZqlY sqY Yqd Yq+ ",
+"YHqd gqY qdY1 q+Y1 Yq1Hd g1Yq SdYq S+Yq qdYZ gYZq ldYq l+Yq lYZqd gqlY oqX ",
+"oXq! qXoB oXqa oq7X oXq8 7oqXB 7oaqX SXoq SqXo! oXqT SqaoX rX r8X rTX rsX o",
+"Xq; oXq+ oqX;B oq+aX 7oqX; oq>X oq;7XB q>oaX SXq; Sq+oX Sq;TX SqaX; r;X r>X",
+" TXr; >Xrs Yqo o!Yq oHYq oqYa 7Yq Y87q 7HYq Ya7q SoYq YqoS! oZYq YqaoZ rY r",
+"Y8 rZY rsY vqY Y+vq qHYv gYvq vq7Y Y>q vq7YH Y>gq YqSv vqYS+ YZvq goqSY rYv",
+" rY> YZrv yrY q9X q&X 9XqB 9aqX 9Xq1 :qX q91XB qa:X 9XqM XMq& 9TqX TXq& q9l",
+"X lX:q lXq9T sX:q 9Xq( 9+qX q9X(B q+9aX q91X( q+:X 9X1q(B :q+aX q9XM( q+9XM",
+" qT9X( q+T9X lXq9( :ql+X qT9lX( sq:+X qG9 qG& 9GqH 9Gqa 9Gq1 :qG qG91H qG:H",
+" 9GqM GMq& 9GqT GTq& l9qG lG:q lGq9H sG:q 9Gqd 9+qG qG9Hd qGg9 qG91d q+:G 9",
+"HXqd1 gX:q qG9dM q+G9M qGT9d gq9GT lGq9d :qGl+ lG9qTd glq:G 49qX 4Xq& q49XB",
+" qa49X q97X 7X:q 7q9XB 7qa:X 9X4M q&4XM qT49X qT&4X l97X 7:lX 7qT9X 7sX:q 9",
+"Xq; X;q& q;9XB qa;9X 7q9X; >X:q q;97XB q>:aX q;9XM q;&XM qT;9X qT;X& lX79; ",
+"q>l:X 7T9lX; sq>:X 49qG 4Gq& qG49H qGa49 79qG 7G:q 7qG9H :qG7H qG49M qG&4M ",
+"qGT49 qGT4& 7qGl9 :qG7l 7qG9T sqG7: 9Gq; G;q& qG;9H gq49G 7qG9d :Gq> 7G9qH;",
+" q>Gg: qG;9M qG;M& qGT9; g49XM 7dXl9 q>Gl: 7G9qTd q>Gs: 9XqP X&qP q9XPB qa9",
+"XP q91XP qX:P 9X1qPB :qaXP q9SX SXq& Sq9TX Sqa9X Slq9X :XSq lXqS9T sq:SX q9",
+"XP( q+9XP 9XPq(B 9+XqaP 9X1qP( :q+XP 91q(XPB q+a:XP Sq9X( Sq+9X qTXS9( S9Xq",
+"+T lXqS9( S:q+X l9qTSX( S:+sqX Yq9 Yq& qHY9 qHY& q9Y1 Y:q Yq91H Ya:q S9Yq S",
+"&Yq Y9Zq Y&Zq lqY9 YqS: lYZq9 Y:sq qdY9 q+Y9 Yq9Hd g9Yq Yq91d Y+:q qH9Y1d Y",
+":gq SqdY9 Yq+S9 ZqY9d gqZY9 lYq9d lY:q+ Zq9lYd glY:q q9oX oXq& oq9XB oqa9X ",
+"7oq9X oq:X oq97XB o:qaX SXo9 Sq&oX oqT9X S9aoX r9X r:X 9TrX s:rX oq9X; oq+9",
+"X q;Xo9B o9Xqa; oq97X; o:q>X 7Boq9X; q>ao:X Sq;9X Sq;X& S9XqT; S9Xo+T 9Xr; ",
+">Xr: r;X9T r>Xs: oqY9 oqY& Y9oqH Yqao9 Y97q Yqo: 7Yq9H o:HYq Y9So Yq&So oZ9",
+"Yq Zq&oY rY9 rY: YZr9 sYr: Y9vq Y&vq vqY9H vq&gY vq7Y9 vqY: 7Y9vqH go:Yq vq",
+"YS9 vq&SY ZqvY9 vq&YZ Yvr9 Y:rv rZYv9 rYy: [q [q! [qD [qa [q1 [q8 qD[1 qD[8",
+" [qM [Mq! Vq[ [aVq [lq q8[l [lVq sq[ [q( [q+ [(qD q+[a [(q1 q+[1 [q1D( [q+1",
+"D [(qM [Mq+ V([q [qV+ l([q [ql+ Vql[( [+sq [qG [!qG Jq Jqa qG[1 qG[8 Jq1 Jq",
+"8 [MqG [qGM! JqV qaVJ [qlG [lqG8 Jql sqJ [qd q+[d Jqd gqJ qd[1 q8[d qdJ1 g1",
+"Jq [Mqd [q+GM VdJq gVJq [qld [l+qG ldJq sqg[ [q4 q![4 qD[4 qa[4 7[ 7[8 7[D ",
+"7[a q4[M [q4M! [qV4 Vq[4a 7[l [87l 7V[ 7[s [q; q+[4 qD[; qa[; 7[; 7[> [;7D ",
+"7D[> [Mq; [q+4M [qV; Vq+[4 l;7[ l>7[ V;7[ V>7[ qG[4 [q4G! Jq4 qaJ4 7[G [87G",
+" 7Jq 7aJq [q4GM qGM[4! J4Vq JqV4a lG7[ 7[lG8 Jq7V 7Jsq qG[; [q+4G Jq; g4Jq ",
+"7[d 7G[> 7dJq g7[ [qd4M [4Mq+G J;Vq Jq;gV ld7[ [>l7G l;Jq 7Vg[ [qP [Pq! [Pq",
+"D [Pqa [Pq1 [Pq8 [q1DP [q8DP Sq[ S![q S[Vq [qSa Sq[l [qS8 SlV[q Sq[s qP[( [",
+"Pq+ [qDP( [q+DP [q1P( [q+1P qDP[1( [1Pq+D S([q [qS+ Sq[V( Vq+S[ Sq[l( [l+Sq",
+" [lSVq( sq[S+ Yq[ [!Yq JqY YaJq [qY1 [qY8 Y1Jq Y8Jq S[Yq Sq[Y! ]q ]qa [lYq ",
+"Yq8[l ]lq ]qs [dYq [qY+ qdYJ gYJq Y1[qd Yq+[1 JqY1d Jq8gY [qSd Yq+S[ ]qd ]q",
+"g lYq[d lY+[q ld]q gl]q o[q o![q [qoD [qoa 7[o o87[ 7Do[ 7ao[ Sqo[ Sq[o! Vq",
+"o[ oVq[a r[ r[8 rV[ r[s [;oq [qo+ o[qD; o[+qD [;7o o[q> 7[oD; [>o7D [qS; o[",
+"+Sq oVq[; oV+[q r[; r[> V[r; V>r[ o[Yq Yqo[! oJq oaJq 7[Y Y87[ oJ7[ Ya7[ Sq",
+"[oY o[SYq! ]oq oq]a r[Y Y8r[ ]r ]rs vq[ [+vq Jqv oJgq 7[v 7[Y> vq7J 7[go Sq",
+"[v vq[S+ ]qv go]q r[v Y>r[ ]rv ]yr tq[ [q& qD[t cq[ [1tq [:q tq[1D [:cq tM[",
+"q [Mq& V[tq [cVq tq[l [l:q Vql[t uq[ t([q [qt+ tq[D( [+cq tq[1( [+:q [1Dtq(",
+" cq[:+ tq[M( tq+[M Vq[t( cqV[+ [lqt( [:lq+ [ltVq( [qu+ tqG [&qG Jqt cqJ t1q",
+"G tG:q J1tq :Jq tMqG tqGM& VqtJ cJVq tqlG [:lqG ltJq uJq [qtd q+tG tdJq cqg",
+"[ tqG1d [q:d Jqt1d :Jgq tqGdM tq+GM JqVtd cqJgV [ldtq [:dlq Jqltd gquJ t4[ ",
+"[&t4 tD[4 t4[c 7[t 7[: [t7D 7[c tM[4 t4[M& V[t4 cqV[4 [l7t l:7[ V[7t u7[ [q",
+"t; [4t+ tq;[D [qc; t;7[ 7[t> 7[tD; [>7c tq;[M t4[+M Vq;[t cq;V[ [l;7t [>l7t",
+" 7V[t; 7[u> [4tG tqG4& t4Jq c4Jq tG7[ 7G[: tJ7[ :J7[ tqG4M t4MqG& JqVt4 cqJ",
+"V4 7tG[l 7[:lG Jql7t 7Juq [4td tq+4G t;Jq t4g[ td7[ tGq> Jq;7t 7[gt tqGM; t",
+"4M[d& Jq;Vt cqJV; 7[dlt [:d7l Jqlt; g7u[ [qtP [Pq& tq[DP [qcP tq[1P [q:P [q",
+"1tPD cq[:P tqS[ [qS& Sq[Vt Sq[c Sq[lt Sq[: VqlSt[ Squ[ tq[P( tq+[P [qDtP( c",
+"q[+P [q1tP( [:q+P t1qD[P( [:+cqP Sq[t( St+[q Vq[St( Scq[+ [lqSt( S:[q+ SlVq",
+"[t( uS+[q tYq Y&tq JqtY Ycq Y1tq Yq[: JqtY1 cqY: YqSt Yq&St ]qt ]qc ltYq lY",
+"t:q lt]q ]uq tdYq t+Yq JqtYd tYgq tYq1d [:dYq tY1Jqd g[:Yq StdYq tY+Sq tq]d",
+" gq]t lYtqd [:dSq ]lqtd ]qug ot[ [qo& [toD o[cq ot7[ o:[ ot7[D oc7[ o[St ot",
+"[S& V[ot oVt[c r[t r[: V[rt ur[ t;o[ t+o[ ot[D; otc[+ ot7[; [>ot 7[Dot; cq>",
+"o[ ot[S; ot+S[ oVt[; oVt[+ t;r[ t>r[ rV[t; r[u> tYo Y&ot oJt otYc tY7 7[Y: ",
+"7JtY 7[Yc SotY tYoS& ]ot ot]c rtY tYr: ]rt ur] vqtY Y+ot oJtv tYgo 7[tv 7Yt",
+"> oJt7v tYg7 vq[St ot+SY tv]o go]t tYrv tYr> rt]v ]yur w w! wB wa w. w8 w.B",
+" w8a wK w!K wT wTa wj w8j wTj sw w* w+ w*B w+a w*. w+8 *Bw. 8*wa w*K w+K wT",
+"* w+T wj* w+j T*wj sw+ wG w!G wH wHa wG. w8G wH. wH8 wGK GKw! wHT GTwa wjG ",
+"G8wj wHj swG fw fw+ fwH gw fw. fw8 f.wH gw8 fwK fKw+ fwT gwT fwj w+fj wHfj ",
+"gws w4 w!4 w4B wa4 w5 w58 w5B w5a w4K 4Kw! wT4 4Twa w5j 48wj w5T sw4 w= w=+",
+" w=B =aw w=5 w> =Bw5 w>a w=K =Kw+ =Tw w+=T =jw w>j w5=T sw> w4G 4Gw! wH4 4G",
+"wa w5G 4Gw8 wH5 4Hw8 4GwK w!4GK 4GwT wH4Ta 4Gwj w5G8j 4Hwj wHs4 fw= w+f= =H",
+"w gw= fw5 w>f wHf5 gw> =Kfw fw=+K fw=T =Tgw fw=j fjw> wH=j s=gw wP w!P wPB ",
+"waP wP. w8P P.wB 8Pwa wQ wQ! wQT wQa wQj wQ8 TPwj swQ wP* w+P P*wB +Pwa P*w",
+". +Pw8 wP*.B w+a8P wQ* w+Q Q*wT +QwT Q*wj +Qw8 wQT*j w+sP Yw Yw! YwH Ywa Yw",
+". Yw8 Y.wH wHY8 YwQ Y!wQ Zw Zwa Ywj wQY8 Zwj sYw Yfw Yw+ wHYf gwY Y.fw fwY8",
+" YfwH. Y8gw fwQ w+fQ Zwf gwZ fwYj w+Yj fjZw sYgw ow ow! owB owa ow5 ow8 oBw",
+"5 w5oa owQ o!wQ owT wQoa pw pw8 pwT swo ow= ow+ =Bow ow=a w5o= w>o ow=5B oa",
+"w> =Qw w+=Q ow=T w+oT pw= pw> =Tpw pws= Ywo o!Yw owH owYa Yw5 owY8 wHY5 wHo",
+"8 wQoY YwoQ! Zwo oaZw pwY Y8pw Zwp osZw x x+ xH xg x5 x> xH5 xg> xQ x+Q xZ ",
+"xZg xp xp> xZp yx w, w& w,B wa& w,. w8& ,.wB ,8wa w,K w&K wT, wT& wj, w&j ,",
+"Twj sw& w*, -w *Bw, -wa ,*w. -w8 w*,.B -8wa ,*wK -wK ,Tw* -wT ,jw* -wj wT*,",
+"j sw- wG, w&G wH, wH& ,Gw. ,Gw8 ,Hw. ,Hw8 ,GwK G&wK ,GwT GTw& ,Gwj G&wj ,Hw",
+"j wHs, fw, -wf f,wH gw- w,f. f8-w fwH,. w8g- w,fK fK-w f,wT fT-w f,wj fj-w ",
+"fwT,j s-gw w4, w&4 ,4wB ,4wa w5, w5& ,5wB ,5wa ,4wK 4&wK ,4wT 4Tw& ,4wj 4&w",
+"j ,5wT w5s, w=, -w= w,=B =a-w =,w5 w>- w=5,B wa-> w,=K =K-w =,wT =T-w =,wj ",
+"=j-w =Tw,5 s-w> ,4wG 4Gw& ,4wH 4Hw& ,Gw5 G5w& ,Hw5 H5w& w4G,K w&4GK wH4,T w",
+"H&4T w5G,j w5&Gj wH5,T sw4,G =,fw f=-w =,wH -wg= f,w5 -wf> =Hw,5 g-w> fw=,K",
+" -wf=K =Hw,T -wTg= fw5,j w>f-j =Hw,j gws-> wP, w&P ,PwB ,awP ,Pw. ,8wP wP,.",
+"B w8a,P wQ, wQ& ,QwT ,Qwa ,Qwj ,Qw8 wQT,j wQs, ,Pw* -wP wP*,B wa-P wP*,. w8",
+"-P P*.w,B -w8aP ,Qw* -wQ wQT,* wQ-T wQ*,j wQ-j P*jwT, sP-w Yw, Yw& wHY, wHY",
+"& w,Y. w8Y& YwH,. Yw8,H wQY, wQY& Zw, Zw& wjY, w&Yj wjZ, s,Zw fwY, Y-w Yfw,",
+"H Y-gw Yfw,. Y8-w fwHY,. gwY-8 f,wQ fQ-w fwZ, Z-w Yfjw, Yj-w Zwf,j Y-sw ow,",
+" ow& w,oB wao& w5o, w5o& ow5,B ow8,a wQo, wQo& wTo, wTo& pw, pw& wTp, s,pw ",
+"w=o, o-w ow=,B oa-w ow=,5 w>o- w=5o,B o-w>a =,wQ =Q-w owT=, oT-w w=p, -pw p",
+"w=,T o-sw Y,o owY& oHY, oaY, o,Y5 o8Y, Yw5,H Yw5,a YQo, Yw&oQ Y,oZ owZ& Y,p",
+"w Y&pw Z,pw Y,os x, x- x,H xg- x,5 x-> ,Hx5 g-x> x,Q x-Q xZ, xZ- xp, xp- Zp",
+"x, yx- wI w!I wD wDa wI. w8I wD. wD8 wIK IKw! wDT TIwa wjI 8Iwj wDj swD wI*",
+" w+I wD* w+D I*w. +Iw8 D*w. +Dw8 I*wK +IwK D*wT +DwT I*wj +Iwj D*wj w+sI wG",
+"I GIw! Jw Jwa GIw. G8wI Jw. Jw8 GIwK w!GIK JwT JTwa GjwI w8GIj Jwj swJ fwI ",
+"fIw+ Jwf gwJ wIf. fIw8 J.fw J8gw wIfK fw+IK fTJw wTgJ fIwj fw8Ij fwJj sJgw ",
+"w4I 4Iw! wD4 4Dwa w5I 48wI w5D 4Dw8 4IwK w!4IK 4DwT wD4Ta 4Iwj w58Ij 4Dwj w",
+"5sI =Iw w+=I =Dw w+=D w5=I w>I w5=D w>D wI=K =Iw+K wD=T =Dw+T wj=I >Iwj wD=",
+"j =Dsw 4GwI w!4GI Jw4 waJ4 G5wI w5G8I Jw5 w5J8 w4GIK 4GIw!K wTJ4 Jw4Ta w5GI",
+"j 4G8wjI w5Jj s4Jw fw=I =Ifw+ J=w J=gw fIw5 >Ifw fwJ5 J>w =IfwK fw+=IK =TJw",
+" J=gwT =Ijfw w>fIj =jJw J>sw wIP IPw! wDP DPwa IPw. 8IwP DPw. D8wP wQI QIw!",
+" wQD QDwa QIwj Q8wI QDwj wQsI IPw* +IwP DPw* +DwP IP*w. w+8IP wDP*. w+D8P Q",
+"Iw* +QwI QDw* +QwD wQI*j w+Q8I wQD*j sw+QD YwI w!YI JwY YaJw wIY. YIw8 Y.Jw",
+" Y8Jw YIwQ YwQI! ZwJ waZJ YIwj Yw8QI YjJw sJZw YIfw YIw+ YfJw JwgY YfwI. Yf",
+"8wI YJfw. Jw8gY fIwQ Yw+QI JwZf gZJw YfjwI Yw+Ij JwjZf gwZsJ owI w!oI owD w",
+"Doa w5oI w8oI w5oD wDo8 wQoI owQI! wQoD owDQa pwI w8pI pwD sIpw =Io o+=I ow",
+"=D oa=I =5oI =Io> owD=5 oDw> oI=Q ow+QI oT=I ow+QD =Ipw pIw> =Dpw =Ios oIYw",
+" YwoI! oJw oaJw YIw5 Yw58I Y5Jw o8Jw YwoQI oIQYw! oJZw oJZwa pIYw pwY8I Jpw",
+" oJsw xI x+I xJ xJg x5I x>I xJ5 xJ> xQI +QxI xZJ gZxJ xpI p>xI xJp yxJ hw h",
+"w& hwD cw hw. hw8 h.wD cw8 hwK hKw& hwT cwT hwj w8hj wDhj hsw hw* -wh h*wD ",
+"cw- w*h. h8-w hwD*. w8c- w*hK hK-w h*wT hT-w h*wj hj-w hwT*j s-cw hwG hGw& ",
+"Jwh cwJ wGh. hGw8 h.Jw h8Jw wGhK hwG&K hTJw wTcJ hGwj hw8Gj hjJw sJcw hfw h",
+"f-w hfJw iw h.fw fwh8 Jwhf. iw8 hKfw -whfK fwhT iwT fwhj -wjhf Jwjhf isw hw",
+"4 w&h4 wDh4 cw4 hw5 w5h8 wDh5 cw5 w4hK hw4&K wTh4 wTc4 w5hj hw5&j w5hT h4sw",
+" h=w -wh= hw=D cw= w=h5 h>w h=w5D cw> =Khw h=-wK hw=T =Tcw hw=j hjw> h=Tw5 ",
+"swh> w4hG hw4G& h4Jw c4Jw hGw5 hw5G8 h5Jw c5Jw hw4GK w&Gh4K Jwh4T cwJ4T hw5",
+"Gj h4Gw&j Jw5hT cw5sJ fwh= h=f-w Jwh= iw= fwh5 hfw> J=hw5 iw> h=fwK -wfh=K ",
+"J=hwT =Tiw h=jfw h>wfj J=jhw swi> hwP w&hP wDhP cwP wPh. w8hP hwDP. w8cP hw",
+"Q w&hQ wQhT cwQ wQhj wQh8 hwQDj hQsw wPh* hP-w hwDP* cP-w hwP*. -wh8P wD*hP",
+". cw-8P h*wQ hQ-w hwQD* cQ-w hwQ*j -wQh8 hQ*wDj cwQs- hYw Y&hw JwhY Ycw h.Y",
+"w Ywh8 hYJw. Y8cw YwhQ hYwQ& hZw Zwc Ywhj hY8wQ hjZw swhZ Yfhw -whY hYJfw i",
+"Yw hYfw. hY8-w JwfhY. Ywi8 fwhQ -wQhY hfZw iZw hYjfw Y-jhw hZwfj sYiw oh oh",
+"& ohD ohc oh5 oh8 oDh5 h5oc ohQ o&hQ ohT hQoc hpo h8pw hTpw hso oh= oh- =Do",
+"h c=oh o=h5 h>o oh=5D och> =Qoh hQo- =Toh =Qcw h=pw o-hp ohTp= ohs= ohY Y&o",
+"h oJh ohYc Ywh5 Y8oh h5oJ h8oJ oYhQ ohYQ& hZo ochZ hYpw oh8Yp Zwhp oJhs xh ",
+"xh- xJh ix xh5 xh> hJx5 ix> xhQ h-xQ xZh ixZ xph hpx- hZxp ixy w6 w!6 w6B w",
+"a6 w1 w18 w1B w1a w6K 6!wK wT6 6Twa w1j 68wj w1T sw6 w6* w+6 6*wB 6+wa w1* ",
+"w1+ 1*wB 1+wa 6*wK 6+wK 6Tw* 6+wT 6*wj 6+wj 1Tw* w1s* w6G 6Gw! wH6 6Gwa w1G",
+" 6Gw8 w1H 6Hw8 6GwK w!6GK 6GwT wH6Ta 6Gwj w1G8j 6Hwj w1sG fw6 w+f6 wHf6 gw6",
+" fw1 w1f8 wHf1 gw1 w6fK fw6+K wTf6 wTg6 w1fj fw1+j w1fT g6sw w46 6!w4 46wB ",
+"4aw6 7w 7w8 7wB 7wa 46wK w!46K 4Tw6 wT46a 7wj 78wj 7wT sw7 w=6 =6w+ w6=B =6",
+"wa 7w= w>7 =B7w =a7w w6=K w=6+K =6wT =Tw6+ =j7w wj7> =T7w 7sw> 4Gw6 w!46G 4",
+"Hw6 wH46a 7wG w87G 7wH wH7a w46GK 4G6w!K wH46T 4GTwa6 wj7G 7wG8j wH7T sG7w ",
+"w=f6 fw=6+ =6wH w=g6 7fw w>7f =H7w g7w fw=6K w=+f6K =Hw6T gw=6T fj7w w>7fj ",
+"fw7T swg7 w6P 6Pw! 6PwB 6awP w1P 68wP 1PwB 1awP wQ6 6Qw! 6QwT 6Qwa w1Q 6Qw8",
+" 1QwT w1sP 6Pw* 6+wP w6P*B w+6aP 1Pw* 1+wP w1P*B w1+aP 6Qw* 6+wQ wQ6T* w+Q6",
+"T 1Qw* 1+wQ w1QT* sw6+Q Yw6 w!Y6 wHY6 waY6 Yw1 w1Y8 wHY1 w1Ya wQY6 Yw6Q! Zw",
+"6 waZ6 w1Yj Yw1Q8 Zw1 s6Zw Yf6 f6Y+ YHf6 Yfg6 fwY1 f6Y8 Yf61H Ywg1 fQY6 Yf6",
+"+Q Y6Zf g6Zw f6Yj Yf6+j fwZ1 g1Zw ow6 w!o6 w6oB o6wa 7wo o87w 7Bow ow7a o6w",
+"Q ow6Q! o6wT owT6a pw7 w87p 7Tpw 7spw =6ow o6w+ ow=6B ow+6a ow7= o>7w 7o=wB",
+" w>o7a =6wQ ow+6Q owT=6 ow+6T p=7w 7pw> pw7=T pw>7s owY6 Ywo6! o6wH Ywao6 7",
+"Yw Y87w 7HYw Ya7w Ywo6Q owQY6! owZ6 Zwo6a pw7Y pw7Y8 7Zw 7Zsw x6 x6+ x6H xg",
+"6 x7 x7> x7H xg7 x6Q 6+xQ xZ6 gZx6 xp7 7px> xZ7 yx7 ?w ?w& ?wB ?wa ?w1 :w ?",
+"Bw1 :wa ?wK ?Kw& ?wT wT?a ?wj :wj w1?T s?w ?w* -w? w*?B ?a-w ?*w1 :w- ?w1*B",
+" wa:- w*?K ?K-w ?*wT ?T-w ?*wj ?j-w ?wT1* s-:w ?wG w&?G ?wH wH?a w1?G :wG w",
+"1?H :wH wG?K ?wG&K wH?T ?wHT& wj?G wj:G wH?j sG:w ?fw -w?f fw?H g?w f1?w :f",
+"w ?wHf1 gw: ?Kfw ?f-wK fw?T ?Tgw fw?j fj:w ?fTw1 s?gw ?w4 ?4w& w4?B ?4wa 7w",
+"? :w7 7B?w ?a7w w4?K ?w4&K ?4wT ?wT4a ?j7w wj7: ?T7w 7s:w ?w= ?=-w =B?w ?w=",
+"a ?=7w Aw ?w=7B Awa =K?w ?w=-K ?w=T -wT?= ?w=j Awj 7wT?= Asw w4?G ?w4G& ?4w",
+"H ?wH4a ?G7w 7G:w ?H7w 7H:w ?w4GK w&4?GK ?wH4T ?G4wT& ?wj7G :w7Gj 7wH?T :wH",
+"7s fw?= ?w=f- ?w=H ?wg= 7w?f Afw 7wH?f Agw ?w=fK -w=?fK ?fTw= g?w=T ?fj7w f",
+"wAj 7fT?w gwAs ?wP w&?P wP?B wa?P w1?P :wP ?w1PB wa:P ?wQ w&?Q wQ?T wQ?a w1",
+"?Q :wQ ?wQ1T sP:w wP?* ?P-w ?wP*B ?-Pwa ?w1P* :P-w w1*?PB :w-aP ?*wQ ?Q-w ?",
+"wQT* -wQ?T ?wQ1* :Q-w ?Q*w1T :wQs- ?Y ?Y& ?YH ?Ya ?Y1 ?Y: Y1?H ?HY: ?YQ Y&?",
+"Q ?ZY ?aZw ?Yj ?QY: ?jZw s?Y ?Yf ?Y- Yf?H g?Y Y1?f :f?Y ?Yf1H Y:g? Yf?Q ?QY",
+"- ?fZw ?Zgw Yf?j ?jY- ?ZYf1 sYg? o?w o&?w ?Bow ow?a o?7w :wo 7wo?B oa:w ow?",
+"Q ?wQo& ow?T o?Twa ?pw :wp ?Tpw ?psw ow?= -wo? ?w=oB o-?wa ?w=7o Aow o?=7wB",
+" owAa ?w=Q o-?wQ o?Tw= o-T?w ?wp= Apw ?pw=T swAo ?Yo Y&o? oY?H Yao? ?Y7 :w7",
+"Y ?H7Y ?a7Y oY?Q ?YoQ& o?Zw ?ZoYa ?pY Y:?p 7Z?Y ?psY x? x?- x?H x?g x?7 Ax ",
+"?Hx7 Axg x?Q ?-xQ x?Z g?xZ x?p Axp ?Zxp Axy w6I 6Iw! wD6 6Dwa w1I 68wI w1D ",
+"6Dw8 6IwK w!6IK 6DwT wD6Ta 6Iwj w18Ij 6Dwj w1sI 6Iw* 6+wI 6Dw* 6+wD 1Iw* 1+",
+"wI 1Dw* 1+wD w6I*K w+6IK wD6T* w+D6T w1I*j w1+Ij w1DT* sw6+D 6GwI w!6GI Jw6",
+" waJ6 1GwI w1G8I Jw1 w1J8 w6GIK 6GIw!K wTJ6 Jw6Ta w1GIj 6G8wjI w1Jj s6Jw w6",
+"fI fw6+I fwJ6 g6Jw fIw1 fw1+I fwJ1 g1Jw fw6IK w+If6K Jwf6T gwJ6T fw1Ij f6Iw",
+"+j Jw1fT gwsJ6 4Iw6 w!46I 4Dw6 wD46a 7wI w87I 7wD wD7a w46IK 4I6w!K wD46T 4",
+"TIwa6 wj7I 7w8Ij wD7T sI7w w6=I =Iw6+ =6wD =Dw6+ =I7w 7Iw> =D7w 7Dw> =Iw6K ",
+"w+6=IK =Dw6T =D6w+T 7w=Ij w>7Ij 7wD=T w>D7s w46GI 4G6w!I w4J6 Jw64a wG7I 7w",
+"G8I 7Jw 7aJw 4G6wIK 6!w4GIK Jw64T wT4J6a 7wGIj w8G7Ij 7TJw 7Jsw =Ifw6 fw6=I",
+"+ w=J6 J=gw6 fw7I w>7fI 7wJ= 7Jgw fw6=IK =6w+fIK J=w6T gw6J=T 7fwIj 7fIw>j ",
+"J=j7w J>w7s 6IwP w!6IP 6DwP wD6aP 1IwP w18IP 1DwP w1D8P 6QwI wQ6I! 6QwD wQD",
+"6a 1QwI w1Q8I 1QwD sw6QD IP6* w+6IP wD6P* w+D6P w1IP* w1+IP w1DP* w1+DP wQ6",
+"I* w+Q6I wQD6* w+Q6D w1QI* w1+QI w1QD* sIP6* w6YI Yw6I! Y6Jw YJ6wa YIw1 Yw1",
+"8I Y1Jw Jw1Y8 Yw6QI wQIY6! Z6Jw ZwJ6a Yw1QI Y6IwQ8 Z1Jw sYwJ6 YIf6 Yf6+I Jf",
+"Y6 gY6Jw Yf61I Yf68I Jw1Yf gw1YJ Yf6QI Y6Iw+Q Zf6Jw gwZJ6 Yf6Ij Y6IfQ8 Zw1J",
+"f gwZJ1 w6oI ow6I! o6wD owD6a ow7I 7oIw8 ow7D 7wDo8 ow6QI wQ6oI! owD6Q oD6w",
+"Qa 7Ipw pw78I 7Dpw osI7w =6oI ow+6I owD=6 ow+6D 7o=I w>o7I 7wDo= w>D7o =Qw6",
+"I o+6=QI oTI=6 o+6=TI pw7=I pw>7I pwD7= osI7= Ywo6I owIY6! J6ow oJw6a 7IYw ",
+"7Yw8I 7woJ oJ87w owQY6I o!Yw6QI oJZw6 Zw6oJa pw7YI 7Y8pwI Zw7J oJs7w x6I 6+",
+"xI xJ6 gJx6 x7I 7>xI xJ7 g7xJ 6QxI x6+QI ZJx6 xZJg6 7pxI xp7>I 7ZxJ x7yJ h?",
+"w w&h? ?wD cw? hw1 :wh w1?D :wc ?Khw ?w&hK ?whT ?Tcw ?whj hj:w w1hT :whs h*",
+"?w h?-w ?*wD -w?c h*w1 -wh: ?wD1* :c-w ?w*hK -w?hK ?wDT* cw?-T ?wjh* :wh-j ",
+"?wD*j :wcs- ?Ghw ?wGh& ?Jw cw?J hGw1 :Ghw h1Jw :Jw ?wGhK hw&?GK ?TJw cw?JT ",
+"?wjhG :whGj ?jJw ?Jsw hw?f ?fh-w Jw?f i?w fwh1 hf:w Jw1?f i:w ?fhwK -wh?fK ",
+"?fTJw ?wiT ?fjhw :fwhj ?Jjfw s?iw ?wh4 ?w4h& ?4wD c4?w 7hw :w7h ?D7w 7cw ?w",
+"4hK h4&?wK ?wD4T cw?4T hj7w :w7hj hT7w 7hsw ?wh= ?w=h- ?w=D ?wc= 7wh= Ahw 7",
+"wDh= Acw ?w=hK -w?h=K h=T?w cw=?T h=j7w hwAj 7hTw= hsAw ?w4hG hw4?G& J4?w c",
+"w?J4 7Ghw :w7hG 7w?J :w7J hw4?GK hGw&?4K ?Jw4T ?J4cwT 7hwGj 7hG:wj ?J7wT hs",
+"7Jw ?w=hf ?f-h=w ?wJ= ?wi= hf7w hfAw ?J7fw Aiw ?fwh=K =K?f-wh ?J=wT i?w=T 7",
+"hfwj Ahjfw J=j?w isAw h?P h&?P ?DhP hP?c ?Ph1 hP:w ?wD1P :Pcw ?whQ ?wQh& ?T",
+"hP ?Qcw ?Phj hQ:w ?wQ1D hPs? h*?P ?-hP ?wDP* cw?-P h?P1* :wh-P ?D*h1P :wc-P",
+" ?wQh* -wQh? ?wQD* cwQ?- ?Pjh* :wQh- ?Q*w1D :wc-Q ?Yh Y&h? ?JY ?Yc h1?Y hY:",
+"w Y1?J Y:?J hQ?Y ?YhQ& ?YhZ Yc?Z hj?Y :wQhY h1Zw ?JsY ?fhY h?Y- YJ?f i?Y hY",
+"1?f ?Y:hf ?JYf1 ?Yi: ?fQhY ?Y-hQ hZ?Yf ?ZiY ?Yjhf :wQhf hZwf1 s?iY oh? o&h?",
+" ?Doh ?coh 7ho oh: 7Doh oh7c hQo? oh?Q& hTo? ohc?Q oh?p :whp ?Dpw ohs? o?h=",
+" h?o- oh?=D ohc?- 7oh= Aoh 7ho=D ohAc oh?=Q oh-?Q ohT?= oh-?T hpo?= hpAo oh",
+"T7= hsAo oh?Y oh?Y& ?Jo oc?J 7hY 7hY: 7J?Y 7hYc oh?YQ ?YQoh& oJ?Z hZo?c ?Yh",
+"p :wphY 7YhZ Yc?p x?h h?x- x?J ix? x7h Axh ?Jx7 Aix h?xQ x?h-Q hZx? x?iZ hp",
+"x? xpAh hZx7 yAix wR w!R wRB waR wR. w8R R.wB R8wa wM wM! wTR waM wMj w8M R",
+"Twj swR wR* w+R R*wB R+wa R*w. R+w8 wR*.B w+R8a wM* w+M RTw* R+wT R*wj R+wj",
+" wTR*j w+sR wRG RGw! wHR RGwa RGw. RGw8 RHw. RHw8 wMG GMw! wHM GawM RGwj G8",
+"wM RHwj wHsR fwR w+fR wHfR gwR wRf. w8fR fwRH. w8gR fwM w+fM wHfM gwM wMfj ",
+"w8fM fwTRj gRsw wR4 R4w! R4wB R4wa w5R R4w8 R5wB R5wa wM4 4Mw! R4wT 4awM w5",
+"M 48wM R5wT w5sR =Rw w+=R wR=B wa=R w5=R w>R =Rw5B >Rwa =Mw w+=M wT=R wa=M ",
+"w5=M w>M =RTw5 >Msw R4wG w!R4G R4wH wHR4a RGw5 w5RG8 RHw5 wH5R8 4GwM wM4G! ",
+"4HwM wHM4a G5wM w5MG8 H5wM swR4G =Rf =+fR fR=H =Rgw f5=R =Rf> =RfH5 gRw> fw",
+"=M =Rf+M fR=T =Mgw fR=j fw>M =RfHj >Mgw wRP RPw! RPwB RawP RPw. R8wP wRP.B ",
+"w8RaP Sw Sw! SwT Swa Swj Sw8 STwj swS R*wP R+wP wRP*B w+RaP wRP*. w+R8P P*.",
+"wRB aP*w8R Sw* Sw+ wTS* w+Sa wjS* w+S8 SwT*j s*Sw YwR w!YR YRwH YRwa wRY. Y",
+"Rw8 YwRH. Yw8RH SwY S!Yw ZwS SaZw YjSw YwS8 wjSZ SsZw fRYw YRw+ YfwRH YwgR ",
+"YfwR. Yf8wR fRHYw. gwYR8 Sfw YwS+ ZwSf gwS fjSw fwS8 SfZwj swgS owR w!oR wR",
+"oB oRwa oRw5 oRw8 owR5B ow8Ra Swo S!ow oTSw owSa pwS S8pw wTSp Sspw ow=R oR",
+"w+ ow=RB ow+Ra ow=R5 >Row =R5owB w>oRa S=w owS+ =TSw =aSw pwS= S>w pw=ST S>",
+"sw YRow YwoR! oRwH YwaoR YRw5 Yw5R8 Yw5RH Yw5Ra YwSo SwoY! oZSw SwaoZ YpSw ",
+"pwYS8 SZpw sYoSw xR xR+ xRH xgR xR5 x>R RHx5 g>xR xS xS+ xZS xgS xpS x>S SZ",
+"xp yxS wR, w&R ,RwB ,Rwa ,Rw. ,Rw8 wR,.B w8R,a wM, wM& ,RwT ,awM ,Rwj ,8wM ",
+"wTR,j wMs, ,Rw* -wR wR*,B wa-R wR*,. w8-R ,R*w.B -wR8a ,Mw* -wM wTR,* wT-R ",
+"wM*,j w8-M ,RTwj* sR-w ,RwG RGw& ,RwH RHw& wRG,. w8R,G wHR,. wH8,R ,GwM GMw",
+"& ,HwM HMw& wMG,j w8M,G wHM,j swR,G wRf, fR-w fwR,H gR-w fwR,. -wfR8 wH,fR.",
+" gw-R8 f,wM fM-w fwT,R gM-w fwM,j -wMf8 fR,wHj gws-R ,Rw4 R4w& wR4,B waR,4 ",
+",Rw5 R5w& w5R,B w5a,R ,4wM 4Mw& wTR,4 wT&R4 ,5wM 5Mw& w5T,R swR,4 wR=, =R-w",
+" =Rw,B -w=Ra =Rw,5 -Rw> w5,=RB w>-Ra =,wM =M-w =RTw, -wT=R =Rjw, >M-w =R,w5",
+"T w>Ms- R4,G w&R4G wHR,4 wH&R4 w5R,G w5&RG wH5,R wH5R& wM4,G wM&4G wHM,4 wH",
+"M4& w5M,G w5MG& wH5,M wH5M& =,fR f-=R =Rf,H g=R-w =Rf,5 w>f-R =R,wH5 gw>-R ",
+"=Rf,M -wMf= =Rf,T gwM-= =Rf,j w>Mf- =R,f5T w>Mg- ,RwP R&wP wRP,B waR,P wRP,",
+". w8R,P ,RPw.B ,R8waP Sw, Sw& wTS, wTS& wjS, w8S& SwT,j s,Sw wRP,* wR-P P*B",
+"wR, -wRaP P*.wR, -wR8P ,RwBP*. w8R-Pa w*S, S-w SwT,* Sa-w Sw*,j S8-w wT*S,j",
+" S-sw wRY, YRw& YwR,H Ywa,R YwR,. Yw8,R wHRY,. Y8RwH& YwS, YwS& S,Zw S&Zw S",
+"Y,wj Sw8Y& ZwS,j sYwS& Yfw,R -RYw fwRY,H gwY-R fwRY,. Y-wR8 ,Hw.YfR Y-Rgw8 ",
+"fwS, SwY- SfZw, S-gw Sfw,j Sf-w8 ZwjSf, gwSs- wRo, oRw& owR,B owa,R owR,5 o",
+"w8,R w5Ro,B oaRw5& owS, owS& Swo,T Swao& S,pw S&pw pwS,T os,Sw ow=,R -Row =",
+"R,owB o-wRa =R5ow, o-w>R =Bow,R5 w>Ro-a w=S, Swo- S=w,T o-TSw pw=S, pwS- S=",
+"Tpw, os-Sw YRo, Yw&oR Y,oRH Yao,R Yw5,R Yw5R& Y5RoH, Y5Roa, Y,So Sw&oY oZ,S",
+"w Zw&So pwYS, pw&SY ZwpS, os,SY x,R x-R ,RxH g-xR ,Rx5 ->xR x,RH5 xg->R xS,",
+" x-S SZx, gSx- Spx, S-xp xZpS, y-xS [w [w! [wD [wa [w. [w8 w.[D [8wD [wM [!",
+"wM Vw Vwa [wj [8wM Vwj swV [w* [w+ [*wD wD[+ w.[* w8[+ [wD*. [w+D8 [*wM wM[",
+"+ Vw* Vw+ [*wj wj[+ wjV* s*Vw [wG wG[! Jw[ wa[J w.[G wG[8 J.[w [wJ8 [GwM [w",
+"GM! VwJ waVJ wG[j [w8GM JjVw sJVw [fw w+[f [fJw g[w f.[w [wf8 Jw[f. w8g[ [w",
+"fM [fw+M Vfw gwV [wfj [f8wM fjVw swg[ [w4 w![4 wD[4 wa[4 [w5 w8[4 [5wD wa[5",
+" wM[4 [w4M! Vw4 waV4 wM[5 [w58M Vw5 s4Vw [= [=+ [=D [=a [=5 [>w [5=D =D[> [",
+"=M [+=M Vw= =aVw [=j >M[= =jVw s=[ wG[4 [w4G! [wJ4 Jw[4a wG[5 [w5G8 [wJ5 Jw",
+"5[8 [w4GM wMG[4! J4Vw VwJ4a [w5GM [4Gw8M J5Vw Vw5sJ [=f [+f= J=[ g[= f5[= f",
+">[= J5[= [>gw =M[f [=f+M VwJ= V=g[ =j[f [>f=M Jj[= s=g[ [wP wP[! wP[D wP[a ",
+"[Pw. wP[8 [wDP. [w8DP Sw[ S![w VwS SaVw wjS[ [wS8 wjSV SsVw wP[* wP[+ [wDP*",
+" [w+DP [wP*. [w+8P [*PwD. [+PwD8 [wS* [wS+ S*Vw S+Vw S[*wj Sw+[8 VwS*j Vw+S",
+"s Yw[ [!Yw [JYw [wYa Y.[w [wY8 Yw[J. Jw8[Y YwS[ Yw[S! ]w ]wa [wYj Sw8[Y ]wj",
+" ]sw Yw[f [wY+ YJf[w Ywg[ Yw[f. [f8Yw [fYJw. g[wY8 [fSw Sw+[f ]fw ]gw [fjSw",
+" Sf8[w fw]j gw]s o[w o![w [woD [woa w5o[ [wo8 o[w5D o[8wD o[Sw Swo[! oVw oa",
+"Vw pw[ w8[p Vwp oVsw [=o o+[= =Do[ =ao[ [5o= o[w> [=o5D [>o=D S=[ S+[= VwS=",
+" S[=a [p= [>S= pwV= VwS> Ywo[ Yw[o! Jwo[ oJ[wa [wY5 o[8Yw oJ[w5 oJ8[w Yw[So",
+" o[YSw! ]ow ow]a Yw[p pw[Y8 ]pw sw]o x[ x[+ xJ[ xg[ x[5 x[> J5x[ g[x> x[S S",
+"[x+ ]x ]xg xp[ S>x[ ]xp ]yx hw[ [w& wD[h cw[ h.[w [wh8 hw[D. w8[c hwM w&hM ",
+"Vwh cwV [whj w8hM hjVw Vwhs [*hw [-w hw[D* [-cw hw[*. w8[- wD*[h. cw[-8 h*w",
+"M hM-w V*hw V-w hwM*j [w-j Vwh*j V-sw hG[w wG[& [Jhw [cJw hw[G. hw8[G Jw[h.",
+" cwJ[8 hGwM hwMG& VhJw cJVw hwMGj hw8GM VwJhj cwVsJ hw[f [f-w Jw[hf i[w [fh",
+"w. [-fw8 [fhJw. [wi8 fwhM [-fwM hfVw iVw [fjhw [-jfw Vfwhj swiV h4[ w&[4 hD",
+"[4 h4[c [wh5 [4h8 hw5[D [wc5 [4hM hwM4& h4Vw c4Vw [4hj hw58M h5Vw h4[s [=h ",
+"[-= [h=D c=[ h5[= w>[- [=h5D [>cw hw=M =M[- h=Vw Vwc= hj[= =j[- Vw=h5 Vwh> ",
+"hG[4 h4[G& [Jh4 cwJ[4 hw5[G h4[G8 Jw5[h cw5[J hwM4G h4GwM& VwJh4 cwVJ4 hw5G",
+"M h4Gw8M Vw5hJ cwVJ5 [fh= f-[= hJ[= i[= [=hf5 [-=f> J=[h5 [>iw [=hfM [-=fM ",
+"J=Vhw Vwi= [=jhf [-=fj J=[hj s=i[ [whP wP[& hw[DP [wcP hw[P. hw8[P hPD[w. c",
+"w[8P Shw S&hw VwSh Scw hjSw h8Sw VwhSj Shsw hw[P* [w-P hPD[w* cw[-P hP*[w. ",
+"[-w8P h*wD[P. [-8cwP S*hw Sw[- VwhS* cwS- Shw*j [-jSw Sh*Vwj V-wSs [hYw [wY",
+"& hYJ[w Yw[c hY[w. hY8[w Jw[hY. Ycw[8 SwhY Sw&hY ]hw ]cw hYjSw Sh8Yw hw]j h",
+"s]w hY[fw Yw[- Jw[hYf Ywi[ [fwhY. Y-[w8 h.Jw[fY i[Yw8 hfSw Shf-w hf]w ]iw S",
+"hfwj [-jYw ]hfwj iw]s oh[ [ho& [hoD o[cw h5o[ h8o[ oh[5D ohc[5 Sho S&oh oVh",
+" ohSc pwSh Soh8 oVhp oVhs [=oh o-[ oh[=D [-oc oh[=5 [>oh [=5ohD cw>o[ Sh= o",
+"hS- V=Sh cwS= S=hp S=h> oVhp= Shs= o[hY oh[Y& hJo[ oJh[c oh[Y5 oh8[Y oJh[5 ",
+"oJh[8 SohY ShoY& ]oh oh]c pw[hY oh8SY hp]o hs]o x[h x[- hJx[ ix[ h5x[ h>x[ ",
+"xJ[h5 x[i> xhS Shx- ]xh ]ix hpx[ h>xS xp]h ix]y wq wq! wqB wqa wq1 wq8 q1wB",
+" q8wa wqM q!wM wqT qTwa lw lw8 lwT lws wq* wq+ wBq* q+wa q*w1 q+w1 wq1*B wq",
+"+1a q*wM q+wM q*wT q+wT lw* lw+ wTl* l+sw wqG w!qG wqH qGwa qGw1 qGw8 qHw1 ",
+"qHw8 qGwM wqGM! qGwT wqHaM lwG w8lG lwH lGsw fq fq+ fqH gqf fq1 fq8 qHf1 g1",
+"fq fqM q+fM fqT gMfq lfq l+fq lHfq glw wq4 w4q! q4wB w4qa 7wq w87q 7Bwq wq7",
+"a q4wM wq4M! w4qT wqT4a lw7 w87l 7Tlw 7slw q=w w+q= =Bwq wq=a q=7w w>q 7wq=",
+"B waq> wq=M q=w+M wq=T q=Tw+ lw= lw> =Tlw swl= w4qG wq4G! w4qH wqH4a wq7G 7",
+"qGw8 wq7H 7wHq8 wq4GM qG4wM! wqH4T wT4qGa lG7w lw7G8 lH7w lws7G fq= q+f= =H",
+"fq g=fq 7fq fq> 7Hfq 7fgq =Mfq fq=+M =Tfq fqTg= 7flw w>lf =Hlw g7lw wqP wPq",
+"! qPwB wPqa q1wP wPq8 wq1PB wq8aP Swq S!wq wTSq wqSa lwS S8lw wTSl Sslw wPq",
+"* wPq+ wqP*B wq+aP wq1P* wq+1P q*Pw1B w1Pqa* wqS* wqS+ Sq*wT Sw+qT l*Sw l+S",
+"w lwST* lwsS+ Yqw q!Yw wHYq wqYa wqY1 wqY8 Yw1qH Yq8wH YqSw SwqY! Zqw waZq ",
+"lYw Y8lw lwZ sYlw fqY Y+fq qHYf gYfq Y1fq Y8fq fqY1H fq8gY Sfq S+fq Zqf Sfg",
+"q Sflw S8fq Zqlf gwlY oqw o!wq oBwq wqoa oq7w wqo8 7woqB 7waoq oqSw Swoq! w",
+"qoT Swaoq rw rw8 rwT rsw owq= wqo+ q=owB q=aow 7o=wq oqw> q=o7wB w>qoa q=Sw",
+" Sw+q= q=TSw S=awq rw= rw> =Trw swr> oqYw Yqow! wqoH Yqaow 7wYq Yq87w 7wHYq",
+" 7Yawq SwoYq YqoSw! oqZw Zqwoa rYw Ywr8 rZw sYrw xq xq+ xqH xqg xq7 xq> 7qx",
+"H gqx7 xqS Sqx+ xZq gqxZ xr xr> xrZ yxr ?qw wq& ?Bwq wq?a w1?q :wq ?qw1B wa",
+":q ?wM w&?M wq?T wa?M lw? lw: ?Tlw s?lw q*?w -qw ?qw*B wa-q ?qw1* -q:w w1*?",
+"qB :wq-a ?*wM ?M-w ?qTw* wq-T ?wl* l-w lw?T* swl- ?qG qGw& wq?H qG?a ?1qG ?",
+"G:q ?qG1H wq:H wM?G ?qGM& wH?M ?qGT& ?qlG lG:w ?wlH lH:w fq? fq- ?Hfq fqg? ",
+"f1?q :fq fq?1H :fgq ?Mfq fM-q ?Tfq ?wgM ?flw :flw fqTl? lwg? ?4wq w4q& ?qw4",
+"B ?qaw4 ?q7w :q7w ?q7wB :wq7a ?4wM ?wM4& ?qTw4 ?wa4M l?7w l:7w 7wTl? lws7? ",
+"?wq= q=-w ?w=qB -qw=a ?q7w= Aqw q=?7wB wqAa ?w=M -qw=M q=T?w -qTw= ?wl= Alw",
+" lw=?T lwAs ?4qG ?qG4& ?qG4H ?qG4a 7q?G :wq7G 7wH?q :wH7q ?qG4M ?G4wM& ?qG4",
+"T ?G4waM lw?7G lw:7G lwH7? :wH7l q=?f f-q= fq?=H fq-g= ?q7f Aqf 7fq?H gqAf ",
+"fq?=M fq-=M fqT?= fq-=T lf?7w lfAq fqT7? glAw wq?P wPq& ?qwPB ?qawP ?qw1P w",
+"q:P wq1?PB :wqaP S?w S&?w ?TSw ?aSw S?lw S:w lw?ST S?sw ?qwP* wq-P wq*?PB -",
+"qwaP wq1?P* :wq-P ?Bwq1P* -qa:wP S*?w Sw-q S?wT* -qTSw lw?S* S-lw S?Tlw* l-",
+"wSs ?Yq Y&?q ?HYq ?aYq Y1?q Yq:w ?Yq1H :wHYq S?Y S&?Y Zq?Y ?aSY lY? ?YS: ?Z",
+"lY s?lY fq?Y Y-q fq?YH ?Ygq fq?Y1 fqY: ?Y1fqH g?Y:q S?f S-?Y Sf?Z S?gw S?lf",
+" ?Yl- lY?Zf g?lY oq?w wqo& o?qwB o?awq ?q7ow oq:w o?q7wB :woqa o?Sw Sw&o? o",
+"?TSw S?aow r?w r:w ?wrT s?rw ?w=oq oq-w q=wo?B o-qwa o?q7w= oqAw =B7wo?q Ao",
+"awq ?wS= o-qSw S?=wT o-qwT ?wr= Arw r=T?w rsAw o?Yq Yq&o? o?HYq ?Yaoq ?q7Y ",
+":woYq ?Y7qH :woqH So?Y S?Yo& S?ZoY S?Yoa r?Y ?Yr: ?ZrY s?rY x?q xq- ?qxH g?",
+"xq ?qx7 Axq x?q7H xqAg x?S S?x- S?xZ g?xS xr? Axr r?xZ yxAr [qw [!wq wqD wa",
+"[q [w1 w8[q wD[1 wa[1 wM[q [qwM! Vwq waVq lw[ w8[l lwV Vwsq [q* w+[q [*qD q",
+"+wD [*w1 [1w+ [q*1D [q8D* [Mq* [q+wM [qV* wqV+ [ql* [wl+ l*Vw l+Vw qG[w [qw",
+"G! Jqw waJq wG[1 [q8wG [wJ1 wqJ8 [qwGM wMG[q! VwJq JqVwa [wlG lw[G8 lwJ Jqs",
+"w fq[ [+fq Jqf Jqgw [qf1 [qf8 J1fq J8fq [qfM fq[+M fqV Vfgq [lfq fq8[l Jqlf",
+" g[lw [4wq [qw4! w4qD [qaw4 7[w w87[ [w7D [w7a [qw4M [4Mwq! wqV4 Vwq4a 7[lw",
+" lw7[8 7Vw 7Vsw [=q [+q= [q=D [q=a 7[= w>7[ =D7[ =a7[ [q=M [=q+M Vq[= Vw=q+",
+" l=[ [>lw Vwl= 7[s= [qw4G [4Gwq! wqJ4 Jqw4a [w7G 7[wG8 7wJq Jq87w [4GwqM [!",
+"wq4GM JqVw4 Vw4Jqa lw7[G 7[Glw8 7Jlw lwJ7s [=fq fq[=+ Jq= J=gq 7[f [>7f Jq7",
+"f 7[gw fq[=M [=+fqM V=Jq Jq=gV 7[lf fq>[l Jql= g[l= wP[q [qwP! wPqD [qawP w",
+"P[1 [q8wP [w1DP [w1aP [qSw Sq[w! VqSw VwqSa [lSw Sw8[l SlVw lwVSs [Pq* [q+w",
+"P [q*DP [qaP* [q*1P [q8P* w1PqD* w1P[a* [qS* Sw+[q VwqS* Vw+Sq lw[S* lw+S[ ",
+"lwVS* Vw+Sl [qYw Yw[q! JwYq JqYwa [wY1 Yq8[w JqYw1 Jq8Yw Sq[Yw Yq[Sw! ]qw w",
+"q]a Yw[l lYw[8 ]lw lw]s [fYq fq[Y+ YJfq JqfgY fq[Y1 fq8[Y JqfY1 JqfY8 Sq[f ",
+"Sfq[+ ]qf gq]f lYf[q fq8S[ lf]q gl]w [qow o[qw! wqoD o[awq o[7w o[87w 7wDo[",
+" 7[aow Sq[ow o[qSw! oqVw oVwqa r[w [wr8 rVw swrV q=o[ [=oq+ [=oqD [=aoq 7o[",
+"= [>o7w 7[=oD w>qoD Sq[= S=[q+ oVwq= oVwq+ r[= [>rw Vwr= s=r[ Yw[oq o[wYq! ",
+"oqJw oJqwa Yw7[ 7[Yw8 oJq7w oJqw8 YqoSw[ Sqo[Yw! oq]w ]oqwa Ywr[ r[Yw8 ]rw ",
+"rs]w xq[ [qx+ xJq gqxJ x7[ 7[x> 7Jxq g7x[ Sqx[ xq[S+ ]xq xq]g xr[ r[x> ]xr ",
+"yx]r z z& zD zc z1 z: z1D z:c zM zM& zV zVc zl zl: zlV uz z* z- z*D zc- z*1",
+" z:- 1Dz* :cz- z*M z-M zV* zV- zl* zl- l*zV uz- zG zG& zJ zJc z1G z:G zJ1 z",
+"J: zGM GMz& zJV cJzV zlG l:zG zlJ uzJ zf zf- zJf iz zf1 z:f Jfz1 iz: zfM f-",
+"zM zVf izV zlf lfz: lfzJ uzi z4 z4& z4D zc4 z7 z7: z7D z7c z4M 4Mz& zV4 c4z",
+"V zl7 l:z7 z7V uz7 z= z-= z=D zc= z7= Az =Dz7 Azc z=M =Mz- zV= c=zV zl= Azl",
+" l=zV Azu z4G 4Gz& zJ4 cJz4 z7G 7:zG zJ7 7Jz: 4GzM z4GM& J4zV zJVc4 lGz7 zl",
+"7:G 7Jzl zJu7 zf= f-z= zJ= iz= z7f Azf 7Jzf Azi =Mzf zf-=M J=zV zVi= lfz7 z",
+"lAf l=zJ uzAi zP zP& zDP zcP z1P z:P 1DzP :czP zS zS& zVS zcS zlS z:S SlzV ",
+"uzS z*P z-P DPz* c-zP 1Pz* :-zP z*1DP z:c-P zS* z-S SVz* Scz- l*zS l-zS zlV",
+"S* z-uS zY zY& zJY zYc zY1 zY: YJz1 Y:zJ zYS SYz& ]z ]zc zlY lYz: ]zl uz] z",
+"Yf zY- YJzf izY Yfz1 Y:zf zJYf1 zYi: zfS Sfz- ]zf ]zi lYzf lYz- zl]f ]zui z",
+"o zo& zoD zoc zo7 zo: 7ozD 7czo zoS Soz& zoV Sczo zr zr: zrV uzr zo= zo- =D",
+"zo ocz- 7oz= Azo zo7=D zoAc z=S S-zo S=zV Scz= zr= Azr rVz= uzAr zoY Y&zo z",
+"oJ Yczo z7Y Y:zo 7Jzo Ycz7 SozY zoYS& ]zo zo]c zrY rYz: ]zr ]zur zx zx- zxJ",
+" izx zx7 Azx xJz7 izAx zxS x-zS ]zx iz]x zxr zxAr zx]r |                   ",
+NULL
+};
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Prepares the data for MSOPs of 4-variable functions.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ReadMsops( char ** ppSopSizes, char *** ppSops )
+{
+    unsigned uMasks[4][2] = {
+        { 0x5555, 0xAAAA },
+        { 0x3333, 0xCCCC },
+        { 0x0F0F, 0xF0F0 },
+        { 0x00FF, 0xFF00 }
+    };
+    char Map[256], * pPrev, * pMemory;
+    char * pSopSizes, ** pSops;
+    int i, k, b, Size;
+
+    // map chars into their numbers
+    for ( i = 0; i < 256; i++ )
+        Map[i] = (char)(-1);
+    for ( i = 0; i < 81; i++ )
+        Map[(int)s_Data3[i]] = (char)i;
+
+    // count the number of strings
+    for ( Size = 0; s_Data4[Size] && Size < 100000; Size++ );
+    assert( Size < 100000 );
+
+    // allocate memory
+    pMemory = ABC_ALLOC( char, Size * 75 );
+    // copy the array into memory
+    for ( i = 0; i < Size; i++ )
+        for ( k = 0; k < 75; k++ )
+            if ( s_Data4[i][k] == ' ' )
+                pMemory[i*75+k] = (char)(-1);
+            else
+                pMemory[i*75+k] = Map[(int)s_Data4[i][k]];
+
+    // set pointers and compute SOP sizes
+    pSopSizes = ABC_ALLOC( char, 65536 );
+    pSops = ABC_ALLOC( char *, 65536 );
+    pSopSizes[0] = 0;
+    pSops[0] = NULL;
+    pPrev = pMemory;
+    for ( k = 0, i = 1; i < 65536; k++ )
+        if ( pMemory[k] == (char)(-1) )
+        {
+            pSopSizes[i] = pMemory + k - pPrev; 
+            pSops[i++] = pPrev;
+            pPrev = pMemory + k + 1;
+        }
+    *ppSopSizes = pSopSizes;
+    *ppSops = pSops;
+
+    // verify the results - derive truth table from SOP
+    for ( i = 1; i < 65536; i++ )
+    {
+        int uTruth = 0, uCube, Lit;
+        for ( k = 0; k < pSopSizes[i]; k++ )
+        {
+            uCube = 0xFFFF;
+            Lit = pSops[i][k];
+            for ( b = 3; b >= 0; b-- )
+            {
+                if ( Lit % 3 == 0 )
+                    uCube &= uMasks[b][0];
+                else if ( Lit % 3 == 1 )
+                    uCube &= uMasks[b][1];
+                Lit = Lit / 3;
+            }
+            uTruth |= uCube;
+        }
+        assert( uTruth == i );
+    }
+}
+
+#if 0
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Aig_ManDeriveCnfTest()
+{
+    int i, k, Lit;
+    printf( "\n" );
+    for ( i = 80; i >= 0; i-- )
+    {
+        Lit = i;
+        for ( k = 0; k < 4; k++ )
+        {
+            if ( Lit % 3 == 0 )
+                printf( "%c", 'A' + k );
+            else if ( Lit % 3 == 1 )
+                printf( "%c", 'a' + k );
+            Lit = Lit / 3;
+        }
+        printf( "\n" );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Aig_ManDeriveCnfTest2()
+{
+    char s_Data3[81] = "!#&()*+,-.0123456789:;<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZ[]abcdefghijklmnopqrstuvwxyz|";
+
+    unsigned uMasks[4][2] = {
+        { 0x5555, 0xAAAA },
+        { 0x3333, 0xCCCC },
+        { 0x0F0F, 0xF0F0 },
+        { 0x00FF, 0xFF00 }
+    };
+    char Buffer[100], * pCur;
+    FILE * pFile;
+    int CountCur, Counter = 0, nLines = 0;
+    int pLines[1<<16] = {0};
+    int pNums[1<<16] = {0};
+    unsigned uTruth, uTruth2, uCube, cCube;
+    char * pSops[1<<16] = {0};
+    char Sop[10];
+    char Cube[4];
+    int i, k;
+
+    pFile = fopen( "cands2.txt", "r" );
+    while ( fgets( Buffer, 100, pFile ) )
+    {
+        if ( Buffer[0] == '0' )
+            Extra_ReadHexadecimal( &uTruth2, Buffer+2, 4 );
+        else
+            uTruth2 = 0xFFFFFF;
+
+        // skip all chars till a-d or A-D
+        if ( Buffer[0] == '0' )
+        for ( pCur = Buffer; *pCur != '\n'; pCur++ )
+        {
+//            if ( *pCur >= 'a' && *pCur <= 'd' || *pCur >= 'A' && *pCur <= 'D' )
+            if ( *pCur == ':' )
+            {
+                pCur++;
+                break;
+            }
+        }
+        else
+            pCur = Buffer;
+
+
+        uTruth = 0;
+        CountCur = 0;
+        uCube = 0xFFFF;
+        for ( i = 0; i < 4; i++ )
+            Cube[i] = 2;
+
+        for ( ; *pCur; pCur++ )
+        {
+            if ( *pCur == '+' || *pCur == '\n' )
+            {
+                uTruth |= uCube;
+                uCube = 0xFFFF;
+
+                // get the cube
+                cCube = 0;
+                for ( i = 0; i < 4; i++ )
+                    cCube = 3 * cCube + Cube[i];
+                for ( i = 0; i < 4; i++ )
+                    Cube[i] = 2;
+
+                assert( cCube >= 0 && cCube < 81 );
+                Sop[CountCur] = cCube;
+                CountCur++;
+                if ( *pCur == '\n' )
+                {
+                    Sop[CountCur] = 0;
+                    break;
+                }
+            }
+            else if ( *pCur >= 'a' && *pCur <= 'd' )
+            {
+                uCube &= uMasks[*pCur-'a'][1];
+                Cube[*pCur-'a'] = 1;
+            }
+            else if ( *pCur >= 'A' && *pCur <= 'D' )
+            {
+                uCube &= uMasks[*pCur-'A'][0];
+                Cube[*pCur-'A'] = 0;
+            }
+        }
+        assert( *pCur == '\n' );
+        assert( uTruth2 == 0xFFFFFF || uTruth2 == uTruth );
+
+        Counter += CountCur;
+        pNums[uTruth] = CountCur;
+        pSops[uTruth] = ALLOC( char, CountCur );
+        memcpy( pSops[uTruth], Sop, CountCur );
+        pLines[nLines++] = Counter;
+    }
+    fclose( pFile );
+
+    printf( "Lines = %d. Counter = %d.\n", nLines, Counter );
+
+/*
+    // write the number of cubes
+    for ( i = 0; i < 65536; i++ )
+        printf( "%d,%d ", pNums[i], pNums[i] + pNums[0xffff & ~i] );
+    printf( "\n" );
+*/
+
+    // write the number of cubes
+    Counter = 0;
+    for ( i = 1; i < 65536; i++ )
+    {
+        CountCur = pNums[i];
+        assert( CountCur > 0 );
+        for ( k = 0; k <= CountCur; k++ )
+        {
+            if ( k < CountCur )
+            {
+                assert( pSops[i][k] >= 0 && pSops[i][k] < 81 );
+                printf( "%c", s_Data3[pSops[i][k]] );
+            }
+            else 
+                printf( " " );
+            if ( ++Counter == 75 )
+            {
+                printf( "\",\n\"" );
+                Counter = 0;
+            }
+        }
+    }
+    printf( "\n" );
+
+    return 1;
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfFast.c b/src/sat/cnf/cnfFast.c
new file mode 100644
index 00000000..6ec2b6a6
--- /dev/null
+++ b/src/sat/cnf/cnfFast.c
@@ -0,0 +1,697 @@
+/**CFile****************************************************************
+
+  FileName    [cnfFast.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfFast.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+#include "src/bool/kit/kit.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Detects multi-input gate rooted at this node.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CollectLeaves_rec( Aig_Obj_t * pRoot, Aig_Obj_t * pObj, Vec_Ptr_t * vSuper, int fStopCompl )
+{
+    if ( pRoot != pObj && (pObj->fMarkA || (fStopCompl && Aig_IsComplement(pObj))) )
+    {
+        Vec_PtrPushUnique( vSuper, fStopCompl ? pObj : Aig_Regular(pObj) );
+        return;
+    }
+    assert( Aig_ObjIsNode(pObj) );
+    if ( fStopCompl )
+    {
+        Cnf_CollectLeaves_rec( pRoot, Aig_ObjChild0(pObj), vSuper, 1 );
+        Cnf_CollectLeaves_rec( pRoot, Aig_ObjChild1(pObj), vSuper, 1 );
+    }
+    else
+    {
+        Cnf_CollectLeaves_rec( pRoot, Aig_ObjFanin0(pObj), vSuper, 0 );
+        Cnf_CollectLeaves_rec( pRoot, Aig_ObjFanin1(pObj), vSuper, 0 );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Detects multi-input gate rooted at this node.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CollectLeaves( Aig_Obj_t * pRoot, Vec_Ptr_t * vSuper, int fStopCompl )
+{
+    assert( !Aig_IsComplement(pRoot) );
+    Vec_PtrClear( vSuper );
+    Cnf_CollectLeaves_rec( pRoot, pRoot, vSuper, fStopCompl );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects nodes inside the cone.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CollectVolume_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vNodes )
+{
+    if ( Aig_ObjIsTravIdCurrent( p, pObj ) )
+        return;
+    Aig_ObjSetTravIdCurrent( p, pObj );
+    assert( Aig_ObjIsNode(pObj) );
+    Cnf_CollectVolume_rec( p, Aig_ObjFanin0(pObj), vNodes );
+    Cnf_CollectVolume_rec( p, Aig_ObjFanin1(pObj), vNodes );
+    Vec_PtrPush( vNodes, pObj );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects nodes inside the cone.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CollectVolume( Aig_Man_t * p, Aig_Obj_t * pRoot, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vNodes )
+{
+    Aig_Obj_t * pObj;
+    int i;
+    Aig_ManIncrementTravId( p );
+    Vec_PtrForEachEntry( Aig_Obj_t *, vLeaves, pObj, i )
+        Aig_ObjSetTravIdCurrent( p, pObj );
+    Vec_PtrClear( vNodes );
+    Cnf_CollectVolume_rec( p, pRoot, vNodes );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derive truth table.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+word Cnf_CutDeriveTruth( Aig_Man_t * p, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vNodes )
+{
+    static word Truth6[6] = {
+        0xAAAAAAAAAAAAAAAA,
+        0xCCCCCCCCCCCCCCCC,
+        0xF0F0F0F0F0F0F0F0,
+        0xFF00FF00FF00FF00,
+        0xFFFF0000FFFF0000,
+        0xFFFFFFFF00000000
+    };
+    static word C[2] = { 0, ~0 };
+    static word S[256];
+    Aig_Obj_t * pObj;
+    int i;
+    assert( Vec_PtrSize(vLeaves) <= 6 && Vec_PtrSize(vNodes) > 0 );
+    assert( Vec_PtrSize(vLeaves) + Vec_PtrSize(vNodes) <= 256 );
+    Vec_PtrForEachEntry( Aig_Obj_t *, vLeaves, pObj, i )
+    {
+        pObj->iData    = i;
+        S[pObj->iData] = Truth6[i];
+    }
+    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
+    {
+        pObj->iData    = Vec_PtrSize(vLeaves) + i;
+        S[pObj->iData] = (S[Aig_ObjFanin0(pObj)->iData] ^ C[Aig_ObjFaninC0(pObj)]) & 
+                         (S[Aig_ObjFanin1(pObj)->iData] ^ C[Aig_ObjFaninC1(pObj)]);
+    }
+    return S[pObj->iData];
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Collects nodes inside the cone.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Cnf_ObjGetLit( Vec_Int_t * vMap, Aig_Obj_t * pObj, int fCompl )
+{
+    int iSatVar = vMap ? Vec_IntEntry(vMap, Aig_ObjId(pObj)) : Aig_ObjId(pObj);
+    assert( iSatVar > 0 );
+    return iSatVar + iSatVar + fCompl;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects nodes inside the cone.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ComputeClauses( Aig_Man_t * p, Aig_Obj_t * pRoot, 
+    Vec_Ptr_t * vLeaves, Vec_Ptr_t * vNodes, Vec_Int_t * vMap, Vec_Int_t * vCover, Vec_Int_t * vClauses )
+{
+    Aig_Obj_t * pLeaf;
+    int c, k, Cube, OutLit, RetValue;
+    word Truth;
+    assert( pRoot->fMarkA );
+
+    Vec_IntClear( vClauses );
+
+    OutLit = Cnf_ObjGetLit( vMap, pRoot, 0 );
+    // detect cone
+    Cnf_CollectLeaves( pRoot, vLeaves, 0 );
+    Cnf_CollectVolume( p, pRoot, vLeaves, vNodes );
+    assert( pRoot == Vec_PtrEntryLast(vNodes) );
+    // check if this is an AND-gate
+    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pLeaf, k )
+    {
+        if ( Aig_ObjFaninC0(pLeaf) && !Aig_ObjFanin0(pLeaf)->fMarkA )
+            break;
+        if ( Aig_ObjFaninC1(pLeaf) && !Aig_ObjFanin1(pLeaf)->fMarkA )
+            break;
+    }
+    if ( k == Vec_PtrSize(vNodes) )
+    {
+        Cnf_CollectLeaves( pRoot, vLeaves, 1 );
+        // write big clause
+        Vec_IntPush( vClauses, 0 );
+        Vec_IntPush( vClauses, OutLit );
+        Vec_PtrForEachEntry( Aig_Obj_t *, vLeaves, pLeaf, k )
+            Vec_IntPush( vClauses, Cnf_ObjGetLit(vMap, Aig_Regular(pLeaf), !Aig_IsComplement(pLeaf)) );
+        // write small clauses
+        Vec_PtrForEachEntry( Aig_Obj_t *, vLeaves, pLeaf, k )
+        {
+            Vec_IntPush( vClauses, 0 );
+            Vec_IntPush( vClauses, OutLit ^ 1 );
+            Vec_IntPush( vClauses, Cnf_ObjGetLit(vMap, Aig_Regular(pLeaf), Aig_IsComplement(pLeaf)) );
+        }
+        return;
+    }
+    if ( Vec_PtrSize(vLeaves) > 6 )
+        printf( "FastCnfGeneration:  Internal error!!!\n" );
+    assert( Vec_PtrSize(vLeaves) <= 6 );
+
+    Truth = Cnf_CutDeriveTruth( p, vLeaves, vNodes );
+    if ( Truth == 0 || Truth == ~0 )
+    {
+        Vec_IntPush( vClauses, 0 );
+        Vec_IntPush( vClauses, (Truth == 0) ? (OutLit ^ 1) : OutLit );
+        return;
+    }
+
+    RetValue = Kit_TruthIsop( (unsigned *)&Truth, Vec_PtrSize(vLeaves), vCover, 0 );
+    assert( RetValue >= 0 );
+
+    Vec_IntForEachEntry( vCover, Cube, c )
+    {
+        Vec_IntPush( vClauses, 0 );
+        Vec_IntPush( vClauses, OutLit );
+        for ( k = 0; k < Vec_PtrSize(vLeaves); k++, Cube >>= 2 )
+        {
+            if ( (Cube & 3) == 0 )
+                continue;
+            assert( (Cube & 3) != 3 );
+            Vec_IntPush( vClauses, Cnf_ObjGetLit(vMap, (Aig_Obj_t *)Vec_PtrEntry(vLeaves,k), (Cube&3)!=1) );
+        }
+    }
+
+    Truth = ~Truth;
+
+    RetValue = Kit_TruthIsop( (unsigned *)&Truth, Vec_PtrSize(vLeaves), vCover, 0 );
+    assert( RetValue >= 0 );
+    Vec_IntForEachEntry( vCover, Cube, c )
+    {
+        Vec_IntPush( vClauses, 0 );
+        Vec_IntPush( vClauses, OutLit ^ 1 );
+        for ( k = 0; k < Vec_PtrSize(vLeaves); k++, Cube >>= 2 )
+        {
+            if ( (Cube & 3) == 0 )
+                continue;
+            assert( (Cube & 3) != 3 );
+            Vec_IntPush( vClauses, Cnf_ObjGetLit(vMap, (Aig_Obj_t *)Vec_PtrEntry(vLeaves,k), (Cube&3)!=1) );
+        }
+    }
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Marks AIG for CNF computation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DeriveFastMark( Aig_Man_t * p )
+{
+    Vec_Int_t * vSupps;
+    Vec_Ptr_t * vLeaves, * vNodes;
+    Aig_Obj_t * pObj, * pTemp, * pObjC, * pObj0, * pObj1;
+    int i, k, nFans, Counter;
+
+    vLeaves = Vec_PtrAlloc( 100 );
+    vNodes  = Vec_PtrAlloc( 100 );
+    vSupps  = Vec_IntStart( Aig_ManObjNumMax(p) );
+
+    // mark CIs
+    Aig_ManForEachPi( p, pObj, i )
+        pObj->fMarkA = 1;
+
+    // mark CO drivers
+    Aig_ManForEachPo( p, pObj, i )
+        Aig_ObjFanin0(pObj)->fMarkA = 1;
+
+    // mark MUX/XOR nodes
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        assert( !pObj->fMarkB );
+        if ( !Aig_ObjIsMuxType(pObj) )
+            continue;
+        pObj0 = Aig_ObjFanin0(pObj);
+        if ( pObj0->fMarkB || Aig_ObjRefs(pObj0) > 1 )
+            continue;
+        pObj1 = Aig_ObjFanin1(pObj);
+        if ( pObj1->fMarkB || Aig_ObjRefs(pObj1) > 1 )
+            continue;
+        // mark nodes
+        pObj->fMarkB = 1;
+        pObj0->fMarkB = 1;
+        pObj1->fMarkB = 1;
+        // mark inputs and outputs
+        pObj->fMarkA = 1;
+        Aig_ObjFanin0(pObj0)->fMarkA = 1;
+        Aig_ObjFanin1(pObj0)->fMarkA = 1;
+        Aig_ObjFanin0(pObj1)->fMarkA = 1;
+        Aig_ObjFanin1(pObj1)->fMarkA = 1;
+    }
+
+    // mark nodes with multiple fanouts and pointed to by complemented edges
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        // mark nodes with many fanouts
+        if ( Aig_ObjRefs(pObj) > 1 )
+            pObj->fMarkA = 1;
+        // mark nodes pointed to by a complemented edge
+        if ( Aig_ObjFaninC0(pObj) && !Aig_ObjFanin0(pObj)->fMarkB )
+            Aig_ObjFanin0(pObj)->fMarkA = 1;
+        if ( Aig_ObjFaninC1(pObj) && !Aig_ObjFanin1(pObj)->fMarkB )
+            Aig_ObjFanin1(pObj)->fMarkA = 1;
+    }
+
+    // compute supergate size for internal marked nodes
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        if ( !pObj->fMarkA )
+            continue;
+        if ( pObj->fMarkB )
+        {
+            if ( !Aig_ObjIsMuxType(pObj) )
+                continue;
+            pObjC = Aig_ObjRecognizeMux( pObj, &pObj1, &pObj0 );
+            pObj0 = Aig_Regular(pObj0);
+            pObj1 = Aig_Regular(pObj1);
+            assert( pObj0->fMarkA );
+            assert( pObj1->fMarkA );
+//            if ( pObj0 == pObj1 )
+//                continue;
+            nFans = 1 + (pObj0 == pObj1);
+            if ( !pObj0->fMarkB && !Aig_ObjIsPi(pObj0) && Aig_ObjRefs(pObj0) == nFans && Vec_IntEntry(vSupps, Aig_ObjId(pObj0)) < 3 )
+            {
+                pObj0->fMarkA = 0;
+                continue;
+            }
+            if ( !pObj1->fMarkB && !Aig_ObjIsPi(pObj1) && Aig_ObjRefs(pObj1) == nFans && Vec_IntEntry(vSupps, Aig_ObjId(pObj1)) < 3 )
+            {
+                pObj1->fMarkA = 0;
+                continue;
+            }
+            continue;
+        }
+
+        Cnf_CollectLeaves( pObj, vLeaves, 1 );
+        Vec_IntWriteEntry( vSupps, Aig_ObjId(pObj), Vec_PtrSize(vLeaves) );
+        if ( Vec_PtrSize(vLeaves) >= 6 )
+            continue;
+        Vec_PtrForEachEntry( Aig_Obj_t *, vLeaves, pTemp, k )
+        {
+            pTemp = Aig_Regular(pTemp);
+            assert( pTemp->fMarkA );
+            if ( pTemp->fMarkB || Aig_ObjIsPi(pTemp) || Aig_ObjRefs(pTemp) > 1 )
+                continue;
+            assert( Vec_IntEntry(vSupps, Aig_ObjId(pTemp)) > 0 );
+            if ( Vec_PtrSize(vLeaves) - 1 + Vec_IntEntry(vSupps, Aig_ObjId(pTemp)) > 6 )
+                continue;
+            pTemp->fMarkA = 0;
+            Vec_IntWriteEntry( vSupps, Aig_ObjId(pObj), 6 );
+//printf( "%d %d   ", Vec_PtrSize(vLeaves), Vec_IntEntry(vSupps, Aig_ObjId(pTemp)) );
+            break;
+        }
+    }
+    Aig_ManCleanMarkB( p );
+
+    // check CO drivers
+    Counter = 0;
+    Aig_ManForEachPo( p, pObj, i )
+        Counter += !Aig_ObjFanin0(pObj)->fMarkA;
+    if ( Counter )
+    printf( "PO-driver rule is violated %d times.\n", Counter );
+
+    // check that the AND-gates are fine
+    Counter = 0;
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        assert( pObj->fMarkB == 0 );
+        if ( !pObj->fMarkA )
+            continue;
+        Cnf_CollectLeaves( pObj, vLeaves, 0 );
+        if ( Vec_PtrSize(vLeaves) <= 6 )
+            continue;
+        Cnf_CollectVolume( p, pObj, vLeaves, vNodes );
+        Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pTemp, k )
+        {
+            if ( Aig_ObjFaninC0(pTemp) && !Aig_ObjFanin0(pTemp)->fMarkA )
+                Counter++;
+            if ( Aig_ObjFaninC1(pTemp) && !Aig_ObjFanin1(pTemp)->fMarkA )
+                Counter++;
+        }
+    }
+    if ( Counter )
+    printf( "AND-gate rule is violated %d times.\n", Counter );
+
+    Vec_PtrFree( vLeaves );
+    Vec_PtrFree( vNodes );
+    Vec_IntFree( vSupps );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of clauses.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_CutCountClauses( Aig_Man_t * p, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vNodes, Vec_Int_t * vCover )
+{
+    word Truth;
+    Aig_Obj_t * pObj;
+    int i, RetValue, nSize = 0;
+    if ( Vec_PtrSize(vLeaves) > 6 )
+    {
+        // make sure this is an AND gate
+        Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
+        {
+            if ( Aig_ObjFaninC0(pObj) && !Aig_ObjFanin0(pObj)->fMarkA )
+                printf( "Unusual 1!\n" );
+            if ( Aig_ObjFaninC1(pObj) && !Aig_ObjFanin1(pObj)->fMarkA )
+                printf( "Unusual 2!\n" );
+            continue;
+
+            assert( !Aig_ObjFaninC0(pObj) || Aig_ObjFanin0(pObj)->fMarkA );
+            assert( !Aig_ObjFaninC1(pObj) || Aig_ObjFanin1(pObj)->fMarkA );
+        }
+        return Vec_PtrSize(vLeaves) + 1;
+    }
+    Truth = Cnf_CutDeriveTruth( p, vLeaves, vNodes );
+
+    RetValue = Kit_TruthIsop( (unsigned *)&Truth, Vec_PtrSize(vLeaves), vCover, 0 );
+    assert( RetValue >= 0 );
+    nSize += Vec_IntSize(vCover);
+
+    Truth = ~Truth;
+
+    RetValue = Kit_TruthIsop( (unsigned *)&Truth, Vec_PtrSize(vLeaves), vCover, 0 );
+    assert( RetValue >= 0 );
+    nSize += Vec_IntSize(vCover);
+    return nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the size of the CNF, assuming marks are set.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_CountCnfSize( Aig_Man_t * p )
+{
+    Vec_Ptr_t * vLeaves, * vNodes;
+    Vec_Int_t * vCover;
+    Aig_Obj_t * pObj;
+    int nVars = 0, nClauses = 0;
+    int i, nSize;
+
+    vLeaves = Vec_PtrAlloc( 100 );
+    vNodes  = Vec_PtrAlloc( 100 );
+    vCover  = Vec_IntAlloc( 1 << 16 );
+
+    Aig_ManForEachObj( p, pObj, i )
+        nVars += pObj->fMarkA;
+
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        if ( !pObj->fMarkA )
+            continue;
+        Cnf_CollectLeaves( pObj, vLeaves, 0 );
+        Cnf_CollectVolume( p, pObj, vLeaves, vNodes );
+        assert( pObj == Vec_PtrEntryLast(vNodes) );
+
+        nSize = Cnf_CutCountClauses( p, vLeaves, vNodes, vCover );
+//        printf( "%d(%d) ", Vec_PtrSize(vLeaves), nSize );
+
+        nClauses += nSize;
+    }
+//    printf( "\n" );
+    printf( "Vars = %d  Clauses = %d\n", nVars, nClauses );
+
+    Vec_PtrFree( vLeaves );
+    Vec_PtrFree( vNodes );
+    Vec_IntFree( vCover );
+    return nClauses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derives CNF from the marked AIG.]
+
+  Description [Assumes that marking is such that when we traverse from each
+  marked node, the logic cone has 6 inputs or less, or it is a multi-input AND.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_DeriveFastClauses( Aig_Man_t * p, int nOutputs )
+{
+    Cnf_Dat_t * pCnf;
+    Vec_Int_t * vLits, * vClas, * vMap, * vTemp;
+    Vec_Ptr_t * vLeaves, * vNodes;
+    Vec_Int_t * vCover;
+    Aig_Obj_t * pObj;
+    int i, k, nVars, Entry, OutLit, DriLit;
+
+    vLits = Vec_IntAlloc( 1 << 16 );
+    vClas = Vec_IntAlloc( 1 << 12 );
+    vMap  = Vec_IntStartFull( Aig_ManObjNumMax(p) );
+
+    // assign variables for the outputs
+    nVars = 1;
+    if ( nOutputs )
+    {
+        if ( Aig_ManRegNum(p) == 0 )
+        {
+            assert( nOutputs == Aig_ManPoNum(p) );
+            Aig_ManForEachPo( p, pObj, i )
+                Vec_IntWriteEntry( vMap, Aig_ObjId(pObj), nVars++ );
+        }
+        else
+        {
+            assert( nOutputs == Aig_ManRegNum(p) );
+            Aig_ManForEachLiSeq( p, pObj, i )
+                Vec_IntWriteEntry( vMap, Aig_ObjId(pObj), nVars++ );
+        }
+    }
+    // assign variables to the internal nodes
+    Aig_ManForEachNodeReverse( p, pObj, i )
+        if ( pObj->fMarkA )
+            Vec_IntWriteEntry( vMap, Aig_ObjId(pObj), nVars++ );
+    // assign variables to the PIs and constant node
+    Aig_ManForEachPi( p, pObj, i )
+        Vec_IntWriteEntry( vMap, Aig_ObjId(pObj), nVars++ );
+    Vec_IntWriteEntry( vMap, Aig_ObjId(Aig_ManConst1(p)), nVars++ );
+
+    // create clauses
+    vLeaves = Vec_PtrAlloc( 100 );
+    vNodes  = Vec_PtrAlloc( 100 );
+    vCover  = Vec_IntAlloc( 1 << 16 );
+    vTemp   = Vec_IntAlloc( 100 );
+    Aig_ManForEachNodeReverse( p, pObj, i )
+    {
+        if ( !pObj->fMarkA )
+            continue;
+        Cnf_ComputeClauses( p, pObj, vLeaves, vNodes, vMap, vCover, vTemp );
+        Vec_IntForEachEntry( vTemp, Entry, k )
+        {
+            if ( Entry == 0 )
+                Vec_IntPush( vClas, Vec_IntSize(vLits) );
+            else
+                Vec_IntPush( vLits, Entry );
+        }       
+    }
+    Vec_PtrFree( vLeaves );
+    Vec_PtrFree( vNodes );
+    Vec_IntFree( vCover );
+    Vec_IntFree( vTemp );
+
+    // create clauses for the outputs
+    Aig_ManForEachPo( p, pObj, i )
+    {
+        DriLit = Cnf_ObjGetLit( vMap, Aig_ObjFanin0(pObj), Aig_ObjFaninC0(pObj) );
+        if ( i < Aig_ManPoNum(p) - nOutputs )
+        {
+            Vec_IntPush( vClas, Vec_IntSize(vLits) );
+            Vec_IntPush( vLits, DriLit );
+        }
+        else
+        {
+            OutLit = Cnf_ObjGetLit( vMap, pObj, 0 );
+            // first clause
+            Vec_IntPush( vClas, Vec_IntSize(vLits) );
+            Vec_IntPush( vLits, OutLit );
+            Vec_IntPush( vLits, DriLit ^ 1 );
+            // second clause
+            Vec_IntPush( vClas, Vec_IntSize(vLits) );
+            Vec_IntPush( vLits, OutLit ^ 1 );
+            Vec_IntPush( vLits, DriLit );
+        }
+    }
+ 
+    // write the constant literal
+    OutLit = Cnf_ObjGetLit( vMap, Aig_ManConst1(p), 0 );
+    Vec_IntPush( vClas, Vec_IntSize(vLits) );
+    Vec_IntPush( vLits, OutLit );
+
+    // create structure
+    pCnf = ABC_CALLOC( Cnf_Dat_t, 1 );
+    pCnf->pMan = p;
+    pCnf->nVars = nVars;
+    pCnf->nLiterals = Vec_IntSize( vLits );
+    pCnf->nClauses  = Vec_IntSize( vClas );
+    pCnf->pClauses  = ABC_ALLOC( int *, pCnf->nClauses + 1 );
+    pCnf->pClauses[0] = Vec_IntReleaseArray( vLits );
+    Vec_IntForEachEntry( vClas, Entry, i )
+        pCnf->pClauses[i] = pCnf->pClauses[0] + Entry;
+    pCnf->pClauses[pCnf->nClauses] = pCnf->pClauses[0] + pCnf->nLiterals;
+    pCnf->pVarNums  = Vec_IntReleaseArray( vMap );
+
+    // cleanup
+    Vec_IntFree( vLits );
+    Vec_IntFree( vClas );
+    Vec_IntFree( vMap );
+    return pCnf;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fast CNF computation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_DeriveFast( Aig_Man_t * p, int nOutputs )
+{
+    Cnf_Dat_t * pCnf = NULL;
+    int clk, clkTotal = clock();
+//    printf( "\n" );
+    Aig_ManCleanMarkAB( p );
+    // create initial marking
+    clk = clock();
+    Cnf_DeriveFastMark( p );
+//    Abc_PrintTime( 1, "Marking", clock() - clk );
+    // compute CNF size
+    clk = clock();
+    pCnf = Cnf_DeriveFastClauses( p, nOutputs );
+//    Abc_PrintTime( 1, "Clauses", clock() - clk );
+    // derive the resulting CNF
+    Aig_ManCleanMarkA( p );
+//    Abc_PrintTime( 1, "TOTAL  ", clock() - clkTotal );
+
+//    printf( "Vars = %6d. Clauses = %7d. Literals = %8d.   \n", pCnf->nVars, pCnf->nClauses, pCnf->nLiterals );
+
+//    Cnf_DataFree( pCnf );
+//    pCnf = NULL;
+    return pCnf;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfMan.c b/src/sat/cnf/cnfMan.c
new file mode 100644
index 00000000..a670a69d
--- /dev/null
+++ b/src/sat/cnf/cnfMan.c
@@ -0,0 +1,693 @@
+/**CFile****************************************************************
+
+  FileName    [cnfMan.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfMan.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+#include "src/sat/bsat/satSolver.h"
+#include "src/sat/bsat/satSolver2.h"
+#include "src/misc/zlib/zlib.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+static inline int Cnf_Lit2Var( int Lit )        { return (Lit & 1)? -(Lit >> 1)-1 : (Lit >> 1)+1;  }
+static inline int Cnf_Lit2Var2( int Lit )       { return (Lit & 1)? -(Lit >> 1)   : (Lit >> 1);    }
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Starts the fraiging manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Man_t * Cnf_ManStart()
+{
+    Cnf_Man_t * p;
+    int i;
+    // allocate the manager
+    p = ABC_ALLOC( Cnf_Man_t, 1 );
+    memset( p, 0, sizeof(Cnf_Man_t) );
+    // derive internal data structures
+    Cnf_ReadMsops( &p->pSopSizes, &p->pSops );
+    // allocate memory manager for cuts
+    p->pMemCuts = Aig_MmFlexStart();
+    p->nMergeLimit = 10;
+    // allocate temporary truth tables
+    p->pTruths[0] = ABC_ALLOC( unsigned, 4 * Abc_TruthWordNum(p->nMergeLimit) );
+    for ( i = 1; i < 4; i++ )
+        p->pTruths[i] = p->pTruths[i-1] + Abc_TruthWordNum(p->nMergeLimit);
+    p->vMemory = Vec_IntAlloc( 1 << 18 );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Stops the fraiging manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ManStop( Cnf_Man_t * p )
+{
+    Vec_IntFree( p->vMemory );
+    ABC_FREE( p->pTruths[0] );
+    Aig_MmFlexStop( p->pMemCuts, 0 );
+    ABC_FREE( p->pSopSizes );
+    ABC_FREE( p->pSops[1] );
+    ABC_FREE( p->pSops );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the array of CI IDs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Cnf_DataCollectPiSatNums( Cnf_Dat_t * pCnf, Aig_Man_t * p )
+{
+    Vec_Int_t * vCiIds;
+    Aig_Obj_t * pObj;
+    int i;
+    vCiIds = Vec_IntAlloc( Aig_ManPiNum(p) );
+    Aig_ManForEachPi( p, pObj, i )
+        Vec_IntPush( vCiIds, pCnf->pVarNums[pObj->Id] );
+    return vCiIds;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates the new CNF.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_DataAlloc( Aig_Man_t * pAig, int nVars, int nClauses, int nLiterals )
+{
+    Cnf_Dat_t * pCnf;
+    int i;
+    pCnf = ABC_ALLOC( Cnf_Dat_t, 1 );
+    memset( pCnf, 0, sizeof(Cnf_Dat_t) );
+    pCnf->pMan = pAig;
+    pCnf->nVars = nVars;
+    pCnf->nClauses = nClauses;
+    pCnf->nLiterals = nLiterals;
+    pCnf->pClauses = ABC_ALLOC( int *, nClauses + 1 );
+    pCnf->pClauses[0] = ABC_ALLOC( int, nLiterals );
+    pCnf->pClauses[nClauses] = pCnf->pClauses[0] + nLiterals;
+    pCnf->pVarNums = ABC_ALLOC( int, Aig_ManObjNumMax(pAig) );
+//    memset( pCnf->pVarNums, 0xff, sizeof(int) * Aig_ManObjNumMax(pAig) );
+    for ( i = 0; i < Aig_ManObjNumMax(pAig); i++ )
+        pCnf->pVarNums[i] = -1;
+    return pCnf;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates the new CNF.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_DataDup( Cnf_Dat_t * p )
+{
+    Cnf_Dat_t * pCnf;
+    int i;
+    pCnf = Cnf_DataAlloc( p->pMan, p->nVars, p->nClauses, p->nLiterals );
+    memcpy( pCnf->pClauses[0], p->pClauses[0], sizeof(int) * p->nLiterals );
+    memcpy( pCnf->pVarNums, p->pVarNums, sizeof(int) * Aig_ManObjNumMax(p->pMan) );
+    for ( i = 1; i < p->nClauses; i++ )
+        pCnf->pClauses[i] = pCnf->pClauses[0] + (p->pClauses[i] - p->pClauses[0]);
+    return pCnf;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DataFree( Cnf_Dat_t * p )
+{
+    if ( p == NULL )
+        return;
+    ABC_FREE( p->pObj2Clause );
+    ABC_FREE( p->pObj2Count );
+    ABC_FREE( p->pClauses[0] );
+    ABC_FREE( p->pClauses );
+    ABC_FREE( p->pVarNums );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DataLift( Cnf_Dat_t * p, int nVarsPlus )
+{
+    Aig_Obj_t * pObj;
+    int v;
+    Aig_ManForEachObj( p->pMan, pObj, v )
+        if ( p->pVarNums[pObj->Id] >= 0 )
+            p->pVarNums[pObj->Id] += nVarsPlus;
+    for ( v = 0; v < p->nLiterals; v++ )
+        p->pClauses[0][v] += 2*nVarsPlus;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DataFlipLastLiteral( Cnf_Dat_t * p )
+{
+    p->pClauses[0][p->nLiterals-1] = lit_neg( p->pClauses[0][p->nLiterals-1] );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DataPrint( Cnf_Dat_t * p, int fReadable )
+{
+    FILE * pFile = stdout;
+    int * pLit, * pStop, i;
+    fprintf( pFile, "p cnf %d %d\n", p->nVars, p->nClauses );
+    for ( i = 0; i < p->nClauses; i++ )
+    {
+        for ( pLit = p->pClauses[i], pStop = p->pClauses[i+1]; pLit < pStop; pLit++ )
+            fprintf( pFile, "%d ", fReadable? Cnf_Lit2Var2(*pLit) : Cnf_Lit2Var(*pLit) );
+        fprintf( pFile, "\n" );
+    }
+    fprintf( pFile, "\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DataWriteIntoFileGz( Cnf_Dat_t * p, char * pFileName, int fReadable )
+{
+    gzFile pFile;
+    int * pLit, * pStop, i;
+    pFile = gzopen( pFileName, "wb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cnf_WriteIntoFile(): Output file cannot be opened.\n" );
+        return;
+    }
+    gzprintf( pFile, "c Result of efficient AIG-to-CNF conversion using package CNF\n" );
+    gzprintf( pFile, "p cnf %d %d\n", p->nVars, p->nClauses );
+    for ( i = 0; i < p->nClauses; i++ )
+    {
+        for ( pLit = p->pClauses[i], pStop = p->pClauses[i+1]; pLit < pStop; pLit++ )
+            gzprintf( pFile, "%d ", fReadable? Cnf_Lit2Var2(*pLit) : Cnf_Lit2Var(*pLit) );
+        gzprintf( pFile, "0\n" );
+    }
+    gzprintf( pFile, "\n" );
+    gzclose( pFile );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DataWriteIntoFile( Cnf_Dat_t * p, char * pFileName, int fReadable )
+{
+    FILE * pFile;
+    int * pLit, * pStop, i;
+    if ( !strncmp(pFileName+strlen(pFileName)-3,".gz",3) ) 
+    {
+        Cnf_DataWriteIntoFileGz( p, pFileName, fReadable );
+        return;
+    }
+    pFile = fopen( pFileName, "w" );
+    if ( pFile == NULL )
+    {
+        printf( "Cnf_WriteIntoFile(): Output file cannot be opened.\n" );
+        return;
+    }
+    fprintf( pFile, "c Result of efficient AIG-to-CNF conversion using package CNF\n" );
+    fprintf( pFile, "p cnf %d %d\n", p->nVars, p->nClauses );
+    for ( i = 0; i < p->nClauses; i++ )
+    {
+        for ( pLit = p->pClauses[i], pStop = p->pClauses[i+1]; pLit < pStop; pLit++ )
+            fprintf( pFile, "%d ", fReadable? Cnf_Lit2Var2(*pLit) : Cnf_Lit2Var(*pLit) );
+        fprintf( pFile, "0\n" );
+    }
+    fprintf( pFile, "\n" );
+    fclose( pFile );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void * Cnf_DataWriteIntoSolverInt( void * pSolver, Cnf_Dat_t * p, int nFrames, int fInit )
+{
+    sat_solver * pSat = (sat_solver *)pSolver;
+    int i, f, status;
+    assert( nFrames > 0 );
+    assert( pSat );
+//    pSat = sat_solver_new();
+    sat_solver_setnvars( pSat, p->nVars * nFrames );
+    for ( i = 0; i < p->nClauses; i++ )
+    {
+        if ( !sat_solver_addclause( pSat, p->pClauses[i], p->pClauses[i+1] ) )
+        {
+            sat_solver_delete( pSat );
+            return NULL;
+        }
+    }
+    if ( nFrames > 1 )
+    {
+        Aig_Obj_t * pObjLo, * pObjLi;
+        int nLitsAll, * pLits, Lits[2];
+        nLitsAll = 2 * p->nVars;
+        pLits = p->pClauses[0];
+        for ( f = 1; f < nFrames; f++ )
+        {
+            // add equality of register inputs/outputs for different timeframes
+            Aig_ManForEachLiLoSeq( p->pMan, pObjLi, pObjLo, i )
+            {
+                Lits[0] = (f-1)*nLitsAll + toLitCond( p->pVarNums[pObjLi->Id], 0 );
+                Lits[1] =  f   *nLitsAll + toLitCond( p->pVarNums[pObjLo->Id], 1 );
+                if ( !sat_solver_addclause( pSat, Lits, Lits + 2 ) )
+                {
+                    sat_solver_delete( pSat );
+                    return NULL;
+                }
+                Lits[0]++;
+                Lits[1]--;
+                if ( !sat_solver_addclause( pSat, Lits, Lits + 2 ) )
+                {
+                    sat_solver_delete( pSat );
+                    return NULL;
+                }
+            }
+            // add clauses for the next timeframe
+            for ( i = 0; i < p->nLiterals; i++ )
+                pLits[i] += nLitsAll;
+            for ( i = 0; i < p->nClauses; i++ )
+            {
+                if ( !sat_solver_addclause( pSat, p->pClauses[i], p->pClauses[i+1] ) )
+                {
+                    sat_solver_delete( pSat );
+                    return NULL;
+                }
+            }
+        }
+        // return literals to their original state
+        nLitsAll = (f-1) * nLitsAll;
+        for ( i = 0; i < p->nLiterals; i++ )
+            pLits[i] -= nLitsAll;
+    }
+    if ( fInit )
+    {
+        Aig_Obj_t * pObjLo;
+        int Lits[1];
+        Aig_ManForEachLoSeq( p->pMan, pObjLo, i )
+        {
+            Lits[0] = toLitCond( p->pVarNums[pObjLo->Id], 1 );
+            if ( !sat_solver_addclause( pSat, Lits, Lits + 1 ) )
+            {
+                sat_solver_delete( pSat );
+                return NULL;
+            }
+        }
+    }
+    status = sat_solver_simplify(pSat);
+    if ( status == 0 )
+    {
+        sat_solver_delete( pSat );
+        return NULL;
+    }
+    return pSat;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void * Cnf_DataWriteIntoSolver( Cnf_Dat_t * p, int nFrames, int fInit )
+{
+    return Cnf_DataWriteIntoSolverInt( sat_solver_new(), p, nFrames, fInit );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes CNF into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void * Cnf_DataWriteIntoSolver2( Cnf_Dat_t * p, int nFrames, int fInit )
+{
+    sat_solver2 * pSat;
+    int i, f, status;
+    assert( nFrames > 0 );
+    pSat = sat_solver2_new();
+    sat_solver2_setnvars( pSat, p->nVars * nFrames );
+    for ( i = 0; i < p->nClauses; i++ )
+    {
+        if ( !sat_solver2_addclause( pSat, p->pClauses[i], p->pClauses[i+1] ) )
+        {
+            sat_solver2_delete( pSat );
+            return NULL;
+        }
+    }
+    if ( nFrames > 1 )
+    {
+        Aig_Obj_t * pObjLo, * pObjLi;
+        int nLitsAll, * pLits, Lits[2];
+        nLitsAll = 2 * p->nVars;
+        pLits = p->pClauses[0];
+        for ( f = 1; f < nFrames; f++ )
+        {
+            // add equality of register inputs/outputs for different timeframes
+            Aig_ManForEachLiLoSeq( p->pMan, pObjLi, pObjLo, i )
+            {
+                Lits[0] = (f-1)*nLitsAll + toLitCond( p->pVarNums[pObjLi->Id], 0 );
+                Lits[1] =  f   *nLitsAll + toLitCond( p->pVarNums[pObjLo->Id], 1 );
+                if ( !sat_solver2_addclause( pSat, Lits, Lits + 2 ) )
+                {
+                    sat_solver2_delete( pSat );
+                    return NULL;
+                }
+                Lits[0]++;
+                Lits[1]--;
+                if ( !sat_solver2_addclause( pSat, Lits, Lits + 2 ) )
+                {
+                    sat_solver2_delete( pSat );
+                    return NULL;
+                }
+            }
+            // add clauses for the next timeframe
+            for ( i = 0; i < p->nLiterals; i++ )
+                pLits[i] += nLitsAll;
+            for ( i = 0; i < p->nClauses; i++ )
+            {
+                if ( !sat_solver2_addclause( pSat, p->pClauses[i], p->pClauses[i+1] ) )
+                {
+                    sat_solver2_delete( pSat );
+                    return NULL;
+                }
+            }
+        }
+        // return literals to their original state
+        nLitsAll = (f-1) * nLitsAll;
+        for ( i = 0; i < p->nLiterals; i++ )
+            pLits[i] -= nLitsAll;
+    }
+    if ( fInit )
+    {
+        Aig_Obj_t * pObjLo;
+        int Lits[1];
+        Aig_ManForEachLoSeq( p->pMan, pObjLo, i )
+        {
+            Lits[0] = toLitCond( p->pVarNums[pObjLo->Id], 1 );
+            if ( !sat_solver2_addclause( pSat, Lits, Lits + 1 ) )
+            {
+                sat_solver2_delete( pSat );
+                return NULL;
+            }
+        }
+    }
+    status = sat_solver2_simplify(pSat);
+    if ( status == 0 )
+    {
+        sat_solver2_delete( pSat );
+        return NULL;
+    }
+    return pSat;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Adds the OR-clause.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_DataWriteOrClause( void * p, Cnf_Dat_t * pCnf )
+{
+    sat_solver * pSat = (sat_solver *)p;
+    Aig_Obj_t * pObj;
+    int i, * pLits;
+    pLits = ABC_ALLOC( int, Aig_ManPoNum(pCnf->pMan) );
+    Aig_ManForEachPo( pCnf->pMan, pObj, i )
+        pLits[i] = toLitCond( pCnf->pVarNums[pObj->Id], 0 );
+    if ( !sat_solver_addclause( pSat, pLits, pLits + Aig_ManPoNum(pCnf->pMan) ) )
+    {
+        ABC_FREE( pLits );
+        return 0;
+    }
+    ABC_FREE( pLits );
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Adds the OR-clause.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_DataWriteOrClause2( void * p, Cnf_Dat_t * pCnf )
+{
+    sat_solver2 * pSat = (sat_solver2 *)p;
+    Aig_Obj_t * pObj;
+    int i, * pLits;
+    pLits = ABC_ALLOC( int, Aig_ManPoNum(pCnf->pMan) );
+    Aig_ManForEachPo( pCnf->pMan, pObj, i )
+        pLits[i] = toLitCond( pCnf->pVarNums[pObj->Id], 0 );
+    if ( !sat_solver2_addclause( pSat, pLits, pLits + Aig_ManPoNum(pCnf->pMan) ) )
+    {
+        ABC_FREE( pLits );
+        return 0;
+    }
+    ABC_FREE( pLits );
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Adds the OR-clause.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_DataWriteAndClauses( void * p, Cnf_Dat_t * pCnf )
+{
+    sat_solver * pSat = (sat_solver *)p;
+    Aig_Obj_t * pObj;
+    int i, Lit;
+    Aig_ManForEachPo( pCnf->pMan, pObj, i )
+    {
+        Lit = toLitCond( pCnf->pVarNums[pObj->Id], 0 );
+        if ( !sat_solver_addclause( pSat, &Lit, &Lit+1 ) )
+            return 0;
+    }
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Transforms polarity of the internal veriables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DataTranformPolarity( Cnf_Dat_t * pCnf, int fTransformPos )
+{
+    Aig_Obj_t * pObj;
+    int * pVarToPol;
+    int i, iVar;
+    // create map from the variable number to its polarity
+    pVarToPol = ABC_CALLOC( int, pCnf->nVars );
+    Aig_ManForEachObj( pCnf->pMan, pObj, i )
+    {
+        if ( !fTransformPos && Aig_ObjIsPo(pObj) )
+            continue;
+        if ( pCnf->pVarNums[pObj->Id] >= 0 )
+            pVarToPol[ pCnf->pVarNums[pObj->Id] ] = pObj->fPhase;
+    }
+    // transform literals
+    for ( i = 0; i < pCnf->nLiterals; i++ )
+    {
+        iVar = lit_var(pCnf->pClauses[0][i]);
+        assert( iVar < pCnf->nVars );
+        if ( pVarToPol[iVar] )
+            pCnf->pClauses[0][i] = lit_neg( pCnf->pClauses[0][i] );
+    }
+    ABC_FREE( pVarToPol );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Adds constraints for the two-input AND-gate.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_DataAddXorClause( void * pSat, int iVarA, int iVarB, int iVarC )
+{
+    lit Lits[3];
+    assert( iVarA > 0 && iVarB > 0 && iVarC > 0 );
+
+    Lits[0] = toLitCond( iVarA, 1 );
+    Lits[1] = toLitCond( iVarB, 1 );
+    Lits[2] = toLitCond( iVarC, 1 );
+    if ( !sat_solver_addclause( (sat_solver *)pSat, Lits, Lits + 3 ) )
+        return 0;
+
+    Lits[0] = toLitCond( iVarA, 1 );
+    Lits[1] = toLitCond( iVarB, 0 );
+    Lits[2] = toLitCond( iVarC, 0 );
+    if ( !sat_solver_addclause( (sat_solver *)pSat, Lits, Lits + 3 ) )
+        return 0;
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVarB, 1 );
+    Lits[2] = toLitCond( iVarC, 0 );
+    if ( !sat_solver_addclause( (sat_solver *)pSat, Lits, Lits + 3 ) )
+        return 0;
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVarB, 0 );
+    Lits[2] = toLitCond( iVarC, 1 );
+    if ( !sat_solver_addclause( (sat_solver *)pSat, Lits, Lits + 3 ) )
+        return 0;
+
+    return 1;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfMap.c b/src/sat/cnf/cnfMap.c
new file mode 100644
index 00000000..8907485e
--- /dev/null
+++ b/src/sat/cnf/cnfMap.c
@@ -0,0 +1,362 @@
+/**CFile****************************************************************
+
+  FileName    [cnfMap.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfMap.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area flow of the cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutAssignAreaFlow( Cnf_Man_t * p, Dar_Cut_t * pCut, int * pAreaFlows )
+{
+    Aig_Obj_t * pLeaf;
+    int i;
+    pCut->Value = 0;
+//    pCut->uSign = 100 * Cnf_CutSopCost( p, pCut );
+    pCut->uSign = 10 * Cnf_CutSopCost( p, pCut );
+    Dar_CutForEachLeaf( p->pManAig, pCut, pLeaf, i )
+    {
+        pCut->Value += pLeaf->nRefs;
+        if ( !Aig_ObjIsNode(pLeaf) )
+            continue;
+        assert( pLeaf->nRefs > 0 );
+        pCut->uSign += pAreaFlows[pLeaf->Id] / (pLeaf->nRefs? pLeaf->nRefs : 1);
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area flow of the supergate.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_CutSuperAreaFlow( Vec_Ptr_t * vSuper, int * pAreaFlows )
+{
+    Aig_Obj_t * pLeaf;
+    int i, nAreaFlow;
+    nAreaFlow = 100 * (Vec_PtrSize(vSuper) + 1);
+    Vec_PtrForEachEntry( Aig_Obj_t *, vSuper, pLeaf, i )
+    {
+        pLeaf = Aig_Regular(pLeaf);
+        if ( !Aig_ObjIsNode(pLeaf) )
+            continue;
+        assert( pLeaf->nRefs > 0 );
+        nAreaFlow += pAreaFlows[pLeaf->Id] / (pLeaf->nRefs? pLeaf->nRefs : 1);
+    }
+    return nAreaFlow;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_DeriveMapping( Cnf_Man_t * p )
+{
+    Vec_Ptr_t * vSuper;
+    Aig_Obj_t * pObj;
+    Dar_Cut_t * pCut, * pCutBest;
+    int i, k, AreaFlow, * pAreaFlows;
+    // allocate area flows
+    pAreaFlows = ABC_ALLOC( int, Aig_ManObjNumMax(p->pManAig) );
+    memset( pAreaFlows, 0, sizeof(int) * Aig_ManObjNumMax(p->pManAig) );
+    // visit the nodes in the topological order and update their best cuts
+    vSuper = Vec_PtrAlloc( 100 );
+    Aig_ManForEachNode( p->pManAig, pObj, i )
+    {
+        // go through the cuts
+        pCutBest = NULL;
+        Dar_ObjForEachCut( pObj, pCut, k )
+        {
+            pCut->fBest = 0;
+            if ( k == 0 )
+                continue;
+            Cnf_CutAssignAreaFlow( p, pCut, pAreaFlows );
+            if ( pCutBest == NULL || pCutBest->uSign > pCut->uSign || 
+                (pCutBest->uSign == pCut->uSign && pCutBest->Value < pCut->Value) )
+                 pCutBest = pCut;
+        }
+        // check the big cut
+//        Aig_ObjCollectSuper( pObj, vSuper );
+        // get the area flow of this cut
+//        AreaFlow = Cnf_CutSuperAreaFlow( vSuper, pAreaFlows );
+        AreaFlow = ABC_INFINITY;
+        if ( AreaFlow >= (int)pCutBest->uSign )
+        {
+            pAreaFlows[pObj->Id] = pCutBest->uSign;
+            pCutBest->fBest = 1;
+        }
+        else
+        {
+            pAreaFlows[pObj->Id] = AreaFlow;
+            pObj->fMarkB = 1; // mark the special node
+        }
+    }
+    Vec_PtrFree( vSuper );
+    ABC_FREE( pAreaFlows );
+
+/*
+    // compute the area of mapping
+    AreaFlow = 0;
+    Aig_ManForEachPo( p->pManAig, pObj, i )
+        AreaFlow += Dar_ObjBestCut(Aig_ObjFanin0(pObj))->uSign / 100 / Aig_ObjFanin0(pObj)->nRefs;
+    printf( "Area of the network = %d.\n", AreaFlow );
+*/
+}
+
+
+
+#if 0
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area of the first level.]
+
+  Description [The cut need to be derefed.]
+               
+  SideEffects []
+
+  SeeAlso     []
+ 
+***********************************************************************/
+void Aig_CutDeref( Aig_Man_t * p, Dar_Cut_t * pCut )
+{ 
+    Aig_Obj_t * pLeaf;
+    int i;
+    Dar_CutForEachLeaf( p, pCut, pLeaf, i )
+    {
+        assert( pLeaf->nRefs > 0 );
+        if ( --pLeaf->nRefs > 0 || !Aig_ObjIsAnd(pLeaf) )
+            continue;
+        Aig_CutDeref( p, Aig_ObjBestCut(pLeaf) );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area of the first level.]
+
+  Description [The cut need to be derefed.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Aig_CutRef( Aig_Man_t * p, Dar_Cut_t * pCut )
+{
+    Aig_Obj_t * pLeaf;
+    int i, Area = pCut->Value;
+    Dar_CutForEachLeaf( p, pCut, pLeaf, i )
+    {
+        assert( pLeaf->nRefs >= 0 );
+        if ( pLeaf->nRefs++ > 0 || !Aig_ObjIsAnd(pLeaf) )
+            continue;
+        Area += Aig_CutRef( p, Aig_ObjBestCut(pLeaf) );
+    }
+    return Area;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes exact area of the cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_CutArea( Aig_Man_t * p, Dar_Cut_t * pCut )
+{
+    int Area;
+    Area = Aig_CutRef( p, pCut );
+    Aig_CutDeref( p, pCut );
+    return Area;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns 1 if the second cut is better.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Cnf_CutCompare( Dar_Cut_t * pC0, Dar_Cut_t * pC1 )
+{
+    if ( pC0->Area < pC1->Area - 0.0001 )
+        return -1;
+    if ( pC0->Area > pC1->Area + 0.0001 ) // smaller area flow is better
+        return 1;
+//    if ( pC0->NoRefs < pC1->NoRefs )
+//        return -1;
+//    if ( pC0->NoRefs > pC1->NoRefs ) // fewer non-referenced fanins is better
+//        return 1;
+//    if ( pC0->FanRefs / pC0->nLeaves > pC1->FanRefs / pC1->nLeaves )
+//        return -1;
+//    if ( pC0->FanRefs / pC0->nLeaves < pC1->FanRefs / pC1->nLeaves )
+//        return 1; // larger average fanin ref-counter is better
+//    return 0;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the cut with the smallest area flow.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Dar_Cut_t * Cnf_ObjFindBestCut( Aig_Obj_t * pObj )
+{
+    Dar_Cut_t * pCut, * pCutBest;
+    int i;
+    pCutBest = NULL;
+    Dar_ObjForEachCut( pObj, pCut, i )
+        if ( pCutBest == NULL || Cnf_CutCompare(pCutBest, pCut) == 1 )
+            pCutBest = pCut;
+    return pCutBest;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area flow of the cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_CutAssignArea( Cnf_Man_t * p, Dar_Cut_t * pCut )
+{
+    Aig_Obj_t * pLeaf;
+    int i;
+    pCut->Area    = (float)pCut->Cost;
+    pCut->NoRefs  = 0;
+    pCut->FanRefs = 0;
+    Dar_CutForEachLeaf( p->pManAig, pCut, pLeaf, i )
+    {
+        if ( !Aig_ObjIsNode(pLeaf) )
+            continue;
+        if ( pLeaf->nRefs == 0 )
+        {
+            pCut->Area += Aig_ObjBestCut(pLeaf)->Cost;
+            pCut->NoRefs++;
+        }
+        else
+        {
+            if ( pCut->FanRefs + pLeaf->nRefs > 15 )
+                pCut->FanRefs = 15;
+            else
+                pCut->FanRefs += pLeaf->nRefs;
+        }
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs one round of "area recovery" using exact local area.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_ManMapForCnf( Cnf_Man_t * p )
+{
+    Aig_Obj_t * pObj;
+    Dar_Cut_t * pCut, * pCutBest;
+    int i, k;
+    // visit the nodes in the topological order and update their best cuts
+    Aig_ManForEachNode( p->pManAig, pObj, i )
+    {
+        // find the old best cut
+        pCutBest = Aig_ObjBestCut(pObj);
+        Dar_ObjClearBestCut(pCutBest);
+        // if the node is used, dereference its cut
+        if ( pObj->nRefs )
+            Aig_CutDeref( p->pManAig, pCutBest );
+
+        // evaluate the cuts of this node
+        Dar_ObjForEachCut( pObj, pCut, k )
+//            Cnf_CutAssignAreaFlow( p, pCut );
+            pCut->Area = (float)Cnf_CutArea( p->pManAig, pCut );
+
+        // find the new best cut
+        pCutBest = Cnf_ObjFindBestCut(pObj);
+        Dar_ObjSetBestCut( pCutBest );
+        // if the node is used, reference its cut
+        if ( pObj->nRefs )
+            Aig_CutRef( p->pManAig, pCutBest );
+    }
+    return 1;
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfPost.c b/src/sat/cnf/cnfPost.c
new file mode 100644
index 00000000..f7491889
--- /dev/null
+++ b/src/sat/cnf/cnfPost.c
@@ -0,0 +1,238 @@
+/**CFile****************************************************************
+
+  FileName    [cnfPost.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfPost.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ManPostprocess_old( Cnf_Man_t * p )
+{
+//    extern int Aig_ManLargeCutEval( Aig_Man_t * p, Aig_Obj_t * pRoot, Dar_Cut_t * pCutR, Dar_Cut_t * pCutL, int Leaf );
+    int nNew, Gain, nGain = 0, nVars = 0;
+
+    Aig_Obj_t * pObj, * pFan;
+    Dar_Cut_t * pCutBest, * pCut;
+    int i, k;//, a, b, Counter;
+    Aig_ManForEachObj( p->pManAig, pObj, i )
+    {
+        if ( !Aig_ObjIsNode(pObj) )
+            continue;
+        if ( pObj->nRefs == 0 )
+            continue;
+//        pCutBest = Aig_ObjBestCut(pObj);
+        pCutBest = NULL;
+
+        Dar_CutForEachLeaf( p->pManAig, pCutBest, pFan, k )
+        {
+            if ( !Aig_ObjIsNode(pFan) )
+                continue;
+            assert( pFan->nRefs != 0 );
+            if ( pFan->nRefs != 1 )
+                continue;
+//            pCut = Aig_ObjBestCut(pFan);
+            pCut = NULL;
+/*
+            // find how many common variable they have
+            Counter = 0;
+            for ( a = 0; a < (int)pCut->nLeaves; a++ )
+            {
+                for ( b = 0; b < (int)pCutBest->nLeaves; b++ )
+                    if ( pCut->pLeaves[a] == pCutBest->pLeaves[b] )
+                        break;
+                if ( b == (int)pCutBest->nLeaves )
+                    continue;
+                Counter++;
+            }
+            printf( "%d ", Counter );
+*/
+            // find the new truth table after collapsing these two cuts
+
+
+//            nNew = Aig_ManLargeCutEval( p->pManAig, pObj, pCutBest, pCut, pFan->Id );
+            nNew = 0;
+
+
+//            printf( "%d+%d=%d:%d(%d) ", pCutBest->Cost, pCut->Cost, 
+//                pCutBest->Cost+pCut->Cost, nNew, pCutBest->Cost+pCut->Cost-nNew );
+
+            Gain = pCutBest->Value + pCut->Value - nNew;
+            if ( Gain > 0 )
+            {
+                nGain += Gain;
+                nVars++;
+            }
+        }
+    }
+    printf( "Total gain = %d.  Vars = %d.\n", nGain, nVars );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Transfers cuts of the mapped nodes into internal representation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ManTransferCuts( Cnf_Man_t * p )
+{
+    Aig_Obj_t * pObj;
+    int i;
+    Aig_MmFlexRestart( p->pMemCuts );
+    Aig_ManForEachObj( p->pManAig, pObj, i )
+    {
+        if ( Aig_ObjIsNode(pObj) && pObj->nRefs > 0 )
+            pObj->pData = Cnf_CutCreate( p, pObj );
+        else
+            pObj->pData = NULL;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Transfers cuts of the mapped nodes into internal representation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ManFreeCuts( Cnf_Man_t * p )
+{
+    Aig_Obj_t * pObj;
+    int i;
+    Aig_ManForEachObj( p->pManAig, pObj, i )
+        if ( pObj->pData )
+        {
+            Cnf_CutFree( (Cnf_Cut_t *)pObj->pData );
+            pObj->pData = NULL;
+        }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_ManPostprocess( Cnf_Man_t * p )
+{
+    Cnf_Cut_t * pCut, * pCutFan, * pCutRes;
+    Aig_Obj_t * pObj, * pFan;
+    int Order[16], Costs[16];
+    int i, k, fChanges;
+    Aig_ManForEachNode( p->pManAig, pObj, i )
+    {
+        if ( pObj->nRefs == 0 )
+            continue;
+        pCut = Cnf_ObjBestCut(pObj);
+
+        // sort fanins according to their size
+        Cnf_CutForEachLeaf( p->pManAig, pCut, pFan, k )
+        {
+            Order[k] = k;
+            Costs[k] = Aig_ObjIsNode(pFan)? Cnf_ObjBestCut(pFan)->Cost : 0;
+        }
+        // sort the cuts by Weight
+        do {
+            int Temp;
+            fChanges = 0;
+            for ( k = 0; k < pCut->nFanins - 1; k++ )
+            {
+                if ( Costs[Order[k]] <= Costs[Order[k+1]] )
+                    continue;
+                Temp = Order[k];
+                Order[k] = Order[k+1];
+                Order[k+1] = Temp;
+                fChanges = 1;
+            }
+        } while ( fChanges );
+
+
+//        Cnf_CutForEachLeaf( p->pManAig, pCut, pFan, k )
+        for ( k = 0; (k < (int)(pCut)->nFanins) && ((pFan) = Aig_ManObj(p->pManAig, (pCut)->pFanins[Order[k]])); k++ )
+        {
+            if ( !Aig_ObjIsNode(pFan) )
+                continue;
+            assert( pFan->nRefs != 0 );
+            if ( pFan->nRefs != 1 )
+                continue;
+            pCutFan = Cnf_ObjBestCut(pFan);
+            // try composing these two cuts
+//            Cnf_CutPrint( pCut );
+            pCutRes = Cnf_CutCompose( p, pCut, pCutFan, pFan->Id );
+//            Cnf_CutPrint( pCut );
+//            printf( "\n" );
+            // check if the cost if reduced
+            if ( pCutRes == NULL || pCutRes->Cost == 127 || pCutRes->Cost > pCut->Cost + pCutFan->Cost )
+            {
+                if ( pCutRes )
+                    Cnf_CutFree( pCutRes );
+                continue;
+            }
+            // update the cut
+            Cnf_ObjSetBestCut( pObj, pCutRes );
+            Cnf_ObjSetBestCut( pFan, NULL );
+            Cnf_CutUpdateRefs( p, pCut, pCutFan, pCutRes );
+            assert( pFan->nRefs == 0 );
+            Cnf_CutFree( pCut );
+            Cnf_CutFree( pCutFan );
+            break;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfUtil.c b/src/sat/cnf/cnfUtil.c
new file mode 100644
index 00000000..236b6bfa
--- /dev/null
+++ b/src/sat/cnf/cnfUtil.c
@@ -0,0 +1,238 @@
+/**CFile****************************************************************
+
+  FileName    [cnfUtil.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfUtil.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area, references, and nodes used in the mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Aig_ManScanMapping_rec( Cnf_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vMapped )
+{
+    Aig_Obj_t * pLeaf;
+    Dar_Cut_t * pCutBest;
+    int aArea, i;
+    if ( pObj->nRefs++ || Aig_ObjIsPi(pObj) || Aig_ObjIsConst1(pObj) )
+        return 0;
+    assert( Aig_ObjIsAnd(pObj) );
+    // collect the node first to derive pre-order
+    if ( vMapped )
+        Vec_PtrPush( vMapped, pObj );
+    // visit the transitive fanin of the selected cut
+    if ( pObj->fMarkB )
+    {
+        Vec_Ptr_t * vSuper = Vec_PtrAlloc( 100 );
+        Aig_ObjCollectSuper( pObj, vSuper );
+        aArea = Vec_PtrSize(vSuper) + 1;
+        Vec_PtrForEachEntry( Aig_Obj_t *, vSuper, pLeaf, i )
+            aArea += Aig_ManScanMapping_rec( p, Aig_Regular(pLeaf), vMapped );
+        Vec_PtrFree( vSuper );
+        ////////////////////////////
+        pObj->fMarkB = 1;
+    }
+    else
+    {
+        pCutBest = Dar_ObjBestCut( pObj );
+        aArea = Cnf_CutSopCost( p, pCutBest );
+        Dar_CutForEachLeaf( p->pManAig, pCutBest, pLeaf, i )
+            aArea += Aig_ManScanMapping_rec( p, pLeaf, vMapped );
+    }
+    return aArea;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area, references, and nodes used in the mapping.]
+
+  Description [Collects the nodes in reverse topological order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Aig_ManScanMapping( Cnf_Man_t * p, int fCollect )
+{
+    Vec_Ptr_t * vMapped = NULL;
+    Aig_Obj_t * pObj;
+    int i;
+    // clean all references
+    Aig_ManForEachObj( p->pManAig, pObj, i )
+        pObj->nRefs = 0;
+    // allocate the array
+    if ( fCollect )
+        vMapped = Vec_PtrAlloc( 1000 );
+    // collect nodes reachable from POs in the DFS order through the best cuts
+    p->aArea = 0;
+    Aig_ManForEachPo( p->pManAig, pObj, i )
+        p->aArea += Aig_ManScanMapping_rec( p, Aig_ObjFanin0(pObj), vMapped );
+//    printf( "Variables = %6d. Clauses = %8d.\n", vMapped? Vec_PtrSize(vMapped) + Aig_ManPiNum(p->pManAig) + 1 : 0, p->aArea + 2 );
+    return vMapped;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area, references, and nodes used in the mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_ManScanMapping_rec( Cnf_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vMapped, int fPreorder )
+{
+    Aig_Obj_t * pLeaf;
+    Cnf_Cut_t * pCutBest;
+    int aArea, i;
+    if ( pObj->nRefs++ || Aig_ObjIsPi(pObj) || Aig_ObjIsConst1(pObj) )
+        return 0;
+    assert( Aig_ObjIsAnd(pObj) );
+    assert( pObj->pData != NULL );
+    // add the node to the mapping
+    if ( vMapped && fPreorder )
+         Vec_PtrPush( vMapped, pObj );
+    // visit the transitive fanin of the selected cut
+    if ( pObj->fMarkB )
+    {
+        Vec_Ptr_t * vSuper = Vec_PtrAlloc( 100 );
+        Aig_ObjCollectSuper( pObj, vSuper );
+        aArea = Vec_PtrSize(vSuper) + 1;
+        Vec_PtrForEachEntry( Aig_Obj_t *, vSuper, pLeaf, i )
+            aArea += Cnf_ManScanMapping_rec( p, Aig_Regular(pLeaf), vMapped, fPreorder );
+        Vec_PtrFree( vSuper );
+        ////////////////////////////
+        pObj->fMarkB = 1;
+    }
+    else
+    {
+        pCutBest = (Cnf_Cut_t *)pObj->pData;
+//        assert( pCutBest->nFanins > 0 );
+        assert( pCutBest->Cost < 127 );
+        aArea = pCutBest->Cost;
+        Cnf_CutForEachLeaf( p->pManAig, pCutBest, pLeaf, i )
+            aArea += Cnf_ManScanMapping_rec( p, pLeaf, vMapped, fPreorder );
+    }
+    // add the node to the mapping
+    if ( vMapped && !fPreorder )
+         Vec_PtrPush( vMapped, pObj );
+    return aArea;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area, references, and nodes used in the mapping.]
+
+  Description [Collects the nodes in reverse topological order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Cnf_ManScanMapping( Cnf_Man_t * p, int fCollect, int fPreorder )
+{
+    Vec_Ptr_t * vMapped = NULL;
+    Aig_Obj_t * pObj;
+    int i;
+    // clean all references
+    Aig_ManForEachObj( p->pManAig, pObj, i )
+        pObj->nRefs = 0;
+    // allocate the array
+    if ( fCollect )
+        vMapped = Vec_PtrAlloc( 1000 );
+    // collect nodes reachable from POs in the DFS order through the best cuts
+    p->aArea = 0;
+    Aig_ManForEachPo( p->pManAig, pObj, i )
+        p->aArea += Cnf_ManScanMapping_rec( p, Aig_ObjFanin0(pObj), vMapped, fPreorder );
+//    printf( "Variables = %6d. Clauses = %8d.\n", vMapped? Vec_PtrSize(vMapped) + Aig_ManPiNum(p->pManAig) + 1 : 0, p->aArea + 2 );
+    return vMapped;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the array of CI IDs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Cnf_DataCollectCiSatNums( Cnf_Dat_t * pCnf, Aig_Man_t * p )
+{
+    Vec_Int_t * vCiIds;
+    Aig_Obj_t * pObj;
+    int i;
+    vCiIds = Vec_IntAlloc( Aig_ManPiNum(p) );
+    Aig_ManForEachPi( p, pObj, i )
+        Vec_IntPush( vCiIds, pCnf->pVarNums[pObj->Id] );
+    return vCiIds;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the array of CI IDs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Cnf_DataCollectCoSatNums( Cnf_Dat_t * pCnf, Aig_Man_t * p )
+{
+    Vec_Int_t * vCoIds;
+    Aig_Obj_t * pObj;
+    int i;
+    vCoIds = Vec_IntAlloc( Aig_ManPoNum(p) );
+    Aig_ManForEachPo( p, pObj, i )
+        Vec_IntPush( vCoIds, pCnf->pVarNums[pObj->Id] );
+    return vCoIds;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/cnf/cnfWrite.c b/src/sat/cnf/cnfWrite.c
new file mode 100644
index 00000000..54c28967
--- /dev/null
+++ b/src/sat/cnf/cnfWrite.c
@@ -0,0 +1,806 @@
+/**CFile****************************************************************
+
+  FileName    [cnfWrite.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [AIG-to-CNF conversion.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - April 28, 2007.]
+
+  Revision    [$Id: cnfWrite.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cnf.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Derives CNF mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Cnf_ManWriteCnfMapping( Cnf_Man_t * p, Vec_Ptr_t * vMapped )
+{
+    Vec_Int_t * vResult;
+    Aig_Obj_t * pObj;
+    Cnf_Cut_t * pCut;
+    int i, k, nOffset;
+    nOffset = Aig_ManObjNumMax(p->pManAig);
+    vResult = Vec_IntStart( nOffset );
+    Vec_PtrForEachEntry( Aig_Obj_t *, vMapped, pObj, i )
+    {
+        assert( Aig_ObjIsNode(pObj) );
+        pCut = Cnf_ObjBestCut( pObj );
+        assert( pCut->nFanins < 5 );
+        Vec_IntWriteEntry( vResult, Aig_ObjId(pObj), nOffset );
+        Vec_IntPush( vResult, *Cnf_CutTruth(pCut) );
+        for ( k = 0; k < pCut->nFanins; k++ )
+            Vec_IntPush( vResult, pCut->pFanins[k] );
+        for (      ; k < 4; k++ )
+            Vec_IntPush( vResult, -1 );
+        nOffset += 5;
+    }
+    return vResult;
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Writes the cover into the array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cnf_SopConvertToVector( char * pSop, int nCubes, Vec_Int_t * vCover )
+{
+    int Lits[4], Cube, iCube, i, b;
+    Vec_IntClear( vCover );
+    for ( i = 0; i < nCubes; i++ )
+    {
+        Cube = pSop[i];
+        for ( b = 0; b < 4; b++ )
+        {
+            if ( Cube % 3 == 0 )
+                Lits[b] = 1;
+            else if ( Cube % 3 == 1 )
+                Lits[b] = 2;
+            else
+                Lits[b] = 0;
+            Cube = Cube / 3;
+        }
+        iCube = 0;
+        for ( b = 0; b < 4; b++ )
+            iCube = (iCube << 2) | Lits[b];
+        Vec_IntPush( vCover, iCube );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the number of literals in the SOP.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_SopCountLiterals( char * pSop, int nCubes )
+{
+    int nLits = 0, Cube, i, b;
+    for ( i = 0; i < nCubes; i++ )
+    {
+        Cube = pSop[i];
+        for ( b = 0; b < 4; b++ )
+        {
+            if ( Cube % 3 != 2 )
+                nLits++;
+            Cube = Cube / 3;
+        }
+    }
+    return nLits;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the number of literals in the SOP.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_IsopCountLiterals( Vec_Int_t * vIsop, int nVars )
+{
+    int nLits = 0, Cube, i, b;
+    Vec_IntForEachEntry( vIsop, Cube, i )
+    {
+        for ( b = 0; b < nVars; b++ )
+        {
+            if ( (Cube & 3) == 1 || (Cube & 3) == 2 )
+                nLits++;
+            Cube >>= 2;
+        }
+    }
+    return nLits;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes the cube and returns the number of literals in it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Cnf_IsopWriteCube( int Cube, int nVars, int * pVars, int * pLiterals )
+{
+    int nLits = nVars, b;
+    for ( b = 0; b < nVars; b++ )
+    {
+        if ( (Cube & 3) == 1 ) // value 0 --> write positive literal
+            *pLiterals++ = 2 * pVars[b];
+        else if ( (Cube & 3) == 2 ) // value 1 --> write negative literal
+            *pLiterals++ = 2 * pVars[b] + 1;
+        else
+            nLits--;
+        Cube >>= 2;
+    }
+    return nLits;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derives CNF for the mapping.]
+
+  Description [The last argument shows the number of last outputs
+  of the manager, which will not be converted into clauses but the
+  new variables for which will be introduced.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_ManWriteCnf( Cnf_Man_t * p, Vec_Ptr_t * vMapped, int nOutputs )
+{
+    int fChangeVariableOrder = 0; // should be set to 0 to improve performance
+    Aig_Obj_t * pObj;
+    Cnf_Dat_t * pCnf;
+    Cnf_Cut_t * pCut;
+    Vec_Int_t * vCover, * vSopTemp;
+    int OutVar, PoVar, pVars[32], * pLits, ** pClas;
+    unsigned uTruth;
+    int i, k, nLiterals, nClauses, Cube, Number;
+
+    // count the number of literals and clauses
+    nLiterals = 1 + Aig_ManPoNum( p->pManAig ) + 3 * nOutputs;
+    nClauses = 1 + Aig_ManPoNum( p->pManAig ) + nOutputs;
+    Vec_PtrForEachEntry( Aig_Obj_t *, vMapped, pObj, i )
+    {
+        assert( Aig_ObjIsNode(pObj) );
+        pCut = Cnf_ObjBestCut( pObj );
+
+        // positive polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & *Cnf_CutTruth(pCut);
+            nLiterals += Cnf_SopCountLiterals( p->pSops[uTruth], p->pSopSizes[uTruth] ) + p->pSopSizes[uTruth];
+            assert( p->pSopSizes[uTruth] >= 0 );
+            nClauses += p->pSopSizes[uTruth];
+        }
+        else
+        {
+            nLiterals += Cnf_IsopCountLiterals( pCut->vIsop[1], pCut->nFanins ) + Vec_IntSize(pCut->vIsop[1]);
+            nClauses += Vec_IntSize(pCut->vIsop[1]);
+        }
+        // negative polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & ~*Cnf_CutTruth(pCut);
+            nLiterals += Cnf_SopCountLiterals( p->pSops[uTruth], p->pSopSizes[uTruth] ) + p->pSopSizes[uTruth];
+            assert( p->pSopSizes[uTruth] >= 0 );
+            nClauses += p->pSopSizes[uTruth];
+        }
+        else
+        {
+            nLiterals += Cnf_IsopCountLiterals( pCut->vIsop[0], pCut->nFanins ) + Vec_IntSize(pCut->vIsop[0]);
+            nClauses += Vec_IntSize(pCut->vIsop[0]);
+        }
+//printf( "%d ", nClauses-(1 + Aig_ManPoNum( p->pManAig )) );
+    }
+//printf( "\n" );
+
+    // allocate CNF
+    pCnf = ABC_CALLOC( Cnf_Dat_t, 1 );
+    pCnf->pMan = p->pManAig;
+    pCnf->nLiterals = nLiterals;
+    pCnf->nClauses = nClauses;
+    pCnf->pClauses = ABC_ALLOC( int *, nClauses + 1 );
+    pCnf->pClauses[0] = ABC_ALLOC( int, nLiterals );
+    pCnf->pClauses[nClauses] = pCnf->pClauses[0] + nLiterals;
+    // create room for variable numbers
+    pCnf->pVarNums = ABC_ALLOC( int, Aig_ManObjNumMax(p->pManAig) );
+//    memset( pCnf->pVarNums, 0xff, sizeof(int) * Aig_ManObjNumMax(p->pManAig) );
+    for ( i = 0; i < Aig_ManObjNumMax(p->pManAig); i++ )
+        pCnf->pVarNums[i] = -1;
+
+    if ( !fChangeVariableOrder )
+    {
+        // assign variables to the last (nOutputs) POs
+        Number = 1;
+        if ( nOutputs )
+        {
+            if ( Aig_ManRegNum(p->pManAig) == 0 )
+            {
+                assert( nOutputs == Aig_ManPoNum(p->pManAig) );
+                Aig_ManForEachPo( p->pManAig, pObj, i )
+                    pCnf->pVarNums[pObj->Id] = Number++;
+            }
+            else
+            {
+                assert( nOutputs == Aig_ManRegNum(p->pManAig) );
+                Aig_ManForEachLiSeq( p->pManAig, pObj, i )
+                    pCnf->pVarNums[pObj->Id] = Number++;
+            }
+        }
+        // assign variables to the internal nodes
+        Vec_PtrForEachEntry( Aig_Obj_t *, vMapped, pObj, i )
+            pCnf->pVarNums[pObj->Id] = Number++;
+        // assign variables to the PIs and constant node
+        Aig_ManForEachPi( p->pManAig, pObj, i )
+            pCnf->pVarNums[pObj->Id] = Number++;
+        pCnf->pVarNums[Aig_ManConst1(p->pManAig)->Id] = Number++;
+        pCnf->nVars = Number;
+    }
+    else
+    {
+        // assign variables to the last (nOutputs) POs
+        Number = Aig_ManObjNumMax(p->pManAig) + 1;
+        pCnf->nVars = Number + 1;
+        if ( nOutputs )
+        {
+            if ( Aig_ManRegNum(p->pManAig) == 0 )
+            {
+                assert( nOutputs == Aig_ManPoNum(p->pManAig) );
+                Aig_ManForEachPo( p->pManAig, pObj, i )
+                    pCnf->pVarNums[pObj->Id] = Number--;
+            }
+            else
+            {
+                assert( nOutputs == Aig_ManRegNum(p->pManAig) );
+                Aig_ManForEachLiSeq( p->pManAig, pObj, i )
+                    pCnf->pVarNums[pObj->Id] = Number--;
+            }
+        }
+        // assign variables to the internal nodes
+        Vec_PtrForEachEntry( Aig_Obj_t *, vMapped, pObj, i )
+            pCnf->pVarNums[pObj->Id] = Number--;
+        // assign variables to the PIs and constant node
+        Aig_ManForEachPi( p->pManAig, pObj, i )
+            pCnf->pVarNums[pObj->Id] = Number--;
+        pCnf->pVarNums[Aig_ManConst1(p->pManAig)->Id] = Number--;
+        assert( Number >= 0 );
+    }
+
+    // assign the clauses
+    vSopTemp = Vec_IntAlloc( 1 << 16 );
+    pLits = pCnf->pClauses[0];
+    pClas = pCnf->pClauses;
+    Vec_PtrForEachEntry( Aig_Obj_t *, vMapped, pObj, i )
+    {
+        pCut = Cnf_ObjBestCut( pObj );
+
+        // save variables of this cut
+        OutVar = pCnf->pVarNums[ pObj->Id ];
+        for ( k = 0; k < (int)pCut->nFanins; k++ )
+        {
+            pVars[k] = pCnf->pVarNums[ pCut->pFanins[k] ];
+            assert( pVars[k] <= Aig_ManObjNumMax(p->pManAig) );
+        }
+
+        // positive polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & *Cnf_CutTruth(pCut);
+            Cnf_SopConvertToVector( p->pSops[uTruth], p->pSopSizes[uTruth], vSopTemp );
+            vCover = vSopTemp;
+        }
+        else
+            vCover = pCut->vIsop[1];
+        Vec_IntForEachEntry( vCover, Cube, k )
+        {
+            *pClas++ = pLits;
+            *pLits++ = 2 * OutVar; 
+            pLits += Cnf_IsopWriteCube( Cube, pCut->nFanins, pVars, pLits );
+        }
+
+        // negative polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & ~*Cnf_CutTruth(pCut);
+            Cnf_SopConvertToVector( p->pSops[uTruth], p->pSopSizes[uTruth], vSopTemp );
+            vCover = vSopTemp;
+        }
+        else
+            vCover = pCut->vIsop[0];
+        Vec_IntForEachEntry( vCover, Cube, k )
+        {
+            *pClas++ = pLits;
+            *pLits++ = 2 * OutVar + 1; 
+            pLits += Cnf_IsopWriteCube( Cube, pCut->nFanins, pVars, pLits );
+        }
+    }
+    Vec_IntFree( vSopTemp );
+ 
+    // write the constant literal
+    OutVar = pCnf->pVarNums[ Aig_ManConst1(p->pManAig)->Id ];
+    assert( OutVar <= Aig_ManObjNumMax(p->pManAig) );
+    *pClas++ = pLits;
+    *pLits++ = 2 * OutVar; 
+
+    // write the output literals
+    Aig_ManForEachPo( p->pManAig, pObj, i )
+    {
+        OutVar = pCnf->pVarNums[ Aig_ObjFanin0(pObj)->Id ];
+        if ( i < Aig_ManPoNum(p->pManAig) - nOutputs )
+        {
+            *pClas++ = pLits;
+            *pLits++ = 2 * OutVar + Aig_ObjFaninC0(pObj); 
+        }
+        else
+        {
+            PoVar = pCnf->pVarNums[ pObj->Id ];
+            // first clause
+            *pClas++ = pLits;
+            *pLits++ = 2 * PoVar; 
+            *pLits++ = 2 * OutVar + !Aig_ObjFaninC0(pObj); 
+            // second clause
+            *pClas++ = pLits;
+            *pLits++ = 2 * PoVar + 1; 
+            *pLits++ = 2 * OutVar + Aig_ObjFaninC0(pObj); 
+        }
+    }
+
+    // verify that the correct number of literals and clauses was written
+    assert( pLits - pCnf->pClauses[0] == nLiterals );
+    assert( pClas - pCnf->pClauses == nClauses );
+//Cnf_DataPrint( pCnf, 1 );
+    return pCnf;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Derives CNF for the mapping.]
+
+  Description [Derives CNF with obj IDs as SAT vars and mapping of
+  objects into clauses (pObj2Clause and pObj2Count).]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_ManWriteCnfOther( Cnf_Man_t * p, Vec_Ptr_t * vMapped )
+{
+    Aig_Obj_t * pObj;
+    Cnf_Dat_t * pCnf;
+    Cnf_Cut_t * pCut;
+    Vec_Int_t * vCover, * vSopTemp;
+    int OutVar, PoVar, pVars[32], * pLits, ** pClas;
+    unsigned uTruth;
+    int i, k, nLiterals, nClauses, Cube;
+
+    // count the number of literals and clauses
+    nLiterals = 1 + 4 * Aig_ManPoNum( p->pManAig );
+    nClauses  = 1 + 2 * Aig_ManPoNum( p->pManAig );
+    Vec_PtrForEachEntry( Aig_Obj_t *, vMapped, pObj, i )
+    {
+        assert( Aig_ObjIsNode(pObj) );
+        pCut = Cnf_ObjBestCut( pObj );
+        // positive polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & *Cnf_CutTruth(pCut);
+            nLiterals += Cnf_SopCountLiterals( p->pSops[uTruth], p->pSopSizes[uTruth] ) + p->pSopSizes[uTruth];
+            assert( p->pSopSizes[uTruth] >= 0 );
+            nClauses += p->pSopSizes[uTruth];
+        }
+        else
+        {
+            nLiterals += Cnf_IsopCountLiterals( pCut->vIsop[1], pCut->nFanins ) + Vec_IntSize(pCut->vIsop[1]);
+            nClauses += Vec_IntSize(pCut->vIsop[1]);
+        }
+        // negative polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & ~*Cnf_CutTruth(pCut);
+            nLiterals += Cnf_SopCountLiterals( p->pSops[uTruth], p->pSopSizes[uTruth] ) + p->pSopSizes[uTruth];
+            assert( p->pSopSizes[uTruth] >= 0 );
+            nClauses += p->pSopSizes[uTruth];
+        }
+        else
+        {
+            nLiterals += Cnf_IsopCountLiterals( pCut->vIsop[0], pCut->nFanins ) + Vec_IntSize(pCut->vIsop[0]);
+            nClauses += Vec_IntSize(pCut->vIsop[0]);
+        }
+    }
+
+    // allocate CNF
+    pCnf = ABC_CALLOC( Cnf_Dat_t, 1 );
+    pCnf->pMan = p->pManAig;
+    pCnf->nLiterals = nLiterals;
+    pCnf->nClauses  = nClauses;
+    pCnf->pClauses  = ABC_ALLOC( int *, nClauses + 1 );
+    pCnf->pClauses[0] = ABC_ALLOC( int, nLiterals );
+    pCnf->pClauses[nClauses] = pCnf->pClauses[0] + nLiterals;
+    // create room for variable numbers
+    pCnf->pObj2Clause = ABC_ALLOC( int, Aig_ManObjNumMax(p->pManAig) );
+    pCnf->pObj2Count  = ABC_ALLOC( int, Aig_ManObjNumMax(p->pManAig) );
+    for ( i = 0; i < Aig_ManObjNumMax(p->pManAig); i++ )
+        pCnf->pObj2Clause[i] = pCnf->pObj2Count[i] = -1;
+    pCnf->nVars = Aig_ManObjNumMax(p->pManAig);
+
+    // clear the PI counters
+    Aig_ManForEachPi( p->pManAig, pObj, i )
+        pCnf->pObj2Count[pObj->Id] = 0;
+
+    // assign the clauses
+    vSopTemp = Vec_IntAlloc( 1 << 16 );
+    pLits = pCnf->pClauses[0];
+    pClas = pCnf->pClauses;
+    Vec_PtrForEachEntry( Aig_Obj_t *, vMapped, pObj, i )
+    {
+        // remember the starting clause
+        pCnf->pObj2Clause[pObj->Id] = pClas - pCnf->pClauses;
+        pCnf->pObj2Count[pObj->Id] = 0;
+
+        // get the best cut
+        pCut = Cnf_ObjBestCut( pObj );
+        // save variables of this cut
+        OutVar = pObj->Id;
+        for ( k = 0; k < (int)pCut->nFanins; k++ )
+        {
+            pVars[k] = pCut->pFanins[k];
+            assert( pVars[k] <= Aig_ManObjNumMax(p->pManAig) );
+        }
+
+        // positive polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & *Cnf_CutTruth(pCut);
+            Cnf_SopConvertToVector( p->pSops[uTruth], p->pSopSizes[uTruth], vSopTemp );
+            vCover = vSopTemp;
+        }
+        else
+            vCover = pCut->vIsop[1];
+        Vec_IntForEachEntry( vCover, Cube, k )
+        {
+            *pClas++ = pLits;
+            *pLits++ = 2 * OutVar; 
+            pLits += Cnf_IsopWriteCube( Cube, pCut->nFanins, pVars, pLits );
+        }
+        pCnf->pObj2Count[pObj->Id] += Vec_IntSize(vCover);
+
+        // negative polarity of the cut
+        if ( pCut->nFanins < 5 )
+        {
+            uTruth = 0xFFFF & ~*Cnf_CutTruth(pCut);
+            Cnf_SopConvertToVector( p->pSops[uTruth], p->pSopSizes[uTruth], vSopTemp );
+            vCover = vSopTemp;
+        }
+        else
+            vCover = pCut->vIsop[0];
+        Vec_IntForEachEntry( vCover, Cube, k )
+        {
+            *pClas++ = pLits;
+            *pLits++ = 2 * OutVar + 1; 
+            pLits += Cnf_IsopWriteCube( Cube, pCut->nFanins, pVars, pLits );
+        }
+        pCnf->pObj2Count[pObj->Id] += Vec_IntSize(vCover);
+    }
+    Vec_IntFree( vSopTemp );
+
+    // write the output literals
+    Aig_ManForEachPo( p->pManAig, pObj, i )
+    {
+        // remember the starting clause
+        pCnf->pObj2Clause[pObj->Id] = pClas - pCnf->pClauses;
+        pCnf->pObj2Count[pObj->Id] = 2;
+        // get variables
+        OutVar = Aig_ObjFanin0(pObj)->Id;
+        PoVar = pObj->Id;
+        // first clause
+        *pClas++ = pLits;
+        *pLits++ = 2 * PoVar; 
+        *pLits++ = 2 * OutVar + !Aig_ObjFaninC0(pObj); 
+        // second clause
+        *pClas++ = pLits;
+        *pLits++ = 2 * PoVar + 1; 
+        *pLits++ = 2 * OutVar + Aig_ObjFaninC0(pObj); 
+    }
+ 
+    // remember the starting clause
+    pCnf->pObj2Clause[Aig_ManConst1(p->pManAig)->Id] = pClas - pCnf->pClauses;
+    pCnf->pObj2Count[Aig_ManConst1(p->pManAig)->Id] = 1;
+    // write the constant literal
+    OutVar = Aig_ManConst1(p->pManAig)->Id;
+    *pClas++ = pLits;
+    *pLits++ = 2 * OutVar; 
+
+    // verify that the correct number of literals and clauses was written
+    assert( pLits - pCnf->pClauses[0] == nLiterals );
+    assert( pClas - pCnf->pClauses == nClauses );
+//Cnf_DataPrint( pCnf, 1 );
+    return pCnf;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Derives a simple CNF for the AIG.]
+
+  Description [The last argument lists the number of last outputs
+  of the manager, which will not be converted into clauses. 
+  New variables will be introduced for these outputs.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_DeriveSimple( Aig_Man_t * p, int nOutputs )
+{
+    Aig_Obj_t * pObj;
+    Cnf_Dat_t * pCnf;
+    int OutVar, PoVar, pVars[32], * pLits, ** pClas;
+    int i, nLiterals, nClauses, Number;
+
+    // count the number of literals and clauses
+    nLiterals = 1 + 7 * Aig_ManNodeNum(p) + Aig_ManPoNum( p ) + 3 * nOutputs;
+    nClauses = 1 + 3 * Aig_ManNodeNum(p) + Aig_ManPoNum( p ) + nOutputs;
+
+    // allocate CNF
+    pCnf = ABC_ALLOC( Cnf_Dat_t, 1 );
+    memset( pCnf, 0, sizeof(Cnf_Dat_t) );
+    pCnf->pMan = p;
+    pCnf->nLiterals = nLiterals;
+    pCnf->nClauses = nClauses;
+    pCnf->pClauses = ABC_ALLOC( int *, nClauses + 1 );
+    pCnf->pClauses[0] = ABC_ALLOC( int, nLiterals );
+    pCnf->pClauses[nClauses] = pCnf->pClauses[0] + nLiterals;
+
+    // create room for variable numbers
+    pCnf->pVarNums = ABC_ALLOC( int, Aig_ManObjNumMax(p) );
+//    memset( pCnf->pVarNums, 0xff, sizeof(int) * Aig_ManObjNumMax(p) );
+    for ( i = 0; i < Aig_ManObjNumMax(p); i++ )
+        pCnf->pVarNums[i] = -1;
+    // assign variables to the last (nOutputs) POs
+    Number = 1;
+    if ( nOutputs )
+    {
+//        assert( nOutputs == Aig_ManRegNum(p) );
+//        Aig_ManForEachLiSeq( p, pObj, i )
+//            pCnf->pVarNums[pObj->Id] = Number++;
+        Aig_ManForEachPo( p, pObj, i )
+            pCnf->pVarNums[pObj->Id] = Number++;
+    }
+    // assign variables to the internal nodes
+    Aig_ManForEachNode( p, pObj, i )
+        pCnf->pVarNums[pObj->Id] = Number++;
+    // assign variables to the PIs and constant node
+    Aig_ManForEachPi( p, pObj, i )
+        pCnf->pVarNums[pObj->Id] = Number++;
+    pCnf->pVarNums[Aig_ManConst1(p)->Id] = Number++;
+    pCnf->nVars = Number;
+/*
+    // print CNF numbers
+    printf( "SAT numbers of each node:\n" );
+    Aig_ManForEachObj( p, pObj, i )
+        printf( "%d=%d ", pObj->Id, pCnf->pVarNums[pObj->Id] );
+    printf( "\n" );
+*/
+    // assign the clauses
+    pLits = pCnf->pClauses[0];
+    pClas = pCnf->pClauses;
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        OutVar   = pCnf->pVarNums[ pObj->Id ];
+        pVars[0] = pCnf->pVarNums[ Aig_ObjFanin0(pObj)->Id ];
+        pVars[1] = pCnf->pVarNums[ Aig_ObjFanin1(pObj)->Id ];
+
+        // positive phase
+        *pClas++ = pLits;
+        *pLits++ = 2 * OutVar; 
+        *pLits++ = 2 * pVars[0] + !Aig_ObjFaninC0(pObj); 
+        *pLits++ = 2 * pVars[1] + !Aig_ObjFaninC1(pObj); 
+        // negative phase
+        *pClas++ = pLits;
+        *pLits++ = 2 * OutVar + 1; 
+        *pLits++ = 2 * pVars[0] + Aig_ObjFaninC0(pObj); 
+        *pClas++ = pLits;
+        *pLits++ = 2 * OutVar + 1; 
+        *pLits++ = 2 * pVars[1] + Aig_ObjFaninC1(pObj); 
+    }
+ 
+    // write the constant literal
+    OutVar = pCnf->pVarNums[ Aig_ManConst1(p)->Id ];
+    assert( OutVar <= Aig_ManObjNumMax(p) );
+    *pClas++ = pLits;
+    *pLits++ = 2 * OutVar;  
+
+    // write the output literals
+    Aig_ManForEachPo( p, pObj, i )
+    {
+        OutVar = pCnf->pVarNums[ Aig_ObjFanin0(pObj)->Id ];
+        if ( i < Aig_ManPoNum(p) - nOutputs )
+        {
+            *pClas++ = pLits;
+            *pLits++ = 2 * OutVar + Aig_ObjFaninC0(pObj); 
+        }
+        else
+        {
+            PoVar  = pCnf->pVarNums[ pObj->Id ];
+            // first clause
+            *pClas++ = pLits;
+            *pLits++ = 2 * PoVar; 
+            *pLits++ = 2 * OutVar + !Aig_ObjFaninC0(pObj); 
+            // second clause
+            *pClas++ = pLits;
+            *pLits++ = 2 * PoVar + 1; 
+            *pLits++ = 2 * OutVar + Aig_ObjFaninC0(pObj); 
+        }
+    }
+
+    // verify that the correct number of literals and clauses was written
+    assert( pLits - pCnf->pClauses[0] == nLiterals );
+    assert( pClas - pCnf->pClauses == nClauses );
+    return pCnf;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derives a simple CNF for backward retiming computation.]
+
+  Description [The last argument shows the number of last outputs
+  of the manager, which will not be converted into clauses. 
+  New variables will be introduced for these outputs.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Cnf_Dat_t * Cnf_DeriveSimpleForRetiming( Aig_Man_t * p )
+{
+    Aig_Obj_t * pObj;
+    Cnf_Dat_t * pCnf;
+    int OutVar, PoVar, pVars[32], * pLits, ** pClas;
+    int i, nLiterals, nClauses, Number;
+
+    // count the number of literals and clauses
+    nLiterals = 1 + 7 * Aig_ManNodeNum(p) + 5 * Aig_ManPoNum(p);
+    nClauses = 1 + 3 * Aig_ManNodeNum(p) + 3 * Aig_ManPoNum(p);
+
+    // allocate CNF
+    pCnf = ABC_ALLOC( Cnf_Dat_t, 1 );
+    memset( pCnf, 0, sizeof(Cnf_Dat_t) );
+    pCnf->pMan = p;
+    pCnf->nLiterals = nLiterals;
+    pCnf->nClauses = nClauses;
+    pCnf->pClauses = ABC_ALLOC( int *, nClauses + 1 );
+    pCnf->pClauses[0] = ABC_ALLOC( int, nLiterals );
+    pCnf->pClauses[nClauses] = pCnf->pClauses[0] + nLiterals;
+
+    // create room for variable numbers
+    pCnf->pVarNums = ABC_ALLOC( int, Aig_ManObjNumMax(p) );
+//    memset( pCnf->pVarNums, 0xff, sizeof(int) * Aig_ManObjNumMax(p) );
+    for ( i = 0; i < Aig_ManObjNumMax(p); i++ )
+        pCnf->pVarNums[i] = -1;
+    // assign variables to the last (nOutputs) POs
+    Number = 1;
+    Aig_ManForEachPo( p, pObj, i )
+        pCnf->pVarNums[pObj->Id] = Number++;
+    // assign variables to the internal nodes
+    Aig_ManForEachNode( p, pObj, i )
+        pCnf->pVarNums[pObj->Id] = Number++;
+    // assign variables to the PIs and constant node
+    Aig_ManForEachPi( p, pObj, i )
+        pCnf->pVarNums[pObj->Id] = Number++;
+    pCnf->pVarNums[Aig_ManConst1(p)->Id] = Number++;
+    pCnf->nVars = Number;
+    // assign the clauses
+    pLits = pCnf->pClauses[0];
+    pClas = pCnf->pClauses;
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        OutVar   = pCnf->pVarNums[ pObj->Id ];
+        pVars[0] = pCnf->pVarNums[ Aig_ObjFanin0(pObj)->Id ];
+        pVars[1] = pCnf->pVarNums[ Aig_ObjFanin1(pObj)->Id ];
+
+        // positive phase
+        *pClas++ = pLits;
+        *pLits++ = 2 * OutVar; 
+        *pLits++ = 2 * pVars[0] + !Aig_ObjFaninC0(pObj); 
+        *pLits++ = 2 * pVars[1] + !Aig_ObjFaninC1(pObj); 
+        // negative phase
+        *pClas++ = pLits;
+        *pLits++ = 2 * OutVar + 1; 
+        *pLits++ = 2 * pVars[0] + Aig_ObjFaninC0(pObj); 
+        *pClas++ = pLits;
+        *pLits++ = 2 * OutVar + 1; 
+        *pLits++ = 2 * pVars[1] + Aig_ObjFaninC1(pObj); 
+    }
+ 
+    // write the constant literal
+    OutVar = pCnf->pVarNums[ Aig_ManConst1(p)->Id ];
+    assert( OutVar <= Aig_ManObjNumMax(p) );
+    *pClas++ = pLits;
+    *pLits++ = 2 * OutVar; 
+
+    // write the output literals
+    Aig_ManForEachPo( p, pObj, i )
+    {
+        OutVar = pCnf->pVarNums[ Aig_ObjFanin0(pObj)->Id ];
+        PoVar  = pCnf->pVarNums[ pObj->Id ];
+        // first clause
+        *pClas++ = pLits;
+        *pLits++ = 2 * PoVar; 
+        *pLits++ = 2 * OutVar + !Aig_ObjFaninC0(pObj); 
+        // second clause
+        *pClas++ = pLits;
+        *pLits++ = 2 * PoVar + 1; 
+        *pLits++ = 2 * OutVar + Aig_ObjFaninC0(pObj); 
+        // final clause (init-state is always 0 -> set the output to 0)
+        *pClas++ = pLits;
+        *pLits++ = 2 * PoVar + 1; 
+    }
+
+    // verify that the correct number of literals and clauses was written
+    assert( pLits - pCnf->pClauses[0] == nLiterals );
+    assert( pClas - pCnf->pClauses == nClauses );
+    return pCnf;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/sat/pdr/pdr.c b/src/sat/cnf/cnf_.c
index 6bdf75b5..acf75093 100644
--- a/src/sat/pdr/pdr.c
+++ b/src/sat/cnf/cnf_.c
@@ -1,10 +1,10 @@
 /**CFile****************************************************************
 
-  FileName    [pdr.c]
+  FileName    [cnf_.c]
 
   SystemName  [ABC: Logic synthesis and verification system.]
 
-  PackageName [Netlist representation.]
+  PackageName [AIG-to-CNF conversion.]
 
   Synopsis    []
 
@@ -12,13 +12,13 @@
   
   Affiliation [UC Berkeley]
 
-  Date        [Ver. 1.0. Started - November 20, 2010.]
+  Date        [Ver. 1.0. Started - April 28, 2007.]
 
-  Revision    [$Id: pdr.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
+  Revision    [$Id: cnf_.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]
 
 ***********************************************************************/
 
-#include "pdrInt.h"
+#include "cnf.h"
 
 ABC_NAMESPACE_IMPL_START
 
diff --git a/src/sat/cnf/module.make b/src/sat/cnf/module.make
new file mode 100644
index 00000000..880e9662
--- /dev/null
+++ b/src/sat/cnf/module.make
@@ -0,0 +1,9 @@
+SRC +=    src/sat/cnf/cnfCore.c \
+    src/sat/cnf/cnfCut.c \
+    src/sat/cnf/cnfData.c \
+    src/sat/cnf/cnfFast.c \
+    src/sat/cnf/cnfMan.c \
+    src/sat/cnf/cnfMap.c \
+    src/sat/cnf/cnfPost.c \
+    src/sat/cnf/cnfUtil.c \
+    src/sat/cnf/cnfWrite.c 
diff --git a/src/sat/csat/csat_apis.c b/src/sat/csat/csat_apis.c
index 78ed2601..582dc1e7 100644
--- a/src/sat/csat/csat_apis.c
+++ b/src/sat/csat/csat_apis.c
@@ -16,11 +16,11 @@
 
 ***********************************************************************/
 
-#include "abc.h"
-#include "fraig.h"
+#include "src/base/abc/abc.h"
+#include "src/proof/fraig/fraig.h"
 #include "csat_apis.h"
-#include "stmm.h"
-#include "main.h"
+#include "src/misc/st/stmm.h"
+#include "src/base/main/main.h"
 
 ABC_NAMESPACE_IMPL_START
 
diff --git a/src/sat/csat/csat_apis.h b/src/sat/csat/csat_apis.h
index a6c1b18a..476e8c2c 100644
--- a/src/sat/csat/csat_apis.h
+++ b/src/sat/csat/csat_apis.h
@@ -16,8 +16,8 @@
 
 ***********************************************************************/
 
-#ifndef __ABC_APIS_H__
-#define __ABC_APIS_H__
+#ifndef ABC__sat__csat__csat_apis_h
+#define ABC__sat__csat__csat_apis_h
 
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/sat/fraig/fraig.h b/src/sat/fraig/fraig.h
deleted file mode 100644
index 2b499967..00000000
--- a/src/sat/fraig/fraig.h
+++ /dev/null
@@ -1,260 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraig.h]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [External declarations of the FRAIG package.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraig.h,v 1.18 2005/07/08 01:01:30 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __FRAIG_H__
-#define __FRAIG_H__
-
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-
-
-ABC_NAMESPACE_HEADER_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                    STRUCTURE DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Fraig_ManStruct_t_         Fraig_Man_t;
-typedef struct Fraig_NodeStruct_t_        Fraig_Node_t;
-typedef struct Fraig_NodeVecStruct_t_     Fraig_NodeVec_t;
-typedef struct Fraig_HashTableStruct_t_   Fraig_HashTable_t;
-typedef struct Fraig_ParamsStruct_t_      Fraig_Params_t;
-typedef struct Fraig_PatternsStruct_t_    Fraig_Patterns_t;
-typedef struct Prove_ParamsStruct_t_      Prove_Params_t;
-
-struct Fraig_ParamsStruct_t_
-{
-    int  nPatsRand;     // the number of words of random simulation info
-    int  nPatsDyna;     // the number of words of dynamic simulation info
-    int  nBTLimit;      // the max number of backtracks to perform
-    int  nSeconds;      // the timeout for the final proof
-    int  fFuncRed;      // performs only one level hashing
-    int  fFeedBack;     // enables solver feedback
-    int  fDist1Pats;    // enables distance-1 patterns
-    int  fDoSparse;     // performs equiv tests for sparse functions 
-    int  fChoicing;     // enables recording structural choices
-    int  fTryProve;     // tries to solve the final miter
-    int  fVerbose;      // the verbosiness flag
-    int  fVerboseP;     // the verbosiness flag (for proof reporting)
-    int  fInternal;     // is set to 1 for internal fraig calls
-    int  nConfLimit;    // the limit on the number of conflicts
-    ABC_INT64_T nInspLimit;  // the limit on the number of inspections
-};
-
-struct Prove_ParamsStruct_t_
-{
-    // general parameters
-    int     fUseFraiging;          // enables fraiging
-    int     fUseRewriting;         // enables rewriting
-    int     fUseBdds;              // enables BDD construction when other methods fail
-    int     fVerbose;              // prints verbose stats
-    // iterations
-    int     nItersMax;             // the number of iterations
-    // mitering 
-    int     nMiteringLimitStart;   // starting mitering limit
-    float   nMiteringLimitMulti;   // multiplicative coefficient to increase the limit in each iteration
-    // rewriting 
-    int     nRewritingLimitStart;  // the number of rewriting iterations
-    float   nRewritingLimitMulti;  // multiplicative coefficient to increase the limit in each iteration
-    // fraiging 
-    int     nFraigingLimitStart;   // starting backtrack(conflict) limit
-    float   nFraigingLimitMulti;   // multiplicative coefficient to increase the limit in each iteration
-    // last-gasp BDD construction
-    int     nBddSizeLimit;         // the number of BDD nodes when construction is aborted
-    int     fBddReorder;           // enables dynamic BDD variable reordering
-    // last-gasp mitering
-    int     nMiteringLimitLast;    // final mitering limit
-    // global SAT solver limits
-    ABC_INT64_T  nTotalBacktrackLimit;  // global limit on the number of backtracks
-    ABC_INT64_T  nTotalInspectLimit;    // global limit on the number of clause inspects
-    // global resources applied
-    ABC_INT64_T  nTotalBacktracksMade;  // the total number of backtracks made
-    ABC_INT64_T  nTotalInspectsMade;    // the total number of inspects made
-};
-
-////////////////////////////////////////////////////////////////////////
-///                       GLOBAL VARIABLES                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                       MACRO DEFINITIONS                          ///
-////////////////////////////////////////////////////////////////////////
- 
-// macros working with complemented attributes of the nodes
-#define Fraig_IsComplement(p)    (((int)((ABC_PTRUINT_T) (p) & 01)))
-#define Fraig_Regular(p)         ((Fraig_Node_t *)((ABC_PTRUINT_T)(p) & ~01)) 
-#define Fraig_Not(p)             ((Fraig_Node_t *)((ABC_PTRUINT_T)(p) ^ 01)) 
-#define Fraig_NotCond(p,c)       ((Fraig_Node_t *)((ABC_PTRUINT_T)(p) ^ (c)))
-
-// these are currently not used
-#define Fraig_Ref(p)              
-#define Fraig_Deref(p)            
-#define Fraig_RecursiveDeref(p,c)
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== fraigApi.c =============================================================*/
-extern Fraig_NodeVec_t *   Fraig_ManReadVecInputs( Fraig_Man_t * p );
-extern Fraig_NodeVec_t *   Fraig_ManReadVecOutputs( Fraig_Man_t * p );    
-extern Fraig_NodeVec_t *   Fraig_ManReadVecNodes( Fraig_Man_t * p );      
-extern Fraig_Node_t **     Fraig_ManReadInputs ( Fraig_Man_t * p );       
-extern Fraig_Node_t **     Fraig_ManReadOutputs( Fraig_Man_t * p );       
-extern Fraig_Node_t **     Fraig_ManReadNodes( Fraig_Man_t * p );         
-extern int                 Fraig_ManReadInputNum ( Fraig_Man_t * p );     
-extern int                 Fraig_ManReadOutputNum( Fraig_Man_t * p );     
-extern int                 Fraig_ManReadNodeNum( Fraig_Man_t * p );       
-extern Fraig_Node_t *      Fraig_ManReadConst1 ( Fraig_Man_t * p );       
-extern Fraig_Node_t *      Fraig_ManReadIthVar( Fraig_Man_t * p, int i ); 
-extern Fraig_Node_t *      Fraig_ManReadIthNode( Fraig_Man_t * p, int i );
-extern char **             Fraig_ManReadInputNames( Fraig_Man_t * p );    
-extern char **             Fraig_ManReadOutputNames( Fraig_Man_t * p );   
-extern char *              Fraig_ManReadVarsInt( Fraig_Man_t * p );       
-extern char *              Fraig_ManReadSat( Fraig_Man_t * p );           
-extern int                 Fraig_ManReadFuncRed( Fraig_Man_t * p );       
-extern int                 Fraig_ManReadFeedBack( Fraig_Man_t * p );      
-extern int                 Fraig_ManReadDoSparse( Fraig_Man_t * p );      
-extern int                 Fraig_ManReadChoicing( Fraig_Man_t * p );      
-extern int                 Fraig_ManReadVerbose( Fraig_Man_t * p );       
-extern int *               Fraig_ManReadModel( Fraig_Man_t * p );
-extern int                 Fraig_ManReadPatternNumRandom( Fraig_Man_t * p );
-extern int                 Fraig_ManReadPatternNumDynamic( Fraig_Man_t * p );
-extern int                 Fraig_ManReadPatternNumDynamicFiltered( Fraig_Man_t * p );
-extern int                 Fraig_ManReadSatFails( Fraig_Man_t * p );      
-extern int                 Fraig_ManReadConflicts( Fraig_Man_t * p );      
-extern int                 Fraig_ManReadInspects( Fraig_Man_t * p );      
-
-extern void                Fraig_ManSetFuncRed( Fraig_Man_t * p, int fFuncRed );        
-extern void                Fraig_ManSetFeedBack( Fraig_Man_t * p, int fFeedBack );      
-extern void                Fraig_ManSetDoSparse( Fraig_Man_t * p, int fDoSparse );      
-extern void                Fraig_ManSetChoicing( Fraig_Man_t * p, int fChoicing ); 
-extern void                Fraig_ManSetTryProve( Fraig_Man_t * p, int fTryProve );
-extern void                Fraig_ManSetVerbose( Fraig_Man_t * p, int fVerbose );        
-extern void                Fraig_ManSetTimeToGraph( Fraig_Man_t * p, int Time );        
-extern void                Fraig_ManSetTimeToNet( Fraig_Man_t * p, int Time );          
-extern void                Fraig_ManSetTimeTotal( Fraig_Man_t * p, int Time );          
-extern void                Fraig_ManSetOutputNames( Fraig_Man_t * p, char ** ppNames ); 
-extern void                Fraig_ManSetInputNames( Fraig_Man_t * p, char ** ppNames );  
-extern void                Fraig_ManSetPo( Fraig_Man_t * p, Fraig_Node_t * pNode );
-
-extern Fraig_Node_t *      Fraig_NodeReadData0( Fraig_Node_t * p );                     
-extern Fraig_Node_t *      Fraig_NodeReadData1( Fraig_Node_t * p );                     
-extern int                 Fraig_NodeReadNum( Fraig_Node_t * p );                       
-extern Fraig_Node_t *      Fraig_NodeReadOne( Fraig_Node_t * p );                       
-extern Fraig_Node_t *      Fraig_NodeReadTwo( Fraig_Node_t * p );                       
-extern Fraig_Node_t *      Fraig_NodeReadNextE( Fraig_Node_t * p );                     
-extern Fraig_Node_t *      Fraig_NodeReadRepr( Fraig_Node_t * p );                      
-extern int                 Fraig_NodeReadNumRefs( Fraig_Node_t * p );                   
-extern int                 Fraig_NodeReadNumFanouts( Fraig_Node_t * p );                
-extern int                 Fraig_NodeReadSimInv( Fraig_Node_t * p );                    
-extern int                 Fraig_NodeReadNumOnes( Fraig_Node_t * p );
-extern unsigned *          Fraig_NodeReadPatternsRandom( Fraig_Node_t * p );
-extern unsigned *          Fraig_NodeReadPatternsDynamic( Fraig_Node_t * p );
-
-extern void                Fraig_NodeSetData0( Fraig_Node_t * p, Fraig_Node_t * pData );
-extern void                Fraig_NodeSetData1( Fraig_Node_t * p, Fraig_Node_t * pData );
-
-extern int                 Fraig_NodeIsConst( Fraig_Node_t * p );
-extern int                 Fraig_NodeIsVar( Fraig_Node_t * p );
-extern int                 Fraig_NodeIsAnd( Fraig_Node_t * p );
-extern int                 Fraig_NodeComparePhase( Fraig_Node_t * p1, Fraig_Node_t * p2 );
-
-extern Fraig_Node_t *      Fraig_NodeOr( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 );
-extern Fraig_Node_t *      Fraig_NodeAnd( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 );
-extern Fraig_Node_t *      Fraig_NodeOr( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 );
-extern Fraig_Node_t *      Fraig_NodeExor( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 );
-extern Fraig_Node_t *      Fraig_NodeMux( Fraig_Man_t * p, Fraig_Node_t * pNode, Fraig_Node_t * pNodeT, Fraig_Node_t * pNodeE );
-extern void                Fraig_NodeSetChoice( Fraig_Man_t * pMan, Fraig_Node_t * pNodeOld, Fraig_Node_t * pNodeNew );
-
-/*=== fraigMan.c =============================================================*/
-extern void                Prove_ParamsSetDefault( Prove_Params_t * pParams );
-extern void                Fraig_ParamsSetDefault( Fraig_Params_t * pParams );
-extern void                Fraig_ParamsSetDefaultFull( Fraig_Params_t * pParams );
-extern Fraig_Man_t *       Fraig_ManCreate( Fraig_Params_t * pParams );
-extern void                Fraig_ManFree( Fraig_Man_t * pMan );
-extern void                Fraig_ManPrintStats( Fraig_Man_t * p );
-extern Fraig_NodeVec_t *   Fraig_ManGetSimInfo( Fraig_Man_t * p );
-extern int                 Fraig_ManCheckClauseUsingSimInfo( Fraig_Man_t * p, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2 );
-extern void                Fraig_ManAddClause( Fraig_Man_t * p, Fraig_Node_t ** ppNodes, int nNodes );
-
-/*=== fraigDfs.c =============================================================*/
-extern Fraig_NodeVec_t *   Fraig_Dfs( Fraig_Man_t * pMan, int fEquiv );
-extern Fraig_NodeVec_t *   Fraig_DfsOne( Fraig_Man_t * pMan, Fraig_Node_t * pNode, int fEquiv );
-extern Fraig_NodeVec_t *   Fraig_DfsNodes( Fraig_Man_t * pMan, Fraig_Node_t ** ppNodes, int nNodes, int fEquiv );
-extern Fraig_NodeVec_t *   Fraig_DfsReverse( Fraig_Man_t * pMan );
-extern int                 Fraig_CountNodes( Fraig_Man_t * pMan, int fEquiv );
-extern int                 Fraig_CheckTfi( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-extern int                 Fraig_CountLevels( Fraig_Man_t * pMan );
-
-/*=== fraigSat.c =============================================================*/
-extern int                 Fraig_NodesAreEqual( Fraig_Man_t * p, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int nBTLimit, int nTimeLimit );
-extern int                 Fraig_NodeIsEquivalent( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew, int nBTLimit, int nTimeLimit );
-extern void                Fraig_ManProveMiter( Fraig_Man_t * p );
-extern int                 Fraig_ManCheckMiter( Fraig_Man_t * p );
-extern int                 Fraig_ManCheckClauseUsingSat( Fraig_Man_t * p, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int nBTLimit );
-
-/*=== fraigVec.c ===============================================================*/
-extern Fraig_NodeVec_t *   Fraig_NodeVecAlloc( int nCap );
-extern void                Fraig_NodeVecFree( Fraig_NodeVec_t * p );
-extern Fraig_NodeVec_t *   Fraig_NodeVecDup( Fraig_NodeVec_t * p );
-extern Fraig_Node_t **     Fraig_NodeVecReadArray( Fraig_NodeVec_t * p );
-extern int                 Fraig_NodeVecReadSize( Fraig_NodeVec_t * p );
-extern void                Fraig_NodeVecGrow( Fraig_NodeVec_t * p, int nCapMin );
-extern void                Fraig_NodeVecShrink( Fraig_NodeVec_t * p, int nSizeNew );
-extern void                Fraig_NodeVecClear( Fraig_NodeVec_t * p );
-extern void                Fraig_NodeVecPush( Fraig_NodeVec_t * p, Fraig_Node_t * Entry );
-extern int                 Fraig_NodeVecPushUnique( Fraig_NodeVec_t * p, Fraig_Node_t * Entry );
-extern void                Fraig_NodeVecPushOrder( Fraig_NodeVec_t * p, Fraig_Node_t * pNode );
-extern int                 Fraig_NodeVecPushUniqueOrder( Fraig_NodeVec_t * p, Fraig_Node_t * pNode );
-extern void                Fraig_NodeVecPushOrderByLevel( Fraig_NodeVec_t * p, Fraig_Node_t * pNode );
-extern int                 Fraig_NodeVecPushUniqueOrderByLevel( Fraig_NodeVec_t * p, Fraig_Node_t * pNode );
-extern Fraig_Node_t *      Fraig_NodeVecPop( Fraig_NodeVec_t * p );
-extern void                Fraig_NodeVecRemove( Fraig_NodeVec_t * p, Fraig_Node_t * Entry );
-extern void                Fraig_NodeVecWriteEntry( Fraig_NodeVec_t * p, int i, Fraig_Node_t * Entry );
-extern Fraig_Node_t *      Fraig_NodeVecReadEntry( Fraig_NodeVec_t * p, int i );
-extern void                Fraig_NodeVecSortByLevel( Fraig_NodeVec_t * p, int fIncreasing );
-extern void                Fraig_NodeVecSortByNumber( Fraig_NodeVec_t * p );
-
-/*=== fraigUtil.c ===============================================================*/
-extern void                Fraig_ManMarkRealFanouts( Fraig_Man_t * p );
-extern int                 Fraig_ManCheckConsistency( Fraig_Man_t * p );
-extern int                 Fraig_GetMaxLevel( Fraig_Man_t * pMan );
-extern void                Fraig_ManReportChoices( Fraig_Man_t * pMan );
-extern void                Fraig_MappingSetChoiceLevels( Fraig_Man_t * pMan, int fMaximum );
-extern Fraig_NodeVec_t *   Fraig_CollectSupergate( Fraig_Node_t * pNode, int fStopAtMux );
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
- 
-
-
-ABC_NAMESPACE_HEADER_END
-
-
-
-#endif
diff --git a/src/sat/fraig/fraigApi.c b/src/sat/fraig/fraigApi.c
deleted file mode 100644
index 6e0ab959..00000000
--- a/src/sat/fraig/fraigApi.c
+++ /dev/null
@@ -1,302 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigApi.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Access APIs for the FRAIG manager and node.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigApi.c,v 1.2 2005/07/08 01:01:30 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Access functions to read the data members of the manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_ManReadVecInputs( Fraig_Man_t * p )                   { return p->vInputs;            }
-Fraig_NodeVec_t * Fraig_ManReadVecOutputs( Fraig_Man_t * p )                  { return p->vOutputs;           }
-Fraig_NodeVec_t * Fraig_ManReadVecNodes( Fraig_Man_t * p )                    { return p->vNodes;             }
-Fraig_Node_t **   Fraig_ManReadInputs ( Fraig_Man_t * p )                     { return p->vInputs->pArray;    }
-Fraig_Node_t **   Fraig_ManReadOutputs( Fraig_Man_t * p )                     { return p->vOutputs->pArray;   }
-Fraig_Node_t **   Fraig_ManReadNodes( Fraig_Man_t * p )                       { return p->vNodes->pArray;     }
-int               Fraig_ManReadInputNum ( Fraig_Man_t * p )                   { return p->vInputs->nSize;     }
-int               Fraig_ManReadOutputNum( Fraig_Man_t * p )                   { return p->vOutputs->nSize;    }
-int               Fraig_ManReadNodeNum( Fraig_Man_t * p )                     { return p->vNodes->nSize;      }
-Fraig_Node_t *    Fraig_ManReadConst1 ( Fraig_Man_t * p )                     { return p->pConst1;            }
-Fraig_Node_t *    Fraig_ManReadIthNode( Fraig_Man_t * p, int i )              { assert ( i < p->vNodes->nSize  ); return p->vNodes->pArray[i];  }
-char **           Fraig_ManReadInputNames( Fraig_Man_t * p )                  { return p->ppInputNames;       }
-char **           Fraig_ManReadOutputNames( Fraig_Man_t * p )                 { return p->ppOutputNames;      }
-char *            Fraig_ManReadVarsInt( Fraig_Man_t * p )                     { return (char *)p->vVarsInt;   }
-char *            Fraig_ManReadSat( Fraig_Man_t * p )                         { return (char *)p->pSat;       }
-int               Fraig_ManReadFuncRed( Fraig_Man_t * p )                     { return p->fFuncRed;   }
-int               Fraig_ManReadFeedBack( Fraig_Man_t * p )                    { return p->fFeedBack;  }
-int               Fraig_ManReadDoSparse( Fraig_Man_t * p )                    { return p->fDoSparse;  }
-int               Fraig_ManReadChoicing( Fraig_Man_t * p )                    { return p->fChoicing;  }
-int               Fraig_ManReadVerbose( Fraig_Man_t * p )                     { return p->fVerbose;   }
-int *             Fraig_ManReadModel( Fraig_Man_t * p )                       { return p->pModel;     }
-// returns the number of patterns used for random simulation (this number is fixed for the FRAIG run)
-int               Fraig_ManReadPatternNumRandom( Fraig_Man_t * p )            { return p->nWordsRand * 32;  }
-// returns the number of dynamic patterns accumulated at runtime (include SAT solver counter-examples and distance-1 patterns derived from them)
-int               Fraig_ManReadPatternNumDynamic( Fraig_Man_t * p )           { return p->iWordStart * 32;  }
-// returns the number of dynamic patterns proved useful to distinquish some FRAIG nodes (this number is more than 0 after the first garbage collection of patterns)
-int               Fraig_ManReadPatternNumDynamicFiltered( Fraig_Man_t * p )   { return p->iPatsPerm;        }
-// returns the number of times FRAIG package timed out
-int               Fraig_ManReadSatFails( Fraig_Man_t * p )                    { return p->nSatFailsReal;    }      
-// returns the number of conflicts in the SAT solver
-int               Fraig_ManReadConflicts( Fraig_Man_t * p )                   { return p->pSat? Msat_SolverReadBackTracks(p->pSat) : 0; }      
-// returns the number of inspections in the SAT solver
-int               Fraig_ManReadInspects( Fraig_Man_t * p )                    { return p->pSat? Msat_SolverReadInspects(p->pSat) : 0;   }            
-
-/**Function*************************************************************
-
-  Synopsis    [Access functions to set the data members of the manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void            Fraig_ManSetFuncRed( Fraig_Man_t * p, int fFuncRed )        { p->fFuncRed  = fFuncRed;  }
-void            Fraig_ManSetFeedBack( Fraig_Man_t * p, int fFeedBack )      { p->fFeedBack = fFeedBack; }
-void            Fraig_ManSetDoSparse( Fraig_Man_t * p, int fDoSparse )      { p->fDoSparse = fDoSparse; }
-void            Fraig_ManSetChoicing( Fraig_Man_t * p, int fChoicing )      { p->fChoicing = fChoicing; }
-void            Fraig_ManSetTryProve( Fraig_Man_t * p, int fTryProve )      { p->fTryProve = fTryProve; }
-void            Fraig_ManSetVerbose( Fraig_Man_t * p, int fVerbose )        { p->fVerbose  = fVerbose;  }
-void            Fraig_ManSetTimeToGraph( Fraig_Man_t * p, int Time )        { p->timeToAig = Time;      }
-void            Fraig_ManSetTimeToNet( Fraig_Man_t * p, int Time )          { p->timeToNet = Time;      }
-void            Fraig_ManSetTimeTotal( Fraig_Man_t * p, int Time )          { p->timeTotal = Time;      }
-void            Fraig_ManSetOutputNames( Fraig_Man_t * p, char ** ppNames ) { p->ppOutputNames = ppNames; }
-void            Fraig_ManSetInputNames( Fraig_Man_t * p, char ** ppNames )  { p->ppInputNames  = ppNames; }
-
-/**Function*************************************************************
-
-  Synopsis    [Access functions to read the data members of the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t *  Fraig_NodeReadData0( Fraig_Node_t * p )                   { return p->pData0;    }
-Fraig_Node_t *  Fraig_NodeReadData1( Fraig_Node_t * p )                   { return p->pData1;    }
-int             Fraig_NodeReadNum( Fraig_Node_t * p )                     { return p->Num;       }
-Fraig_Node_t *  Fraig_NodeReadOne( Fraig_Node_t * p )                     { assert (!Fraig_IsComplement(p)); return p->p1; }
-Fraig_Node_t *  Fraig_NodeReadTwo( Fraig_Node_t * p )                     { assert (!Fraig_IsComplement(p)); return p->p2; }
-Fraig_Node_t *  Fraig_NodeReadNextE( Fraig_Node_t * p )                   { return p->pNextE;    }
-Fraig_Node_t *  Fraig_NodeReadRepr( Fraig_Node_t * p )                    { return p->pRepr;     }
-int             Fraig_NodeReadNumRefs( Fraig_Node_t * p )                 { return p->nRefs;     }
-int             Fraig_NodeReadNumFanouts( Fraig_Node_t * p )              { return p->nFanouts;  }
-int             Fraig_NodeReadSimInv( Fraig_Node_t * p )                  { return p->fInv;      }
-int             Fraig_NodeReadNumOnes( Fraig_Node_t * p )                 { return p->nOnes;     }
-// returns the pointer to the random simulation patterns (their number is returned by Fraig_ManReadPatternNumRandom)
-// memory pointed to by this and the following procedure is maintained by the FRAIG package and exists as long as the package runs
-unsigned *      Fraig_NodeReadPatternsRandom( Fraig_Node_t * p )          { return p->puSimR;    }
-// returns the pointer to the dynamic simulation patterns (their number is returned by Fraig_ManReadPatternNumDynamic or Fraig_ManReadPatternNumDynamicFiltered)
-// if the number of patterns is not evenly divisible by 32, the patterns beyond the given number contain garbage
-unsigned *      Fraig_NodeReadPatternsDynamic( Fraig_Node_t * p )         { return p->puSimD;    }
-
-/**Function*************************************************************
-
-  Synopsis    [Access functions to set the data members of the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void            Fraig_NodeSetData0( Fraig_Node_t * p, Fraig_Node_t * pData )      { p->pData0  = pData;  }
-void            Fraig_NodeSetData1( Fraig_Node_t * p, Fraig_Node_t * pData )      { p->pData1  = pData;  }
-
-/**Function*************************************************************
-
-  Synopsis    [Checks the type of the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int             Fraig_NodeIsConst( Fraig_Node_t * p )    {  return (Fraig_Regular(p))->Num   == 0;  }
-int             Fraig_NodeIsVar( Fraig_Node_t * p )      {  return (Fraig_Regular(p))->NumPi >= 0;  }
-int             Fraig_NodeIsAnd( Fraig_Node_t * p )      {  return (Fraig_Regular(p))->NumPi <  0 && (Fraig_Regular(p))->Num > 0;  }
-int             Fraig_NodeComparePhase( Fraig_Node_t * p1, Fraig_Node_t * p2 ) { assert( !Fraig_IsComplement(p1) ); assert( !Fraig_IsComplement(p2) ); return p1->fInv ^ p2->fInv; }
-
-/**Function*************************************************************
-
-  Synopsis    [Returns a new primary input node.]
-
-  Description [If the node with this number does not exist, 
-  create a new PI node with this number.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_ManReadIthVar( Fraig_Man_t * p, int i )
-{
-    int k;
-    if ( i < 0 )
-    {
-        printf( "Requesting a PI with a negative number\n" );
-        return NULL;
-    }
-    // create the PIs to fill in the interval
-    if ( i >= p->vInputs->nSize )
-        for ( k = p->vInputs->nSize; k <= i; k++ )
-            Fraig_NodeCreatePi( p ); 
-    return p->vInputs->pArray[i];
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates a new PO node.]
-
-  Description [This procedure may take a complemented node.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManSetPo( Fraig_Man_t * p, Fraig_Node_t * pNode )
-{
-    // internal node may be a PO two times
-    Fraig_Regular(pNode)->fNodePo = 1;
-    Fraig_NodeVecPush( p->vOutputs, pNode );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perfoms the AND operation with functional hashing.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeAnd( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 )
-{
-    return Fraig_NodeAndCanon( p, p1, p2 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perfoms the OR operation with functional hashing.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeOr( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 )
-{
-    return Fraig_Not( Fraig_NodeAndCanon( p, Fraig_Not(p1), Fraig_Not(p2) ) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perfoms the EXOR operation with functional hashing.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeExor( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 )
-{
-    return Fraig_NodeMux( p, p1, Fraig_Not(p2), p2 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perfoms the MUX operation with functional hashing.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeMux( Fraig_Man_t * p, Fraig_Node_t * pC, Fraig_Node_t * pT, Fraig_Node_t * pE )
-{
-    Fraig_Node_t * pAnd1, * pAnd2, * pRes;
-    pAnd1 = Fraig_NodeAndCanon( p, pC,          pT );     Fraig_Ref( pAnd1 );
-    pAnd2 = Fraig_NodeAndCanon( p, Fraig_Not(pC), pE );   Fraig_Ref( pAnd2 );
-    pRes  = Fraig_NodeOr( p, pAnd1, pAnd2 ); 
-    Fraig_RecursiveDeref( p, pAnd1 );
-    Fraig_RecursiveDeref( p, pAnd2 );
-    Fraig_Deref( pRes );
-    return pRes;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the node to be equivalent to the given one.]
-
-  Description [This procedure is a work-around for the equivalence check.
-  Does not verify the equivalence. Use at the user's risk.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeSetChoice( Fraig_Man_t * pMan, Fraig_Node_t * pNodeOld, Fraig_Node_t * pNodeNew )
-{
-//    assert( pMan->fChoicing );
-    pNodeNew->pNextE = pNodeOld->pNextE;
-    pNodeOld->pNextE = pNodeNew;
-    pNodeNew->pRepr  = pNodeOld;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigCanon.c b/src/sat/fraig/fraigCanon.c
deleted file mode 100644
index 47539db2..00000000
--- a/src/sat/fraig/fraigCanon.c
+++ /dev/null
@@ -1,223 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigCanon.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [AND-node creation and elementary AND-operation.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigCanon.c,v 1.4 2005/07/08 01:01:31 alanmi Exp $]
-
-***********************************************************************/
-
-#include <limits.h>
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [The internal AND operation for the two FRAIG nodes.]
-
-  Description [This procedure is the core of the FRAIG package, because
-  it performs the two-step canonicization of FRAIG nodes. The first step
-  involves the lookup in the structural hash table (which hashes two ANDs 
-  into a node that has them as fanins, if such a node exists). If the node 
-  is not found in the structural hash table, an attempt is made to find a 
-  functionally equivalent node in another hash table (which hashes the 
-  simulation info into the nodes, which has this simulation info). Some 
-  tricks used on the way are described in the comments to the code and
-  in the paper "FRAIGs: Functionally reduced AND-INV graphs".]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeAndCanon( Fraig_Man_t * pMan, Fraig_Node_t * p1, Fraig_Node_t * p2 )
-{
-    Fraig_Node_t * pNodeNew, * pNodeOld, * pNodeRepr;
-    int fUseSatCheck;
-//    int RetValue;
-
-    // check for trivial cases
-    if ( p1 == p2 )
-        return p1;
-    if ( p1 == Fraig_Not(p2) )
-        return Fraig_Not(pMan->pConst1);
-    if ( Fraig_NodeIsConst(p1) )
-    {
-        if ( p1 == pMan->pConst1 )
-            return p2;
-        return Fraig_Not(pMan->pConst1);
-    }
-    if ( Fraig_NodeIsConst(p2) )
-    {
-        if ( p2 == pMan->pConst1 )
-            return p1;
-        return Fraig_Not(pMan->pConst1);
-    }
-/*
-    // check for less trivial cases
-    if ( Fraig_IsComplement(p1) )
-    {
-        if ( RetValue = Fraig_NodeIsInSupergate( Fraig_Regular(p1), p2 ) )
-        {
-            if ( RetValue == -1 )
-                pMan->nImplies0++;
-            else
-                pMan->nImplies1++;
-
-            if ( RetValue == -1 )
-                return p2;
-        }
-    }
-    else
-    {
-        if ( RetValue = Fraig_NodeIsInSupergate( p1, p2 ) )
-        {
-            if ( RetValue == 1 )
-                pMan->nSimplifies1++;
-            else
-                pMan->nSimplifies0++;
-
-            if ( RetValue == 1 )
-                return p1;
-            return Fraig_Not(pMan->pConst1);
-        }
-    }
- 
-    if ( Fraig_IsComplement(p2) )
-    {
-        if ( RetValue = Fraig_NodeIsInSupergate( Fraig_Regular(p2), p1 ) )
-        {
-            if ( RetValue == -1 )
-                pMan->nImplies0++;
-            else
-                pMan->nImplies1++;
-
-            if ( RetValue == -1 )
-                return p1;
-        }
-    }
-    else
-    {
-        if ( RetValue = Fraig_NodeIsInSupergate( p2, p1 ) )
-        {
-            if ( RetValue == 1 )
-                pMan->nSimplifies1++;
-            else
-                pMan->nSimplifies0++;
-
-            if ( RetValue == 1 )
-                return p2;
-            return Fraig_Not(pMan->pConst1);
-        }
-    }
-*/
-    // perform level-one structural hashing
-    if ( Fraig_HashTableLookupS( pMan, p1, p2, &pNodeNew ) ) // the node with these children is found
-    {
-        // if the existent node is part of the cone of unused logic
-        // (that is logic feeding the node which is equivalent to the given node)
-        // return the canonical representative of this node
-        // determine the phase of the given node, with respect to its canonical form
-        pNodeRepr = Fraig_Regular(pNodeNew)->pRepr;
-        if ( pMan->fFuncRed && pNodeRepr )
-            return Fraig_NotCond( pNodeRepr, Fraig_IsComplement(pNodeNew) ^ Fraig_NodeComparePhase(Fraig_Regular(pNodeNew), pNodeRepr) );
-        // otherwise, the node is itself a canonical representative, return it
-        return pNodeNew;
-    }
-    // the same node is not found, but the new one is created
-
-    // if one level hashing is requested (without functionality hashing), return
-    if ( !pMan->fFuncRed )
-        return pNodeNew;
-
-    // check if the new node is unique using the simulation info
-    if ( pNodeNew->nOnes == 0 || pNodeNew->nOnes == (unsigned)pMan->nWordsRand * 32 )
-    {
-        pMan->nSatZeros++;
-        if ( !pMan->fDoSparse ) // if we do not do sparse functions, skip
-            return pNodeNew;
-        // check the sparse function simulation hash table
-        pNodeOld = Fraig_HashTableLookupF0( pMan, pNodeNew );
-        if ( pNodeOld == NULL ) // the node is unique (it is added to the table)
-            return pNodeNew;
-    }
-    else
-    {
-        // check the simulation hash table
-        pNodeOld = Fraig_HashTableLookupF( pMan, pNodeNew );
-        if ( pNodeOld == NULL ) // the node is unique
-            return pNodeNew;
-    }
-    assert( pNodeOld->pRepr == 0 );
-    // there is another node which looks the same according to simulation
-
-    // use SAT to resolve the ambiguity
-    fUseSatCheck = (pMan->nInspLimit == 0 || Fraig_ManReadInspects(pMan) < pMan->nInspLimit); 
-    if ( fUseSatCheck && Fraig_NodeIsEquivalent( pMan, pNodeOld, pNodeNew, pMan->nBTLimit, 1000000 ) )
-    {
-        // set the node to be equivalent with this node
-        // to prevent loops, only set if the old node is not in the TFI of the new node
-        // the loop may happen in the following case: suppose 
-        // NodeC = AND(NodeA, NodeB) and at the same time NodeA => NodeB
-        // in this case, NodeA and NodeC are functionally equivalent
-        // however, NodeA is a fanin of node NodeC (this leads to the loop)
-        // add the node to the list of equivalent nodes or dereference it
-        if ( pMan->fChoicing && !Fraig_CheckTfi( pMan, pNodeOld, pNodeNew ) )
-        { 
-            // if the old node is not in the TFI of the new node and choicing 
-            // is enabled, add the new node to the list of equivalent ones
-            pNodeNew->pNextE = pNodeOld->pNextE;
-            pNodeOld->pNextE = pNodeNew;
-        }
-        // set the canonical representative of this node
-        pNodeNew->pRepr = pNodeOld;
-        // return the equivalent node
-        return Fraig_NotCond( pNodeOld, Fraig_NodeComparePhase(pNodeOld, pNodeNew) );
-    }
-
-    // now we add another member to this simulation class
-    if ( pNodeNew->nOnes == 0 || pNodeNew->nOnes == (unsigned)pMan->nWordsRand * 32 )
-    {
-        Fraig_Node_t * pNodeTemp;
-        assert( pMan->fDoSparse );
-        pNodeTemp = Fraig_HashTableLookupF0( pMan, pNodeNew );
-//        assert( pNodeTemp == NULL );
-//        Fraig_HashTableInsertF0( pMan, pNodeNew );
-    }
-    else
-    {
-        pNodeNew->pNextD = pNodeOld->pNextD;
-        pNodeOld->pNextD = pNodeNew;
-    }
-    // return the new node
-    assert( pNodeNew->pRepr == 0 );
-    return pNodeNew;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigChoice.c b/src/sat/fraig/fraigChoice.c
deleted file mode 100644
index 21d4fe10..00000000
--- a/src/sat/fraig/fraigChoice.c
+++ /dev/null
@@ -1,246 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigTrans.c]
-
-  PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
-
-  Synopsis    [Adds the additive and distributive choices to the AIG.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - February 1, 2003.]
-
-  Revision    [$Id: fraigTrans.c,v 1.1 2005/02/28 05:34:34 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Adds choice nodes based on associativity.]
-
-  Description [Make nLimit big AND gates and add all decompositions
-               to the Fraig.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManAddChoices( Fraig_Man_t * pMan, int fVerbose, int nLimit )
-{
-//    ProgressBar * pProgress;
-    char Buffer[100];
-    int clkTotal = clock();
-    int i, nNodesBefore, nNodesAfter, nInputs, nMaxNodes;
-    int /*nMaxLevel,*/ nDistributive;
-    Fraig_Node_t *pNode, *pRepr;
-    Fraig_Node_t *pX, *pA, *pB, *pC, /* *pD,*/ *pN, /* *pQ, *pR,*/ *pT;
-    int fShortCut = 0;
-
-    nDistributive = 0;
-
-//    Fraig_ManSetApprox( pMan, 1 );
-
-    // NO functional reduction
-    if (fShortCut) Fraig_ManSetFuncRed( pMan, 0 );
-
-    // First we mark critical functions i.e. compute those
-    // nodes which lie on the critical path. Note that this
-    // doesn't update the required times on any choice nodes
-    // which are not the representatives
-/*
-    nMaxLevel = Fraig_GetMaxLevel( pMan );
-    for ( i = 0; i < pMan->nOutputs; i++ )
-    {
-        Fraig_SetNodeRequired( pMan, pMan->pOutputs[i], nMaxLevel );
-    }
-*/
-    nNodesBefore = Fraig_ManReadNodeNum( pMan );
-    nInputs      = Fraig_ManReadInputNum( pMan );
-    nMaxNodes    = nInputs + nLimit * ( nNodesBefore - nInputs );
-
-    printf ("Limit = %d, Before = %d\n", nMaxNodes, nNodesBefore );
-
-    if (0) 
-    {
-        char buffer[128];
-        sprintf (buffer, "test" );
-//        Fraig_MappingShow( pMan, buffer );
-    }
-
-//    pProgress = Extra_ProgressBarStart( stdout, nMaxNodes );
-Fraig_ManCheckConsistency( pMan );
-
-    for ( i = nInputs+1; (i < Fraig_ManReadNodeNum( pMan )) 
-            && (nMaxNodes > Fraig_ManReadNodeNum( pMan )); ++i )
-    {
-//        if ( i == nNodesBefore )
-//            break;
-
-        pNode = Fraig_ManReadIthNode( pMan, i );
-        assert ( pNode );
-
-        pRepr = pNode->pRepr ? pNode->pRepr : pNode;
-        //printf ("Slack: %d\n", Fraig_NodeReadSlack( pRepr ));
-        
-        // All the new associative choices we add will have huge slack
-        // since we do not redo timing, and timing doesnt handle choices
-        // well anyway. However every newly added node is a choice of an
-        // existing critical node, so they are considered critical.
-//        if ( (Fraig_NodeReadSlack( pRepr ) > 3) && (i < nNodesBefore)  )     
-//            continue;
-
-//        if ( pNode->pRepr )
-//            continue;
-
-        // Try ((ab)c), x = ab -> (a(bc)) and (b(ac))
-        pX = Fraig_NodeReadOne(pNode);
-        pC = Fraig_NodeReadTwo(pNode);
-        if (Fraig_NodeIsAnd(pX) && !Fraig_IsComplement(pX))
-        {
-            pA = Fraig_NodeReadOne(Fraig_Regular(pX));
-            pB = Fraig_NodeReadTwo(Fraig_Regular(pX));
-
-//            pA = Fraig_NodeGetRepr( pA );
-//            pB = Fraig_NodeGetRepr( pB );
-//            pC = Fraig_NodeGetRepr( pC );
-
-            if (fShortCut) 
-            {
-                pT = Fraig_NodeAnd(pMan, pB, pC);
-                if ( !pT->pRepr )
-                {
-                    pN = Fraig_NodeAnd(pMan, pA, pT);
-//                    Fraig_NodeAddChoice( pMan, pNode, pN );
-                }
-            }
-            else
-                pN = Fraig_NodeAnd(pMan, pA, Fraig_NodeAnd(pMan, pB, pC));
-            // assert ( Fraig_NodesEqual(pN, pNode) );
-
-
-            if (fShortCut) 
-            {
-                pT = Fraig_NodeAnd(pMan, pA, pC);
-                if ( !pT->pRepr )
-                {
-                    pN = Fraig_NodeAnd(pMan, pB, pT);
-//                    Fraig_NodeAddChoice( pMan, pNode, pN );
-                }
-            }
-            else
-                pN = Fraig_NodeAnd(pMan, pB, Fraig_NodeAnd(pMan, pA, pC));
-            // assert ( Fraig_NodesEqual(pN, pNode) );
-        }
-
-
-        // Try (a(bc)), x = bc -> ((ab)c) and ((ac)b)
-        pA = Fraig_NodeReadOne(pNode);
-        pX = Fraig_NodeReadTwo(pNode);
-        if (Fraig_NodeIsAnd(pX) && !Fraig_IsComplement(pX))
-        {
-            pB = Fraig_NodeReadOne(Fraig_Regular(pX));
-            pC = Fraig_NodeReadTwo(Fraig_Regular(pX));
-
-//            pA = Fraig_NodeGetRepr( pA );
-//            pB = Fraig_NodeGetRepr( pB );
-//            pC = Fraig_NodeGetRepr( pC );
-
-            if (fShortCut) 
-            {
-                pT = Fraig_NodeAnd(pMan, pA, pB);
-                if ( !pT->pRepr )
-                {
-                    pN = Fraig_NodeAnd(pMan, pC, pT);
-//                    Fraig_NodeAddChoice( pMan, pNode, pN );
-                }
-            }
-            else
-                pN = Fraig_NodeAnd(pMan, Fraig_NodeAnd(pMan, pA, pB), pC);
-            // assert ( Fraig_NodesEqual(pN, pNode) );
-
-            if (fShortCut) 
-            {
-                pT = Fraig_NodeAnd(pMan, pA, pC);
-                if ( !pT->pRepr )
-                {
-                    pN = Fraig_NodeAnd(pMan, pB, pT);
-//                    Fraig_NodeAddChoice( pMan, pNode, pN );
-                }
-            }
-            else
-                pN = Fraig_NodeAnd(pMan, Fraig_NodeAnd(pMan, pA, pC), pB);
-            // assert ( Fraig_NodesEqual(pN, pNode) );
-        }
-
-
-/*
-        // Try distributive transform
-        pQ = Fraig_NodeReadOne(pNode);
-        pR = Fraig_NodeReadTwo(pNode);
-        if ( (Fraig_IsComplement(pQ) && Fraig_NodeIsAnd(pQ))
-             && (Fraig_IsComplement(pR) && Fraig_NodeIsAnd(pR)) )
-        {
-            pA = Fraig_NodeReadOne(Fraig_Regular(pQ));
-            pB = Fraig_NodeReadTwo(Fraig_Regular(pQ));
-            pC = Fraig_NodeReadOne(Fraig_Regular(pR));
-            pD = Fraig_NodeReadTwo(Fraig_Regular(pR));
-
-            // Now detect the !(xy + xz) pattern, store 
-            // x in pA, y in pB and z in pC and set pD = 0 to indicate
-            // pattern was found
-            assert (pD != 0);
-            if (pA == pC) { pC = pD;                   pD = 0; } 
-            if (pA == pD) {                            pD = 0; } 
-            if (pB == pC) { pB = pA; pA = pC; pC = pD; pD = 0; }
-            if (pB == pD) { pB = pA; pA = pD;          pD = 0; }
-            if (pD == 0)
-            {
-                nDistributive++;
-                pN = Fraig_Not(Fraig_NodeAnd(pMan, pA, 
-                        Fraig_NodeOr(pMan, pB, pC)));
-                if (fShortCut) Fraig_NodeAddChoice( pMan, pNode, pN );
-                // assert ( Fraig_NodesEqual(pN, pNode) );
-            }
-        }
-*/            
-        if ( i % 1000 == 0 )
-        {
-            sprintf( Buffer, "Adding choice %6d...", i - nNodesBefore );
-//            Extra_ProgressBarUpdate( pProgress, i, Buffer );
-        }
-    }
-
-//    Extra_ProgressBarStop( pProgress );
-
-Fraig_ManCheckConsistency( pMan );
-
-    nNodesAfter = Fraig_ManReadNodeNum( pMan );
-    printf ( "Nodes before = %6d. Nodes with associative choices = %6d. Increase = %4.2f %%.\n", 
-            nNodesBefore, nNodesAfter, ((float)(nNodesAfter - nNodesBefore)) * 100.0/(nNodesBefore - nInputs) );
-    printf ( "Distributive = %d\n", nDistributive );
-
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigFanout.c b/src/sat/fraig/fraigFanout.c
deleted file mode 100644
index 0e6c86f8..00000000
--- a/src/sat/fraig/fraigFanout.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigFanout.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Procedures to manipulate fanouts of the FRAIG nodes.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigFanout.c,v 1.5 2005/07/08 01:01:31 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-#ifdef FRAIG_ENABLE_FANOUTS
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Add the fanout to the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeAddFaninFanout( Fraig_Node_t * pFanin, Fraig_Node_t * pFanout )
-{
-    Fraig_Node_t * pPivot;
-
-    // pFanins is a fanin of pFanout
-    assert( !Fraig_IsComplement(pFanin) );
-    assert( !Fraig_IsComplement(pFanout) );
-    assert( Fraig_Regular(pFanout->p1) == pFanin || Fraig_Regular(pFanout->p2) == pFanin );
-
-    pPivot = pFanin->pFanPivot;
-    if ( pPivot == NULL )
-    {
-        pFanin->pFanPivot = pFanout;
-        return;
-    }
-
-    if ( Fraig_Regular(pPivot->p1) == pFanin )
-    {
-        if ( Fraig_Regular(pFanout->p1) == pFanin )
-        {
-            pFanout->pFanFanin1 = pPivot->pFanFanin1;
-            pPivot->pFanFanin1  = pFanout;
-        }
-        else // if ( Fraig_Regular(pFanout->p2) == pFanin )
-        {
-            pFanout->pFanFanin2 = pPivot->pFanFanin1;
-            pPivot->pFanFanin1  = pFanout;
-        }
-    }
-    else // if ( Fraig_Regular(pPivot->p2) == pFanin )
-    {
-        assert( Fraig_Regular(pPivot->p2) == pFanin );
-        if ( Fraig_Regular(pFanout->p1) == pFanin )
-        {
-            pFanout->pFanFanin1 = pPivot->pFanFanin2;
-            pPivot->pFanFanin2  = pFanout;
-        }
-        else // if ( Fraig_Regular(pFanout->p2) == pFanin )
-        {
-            pFanout->pFanFanin2 = pPivot->pFanFanin2;
-            pPivot->pFanFanin2  = pFanout;
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Add the fanout to the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeRemoveFaninFanout( Fraig_Node_t * pFanin, Fraig_Node_t * pFanoutToRemove )
-{
-    Fraig_Node_t * pFanout, * pFanout2, ** ppFanList;
-    // start the linked list of fanouts
-    ppFanList = &pFanin->pFanPivot; 
-    // go through the fanouts
-    Fraig_NodeForEachFanoutSafe( pFanin, pFanout, pFanout2 )
-    {
-        // skip the fanout-to-remove
-        if ( pFanout == pFanoutToRemove )
-            continue;
-        // add useful fanouts to the list
-        *ppFanList = pFanout;
-        ppFanList = Fraig_NodeReadNextFanoutPlace( pFanin, pFanout );
-    }
-    *ppFanList = NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Transfers fanout to a different node.]
-
-  Description [Assumes that the other node currently has no fanouts.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeTransferFanout( Fraig_Node_t * pNodeFrom, Fraig_Node_t * pNodeTo )
-{
-    Fraig_Node_t * pFanout;
-    assert( pNodeTo->pFanPivot == NULL );
-    assert( pNodeTo->pFanFanin1 == NULL );
-    assert( pNodeTo->pFanFanin2 == NULL );
-    // go through the fanouts and update their fanins
-    Fraig_NodeForEachFanout( pNodeFrom, pFanout )
-    {
-        if ( Fraig_Regular(pFanout->p1) == pNodeFrom )
-            pFanout->p1 = Fraig_NotCond( pNodeTo, Fraig_IsComplement(pFanout->p1) );
-        else if ( Fraig_Regular(pFanout->p2) == pNodeFrom )
-            pFanout->p2 = Fraig_NotCond( pNodeTo, Fraig_IsComplement(pFanout->p2) );            
-    }
-    // move the pointers
-    pNodeTo->pFanPivot  = pNodeFrom->pFanPivot;  
-    pNodeTo->pFanFanin1 = pNodeFrom->pFanFanin1; 
-    pNodeTo->pFanFanin2 = pNodeFrom->pFanFanin2;
-    pNodeFrom->pFanPivot  = NULL; 
-    pNodeFrom->pFanFanin1 = NULL; 
-    pNodeFrom->pFanFanin2 = NULL;  
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the number of fanouts of a node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeGetFanoutNum( Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pFanout;
-    int Counter = 0;
-    Fraig_NodeForEachFanout( pNode, pFanout )
-        Counter++;
-    return Counter;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-#endif
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigFeed.c b/src/sat/fraig/fraigFeed.c
deleted file mode 100644
index 47f946e1..00000000
--- a/src/sat/fraig/fraigFeed.c
+++ /dev/null
@@ -1,913 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigFeed.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Procedures to support the solver feedback.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigFeed.c,v 1.8 2005/07/08 01:01:31 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static int   Fraig_FeedBackPrepare( Fraig_Man_t * p, int * pModel, Msat_IntVec_t * vVars );
-static int   Fraig_FeedBackInsert( Fraig_Man_t * p, int nVarsPi );
-static void  Fraig_FeedBackVerify( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-
-static void  Fraig_FeedBackCovering( Fraig_Man_t * p, Msat_IntVec_t * vPats );
-static       Fraig_NodeVec_t * Fraig_FeedBackCoveringStart( Fraig_Man_t * pMan );
-static int   Fraig_GetSmallestColumn( int * pHits, int nHits );
-static int   Fraig_GetHittingPattern( unsigned * pSims, int nWords );
-static void  Fraig_CancelCoveredColumns( Fraig_NodeVec_t * vColumns, int * pHits, int iPat );
-static void  Fraig_FeedBackCheckTable( Fraig_Man_t * p );
-static void  Fraig_FeedBackCheckTableF0( Fraig_Man_t * p );
-static void  Fraig_ReallocateSimulationInfo( Fraig_Man_t * p );
-
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Initializes the feedback information.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_FeedBackInit( Fraig_Man_t * p )
-{
-    p->vCones    = Fraig_NodeVecAlloc( 500 );
-    p->vPatsReal = Msat_IntVecAlloc( 1000 ); 
-    p->pSimsReal = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-    memset( p->pSimsReal, 0, sizeof(unsigned) * p->nWordsDyna );
-    p->pSimsTemp = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-    p->pSimsDiff = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Processes the feedback from teh solver.]
-
-  Description [Array pModel gives the value of each variable in the SAT 
-  solver. Array vVars is the array of integer numbers of variables
-  involves in this conflict.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_FeedBack( Fraig_Man_t * p, int * pModel, Msat_IntVec_t * vVars, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    int nVarsPi, nWords;
-    int i, clk = clock();
-
-    // get the number of PI vars in the feedback (also sets the PI values)
-    nVarsPi = Fraig_FeedBackPrepare( p, pModel, vVars );
-
-    // set the PI values
-    nWords = Fraig_FeedBackInsert( p, nVarsPi );
-    assert( p->iWordStart + nWords <= p->nWordsDyna );
-
-    // resimulates the words from p->iWordStart to iWordStop
-    for ( i = 1; i < p->vNodes->nSize; i++ )
-        if ( Fraig_NodeIsAnd(p->vNodes->pArray[i]) )
-            Fraig_NodeSimulate( p->vNodes->pArray[i], p->iWordStart, p->iWordStart + nWords, 0 );
-
-    if ( p->fDoSparse )
-        Fraig_TableRehashF0( p, 0 );
-
-    if ( !p->fChoicing )
-    Fraig_FeedBackVerify( p, pOld, pNew );
-
-    // if there is no room left, compress the patterns
-    if ( p->iWordStart + nWords == p->nWordsDyna )
-        p->iWordStart = Fraig_FeedBackCompress( p );
-    else  // otherwise, update the starting word
-        p->iWordStart += nWords;
-
-p->timeFeed += clock() - clk;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Get the number and values of the PI variables.]
-
-  Description [Returns the number of PI variables involved in this feedback.
-  Fills in the internal presence and value data for the primary inputs.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_FeedBackPrepare( Fraig_Man_t * p, int * pModel, Msat_IntVec_t * vVars )
-{
-    Fraig_Node_t * pNode;
-    int i, nVars, nVarsPis, * pVars;
-
-    // clean the presence flag for all PIs
-    for ( i = 0; i < p->vInputs->nSize; i++ )
-    {
-        pNode = p->vInputs->pArray[i];
-        pNode->fFeedUse = 0;
-    }
-
-    // get the variables involved in the feedback
-    nVars = Msat_IntVecReadSize(vVars);
-    pVars = Msat_IntVecReadArray(vVars);
-
-    // set the values for the present variables
-    nVarsPis = 0;
-    for ( i = 0; i < nVars; i++ )
-    {
-        pNode = p->vNodes->pArray[ pVars[i] ];
-        if ( !Fraig_NodeIsVar(pNode) )
-            continue;
-        // set its value
-        pNode->fFeedUse = 1;
-        pNode->fFeedVal = !MSAT_LITSIGN(pModel[pVars[i]]);
-        nVarsPis++;
-    }
-    return nVarsPis;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Inserts the new simulation patterns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_FeedBackInsert( Fraig_Man_t * p, int nVarsPi )
-{
-    Fraig_Node_t * pNode;
-    int nWords, iPatFlip, nPatFlipLimit, i, w;
-    int fUseNoPats = 0;
-    int fUse2Pats = 0;
-
-    // get the number of words 
-    if ( fUse2Pats )
-        nWords = FRAIG_NUM_WORDS( 2 * nVarsPi + 1 );
-    else if ( fUseNoPats )
-        nWords = 1;
-    else
-        nWords = FRAIG_NUM_WORDS( nVarsPi + 1 );
-    // update the number of words if they do not fit into the simulation info
-    if ( nWords > p->nWordsDyna - p->iWordStart )
-        nWords = p->nWordsDyna - p->iWordStart; 
-    // determine the bound on the flipping bit
-    nPatFlipLimit = nWords * 32 - 2;
-
-    // mark the real pattern
-    Msat_IntVecPush( p->vPatsReal, p->iWordStart * 32 ); 
-    // record the real pattern
-    Fraig_BitStringSetBit( p->pSimsReal, p->iWordStart * 32 );
-
-    // set the values at the PIs
-    iPatFlip = 1;
-    for ( i = 0; i < p->vInputs->nSize; i++ )
-    {
-        pNode = p->vInputs->pArray[i];
-        for ( w = p->iWordStart; w < p->iWordStart + nWords; w++ )
-            if ( !pNode->fFeedUse )
-                pNode->puSimD[w] = FRAIG_RANDOM_UNSIGNED;
-            else if ( pNode->fFeedVal )
-                pNode->puSimD[w] = FRAIG_FULL;
-            else // if ( !pNode->fFeedVal )
-                pNode->puSimD[w] = 0;
-
-        if ( fUse2Pats )
-        {
-            // flip two patterns
-            if ( pNode->fFeedUse && 2 * iPatFlip < nPatFlipLimit )
-            {
-                Fraig_BitStringXorBit( pNode->puSimD + p->iWordStart, 2 * iPatFlip - 1 );
-                Fraig_BitStringXorBit( pNode->puSimD + p->iWordStart, 2 * iPatFlip     );
-                Fraig_BitStringXorBit( pNode->puSimD + p->iWordStart, 2 * iPatFlip + 1 );
-                iPatFlip++;
-            }
-        }
-        else if ( fUseNoPats )
-        {
-        }
-        else
-        {
-            // flip the diagonal
-            if ( pNode->fFeedUse && iPatFlip < nPatFlipLimit )
-            {
-                Fraig_BitStringXorBit( pNode->puSimD + p->iWordStart, iPatFlip );
-                iPatFlip++;
-    //            Extra_PrintBinary( stdout, &pNode->puSimD, 45 ); printf( "\n" );
-            }
-        }
-        // clean the use mask
-        pNode->fFeedUse = 0;
-
-        // add the info to the D hash value of the PIs
-        for ( w = p->iWordStart; w < p->iWordStart + nWords; w++ )
-            pNode->uHashD ^= pNode->puSimD[w] * s_FraigPrimes[w];
-
-    }
-    return nWords;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Checks that the SAT solver pattern indeed distinquishes the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_FeedBackVerify( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    int fValue1, fValue2, iPat;
-    iPat   = Msat_IntVecReadEntry( p->vPatsReal, Msat_IntVecReadSize(p->vPatsReal)-1 );
-    fValue1 = (Fraig_BitStringHasBit( pOld->puSimD, iPat ));
-    fValue2 = (Fraig_BitStringHasBit( pNew->puSimD, iPat ));
-/*
-Fraig_PrintNode( p, pOld );
-printf( "\n" );
-Fraig_PrintNode( p, pNew );
-printf( "\n" );
-*/
-//    assert( fValue1 != fValue2 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compress the simulation patterns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_FeedBackCompress( Fraig_Man_t * p )
-{
-    unsigned * pSims;
-    unsigned uHash;
-    int i, w, t, nPats, * pPats;
-    int fPerformChecks = (p->nBTLimit == -1);
-
-    // solve the covering problem
-    if ( fPerformChecks )
-    {
-        Fraig_FeedBackCheckTable( p );
-        if ( p->fDoSparse ) 
-            Fraig_FeedBackCheckTableF0( p );
-    }
-
-    // solve the covering problem
-    Fraig_FeedBackCovering( p, p->vPatsReal );
-
-
-    // get the number of additional patterns
-    nPats = Msat_IntVecReadSize( p->vPatsReal );
-    pPats = Msat_IntVecReadArray( p->vPatsReal );
-    // get the new starting word
-    p->iWordStart = FRAIG_NUM_WORDS( p->iPatsPerm + nPats );
-
-    // set the simulation info for the PIs
-    for ( i = 0; i < p->vInputs->nSize; i++ )
-    {
-        // get hold of the simulation info for this PI
-        pSims = p->vInputs->pArray[i]->puSimD;
-        // clean the storage for the new patterns
-        for ( w = p->iWordPerm; w < p->iWordStart; w++ )
-            p->pSimsTemp[w] = 0;
-        // set the patterns
-        for ( t = 0; t < nPats; t++ )
-            if ( Fraig_BitStringHasBit( pSims, pPats[t] ) )
-            {
-                // check if this pattern falls into temporary storage
-                if ( p->iPatsPerm + t < p->iWordPerm * 32 )
-                    Fraig_BitStringSetBit( pSims, p->iPatsPerm + t );
-                else
-                    Fraig_BitStringSetBit( p->pSimsTemp, p->iPatsPerm + t );
-            }
-        // copy the pattern 
-        for ( w = p->iWordPerm; w < p->iWordStart; w++ )
-            pSims[w] = p->pSimsTemp[w];
-        // recompute the hashing info
-        uHash = 0;
-        for ( w = 0; w < p->iWordStart; w++ )
-            uHash ^= pSims[w] * s_FraigPrimes[w];
-        p->vInputs->pArray[i]->uHashD = uHash;
-    }
-
-    // update info about the permanently stored patterns
-    p->iWordPerm = p->iWordStart;
-    p->iPatsPerm += nPats;
-    assert( p->iWordPerm == FRAIG_NUM_WORDS( p->iPatsPerm ) );
-
-    // resimulate and recompute the hash values
-    for ( i = 1; i < p->vNodes->nSize; i++ )
-        if ( Fraig_NodeIsAnd(p->vNodes->pArray[i]) )
-        {
-            p->vNodes->pArray[i]->uHashD = 0;
-            Fraig_NodeSimulate( p->vNodes->pArray[i], 0, p->iWordPerm, 0 );
-        }
-
-    // double-check that the nodes are still distinguished
-    if ( fPerformChecks )
-        Fraig_FeedBackCheckTable( p );
-
-    // rehash the values in the F0 table
-    if ( p->fDoSparse ) 
-    {
-        Fraig_TableRehashF0( p, 0 );
-        if ( fPerformChecks )
-            Fraig_FeedBackCheckTableF0( p );
-    }
-
-    // check if we need to resize the simulation info
-    // if less than FRAIG_WORDS_STORE words are left, reallocate simulation info
-    if ( p->iWordPerm + FRAIG_WORDS_STORE > p->nWordsDyna )
-        Fraig_ReallocateSimulationInfo( p );
-
-    // set the real patterns
-    Msat_IntVecClear( p->vPatsReal );
-    memset( p->pSimsReal, 0, sizeof(unsigned)*p->nWordsDyna );
-    for ( w = 0; w < p->iWordPerm; w++ )
-        p->pSimsReal[w] = FRAIG_FULL;
-    if ( p->iPatsPerm % 32 > 0 )
-        p->pSimsReal[p->iWordPerm-1] = FRAIG_MASK( p->iPatsPerm % 32 );
-//    printf( "The number of permanent words = %d.\n", p->iWordPerm );
-    return p->iWordStart;
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Checks the correctness of the functional simulation table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_FeedBackCovering( Fraig_Man_t * p, Msat_IntVec_t * vPats )
-{
-    Fraig_NodeVec_t * vColumns;
-    unsigned * pSims;
-    int * pHits, iPat, iCol, i;
-    int nOnesTotal, nSolStarting;
-    int fVeryVerbose = 0;
-
-    // collect the pairs to be distinguished
-    vColumns = Fraig_FeedBackCoveringStart( p );
-    // collect the number of 1s in each simulation vector
-    nOnesTotal = 0;
-    pHits = ABC_ALLOC( int, vColumns->nSize );
-    for ( i = 0; i < vColumns->nSize; i++ )
-    {
-        pSims = (unsigned *)vColumns->pArray[i];
-        pHits[i] = Fraig_BitStringCountOnes( pSims, p->iWordStart );
-        nOnesTotal += pHits[i];
-//        assert( pHits[i] > 0 );
-    }
- 
-    // go through the patterns
-    nSolStarting = Msat_IntVecReadSize(vPats);
-    while ( (iCol = Fraig_GetSmallestColumn( pHits, vColumns->nSize )) != -1 )
-    {
-        // find the pattern, which hits this column
-        iPat = Fraig_GetHittingPattern( (unsigned *)vColumns->pArray[iCol], p->iWordStart );
-        // cancel the columns covered by this pattern
-        Fraig_CancelCoveredColumns( vColumns, pHits, iPat );
-        // save the pattern
-        Msat_IntVecPush( vPats, iPat );
-    }
-
-    // free the set of columns
-    for ( i = 0; i < vColumns->nSize; i++ )
-        Fraig_MemFixedEntryRecycle( p->mmSims, (char *)vColumns->pArray[i] );
-
-    // print stats related to the covering problem
-    if ( p->fVerbose && fVeryVerbose )
-    {
-        printf( "%3d\\%3d\\%3d   ",     p->nWordsRand, p->nWordsDyna, p->iWordPerm );
-        printf( "Col (pairs) = %5d.  ", vColumns->nSize );
-        printf( "Row (pats) = %5d.  ",  p->iWordStart * 32 );
-        printf( "Dns = %6.2f %%.  ",    vColumns->nSize==0? 0.0 : 100.0 * nOnesTotal / vColumns->nSize / p->iWordStart / 32 );
-        printf( "Sol = %3d (%3d).  ",   Msat_IntVecReadSize(vPats), nSolStarting );
-        printf( "\n" );
-    }
-    Fraig_NodeVecFree( vColumns );
-    ABC_FREE( pHits );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Checks the correctness of the functional simulation table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_FeedBackCoveringStart( Fraig_Man_t * p )
-{
-    Fraig_NodeVec_t * vColumns;
-    Fraig_HashTable_t * pT = p->pTableF;
-    Fraig_Node_t * pEntF, * pEntD;
-    unsigned * pSims;
-    unsigned * pUnsigned1, * pUnsigned2;
-    int i, k, m, w;//, nOnes;
-
-    // start the set of columns
-    vColumns = Fraig_NodeVecAlloc( 100 );
-
-    // go through the pairs of nodes to be distinguished
-    for ( i = 0; i < pT->nBins; i++ )
-    Fraig_TableBinForEachEntryF( pT->pBins[i], pEntF )
-    {
-        p->vCones->nSize = 0;
-        Fraig_TableBinForEachEntryD( pEntF, pEntD )
-            Fraig_NodeVecPush( p->vCones, pEntD );
-        if ( p->vCones->nSize == 1 )
-            continue;
-        //////////////////////////////// bug fix by alanmi, September 14, 2006
-        if ( p->vCones->nSize > 20 ) 
-            continue;
-        ////////////////////////////////
-
-        for ( k = 0; k < p->vCones->nSize; k++ )
-            for ( m = k+1; m < p->vCones->nSize; m++ )
-            {
-                if ( !Fraig_CompareSimInfoUnderMask( p->vCones->pArray[k], p->vCones->pArray[m], p->iWordStart, 0, p->pSimsReal ) )
-                    continue;
-
-                // primary simulation patterns (counter-examples) cannot distinguish this pair
-                // get memory to store the feasible simulation patterns
-                pSims = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-                // find the pattern that distinguish this column, exept the primary ones
-                pUnsigned1 = p->vCones->pArray[k]->puSimD;
-                pUnsigned2 = p->vCones->pArray[m]->puSimD;
-                for ( w = 0; w < p->iWordStart; w++ )
-                    pSims[w] = (pUnsigned1[w] ^ pUnsigned2[w]) & ~p->pSimsReal[w];
-                // store the pattern
-                Fraig_NodeVecPush( vColumns, (Fraig_Node_t *)pSims );
-//                nOnes = Fraig_BitStringCountOnes(pSims, p->iWordStart);
-//                assert( nOnes > 0 );
-            }      
-    }
-
-    // if the flag is not set, do not consider sparse nodes in p->pTableF0
-    if ( !p->fDoSparse )
-        return vColumns;
-
-    // recalculate their hash values based on p->pSimsReal
-    pT = p->pTableF0;
-    for ( i = 0; i < pT->nBins; i++ )
-    Fraig_TableBinForEachEntryF( pT->pBins[i], pEntF )
-    {
-        pSims = pEntF->puSimD;
-        pEntF->uHashD = 0;
-        for ( w = 0; w < p->iWordStart; w++ )
-            pEntF->uHashD ^= (pSims[w] & p->pSimsReal[w]) * s_FraigPrimes[w];
-    }
-
-    // rehash the table using these values
-    Fraig_TableRehashF0( p, 1 );
-
-    // collect the classes of equivalent node pairs
-    for ( i = 0; i < pT->nBins; i++ )
-    Fraig_TableBinForEachEntryF( pT->pBins[i], pEntF )
-    {
-        p->vCones->nSize = 0;
-        Fraig_TableBinForEachEntryD( pEntF, pEntD )
-            Fraig_NodeVecPush( p->vCones, pEntD );
-        if ( p->vCones->nSize == 1 )
-            continue;
-
-        // primary simulation patterns (counter-examples) cannot distinguish all these pairs
-        for ( k = 0; k < p->vCones->nSize; k++ )
-            for ( m = k+1; m < p->vCones->nSize; m++ )
-            {
-                // get memory to store the feasible simulation patterns
-                pSims = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-                // find the patterns that are not distinquished
-                pUnsigned1 = p->vCones->pArray[k]->puSimD;
-                pUnsigned2 = p->vCones->pArray[m]->puSimD;
-                for ( w = 0; w < p->iWordStart; w++ )
-                    pSims[w] = (pUnsigned1[w] ^ pUnsigned2[w]) & ~p->pSimsReal[w];
-                // store the pattern
-                Fraig_NodeVecPush( vColumns, (Fraig_Node_t *)pSims );
-//                nOnes = Fraig_BitStringCountOnes(pSims, p->iWordStart);
-//                assert( nOnes > 0 );
-            }      
-    }
-    return vColumns;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Selects the column, which has the smallest number of hits.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_GetSmallestColumn( int * pHits, int nHits )
-{
-    int i, iColMin = -1, nHitsMin = 1000000;
-    for ( i = 0; i < nHits; i++ )
-    {
-        // skip covered columns
-        if ( pHits[i] == 0 )
-            continue;
-        // take the column if it can only be covered by one pattern
-        if ( pHits[i] == 1 )
-            return i;
-        // find the column, which requires the smallest number of patterns
-        if ( nHitsMin > pHits[i] )
-        {
-            nHitsMin = pHits[i];
-            iColMin = i;
-        }
-    }
-    return iColMin;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Select the pattern, which hits this column.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_GetHittingPattern( unsigned * pSims, int nWords )
-{
-    int i, b;
-    for ( i = 0; i < nWords; i++ )
-    {
-        if ( pSims[i] == 0 )
-            continue;
-        for ( b = 0; b < 32; b++ )
-            if ( pSims[i] & (1 << b) )
-                return i * 32 + b;
-    }
-    return -1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Cancel covered patterns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_CancelCoveredColumns( Fraig_NodeVec_t * vColumns, int * pHits, int iPat )
-{
-    unsigned * pSims;
-    int i;
-    for ( i = 0; i < vColumns->nSize; i++ )
-    {
-        pSims = (unsigned *)vColumns->pArray[i];
-        if ( Fraig_BitStringHasBit( pSims, iPat ) )
-            pHits[i] = 0;
-    }
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Checks the correctness of the functional simulation table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_FeedBackCheckTable( Fraig_Man_t * p )
-{
-    Fraig_HashTable_t * pT = p->pTableF;
-    Fraig_Node_t * pEntF, * pEntD;
-    int i, k, m, nPairs;
-
-    nPairs = 0;
-    for ( i = 0; i < pT->nBins; i++ )
-    Fraig_TableBinForEachEntryF( pT->pBins[i], pEntF )
-    {
-        p->vCones->nSize = 0;
-        Fraig_TableBinForEachEntryD( pEntF, pEntD )
-            Fraig_NodeVecPush( p->vCones, pEntD );
-        if ( p->vCones->nSize == 1 )
-            continue;
-        for ( k = 0; k < p->vCones->nSize; k++ )
-            for ( m = k+1; m < p->vCones->nSize; m++ )
-            {
-                if ( Fraig_CompareSimInfo( p->vCones->pArray[k], p->vCones->pArray[m], p->iWordStart, 0 ) )
-                    printf( "Nodes %d and %d have the same D simulation info.\n", 
-                        p->vCones->pArray[k]->Num, p->vCones->pArray[m]->Num );
-                nPairs++;
-            }   
-    }
-//    printf( "\nThe total of %d node pairs have been verified.\n", nPairs );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks the correctness of the functional simulation table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_FeedBackCheckTableF0( Fraig_Man_t * p )
-{
-    Fraig_HashTable_t * pT = p->pTableF0;
-    Fraig_Node_t * pEntF;
-    int i, k, m, nPairs;
-
-    nPairs = 0;
-    for ( i = 0; i < pT->nBins; i++ )
-    {
-        p->vCones->nSize = 0;
-        Fraig_TableBinForEachEntryF( pT->pBins[i], pEntF )
-            Fraig_NodeVecPush( p->vCones, pEntF );
-        if ( p->vCones->nSize == 1 )
-            continue;
-        for ( k = 0; k < p->vCones->nSize; k++ )
-            for ( m = k+1; m < p->vCones->nSize; m++ )
-            {
-                if ( Fraig_CompareSimInfo( p->vCones->pArray[k], p->vCones->pArray[m], p->iWordStart, 0 ) )
-                    printf( "Nodes %d and %d have the same D simulation info.\n", 
-                        p->vCones->pArray[k]->Num, p->vCones->pArray[m]->Num );
-                nPairs++;
-            }   
-    }
-//    printf( "\nThe total of %d node pairs have been verified.\n", nPairs );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Doubles the size of simulation info.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ReallocateSimulationInfo( Fraig_Man_t * p )
-{
-    Fraig_MemFixed_t * mmSimsNew;        // new memory manager for simulation info
-    Fraig_Node_t * pNode;
-    unsigned * pSimsNew;
-    unsigned uSignOld;
-    int i;
-
-    // allocate a new memory manager
-    p->nWordsDyna *= 2;
-    mmSimsNew = Fraig_MemFixedStart( sizeof(unsigned) * (p->nWordsRand + p->nWordsDyna) );
-
-    // set the new data for the constant node
-    pNode = p->pConst1;
-    pNode->puSimR = (unsigned *)Fraig_MemFixedEntryFetch( mmSimsNew );
-    pNode->puSimD = pNode->puSimR + p->nWordsRand;
-    memset( pNode->puSimR, 0, sizeof(unsigned) * p->nWordsRand );
-    memset( pNode->puSimD, 0, sizeof(unsigned) * p->nWordsDyna );
-
-    // copy the simulation info of the PIs
-    for ( i = 0; i < p->vInputs->nSize; i++ )
-    {
-        pNode = p->vInputs->pArray[i];
-        // copy the simulation info
-        pSimsNew = (unsigned *)Fraig_MemFixedEntryFetch( mmSimsNew );
-        memmove( pSimsNew, pNode->puSimR, sizeof(unsigned) * (p->nWordsRand + p->iWordStart) );
-        // attach the new info
-        pNode->puSimR = pSimsNew;
-        pNode->puSimD = pNode->puSimR + p->nWordsRand;
-        // signatures remain without changes
-    }
-
-    // replace the manager to free up some memory
-    Fraig_MemFixedStop( p->mmSims, 0 );
-    p->mmSims = mmSimsNew;
-
-    // resimulate the internal nodes (this should lead to the same signatures)
-    for ( i = 1; i < p->vNodes->nSize; i++ )
-    {
-        pNode = p->vNodes->pArray[i];
-        if ( !Fraig_NodeIsAnd(pNode) )
-            continue;
-        // allocate memory for the simulation info
-        pNode->puSimR = (unsigned *)Fraig_MemFixedEntryFetch( mmSimsNew );
-        pNode->puSimD = pNode->puSimR + p->nWordsRand;
-        // derive random simulation info
-        uSignOld = pNode->uHashR;
-        pNode->uHashR = 0;
-        Fraig_NodeSimulate( pNode, 0, p->nWordsRand, 1 );
-        assert( uSignOld == pNode->uHashR );
-        // derive dynamic simulation info
-        uSignOld = pNode->uHashD;
-        pNode->uHashD = 0;
-        Fraig_NodeSimulate( pNode, 0, p->iWordStart, 0 );
-        assert( uSignOld == pNode->uHashD );
-    }
-
-    // realloc temporary storage
-    p->pSimsReal = (unsigned *)Fraig_MemFixedEntryFetch( mmSimsNew );
-    memset( p->pSimsReal, 0, sizeof(unsigned) * p->nWordsDyna );
-    p->pSimsTemp = (unsigned *)Fraig_MemFixedEntryFetch( mmSimsNew );
-    p->pSimsDiff = (unsigned *)Fraig_MemFixedEntryFetch( mmSimsNew );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Generated trivial counter example.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int * Fraig_ManAllocCounterExample( Fraig_Man_t * p )
-{
-    int * pModel;
-    pModel = ABC_ALLOC( int, p->vInputs->nSize );
-    memset( pModel, 0, sizeof(int) * p->vInputs->nSize );
-    return pModel;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Saves the counter example.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManSimulateBitNode_rec( Fraig_Man_t * p, Fraig_Node_t * pNode )
-{
-    int Value0, Value1;
-    if ( Fraig_NodeIsTravIdCurrent( p, pNode ) )
-        return pNode->fMark3;
-    Fraig_NodeSetTravIdCurrent( p, pNode );
-    Value0 = Fraig_ManSimulateBitNode_rec( p, Fraig_Regular(pNode->p1) );
-    Value1 = Fraig_ManSimulateBitNode_rec( p, Fraig_Regular(pNode->p2) );
-    Value0 ^= Fraig_IsComplement(pNode->p1);
-    Value1 ^= Fraig_IsComplement(pNode->p2);
-    pNode->fMark3 = Value0 & Value1;
-    return pNode->fMark3;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Simulates one bit.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManSimulateBitNode( Fraig_Man_t * p, Fraig_Node_t * pNode, int * pModel )
-{
-    int fCompl, RetValue, i;
-    // set the PI values
-    Fraig_ManIncrementTravId( p );
-    for ( i = 0; i < p->vInputs->nSize; i++ )
-    {
-        Fraig_NodeSetTravIdCurrent( p, p->vInputs->pArray[i] );
-        p->vInputs->pArray[i]->fMark3 = pModel[i];
-    }
-    // perform the traversal
-    fCompl = Fraig_IsComplement(pNode);
-    RetValue = Fraig_ManSimulateBitNode_rec( p, Fraig_Regular(pNode) );
-    return fCompl ^ RetValue;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Saves the counter example.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int * Fraig_ManSaveCounterExample( Fraig_Man_t * p, Fraig_Node_t * pNode )
-{
-    int * pModel;
-    int iPattern;
-    int i, fCompl;
-
-    // the node can be complemented
-    fCompl = Fraig_IsComplement(pNode);
-    // because we compare with constant 0, p->pConst1 should also be complemented
-    fCompl = !fCompl;
-
-    // derive the model
-    pModel = Fraig_ManAllocCounterExample( p );
-    iPattern = Fraig_FindFirstDiff( p->pConst1, Fraig_Regular(pNode), fCompl, p->nWordsRand, 1 );
-    if ( iPattern >= 0 )
-    {
-        for ( i = 0; i < p->vInputs->nSize; i++ )
-            if ( Fraig_BitStringHasBit( p->vInputs->pArray[i]->puSimR, iPattern ) )
-                pModel[i] = 1;
-/*
-printf( "SAT solver's pattern:\n" );
-for ( i = 0; i < p->vInputs->nSize; i++ )
-    printf( "%d", pModel[i] );
-printf( "\n" );
-*/
-        assert( Fraig_ManSimulateBitNode( p, pNode, pModel ) );
-        return pModel;
-    }
-    iPattern = Fraig_FindFirstDiff( p->pConst1, Fraig_Regular(pNode), fCompl, p->iWordStart, 0 );
-    if ( iPattern >= 0 )
-    {
-        for ( i = 0; i < p->vInputs->nSize; i++ )
-            if ( Fraig_BitStringHasBit( p->vInputs->pArray[i]->puSimD, iPattern ) )
-                pModel[i] = 1;
-/*
-printf( "SAT solver's pattern:\n" );
-for ( i = 0; i < p->vInputs->nSize; i++ )
-    printf( "%d", pModel[i] );
-printf( "\n" );
-*/
-        assert( Fraig_ManSimulateBitNode( p, pNode, pModel ) );
-        return pModel;
-    }
-    ABC_FREE( pModel );
-    return NULL;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigInt.h b/src/sat/fraig/fraigInt.h
deleted file mode 100644
index 7cc2194a..00000000
--- a/src/sat/fraig/fraigInt.h
+++ /dev/null
@@ -1,434 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigInt.h]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Internal declarations of the FRAIG package.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigInt.h,v 1.15 2005/07/08 01:01:31 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __FRAIG_INT_H__
-#define __FRAIG_INT_H__
-
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <time.h>
-
-#include "abc_global.h"
-#include "fraig.h"
-#include "msat.h"
-
-ABC_NAMESPACE_HEADER_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
- 
-/*
-    The AIG node policy:
-    - Each node has its main number (pNode->Num)
-      This is the number of this node in the array of all nodes and its SAT variable number
-    - The PI nodes are stored along with other nodes
-      Additionally, PI nodes have a PI number, by which they are stored in the PI node array
-    - The constant node is has number 0 and is also stored in the array
-*/
-
-////////////////////////////////////////////////////////////////////////
-///                       MACRO DEFINITIONS                          ///
-////////////////////////////////////////////////////////////////////////
- 
-// enable this macro to support the fanouts
-#define FRAIG_ENABLE_FANOUTS
-#define FRAIG_PATTERNS_RANDOM   2048   // should not be less than 128 and more than 32768 (2^15)
-#define FRAIG_PATTERNS_DYNAMIC  2048   // should not be less than 256 and more than 32768 (2^15)
-#define FRAIG_MAX_PRIMES        1024   // the maximum number of primes used for hashing
-
-// this parameter determines when simulation info is extended
-// it will be extended when the free storage in the dynamic simulation
-// info is less or equal to this number of words (FRAIG_WORDS_STORE)
-// this is done because if the free storage for dynamic simulation info 
-// is not sufficient, computation becomes inefficient 
-#define FRAIG_WORDS_STORE           5   
-
-// the bit masks
-#define FRAIG_MASK(n)             ((~((unsigned)0)) >> (32-(n)))
-#define FRAIG_FULL                 (~((unsigned)0))
-#define FRAIG_NUM_WORDS(n)         (((n)>>5) + (((n)&31) > 0))
-
-// generating random unsigned (#define RAND_MAX 0x7fff)
-#define FRAIG_RANDOM_UNSIGNED   ((((unsigned)rand()) << 24) ^ (((unsigned)rand()) << 12) ^ ((unsigned)rand()))
-
-// macros to get hold of the bits in a bit string
-#define Fraig_BitStringSetBit(p,i)  ((p)[(i)>>5] |= (1<<((i) & 31)))
-#define Fraig_BitStringXorBit(p,i)  ((p)[(i)>>5] ^= (1<<((i) & 31)))
-#define Fraig_BitStringHasBit(p,i) (((p)[(i)>>5]  & (1<<((i) & 31))) > 0)
-
-// macros to get hold of the bits in the support info
-//#define Fraig_NodeSetVarStr(p,i)      (Fraig_Regular(p)->pSuppStr[((i)%FRAIG_SUPP_SIGN)>>5] |= (1<<(((i)%FRAIG_SUPP_SIGN) & 31)))
-//#define Fraig_NodeHasVarStr(p,i)     ((Fraig_Regular(p)->pSuppStr[((i)%FRAIG_SUPP_SIGN)>>5]  & (1<<(((i)%FRAIG_SUPP_SIGN) & 31))) > 0)
-#define Fraig_NodeSetVarStr(p,i)     Fraig_BitStringSetBit(Fraig_Regular(p)->pSuppStr,i)
-#define Fraig_NodeHasVarStr(p,i)     Fraig_BitStringHasBit(Fraig_Regular(p)->pSuppStr,i)
-
-// copied from "extra.h" for stand-aloneness
-#define Fraig_PrintTime(a,t)      printf( "%s = ", (a) ); printf( "%6.2f sec\n", (float)(t)/(float)(CLOCKS_PER_SEC) )
-
-#define Fraig_HashKey2(a,b,TSIZE) (((ABC_PTRUINT_T)(a) + (ABC_PTRUINT_T)(b) * 12582917) % TSIZE)
-//#define Fraig_HashKey2(a,b,TSIZE) (( ((unsigned)(a)->Num * 19) ^ ((unsigned)(b)->Num * 1999) ) % TSIZE)
-//#define Fraig_HashKey2(a,b,TSIZE) ( ((unsigned)((a)->Num + (b)->Num) * ((a)->Num + (b)->Num + 1) / 2) % TSIZE)
-// the other two hash functions give bad distribution of hash chain lengths (not clear why)
-
-////////////////////////////////////////////////////////////////////////
-///                    STRUCTURE DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Fraig_MemFixed_t_    Fraig_MemFixed_t;    
-
-// the mapping manager
-struct Fraig_ManStruct_t_
-{
-    // the AIG nodes
-    Fraig_NodeVec_t *     vInputs;       // the array of primary inputs
-    Fraig_NodeVec_t *     vNodes;        // the array of all nodes, including primary inputs
-    Fraig_NodeVec_t *     vOutputs;      // the array of primary outputs (some internal nodes)
-    Fraig_Node_t *        pConst1;       // the pointer to the constant node (vNodes->pArray[0])
-
-    // info about the original circuit
-    char **               ppInputNames;  // the primary input names
-    char **               ppOutputNames; // the primary output names
-
-    // various hash-tables
-    Fraig_HashTable_t *   pTableS;       // hashing by structure
-    Fraig_HashTable_t *   pTableF;       // hashing by simulation info
-    Fraig_HashTable_t *   pTableF0;      // hashing by simulation info (sparse functions)
-
-    // parameters
-    int                   nWordsRand;    // the number of words of random simulation info
-    int                   nWordsDyna;    // the number of words of dynamic simulation info
-    int                   nBTLimit;      // the max number of backtracks to perform
-    int                   nSeconds;      // the runtime limit for the miter proof
-    int                   fFuncRed;      // performs only one level hashing
-    int                   fFeedBack;     // enables solver feedback
-    int                   fDist1Pats;    // enables solver feedback
-    int                   fDoSparse;     // performs equiv tests for sparse functions 
-    int                   fChoicing;     // enables recording structural choices
-    int                   fTryProve;     // tries to solve the final miter
-    int                   fVerbose;      // the verbosiness flag
-    int                   fVerboseP;     // the verbosiness flag
-    ABC_INT64_T                nInspLimit;    // the inspection limit
-
-    int                   nTravIds;      // the traversal counter
-    int                   nTravIds2;     // the traversal counter
-
-    // info related to the solver feedback
-    int                   iWordStart;    // the first word to use for simulation
-    int                   iWordPerm;     // the number of words stored permanently
-    int                   iPatsPerm;     // the number of patterns stored permanently
-    Fraig_NodeVec_t *     vCones;        // the temporary array of internal variables
-    Msat_IntVec_t *       vPatsReal;     // the array of real pattern numbers
-    unsigned *            pSimsReal;     // used for simulation patterns
-    unsigned *            pSimsDiff;     // used for simulation patterns
-    unsigned *            pSimsTemp;     // used for simulation patterns
-
-    // the support information
-    int                   nSuppWords;
-    unsigned **           pSuppS;
-    unsigned **           pSuppF;
-
-    // the memory managers
-    Fraig_MemFixed_t *    mmNodes;       // the memory manager for nodes
-    Fraig_MemFixed_t *    mmSims;        // the memory manager for simulation info
-
-    // solving the SAT problem
-    Msat_Solver_t *       pSat;          // the SAT solver
-    Msat_IntVec_t *       vProj;         // the temporary array of projection vars 
-    int                   nSatNums;      // the counter of SAT variables
-    int *                 pModel;        // the assignment, which satisfies the miter
-    // these arrays belong to the solver
-    Msat_IntVec_t *       vVarsInt;      // the temporary array of variables
-    Msat_ClauseVec_t *    vAdjacents;    // the temporary storage for connectivity
-    Msat_IntVec_t *       vVarsUsed;     // the array marking vars appearing in the cone
-
-    // various statistic variables
-    int                   nSatCalls;     // the number of times equivalence checking was called
-    int                   nSatProof;     // the number of times a proof was found
-    int                   nSatCounter;   // the number of times a counter example was found
-    int                   nSatFails;     // the number of times the SAT solver failed to complete due to resource limit or prediction
-    int                   nSatFailsReal; // the number of times the SAT solver failed to complete due to resource limit
-
-    int                   nSatCallsImp;  // the number of times equivalence checking was called
-    int                   nSatProofImp;  // the number of times a proof was found
-    int                   nSatCounterImp;// the number of times a counter example was found
-    int                   nSatFailsImp;  // the number of times the SAT solver failed to complete
-
-    int                   nSatZeros;     // the number of times the simulation vector is zero
-    int                   nSatSupps;     // the number of times the support info was useful
-    int                   nRefErrors;    // the number of ref counting errors
-    int                   nImplies;      // the number of implication cases
-    int                   nSatImpls;     // the number of implication SAT calls
-    int                   nVarsClauses;  // the number of variables with clauses
-    int                   nSimplifies0;
-    int                   nSimplifies1;
-    int                   nImplies0;
-    int                   nImplies1;
-
-    // runtime statistics
-    int                   timeToAig;     // time to transfer to the mapping structure
-    int                   timeSims;      // time to compute k-feasible cuts
-    int                   timeTrav;      // time to traverse the network
-    int                   timeFeed;      // time for solver feedback (recording and resimulating)
-    int                   timeImply;     // time to analyze implications
-    int                   timeSat;       // time to compute the truth table for each cut
-    int                   timeToNet;     // time to transfer back to the network
-    int                   timeTotal;     // the total mapping time
-    int                   time1;         // time to perform one task
-    int                   time2;         // time to perform another task
-    int                   time3;         // time to perform another task
-    int                   time4;         // time to perform another task
-};
-
-// the mapping node
-struct Fraig_NodeStruct_t_ 
-{
-    // various numbers associated with the node
-    int                   Num;           // the unique number (SAT var number) of this node 
-    int                   NumPi;         // if the node is a PI, this is its variable number
-    int                   Level;         // the level of the node
-    int                   nRefs;         // the number of references of the node
-    int                   TravId;        // the traversal ID (use to avoid cleaning marks)
-    int                   TravId2;       // the traversal ID (use to avoid cleaning marks)
-
-    // general information about the node
-    unsigned              fInv     :  1; // the mark to show that simulation info is complemented
-    unsigned              fNodePo  :  1; // the mark used for primary outputs
-    unsigned              fClauses :  1; // the clauses for this node are loaded
-    unsigned              fMark0   :  1; // the mark used for traversals
-    unsigned              fMark1   :  1; // the mark used for traversals
-    unsigned              fMark2   :  1; // the mark used for traversals
-    unsigned              fMark3   :  1; // the mark used for traversals
-    unsigned              fFeedUse :  1; // the presence of the variable in the feedback
-    unsigned              fFeedVal :  1; // the value of the variable in the feedback
-    unsigned              fFailTfo :  1; // the node is in the TFO of the failed SAT run
-    unsigned              nFanouts :  2; // the indicator of fanouts (none, one, or many)
-    unsigned              nOnes    : 20; // the number of 1's in the random sim info
- 
-    // the children of the node
-    Fraig_Node_t *        p1;            // the first child
-    Fraig_Node_t *        p2;            // the second child
-    Fraig_NodeVec_t *     vFanins;       // the fanins of the supergate rooted at this node
-//    Fraig_NodeVec_t *     vFanouts;      // the fanouts of the supergate rooted at this node
-
-    // various linked lists
-    Fraig_Node_t *        pNextS;        // the next node in the structural hash table
-    Fraig_Node_t *        pNextF;        // the next node in the functional (simulation) hash table
-    Fraig_Node_t *        pNextD;        // the next node in the list of nodes based on dynamic simulation
-    Fraig_Node_t *        pNextE;        // the next structural choice (functionally-equivalent node)
-    Fraig_Node_t *        pRepr;         // the canonical functional representative of the node
-
-    // simulation data
-    unsigned              uHashR;        // the hash value for random information
-    unsigned              uHashD;        // the hash value for dynamic information 
-    unsigned *            puSimR;        // the simulation information (random)
-    unsigned *            puSimD;        // the simulation information (dynamic)
-
-    // misc information  
-    Fraig_Node_t *        pData0;        // temporary storage for the corresponding network node
-    Fraig_Node_t *        pData1;        // temporary storage for the corresponding network node
-
-#ifdef FRAIG_ENABLE_FANOUTS
-    // representation of node's fanouts
-    Fraig_Node_t *        pFanPivot;     // the first fanout of this node
-    Fraig_Node_t *        pFanFanin1;    // the next fanout of p1
-    Fraig_Node_t *        pFanFanin2;    // the next fanout of p2
-#endif
-}; 
-
-// the vector of nodes
-struct Fraig_NodeVecStruct_t_
-{
-    int                   nCap;          // the number of allocated entries
-    int                   nSize;         // the number of entries in the array
-    Fraig_Node_t **       pArray;        // the array of nodes
-};
-
-// the hash table 
-struct Fraig_HashTableStruct_t_
-{
-    Fraig_Node_t **       pBins;         // the table bins
-    int                   nBins;         // the size of the table
-    int                   nEntries;      // the total number of entries in the table
-};
-
-// getting hold of the next fanout of the node
-#define Fraig_NodeReadNextFanout( pNode, pFanout )                \
-    ( ( pFanout == NULL )? NULL :                                 \
-        ((Fraig_Regular((pFanout)->p1) == (pNode))?               \
-             (pFanout)->pFanFanin1 : (pFanout)->pFanFanin2) )
-// getting hold of the place where the next fanout will be attached
-#define Fraig_NodeReadNextFanoutPlace( pNode, pFanout )           \
-    ( (Fraig_Regular((pFanout)->p1) == (pNode))?                  \
-         &(pFanout)->pFanFanin1 : &(pFanout)->pFanFanin2 )
-// iterator through the fanouts of the node
-#define Fraig_NodeForEachFanout( pNode, pFanout )                 \
-    for ( pFanout = (pNode)->pFanPivot; pFanout;                  \
-          pFanout = Fraig_NodeReadNextFanout(pNode, pFanout) )
-// safe iterator through the fanouts of the node
-#define Fraig_NodeForEachFanoutSafe( pNode, pFanout, pFanout2 )   \
-    for ( pFanout  = (pNode)->pFanPivot,                          \
-          pFanout2 = Fraig_NodeReadNextFanout(pNode, pFanout);    \
-          pFanout;                                                \
-          pFanout  = pFanout2,                                    \
-          pFanout2 = Fraig_NodeReadNextFanout(pNode, pFanout) )
-
-// iterators through the entries in the linked lists of nodes
-// the list of nodes in the structural hash table
-#define Fraig_TableBinForEachEntryS( pBin, pEnt )                 \
-    for ( pEnt = pBin;                                            \
-          pEnt;                                                   \
-          pEnt = pEnt->pNextS )
-#define Fraig_TableBinForEachEntrySafeS( pBin, pEnt, pEnt2 )      \
-    for ( pEnt = pBin,                                            \
-          pEnt2 = pEnt? pEnt->pNextS: NULL;                       \
-          pEnt;                                                   \
-          pEnt = pEnt2,                                           \
-          pEnt2 = pEnt? pEnt->pNextS: NULL )
-// the list of nodes in the functional (simulation) hash table
-#define Fraig_TableBinForEachEntryF( pBin, pEnt )                 \
-    for ( pEnt = pBin;                                            \
-          pEnt;                                                   \
-          pEnt = pEnt->pNextF )
-#define Fraig_TableBinForEachEntrySafeF( pBin, pEnt, pEnt2 )      \
-    for ( pEnt = pBin,                                            \
-          pEnt2 = pEnt? pEnt->pNextF: NULL;                       \
-          pEnt;                                                   \
-          pEnt = pEnt2,                                           \
-          pEnt2 = pEnt? pEnt->pNextF: NULL )
-// the list of nodes with the same simulation and different functionality
-#define Fraig_TableBinForEachEntryD( pBin, pEnt )                 \
-    for ( pEnt = pBin;                                            \
-          pEnt;                                                   \
-          pEnt = pEnt->pNextD )
-#define Fraig_TableBinForEachEntrySafeD( pBin, pEnt, pEnt2 )      \
-    for ( pEnt = pBin,                                            \
-          pEnt2 = pEnt? pEnt->pNextD: NULL;                       \
-          pEnt;                                                   \
-          pEnt = pEnt2,                                           \
-          pEnt2 = pEnt? pEnt->pNextD: NULL )
-// the list of nodes with the same functionality 
-#define Fraig_TableBinForEachEntryE( pBin, pEnt )                 \
-    for ( pEnt = pBin;                                            \
-          pEnt;                                                   \
-          pEnt = pEnt->pNextE )
-#define Fraig_TableBinForEachEntrySafeE( pBin, pEnt, pEnt2 )      \
-    for ( pEnt = pBin,                                            \
-          pEnt2 = pEnt? pEnt->pNextE: NULL;                       \
-          pEnt;                                                   \
-          pEnt = pEnt2,                                           \
-          pEnt2 = pEnt? pEnt->pNextE: NULL )
-
-////////////////////////////////////////////////////////////////////////
-///                       GLOBAL VARIABLES                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== fraigCanon.c =============================================================*/
-extern Fraig_Node_t *      Fraig_NodeAndCanon( Fraig_Man_t * pMan, Fraig_Node_t * p1, Fraig_Node_t * p2 );
-/*=== fraigFanout.c =============================================================*/
-extern void                Fraig_NodeAddFaninFanout( Fraig_Node_t * pFanin, Fraig_Node_t * pFanout );
-extern void                Fraig_NodeRemoveFaninFanout( Fraig_Node_t * pFanin, Fraig_Node_t * pFanoutToRemove );
-extern int                 Fraig_NodeGetFanoutNum( Fraig_Node_t * pNode );
-/*=== fraigFeed.c =============================================================*/
-extern void                Fraig_FeedBackInit( Fraig_Man_t * p );
-extern void                Fraig_FeedBack( Fraig_Man_t * p, int * pModel, Msat_IntVec_t * vVars, Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-extern void                Fraig_FeedBackTest( Fraig_Man_t * p );
-extern int                 Fraig_FeedBackCompress( Fraig_Man_t * p );
-extern int *               Fraig_ManAllocCounterExample( Fraig_Man_t * p );
-extern int *               Fraig_ManSaveCounterExample( Fraig_Man_t * p, Fraig_Node_t * pNode );
-/*=== fraigMan.c =============================================================*/
-extern void                Fraig_ManCreateSolver( Fraig_Man_t * p );
-/*=== fraigMem.c =============================================================*/
-extern Fraig_MemFixed_t *  Fraig_MemFixedStart( int nEntrySize );
-extern void                Fraig_MemFixedStop( Fraig_MemFixed_t * p, int fVerbose );
-extern char *              Fraig_MemFixedEntryFetch( Fraig_MemFixed_t * p );
-extern void                Fraig_MemFixedEntryRecycle( Fraig_MemFixed_t * p, char * pEntry );
-extern void                Fraig_MemFixedRestart( Fraig_MemFixed_t * p );
-extern int                 Fraig_MemFixedReadMemUsage( Fraig_MemFixed_t * p );
-/*=== fraigNode.c =============================================================*/
-extern Fraig_Node_t *      Fraig_NodeCreateConst( Fraig_Man_t * p );
-extern Fraig_Node_t *      Fraig_NodeCreatePi( Fraig_Man_t * p );
-extern Fraig_Node_t *      Fraig_NodeCreate( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 );
-extern void                Fraig_NodeSimulate( Fraig_Node_t * pNode, int iWordStart, int iWordStop, int fUseRand );
-/*=== fraigPrime.c =============================================================*/
-extern int                 s_FraigPrimes[FRAIG_MAX_PRIMES];
-extern unsigned int        Cudd_PrimeFraig( unsigned int  p );
-/*=== fraigSat.c ===============================================================*/
-extern int                 Fraig_NodeIsImplication( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew, int nBTLimit );
-/*=== fraigTable.c =============================================================*/
-extern Fraig_HashTable_t * Fraig_HashTableCreate( int nSize );
-extern void                Fraig_HashTableFree( Fraig_HashTable_t * p );
-extern int                 Fraig_HashTableLookupS( Fraig_Man_t * pMan, Fraig_Node_t * p1, Fraig_Node_t * p2, Fraig_Node_t ** ppNodeRes );
-extern Fraig_Node_t *      Fraig_HashTableLookupF( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-extern Fraig_Node_t *      Fraig_HashTableLookupF0( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-extern void                Fraig_HashTableInsertF0( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-extern int                 Fraig_CompareSimInfo( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int iWordLast, int fUseRand );
-extern int                 Fraig_CompareSimInfoUnderMask( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int iWordLast, int fUseRand, unsigned * puMask );
-extern int                 Fraig_FindFirstDiff( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int fCompl, int iWordLast, int fUseRand );
-extern void                Fraig_CollectXors( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int iWordLast, int fUseRand, unsigned * puMask );
-extern void                Fraig_TablePrintStatsS( Fraig_Man_t * pMan );
-extern void                Fraig_TablePrintStatsF( Fraig_Man_t * pMan );
-extern void                Fraig_TablePrintStatsF0( Fraig_Man_t * pMan );
-extern int                 Fraig_TableRehashF0( Fraig_Man_t * pMan, int fLinkEquiv );
-/*=== fraigUtil.c ===============================================================*/
-extern int                 Fraig_NodeCountPis( Msat_IntVec_t * vVars, int nVarsPi );
-extern int                 Fraig_NodeCountSuppVars( Fraig_Man_t * p, Fraig_Node_t * pNode, int fSuppStr );
-extern int                 Fraig_NodesCompareSupps( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-extern int                 Fraig_NodeAndSimpleCase_rec( Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-extern int                 Fraig_NodeIsExorType( Fraig_Node_t * pNode );
-extern void                Fraig_ManSelectBestChoice( Fraig_Man_t * p );
-extern int                 Fraig_BitStringCountOnes( unsigned * pString, int nWords );
-extern void                Fraig_PrintBinary( FILE * pFile, unsigned * pSign, int nBits );
-extern int                 Fraig_NodeIsExorType( Fraig_Node_t * pNode );
-extern int                 Fraig_NodeIsExor( Fraig_Node_t * pNode );
-extern int                 Fraig_NodeIsMuxType( Fraig_Node_t * pNode );
-extern Fraig_Node_t *      Fraig_NodeRecognizeMux( Fraig_Node_t * pNode, Fraig_Node_t ** ppNodeT, Fraig_Node_t ** ppNodeE );
-extern int                 Fraig_ManCountExors( Fraig_Man_t * pMan );
-extern int                 Fraig_ManCountMuxes( Fraig_Man_t * pMan );
-extern int                 Fraig_NodeSimsContained( Fraig_Man_t * pMan, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2 );
-extern int                 Fraig_NodeIsInSupergate( Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-extern Fraig_NodeVec_t *   Fraig_CollectSupergate( Fraig_Node_t * pNode, int fStopAtMux );
-extern int                 Fraig_CountPis( Fraig_Man_t * p, Msat_IntVec_t * vVarNums );
-extern void                Fraig_ManIncrementTravId( Fraig_Man_t * pMan );
-extern void                Fraig_NodeSetTravIdCurrent( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-extern int                 Fraig_NodeIsTravIdCurrent( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-extern int                 Fraig_NodeIsTravIdPrevious( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-/*=== fraigVec.c ===============================================================*/
-extern void                Fraig_NodeVecSortByRefCount( Fraig_NodeVec_t * p );
-
-
-
-ABC_NAMESPACE_HEADER_END
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
diff --git a/src/sat/fraig/fraigMan.c b/src/sat/fraig/fraigMan.c
deleted file mode 100644
index ba08d793..00000000
--- a/src/sat/fraig/fraigMan.c
+++ /dev/null
@@ -1,545 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigMan.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Implementation of the FRAIG manager.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigMan.c,v 1.11 2005/07/08 01:01:31 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-int timeSelect;
-int timeAssign;
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the default parameters of the package.]
-
-  Description [This set of parameters is tuned for equivalence checking.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Prove_ParamsSetDefault( Prove_Params_t * pParams )
-{
-    // clean the parameter structure 
-    memset( pParams, 0, sizeof(Prove_Params_t) );
-    // general parameters
-    pParams->fUseFraiging         = 1;       // enables fraiging
-    pParams->fUseRewriting        = 1;       // enables rewriting
-    pParams->fUseBdds             = 0;       // enables BDD construction when other methods fail
-    pParams->fVerbose             = 0;       // prints verbose stats
-    // iterations
-    pParams->nItersMax            = 6;       // the number of iterations
-    // mitering 
-    pParams->nMiteringLimitStart  = 5000;    // starting mitering limit
-    pParams->nMiteringLimitMulti  = 2.0;     // multiplicative coefficient to increase the limit in each iteration
-    // rewriting (currently not used)
-    pParams->nRewritingLimitStart = 3;       // the number of rewriting iterations
-    pParams->nRewritingLimitMulti = 1.0;     // multiplicative coefficient to increase the limit in each iteration
-    // fraiging 
-    pParams->nFraigingLimitStart  = 2;       // starting backtrack(conflict) limit
-    pParams->nFraigingLimitMulti  = 8.0;     // multiplicative coefficient to increase the limit in each iteration
-    // last-gasp BDD construction
-    pParams->nBddSizeLimit        = 1000000; // the number of BDD nodes when construction is aborted
-    pParams->fBddReorder          = 1;       // enables dynamic BDD variable reordering
-    // last-gasp mitering
-//    pParams->nMiteringLimitLast   = 1000000; // final mitering limit
-    pParams->nMiteringLimitLast   = 0;       // final mitering limit
-    // global SAT solver limits
-    pParams->nTotalBacktrackLimit = 0;       // global limit on the number of backtracks
-    pParams->nTotalInspectLimit   = 0;       // global limit on the number of clause inspects
-//    pParams->nTotalInspectLimit   = 100000000;  // global limit on the number of clause inspects
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints out the current values of CEC engine parameters.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Prove_ParamsPrint( Prove_Params_t * pParams )
-{
-    printf( "CEC enging parameters:\n" );
-    printf( "Fraiging enabled: %s\n", pParams->fUseFraiging? "yes":"no" );
-    printf( "Rewriting enabled: %s\n", pParams->fUseRewriting? "yes":"no" );
-    printf( "BDD construction enabled: %s\n", pParams->fUseBdds? "yes":"no" );
-    printf( "Verbose output enabled: %s\n", pParams->fVerbose? "yes":"no" );
-    printf( "Solver iterations: %d\n", pParams->nItersMax );
-    printf( "Starting mitering limit: %d\n", pParams->nMiteringLimitStart );
-    printf( "Multiplicative coeficient for mitering: %.2f\n", pParams->nMiteringLimitMulti );
-    printf( "Starting number of rewriting iterations: %d\n", pParams->nRewritingLimitStart );
-    printf( "Multiplicative coeficient for rewriting: %.2f\n", pParams->nRewritingLimitMulti );
-    printf( "Starting number of conflicts in fraiging: %.2f\n", pParams->nFraigingLimitMulti );
-    printf( "Multiplicative coeficient for fraiging: %.2f\n", pParams->nRewritingLimitMulti );
-    printf( "BDD size limit for bailing out: %d\n", pParams->nBddSizeLimit );
-    printf( "BDD reordering enabled: %s\n", pParams->fBddReorder? "yes":"no" );
-    printf( "Last-gasp mitering limit: %d\n", pParams->nMiteringLimitLast );
-    printf( "Total conflict limit: %lld\n", pParams->nTotalBacktrackLimit );
-    printf( "Total inspection limit: %lld\n", pParams->nTotalInspectLimit );
-    printf( "Parameter dump complete.\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the default parameters of the package.]
-
-  Description [This set of parameters is tuned for equivalence checking.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ParamsSetDefault( Fraig_Params_t * pParams )
-{
-    memset( pParams, 0, sizeof(Fraig_Params_t) );
-    pParams->nPatsRand  = FRAIG_PATTERNS_RANDOM;  // the number of words of random simulation info
-    pParams->nPatsDyna  = FRAIG_PATTERNS_DYNAMIC; // the number of words of dynamic simulation info
-    pParams->nBTLimit   = 99;                     // the max number of backtracks to perform
-    pParams->nSeconds   = 20;                     // the max number of seconds to solve the miter
-    pParams->fFuncRed   =  1;                     // performs only one level hashing
-    pParams->fFeedBack  =  1;                     // enables solver feedback
-    pParams->fDist1Pats =  1;                     // enables distance-1 patterns
-    pParams->fDoSparse  =  0;                     // performs equiv tests for sparse functions 
-    pParams->fChoicing  =  0;                     // enables recording structural choices
-    pParams->fTryProve  =  1;                     // tries to solve the final miter
-    pParams->fVerbose   =  0;                     // the verbosiness flag
-    pParams->fVerboseP  =  0;                     // the verbose flag for reporting the proof
-    pParams->fInternal  =  0;                     // the flag indicates the internal run 
-    pParams->nConfLimit =  0;                     // the limit on the number of conflicts
-    pParams->nInspLimit =  0;                     // the limit on the number of inspections
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the default parameters of the package.]
-
-  Description [This set of parameters is tuned for complete FRAIGing.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ParamsSetDefaultFull( Fraig_Params_t * pParams )
-{
-    memset( pParams, 0, sizeof(Fraig_Params_t) );
-    pParams->nPatsRand  = FRAIG_PATTERNS_RANDOM;  // the number of words of random simulation info
-    pParams->nPatsDyna  = FRAIG_PATTERNS_DYNAMIC; // the number of words of dynamic simulation info
-    pParams->nBTLimit   = -1;                     // the max number of backtracks to perform
-    pParams->nSeconds   = 20;                     // the max number of seconds to solve the miter
-    pParams->fFuncRed   =  1;                     // performs only one level hashing
-    pParams->fFeedBack  =  1;                     // enables solver feedback
-    pParams->fDist1Pats =  1;                     // enables distance-1 patterns
-    pParams->fDoSparse  =  1;                     // performs equiv tests for sparse functions 
-    pParams->fChoicing  =  0;                     // enables recording structural choices
-    pParams->fTryProve  =  0;                     // tries to solve the final miter
-    pParams->fVerbose   =  0;                     // the verbosiness flag
-    pParams->fVerboseP  =  0;                     // the verbose flag for reporting the proof
-    pParams->fInternal  =  0;                     // the flag indicates the internal run 
-    pParams->nConfLimit =  0;                     // the limit on the number of conflicts
-    pParams->nInspLimit =  0;                     // the limit on the number of inspections
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates the new FRAIG manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Man_t * Fraig_ManCreate( Fraig_Params_t * pParams )
-{
-    Fraig_Params_t Params;
-    Fraig_Man_t * p;
-
-    // set the random seed for simulation
-//    srand( 0xFEEDDEAF );
-    srand( 0xDEADCAFE );
-
-    // set parameters for equivalence checking
-    if ( pParams == NULL )
-        Fraig_ParamsSetDefault( pParams = &Params );
-    // adjust the amount of simulation info
-    if ( pParams->nPatsRand < 128 )
-        pParams->nPatsRand = 128;
-    if ( pParams->nPatsRand > 32768 )
-        pParams->nPatsRand = 32768;
-    if ( pParams->nPatsDyna < 128 )
-        pParams->nPatsDyna = 128;
-    if ( pParams->nPatsDyna > 32768 )
-        pParams->nPatsDyna = 32768;
-    // if reduction is not performed, allocate minimum simulation info
-    if ( !pParams->fFuncRed )
-        pParams->nPatsRand = pParams->nPatsDyna = 128;
-
-    // start the manager
-    p = ABC_ALLOC( Fraig_Man_t, 1 );
-    memset( p, 0, sizeof(Fraig_Man_t) );
-
-    // set the default parameters
-    p->nWordsRand = FRAIG_NUM_WORDS( pParams->nPatsRand );  // the number of words of random simulation info
-    p->nWordsDyna = FRAIG_NUM_WORDS( pParams->nPatsDyna );  // the number of patterns for dynamic simulation info
-    p->nBTLimit   = pParams->nBTLimit;    // -1 means infinite backtrack limit
-    p->nSeconds   = pParams->nSeconds;    // the timeout for the final miter
-    p->fFuncRed   = pParams->fFuncRed;    // enables functional reduction (otherwise, only one-level hashing is performed)
-    p->fFeedBack  = pParams->fFeedBack;   // enables solver feedback (the use of counter-examples in simulation)
-    p->fDist1Pats = pParams->fDist1Pats;  // enables solver feedback (the use of counter-examples in simulation)
-    p->fDoSparse  = pParams->fDoSparse;   // performs equivalence checking for sparse functions (whose sim-info is 0)
-    p->fChoicing  = pParams->fChoicing;   // disable accumulation of structural choices (keeps only the first choice)
-    p->fTryProve  = pParams->fTryProve;   // disable accumulation of structural choices (keeps only the first choice)
-    p->fVerbose   = pParams->fVerbose;    // disable verbose output
-    p->fVerboseP  = pParams->fVerboseP;   // disable verbose output
-    p->nInspLimit = pParams->nInspLimit;  // the limit on the number of inspections
-
-    // start memory managers
-    p->mmNodes    = Fraig_MemFixedStart( sizeof(Fraig_Node_t) );
-    p->mmSims     = Fraig_MemFixedStart( sizeof(unsigned) * (p->nWordsRand + p->nWordsDyna) );
-    // allocate node arrays
-    p->vInputs    = Fraig_NodeVecAlloc( 1000 );    // the array of primary inputs
-    p->vOutputs   = Fraig_NodeVecAlloc( 1000 );    // the array of primary outputs
-    p->vNodes     = Fraig_NodeVecAlloc( 1000 );    // the array of internal nodes
-    // start the tables
-    p->pTableS    = Fraig_HashTableCreate( 1000 ); // hashing by structure
-    p->pTableF    = Fraig_HashTableCreate( 1000 ); // hashing by function
-    p->pTableF0   = Fraig_HashTableCreate( 1000 ); // hashing by function (for sparse functions)
-    // create the constant node
-    p->pConst1    = Fraig_NodeCreateConst( p );
-    // initialize SAT solver feedback data structures
-    Fraig_FeedBackInit( p );
-    // initialize other variables
-    p->vProj      = Msat_IntVecAlloc( 10 ); 
-    p->nTravIds   = 1;
-    p->nTravIds2  = 1;
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Deallocates the mapping manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManFree( Fraig_Man_t * p )
-{
-    int i;
-    if ( p->fVerbose )   
-    {
-        if ( p->fChoicing ) Fraig_ManReportChoices( p );
-        Fraig_ManPrintStats( p );
-//        Fraig_TablePrintStatsS( p );
-//        Fraig_TablePrintStatsF( p );
-//        Fraig_TablePrintStatsF0( p );
-    }
- 
-    for ( i = 0; i < p->vNodes->nSize; i++ )
-        if ( p->vNodes->pArray[i]->vFanins )
-        {
-            Fraig_NodeVecFree( p->vNodes->pArray[i]->vFanins );
-            p->vNodes->pArray[i]->vFanins = NULL;
-        }
-
-    if ( p->vInputs )    Fraig_NodeVecFree( p->vInputs );
-    if ( p->vNodes )     Fraig_NodeVecFree( p->vNodes );
-    if ( p->vOutputs )   Fraig_NodeVecFree( p->vOutputs );
-
-    if ( p->pTableS )    Fraig_HashTableFree( p->pTableS );
-    if ( p->pTableF )    Fraig_HashTableFree( p->pTableF );
-    if ( p->pTableF0 )   Fraig_HashTableFree( p->pTableF0 );
-
-    if ( p->pSat )       Msat_SolverFree( p->pSat );
-    if ( p->vProj )      Msat_IntVecFree( p->vProj );
-    if ( p->vCones )     Fraig_NodeVecFree( p->vCones );
-    if ( p->vPatsReal )  Msat_IntVecFree( p->vPatsReal );
-    if ( p->pModel )     ABC_FREE( p->pModel );
-
-    Fraig_MemFixedStop( p->mmNodes, 0 );
-    Fraig_MemFixedStop( p->mmSims, 0 );
-
-    if ( p->pSuppS )
-    {
-        ABC_FREE( p->pSuppS[0] );
-        ABC_FREE( p->pSuppS );
-    }
-    if ( p->pSuppF )
-    {
-        ABC_FREE( p->pSuppF[0] );
-        ABC_FREE( p->pSuppF );
-    }
-
-    ABC_FREE( p->ppOutputNames );
-    ABC_FREE( p->ppInputNames );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prepares the SAT solver to run on the two nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManCreateSolver( Fraig_Man_t * p )
-{
-    extern int timeSelect;
-    extern int timeAssign;
-    assert( p->pSat == NULL );
-    // allocate data for SAT solving
-    p->pSat       = Msat_SolverAlloc( 500, 1, 1, 1, 1, 0 );
-    p->vVarsInt   = Msat_SolverReadConeVars( p->pSat );   
-    p->vAdjacents = Msat_SolverReadAdjacents( p->pSat );
-    p->vVarsUsed  = Msat_SolverReadVarsUsed( p->pSat );
-    timeSelect = 0;
-    timeAssign = 0;
-}
-
- 
-/**Function*************************************************************
-
-  Synopsis    [Deallocates the mapping manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManPrintStats( Fraig_Man_t * p )
-{
-    double nMemory;
-    nMemory = ((double)(p->vInputs->nSize + p->vNodes->nSize) * 
-        (sizeof(Fraig_Node_t) + sizeof(unsigned)*(p->nWordsRand + p->nWordsDyna) /*+ p->nSuppWords*sizeof(unsigned)*/))/(1<<20);
-    printf( "Words: Random = %d. Dynamic = %d. Used = %d. Memory = %0.2f Mb.\n", 
-        p->nWordsRand, p->nWordsDyna, p->iWordPerm, nMemory );
-    printf( "Proof = %d. Counter-example = %d. Fail = %d. FailReal = %d. Zero = %d.\n", 
-        p->nSatProof, p->nSatCounter, p->nSatFails, p->nSatFailsReal, p->nSatZeros );
-    printf( "Nodes: Final = %d. Total = %d. Mux = %d. (Exor = %d.) ClaVars = %d.\n", 
-        Fraig_CountNodes(p,0), p->vNodes->nSize, Fraig_ManCountMuxes(p), Fraig_ManCountExors(p), p->nVarsClauses );
-    if ( p->pSat ) Msat_SolverPrintStats( p->pSat );
-    Fraig_PrintTime( "AIG simulation  ", p->timeSims  );
-    Fraig_PrintTime( "AIG traversal   ", p->timeTrav  );
-    Fraig_PrintTime( "Solver feedback ", p->timeFeed  );
-    Fraig_PrintTime( "SAT solving     ", p->timeSat   );
-    Fraig_PrintTime( "Network update  ", p->timeToNet );
-    Fraig_PrintTime( "TOTAL RUNTIME   ", p->timeTotal );
-    if ( p->time1 > 0 ) { Fraig_PrintTime( "time1", p->time1 ); }
-    if ( p->time2 > 0 ) { Fraig_PrintTime( "time2", p->time2 ); }
-    if ( p->time3 > 0 ) { Fraig_PrintTime( "time3", p->time3 ); }
-    if ( p->time4 > 0 ) { Fraig_PrintTime( "time4", p->time4 ); }
-//    ABC_PRT( "Selection ", timeSelect );
-//    ABC_PRT( "Assignment", timeAssign );
-    fflush( stdout );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Allocates simulation information for all nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_UtilInfoAlloc( int nSize, int nWords, int fClean )
-{
-    Fraig_NodeVec_t * vInfo;
-    unsigned * pUnsigned;
-    int i;
-    assert( nSize > 0 && nWords > 0 );
-    vInfo = Fraig_NodeVecAlloc( nSize );
-    pUnsigned = ABC_ALLOC( unsigned, nSize * nWords );
-    vInfo->pArray[0] = (Fraig_Node_t *)pUnsigned;
-    if ( fClean )
-        memset( pUnsigned, 0, sizeof(unsigned) * nSize * nWords );
-    for ( i = 1; i < nSize; i++ )
-        vInfo->pArray[i] = (Fraig_Node_t *)(((unsigned *)vInfo->pArray[i-1]) + nWords);
-    vInfo->nSize = nSize;
-    return vInfo;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns simulation info of all nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_ManGetSimInfo( Fraig_Man_t * p )
-{
-    Fraig_NodeVec_t * vInfo;
-    Fraig_Node_t * pNode;
-    unsigned * pUnsigned;
-    int nRandom, nDynamic;
-    int i, k, nWords;
-
-    nRandom  = Fraig_ManReadPatternNumRandom( p );
-    nDynamic = Fraig_ManReadPatternNumDynamic( p );
-    nWords = nRandom / 32 + nDynamic / 32;
-
-    vInfo = Fraig_UtilInfoAlloc( p->vNodes->nSize, nWords, 0 );
-    for ( i = 0; i < p->vNodes->nSize; i++ )
-    {
-        pNode = p->vNodes->pArray[i];
-        assert( i == pNode->Num );
-        pUnsigned = (unsigned *)vInfo->pArray[i];
-        for ( k = 0; k < nRandom / 32; k++ )
-            pUnsigned[k] = pNode->puSimR[k];
-        for ( k = 0; k < nDynamic / 32; k++ )
-            pUnsigned[nRandom / 32 + k] = pNode->puSimD[k];
-    }
-    return vInfo;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if A v B is always true based on the siminfo.]
-
-  Description [A v B is always true iff A' * B' is always false.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManCheckClauseUsingSimInfo( Fraig_Man_t * p, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2 )
-{
-    int fCompl1, fCompl2, i;
-
-    fCompl1 = 1 ^ Fraig_IsComplement(pNode1) ^ Fraig_Regular(pNode1)->fInv;
-    fCompl2 = 1 ^ Fraig_IsComplement(pNode2) ^ Fraig_Regular(pNode2)->fInv;
-
-    pNode1 = Fraig_Regular(pNode1);
-    pNode2 = Fraig_Regular(pNode2);
-    assert( pNode1 != pNode2 );
-    
-    // check the simulation info
-    if ( fCompl1 && fCompl2 )
-    {
-        for ( i = 0; i < p->nWordsRand; i++ )
-            if ( ~pNode1->puSimR[i] & ~pNode2->puSimR[i] )
-                return 0;
-        for ( i = 0; i < p->iWordStart; i++ )
-            if ( ~pNode1->puSimD[i] & ~pNode2->puSimD[i] )
-                return 0;
-        return 1;
-    }
-    if ( !fCompl1 && fCompl2 )
-    {
-        for ( i = 0; i < p->nWordsRand; i++ )
-            if ( pNode1->puSimR[i] & ~pNode2->puSimR[i] )
-                return 0;
-        for ( i = 0; i < p->iWordStart; i++ )
-            if ( pNode1->puSimD[i] & ~pNode2->puSimD[i] )
-                return 0;
-        return 1;
-    }
-    if ( fCompl1 && !fCompl2 )
-    {
-        for ( i = 0; i < p->nWordsRand; i++ )
-            if ( ~pNode1->puSimR[i] & pNode2->puSimR[i] )
-                return 0;
-        for ( i = 0; i < p->iWordStart; i++ )
-            if ( ~pNode1->puSimD[i] & pNode2->puSimD[i] )
-                return 0;
-        return 1;
-    }
-//    if ( fCompl1 && fCompl2 )
-    {
-        for ( i = 0; i < p->nWordsRand; i++ )
-            if ( pNode1->puSimR[i] & pNode2->puSimR[i] )
-                return 0;
-        for ( i = 0; i < p->iWordStart; i++ )
-            if ( pNode1->puSimD[i] & pNode2->puSimD[i] )
-                return 0;
-        return 1;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds clauses to the solver.]
-
-  Description [This procedure is used to add external clauses to the solver.
-  The clauses are given by sets of nodes. Each node stands for one literal.
-  If the node is complemented, the literal is negated.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManAddClause( Fraig_Man_t * p, Fraig_Node_t ** ppNodes, int nNodes )
-{
-    Fraig_Node_t * pNode;
-    int i, fComp, RetValue;
-    if ( p->pSat == NULL )
-        Fraig_ManCreateSolver( p );
-    // create four clauses
-    Msat_IntVecClear( p->vProj );
-    for ( i = 0; i < nNodes; i++ )
-    {
-        pNode = Fraig_Regular(ppNodes[i]);
-        fComp = Fraig_IsComplement(ppNodes[i]);
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num, fComp) );
-//        printf( "%d(%d) ", pNode->Num, fComp );
-    }
-//    printf( "\n" );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigMem.c b/src/sat/fraig/fraigMem.c
deleted file mode 100644
index ef52765e..00000000
--- a/src/sat/fraig/fraigMem.c
+++ /dev/null
@@ -1,251 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigMem.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Fixed-size-entry memory manager for the FRAIG package.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigMem.c,v 1.4 2005/07/08 01:01:31 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-struct Fraig_MemFixed_t_
-{
-    // information about individual entries
-    int           nEntrySize;    // the size of one entry
-    int           nEntriesAlloc; // the total number of entries allocated
-    int           nEntriesUsed;  // the number of entries in use
-    int           nEntriesMax;   // the max number of entries in use
-    char *        pEntriesFree;  // the linked list of free entries
-
-    // this is where the memory is stored
-    int           nChunkSize;    // the size of one chunk
-    int           nChunksAlloc;  // the maximum number of memory chunks 
-    int           nChunks;       // the current number of memory chunks 
-    char **       pChunks;       // the allocated memory
-
-    // statistics
-    int           nMemoryUsed;   // memory used in the allocated entries
-    int           nMemoryAlloc;  // memory allocated
-};
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Starts the internal memory manager.]
-
-  Description [Can only work with entry size at least 4 byte long.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_MemFixed_t * Fraig_MemFixedStart( int nEntrySize )
-{
-    Fraig_MemFixed_t * p;
-
-    p = ABC_ALLOC( Fraig_MemFixed_t, 1 );
-    memset( p, 0, sizeof(Fraig_MemFixed_t) );
-
-    p->nEntrySize    = nEntrySize;
-    p->nEntriesAlloc = 0;
-    p->nEntriesUsed  = 0;
-    p->pEntriesFree  = NULL;
-
-    if ( nEntrySize * (1 << 10) < (1<<16) )
-        p->nChunkSize = (1 << 10);
-    else
-        p->nChunkSize = (1<<16) / nEntrySize;
-    if ( p->nChunkSize < 8 )
-        p->nChunkSize = 8;
-
-    p->nChunksAlloc  = 64;
-    p->nChunks       = 0;
-    p->pChunks       = ABC_ALLOC( char *, p->nChunksAlloc );
-
-    p->nMemoryUsed   = 0;
-    p->nMemoryAlloc  = 0;
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the internal memory manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_MemFixedStop( Fraig_MemFixed_t * p, int fVerbose )
-{
-    int i;
-    if ( p == NULL )
-        return;
-    if ( fVerbose )
-    {
-        printf( "Fixed memory manager: Entry = %5d. Chunk = %5d. Chunks used = %5d.\n",
-            p->nEntrySize, p->nChunkSize, p->nChunks );
-        printf( "   Entries used = %8d. Entries peak = %8d. Memory used = %8d. Memory alloc = %8d.\n",
-            p->nEntriesUsed, p->nEntriesMax, p->nEntrySize * p->nEntriesUsed, p->nMemoryAlloc );
-    }
-    for ( i = 0; i < p->nChunks; i++ )
-        ABC_FREE( p->pChunks[i] );
-    ABC_FREE( p->pChunks );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Extracts one entry from the memory manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char * Fraig_MemFixedEntryFetch( Fraig_MemFixed_t * p )
-{
-    char * pTemp;
-    int i;
-
-    // check if there are still free entries
-    if ( p->nEntriesUsed == p->nEntriesAlloc )
-    { // need to allocate more entries
-        assert( p->pEntriesFree == NULL );
-        if ( p->nChunks == p->nChunksAlloc )
-        {
-            p->nChunksAlloc *= 2;
-            p->pChunks = ABC_REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
-        }
-        p->pEntriesFree = ABC_ALLOC( char, p->nEntrySize * p->nChunkSize );
-        p->nMemoryAlloc += p->nEntrySize * p->nChunkSize;
-        // transform these entries into a linked list
-        pTemp = p->pEntriesFree;
-        for ( i = 1; i < p->nChunkSize; i++ )
-        {
-            *((char **)pTemp) = pTemp + p->nEntrySize;
-            pTemp += p->nEntrySize;
-        }
-        // set the last link
-        *((char **)pTemp) = NULL;
-        // add the chunk to the chunk storage
-        p->pChunks[ p->nChunks++ ] = p->pEntriesFree;
-        // add to the number of entries allocated
-        p->nEntriesAlloc += p->nChunkSize;
-    }
-    // incrememt the counter of used entries
-    p->nEntriesUsed++;
-    if ( p->nEntriesMax < p->nEntriesUsed )
-        p->nEntriesMax = p->nEntriesUsed;
-    // return the first entry in the free entry list
-    pTemp = p->pEntriesFree;
-    p->pEntriesFree = *((char **)pTemp);
-    return pTemp;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns one entry into the memory manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_MemFixedEntryRecycle( Fraig_MemFixed_t * p, char * pEntry )
-{
-    // decrement the counter of used entries
-    p->nEntriesUsed--;
-    // add the entry to the linked list of free entries
-    *((char **)pEntry) = p->pEntriesFree;
-    p->pEntriesFree = pEntry;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Frees all associated memory and resets the manager.]
-
-  Description [Relocates all the memory except the first chunk.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_MemFixedRestart( Fraig_MemFixed_t * p )
-{
-    int i;
-    char * pTemp;
-
-    // deallocate all chunks except the first one
-    for ( i = 1; i < p->nChunks; i++ )
-        ABC_FREE( p->pChunks[i] );
-    p->nChunks = 1;
-    // transform these entries into a linked list
-    pTemp = p->pChunks[0];
-    for ( i = 1; i < p->nChunkSize; i++ )
-    {
-        *((char **)pTemp) = pTemp + p->nEntrySize;
-        pTemp += p->nEntrySize;
-    }
-    // set the last link
-    *((char **)pTemp) = NULL;
-    // set the free entry list
-    p->pEntriesFree  = p->pChunks[0];
-    // set the correct statistics
-    p->nMemoryAlloc  = p->nEntrySize * p->nChunkSize;
-    p->nMemoryUsed   = 0;
-    p->nEntriesAlloc = p->nChunkSize;
-    p->nEntriesUsed  = 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reports the memory usage.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_MemFixedReadMemUsage( Fraig_MemFixed_t * p )
-{
-    return p->nMemoryAlloc;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigNode.c b/src/sat/fraig/fraigNode.c
deleted file mode 100644
index 9f95cd46..00000000
--- a/src/sat/fraig/fraigNode.c
+++ /dev/null
@@ -1,318 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigNode.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Implementation of the FRAIG node.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigNode.c,v 1.3 2005/07/08 01:01:32 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-// returns the complemented attribute of the node
-#define Fraig_NodeIsSimComplement(p) (Fraig_IsComplement(p)? !(Fraig_Regular(p)->fInv) : (p)->fInv)
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Creates the constant 1 node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeCreateConst( Fraig_Man_t * p )
-{
-    Fraig_Node_t * pNode;
-
-    // create the node
-    pNode = (Fraig_Node_t *)Fraig_MemFixedEntryFetch( p->mmNodes );
-    memset( pNode, 0, sizeof(Fraig_Node_t) );
-
-    // assign the number and add to the array of nodes
-    pNode->Num   = p->vNodes->nSize;
-    Fraig_NodeVecPush( p->vNodes,  pNode );
-    pNode->NumPi = -1;  // this is not a PI, so its number is -1
-    pNode->Level =  0;  // just like a PI, it has 0 level
-    pNode->nRefs =  1;  // it is a persistent node, which comes referenced
-    pNode->fInv  =  1;  // the simulation info is complemented
-
-    // create the simulation info
-    pNode->puSimR = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-    pNode->puSimD = pNode->puSimR + p->nWordsRand;
-    memset( pNode->puSimR, 0, sizeof(unsigned) * p->nWordsRand );
-    memset( pNode->puSimD, 0, sizeof(unsigned) * p->nWordsDyna );
-
-    // count the number of ones in the simulation vector
-    pNode->nOnes = p->nWordsRand * sizeof(unsigned) * 8;
-
-    // insert it into the hash table
-    Fraig_HashTableLookupF0( p, pNode );
-    return pNode;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates a primary input node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeCreatePi( Fraig_Man_t * p )
-{
-    Fraig_Node_t * pNode, * pNodeRes;
-    int i, clk;
-
-    // create the node
-    pNode = (Fraig_Node_t *)Fraig_MemFixedEntryFetch( p->mmNodes );
-    memset( pNode, 0, sizeof(Fraig_Node_t) );
-    pNode->puSimR = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-    pNode->puSimD = pNode->puSimR + p->nWordsRand;
-    memset( pNode->puSimD, 0, sizeof(unsigned) * p->nWordsDyna );
-
-    // assign the number and add to the array of nodes
-    pNode->Num   = p->vNodes->nSize;
-    Fraig_NodeVecPush( p->vNodes,  pNode );
-
-    // assign the PI number and add to the array of primary inputs
-    pNode->NumPi = p->vInputs->nSize;   
-    Fraig_NodeVecPush( p->vInputs, pNode );
-
-    pNode->Level =  0;  // PI has 0 level
-    pNode->nRefs =  1;  // it is a persistent node, which comes referenced
-    pNode->fInv  =  0;  // the simulation info of the PI is not complemented
-
-    // derive the simulation info for the new node
-clk = clock();
-    // set the random simulation info for the primary input
-    pNode->uHashR = 0;
-    for ( i = 0; i < p->nWordsRand; i++ )
-    {
-        // generate the simulation info
-        pNode->puSimR[i] = FRAIG_RANDOM_UNSIGNED;
-        // for reasons that take very long to explain, it makes sense to have (0000000...) 
-        // pattern in the set (this helps if we need to return the counter-examples)
-        if ( i == 0 )
-            pNode->puSimR[i] <<= 1;
-        // compute the hash key
-        pNode->uHashR ^= pNode->puSimR[i] * s_FraigPrimes[i];
-    }
-    // count the number of ones in the simulation vector
-    pNode->nOnes = Fraig_BitStringCountOnes( pNode->puSimR, p->nWordsRand );
-
-    // set the systematic simulation info for the primary input
-    pNode->uHashD = 0;
-    for ( i = 0; i < p->iWordStart; i++ )
-    {
-        // generate the simulation info
-        pNode->puSimD[i] = FRAIG_RANDOM_UNSIGNED;
-        // compute the hash key
-        pNode->uHashD ^= pNode->puSimD[i] * s_FraigPrimes[i];
-    }
-p->timeSims += clock() - clk;
-
-    // insert it into the hash table
-    pNodeRes = Fraig_HashTableLookupF( p, pNode );
-    assert( pNodeRes == NULL );
-    // add to the runtime of simulation
-    return pNode;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates a new node.]
-
-  Description [This procedure should be called to create the constant
-  node and the PI nodes first.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeCreate( Fraig_Man_t * p, Fraig_Node_t * p1, Fraig_Node_t * p2 )
-{
-    Fraig_Node_t * pNode;
-    int clk;
-
-    // create the node
-    pNode = (Fraig_Node_t *)Fraig_MemFixedEntryFetch( p->mmNodes );
-    memset( pNode, 0, sizeof(Fraig_Node_t) );
-
-    // assign the children
-    pNode->p1  = p1;  Fraig_Ref(p1);  Fraig_Regular(p1)->nRefs++;
-    pNode->p2  = p2;  Fraig_Ref(p2);  Fraig_Regular(p2)->nRefs++;
-
-    // assign the number and add to the array of nodes
-    pNode->Num = p->vNodes->nSize;
-    Fraig_NodeVecPush( p->vNodes,  pNode );
-
-    // assign the PI number
-    pNode->NumPi = -1;
-
-    // compute the level of this node
-    pNode->Level = 1 + ABC_MAX(Fraig_Regular(p1)->Level, Fraig_Regular(p2)->Level);
-    pNode->fInv  = Fraig_NodeIsSimComplement(p1) & Fraig_NodeIsSimComplement(p2);
-    pNode->fFailTfo = Fraig_Regular(p1)->fFailTfo | Fraig_Regular(p2)->fFailTfo;
-
-    // derive the simulation info 
-clk = clock();
-    // allocate memory for the simulation info
-    pNode->puSimR = (unsigned *)Fraig_MemFixedEntryFetch( p->mmSims );
-    pNode->puSimD = pNode->puSimR + p->nWordsRand;
-    // derive random simulation info
-    pNode->uHashR = 0;
-    Fraig_NodeSimulate( pNode, 0, p->nWordsRand, 1 );
-    // derive dynamic simulation info
-    pNode->uHashD = 0;
-    Fraig_NodeSimulate( pNode, 0, p->iWordStart, 0 );
-    // count the number of ones in the random simulation info
-    pNode->nOnes = Fraig_BitStringCountOnes( pNode->puSimR, p->nWordsRand );
-    if ( pNode->fInv )
-        pNode->nOnes = p->nWordsRand * 32 - pNode->nOnes;
-    // add to the runtime of simulation
-p->timeSims += clock() - clk;
-
-#ifdef FRAIG_ENABLE_FANOUTS
-    // create the fanout info
-    Fraig_NodeAddFaninFanout( Fraig_Regular(p1), pNode );
-    Fraig_NodeAddFaninFanout( Fraig_Regular(p2), pNode );
-#endif
-    return pNode;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Simulates the node.]
-
-  Description [Simulates the random or dynamic simulation info through 
-  the node. Uses phases of the children to determine their real simulation
-  info. Uses phase of the node to determine the way its simulation info 
-  is stored. The resulting info is guaranteed to be 0 for the first pattern.]
-  
-  SideEffects [This procedure modified the hash value of the simulation info.]
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeSimulate( Fraig_Node_t * pNode, int iWordStart, int iWordStop, int fUseRand )
-{
-    unsigned * pSims, * pSims1, * pSims2;
-    unsigned uHash;
-    int fCompl, fCompl1, fCompl2, i;
-
-    assert( !Fraig_IsComplement(pNode) );
-
-    // get hold of the simulation information
-    pSims  = fUseRand? pNode->puSimR                    : pNode->puSimD;
-    pSims1 = fUseRand? Fraig_Regular(pNode->p1)->puSimR : Fraig_Regular(pNode->p1)->puSimD;
-    pSims2 = fUseRand? Fraig_Regular(pNode->p2)->puSimR : Fraig_Regular(pNode->p2)->puSimD;
-
-    // get complemented attributes of the children using their random info
-    fCompl  = pNode->fInv;
-    fCompl1 = Fraig_NodeIsSimComplement(pNode->p1);
-    fCompl2 = Fraig_NodeIsSimComplement(pNode->p2);
-
-    // simulate
-    uHash = 0;
-    if ( fCompl1 && fCompl2 )
-    {
-        if ( fCompl )
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = (pSims1[i] | pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-        else
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = ~(pSims1[i] | pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-    }
-    else if ( fCompl1 && !fCompl2 )
-    {
-        if ( fCompl )
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = (pSims1[i] | ~pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-        else
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = (~pSims1[i] & pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-    }
-    else if ( !fCompl1 && fCompl2 )
-    {
-        if ( fCompl )
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = (~pSims1[i] | pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-        else
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = (pSims1[i] & ~pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-    }
-    else // if ( !fCompl1 && !fCompl2 )
-    {
-        if ( fCompl )
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = ~(pSims1[i] & pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-        else
-            for ( i = iWordStart; i < iWordStop; i++ )
-            {
-                pSims[i] = (pSims1[i] & pSims2[i]);
-                uHash ^= pSims[i] * s_FraigPrimes[i];
-            }
-    }
-
-    if ( fUseRand )
-        pNode->uHashR ^= uHash;
-    else
-        pNode->uHashD ^= uHash;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigPrime.c b/src/sat/fraig/fraigPrime.c
deleted file mode 100644
index 42a079fd..00000000
--- a/src/sat/fraig/fraigPrime.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigPrime.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [The table of the first 1000 primes.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigPrime.c,v 1.4 2005/07/08 01:01:32 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-// The 1,024 smallest prime numbers used to compute the hash value
-// http://www.math.utah.edu/~alfeld/math/primelist.html
-int s_FraigPrimes[FRAIG_MAX_PRIMES] = { 2, 3, 5, 
-7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 
-101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 
-193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 
-293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 
-409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 
-521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 
-641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 
-757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 
-881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 
-1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 
-1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 
-1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 
-1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 
-1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 
-1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 
-1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 
-1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 
-1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 
-1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 
-2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 
-2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 
-2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 
-2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 
-2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 
-2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 
-2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 
-2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 
-2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 
-3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 
-3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 
-3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 
-3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 
-3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 
-3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 
-3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 
-3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 
-3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 
-4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 
-4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 
-4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 
-4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 
-4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 
-4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 
-4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 
-4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 
-5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 
-5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 
-5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 
-5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 
-5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 
-5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 
-5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 
-5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 
-6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 
-6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 
-6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 
-6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 
-6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 
-6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 
-6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 
-6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 
-6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 
-7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 
-7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 
-7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 
-7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 
-7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 
-7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 
-7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 
-8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 
-8147, 8161 };
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function********************************************************************
-
-  Synopsis    [Returns the next prime &gt;= p.]
-
-  Description [Copied from CUDD, for stand-aloneness.]
-
-  SideEffects [None]
-
-  SeeAlso     []
-
-******************************************************************************/
-unsigned int Cudd_PrimeFraig( unsigned int  p)
-{
-    int i,pn;
-
-    p--;
-    do {
-        p++;
-        if (p&1) {
-        pn = 1;
-        i = 3;
-        while ((unsigned) (i * i) <= p) {
-        if (p % i == 0) {
-            pn = 0;
-            break;
-        }
-        i += 2;
-        }
-    } else {
-        pn = 0;
-    }
-    } while (!pn);
-    return(p);
-
-} /* end of Cudd_Prime */
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigSat.c b/src/sat/fraig/fraigSat.c
deleted file mode 100644
index b96bc5a1..00000000
--- a/src/sat/fraig/fraigSat.c
+++ /dev/null
@@ -1,1459 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigSat.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Proving functional equivalence using SAT.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigSat.c,v 1.10 2005/07/08 01:01:32 alanmi Exp $]
-
-***********************************************************************/
-
-#include <math.h>
-#include "fraigInt.h"
-#include "msatInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static void Fraig_OrderVariables( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-static void Fraig_SetupAdjacent( Fraig_Man_t * pMan, Msat_IntVec_t * vConeVars );
-static void Fraig_SetupAdjacentMark( Fraig_Man_t * pMan, Msat_IntVec_t * vConeVars );
-static void Fraig_PrepareCones( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-static void Fraig_PrepareCones_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-
-static void Fraig_SupergateAddClauses( Fraig_Man_t * pMan, Fraig_Node_t * pNode, Fraig_NodeVec_t * vSuper );
-static void Fraig_SupergateAddClausesExor( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-static void Fraig_SupergateAddClausesMux( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-//static void Fraig_DetectFanoutFreeCone( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-static void Fraig_DetectFanoutFreeConeMux( Fraig_Man_t * pMan, Fraig_Node_t * pNode );
-static void Fraig_SetActivity( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew );
-
-// The lesson learned seems to be that variable should be in reverse topological order
-// from the output of the miter. The ordering of adjacency lists is very important.
-// The best way seems to be fanins followed by fanouts. Slight changes to this order
-// leads to big degradation in quality.
-
-static int nMuxes;
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Checks equivalence of two nodes.]
-
-  Description [Returns 1 iff the nodes are equivalent.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodesAreEqual( Fraig_Man_t * p, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int nBTLimit, int nTimeLimit )
-{
-    if ( pNode1 == pNode2 )
-        return 1;
-    if ( pNode1 == Fraig_Not(pNode2) )
-        return 0;
-    return Fraig_NodeIsEquivalent( p, Fraig_Regular(pNode1), Fraig_Regular(pNode2), nBTLimit, nTimeLimit );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Tries to prove the final miter.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManProveMiter( Fraig_Man_t * p )
-{
-    Fraig_Node_t * pNode;
-    int i, clk;
-
-    if ( !p->fTryProve )
-        return;
- 
-    clk = clock();
-    // consider all outputs of the multi-output miter
-    for ( i = 0; i < p->vOutputs->nSize; i++ )
-    {
-        pNode = Fraig_Regular(p->vOutputs->pArray[i]);
-        // skip already constant nodes
-        if ( pNode == p->pConst1 )
-            continue;
-        // skip nodes that are different according to simulation
-        if ( !Fraig_CompareSimInfo( pNode, p->pConst1, p->nWordsRand, 1 ) )
-            continue;
-        if ( Fraig_NodeIsEquivalent( p, p->pConst1, pNode, -1, p->nSeconds ) )
-        {
-            if ( Fraig_IsComplement(p->vOutputs->pArray[i]) ^ Fraig_NodeComparePhase(p->pConst1, pNode) )
-                p->vOutputs->pArray[i] = Fraig_Not(p->pConst1);
-            else
-                p->vOutputs->pArray[i] = p->pConst1;
-        }
-    }
-    if ( p->fVerboseP ) 
-    {
-//        ABC_PRT( "Final miter proof time", clock() - clk );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the miter is unsat; 0 if sat; -1 if undecided.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManCheckMiter( Fraig_Man_t * p )
-{
-    Fraig_Node_t * pNode;
-    int i;
-    ABC_FREE( p->pModel );
-    for ( i = 0; i < p->vOutputs->nSize; i++ )
-    {
-        // get the output node (it can be complemented!)
-        pNode = p->vOutputs->pArray[i];
-        // if the miter is constant 0, the problem is UNSAT
-        if ( pNode == Fraig_Not(p->pConst1) )
-            continue;
-        // consider the special case when the miter is constant 1
-        if ( pNode == p->pConst1 )
-        {
-            // in this case, any counter example will do to distinquish it from constant 0
-            // here we pick the counter example composed of all zeros
-            p->pModel = Fraig_ManAllocCounterExample( p );
-            return 0;
-        }
-        // save the counter example
-        p->pModel = Fraig_ManSaveCounterExample( p, pNode );
-        // if the model is not found, return undecided
-        if ( p->pModel == NULL )
-            return -1;
-        else
-            return 0;
-    }
-    return 1;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if pOld is in the TFI of pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_MarkTfi_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    // skip the visited node
-    if ( pNode->TravId == pMan->nTravIds )
-        return 0;
-    pNode->TravId = pMan->nTravIds;
-    // skip the PI node
-    if ( pNode->NumPi >= 0 )
-        return 1;
-    // check the children
-    return Fraig_MarkTfi_rec( pMan, Fraig_Regular(pNode->p1) ) +
-           Fraig_MarkTfi_rec( pMan, Fraig_Regular(pNode->p2) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if pOld is in the TFI of pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_MarkTfi2_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    // skip the visited node
-    if ( pNode->TravId == pMan->nTravIds )
-        return 0;
-    // skip the boundary node
-    if ( pNode->TravId == pMan->nTravIds-1 )
-    {
-        pNode->TravId = pMan->nTravIds;
-        return 1;
-    }
-    pNode->TravId = pMan->nTravIds;
-    // skip the PI node
-    if ( pNode->NumPi >= 0 )
-        return 1;
-    // check the children
-    return Fraig_MarkTfi2_rec( pMan, Fraig_Regular(pNode->p1) ) +
-           Fraig_MarkTfi2_rec( pMan, Fraig_Regular(pNode->p2) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if pOld is in the TFI of pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_MarkTfi3_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    // skip the visited node
-    if ( pNode->TravId == pMan->nTravIds )
-        return 1;
-    // skip the boundary node
-    if ( pNode->TravId == pMan->nTravIds-1 )
-    {
-        pNode->TravId = pMan->nTravIds;
-        return 1;
-    }
-    pNode->TravId = pMan->nTravIds;
-    // skip the PI node
-    if ( pNode->NumPi >= 0 )
-        return 0;
-    // check the children
-    return Fraig_MarkTfi3_rec( pMan, Fraig_Regular(pNode->p1) ) *
-           Fraig_MarkTfi3_rec( pMan, Fraig_Regular(pNode->p2) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_VarsStudy( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    int NumPis, NumCut, fContain;
-
-    // mark the TFI of pNew
-    p->nTravIds++;
-    NumPis = Fraig_MarkTfi_rec( p, pNew );
-    printf( "(%d)(%d,%d):", NumPis, pOld->Level, pNew->Level );
-
-    // check if the old is in the TFI
-    if ( pOld->TravId == p->nTravIds )
-    {
-        printf( "* " );
-        return;
-    }
-
-    // count the boundary of nodes in pOld
-    p->nTravIds++;
-    NumCut = Fraig_MarkTfi2_rec( p, pOld );
-    printf( "%d", NumCut );
-
-    // check if the new is contained in the old's support
-    p->nTravIds++;
-    fContain = Fraig_MarkTfi3_rec( p, pNew );
-    printf( "%c ", fContain? '+':'-' );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Checks whether two nodes are functinally equivalent.]
-
-  Description [The flag (fComp) tells whether the nodes to be checked
-  are in the opposite polarity. The second flag (fSkipZeros) tells whether
-  the checking should be performed if the simulation vectors are zeros.
-  Returns 1 if the nodes are equivalent; 0 othewise.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsEquivalent( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew, int nBTLimit, int nTimeLimit )
-{
-    int RetValue, RetValue1, i, fComp, clk;
-    int fVerbose = 0;
-    int fSwitch = 0;
-
-    // make sure the nodes are not complemented
-    assert( !Fraig_IsComplement(pNew) );
-    assert( !Fraig_IsComplement(pOld) );
-    assert( pNew != pOld );
-
-    // if at least one of the nodes is a failed node, perform adjustments:
-    // if the backtrack limit is small, simply skip this node
-    // if the backtrack limit is > 10, take the quare root of the limit
-    if ( nBTLimit > 0 && (pOld->fFailTfo || pNew->fFailTfo) )
-    {
-        p->nSatFails++;
-//            return 0;
-//        if ( nBTLimit > 10 )
-//            nBTLimit /= 10;
-        if ( nBTLimit <= 10 )
-            return 0;
-        nBTLimit = (int)sqrt((double)nBTLimit);
-//        fSwitch = 1;
-    }
-
-    p->nSatCalls++;
-
-    // make sure the solver is allocated and has enough variables
-    if ( p->pSat == NULL )
-        Fraig_ManCreateSolver( p );
-    // make sure the SAT solver has enough variables
-    for ( i = Msat_SolverReadVarNum(p->pSat); i < p->vNodes->nSize; i++ )
-        Msat_SolverAddVar( p->pSat, p->vNodes->pArray[i]->Level );
-
-
- 
-/*
-    {
-        Fraig_Node_t * ppNodes[2] = { pOld, pNew };
-        extern void Fraig_MappingShowNodes( Fraig_Man_t * pMan, Fraig_Node_t ** ppRoots, int nRoots, char * pFileName );
-        Fraig_MappingShowNodes( p, ppNodes, 2, "temp_aig" );
-    }
-*/
-
-    nMuxes = 0;
-
-
-    // get the logic cone
-clk = clock();
-//    Fraig_VarsStudy( p, pOld, pNew );
-    Fraig_OrderVariables( p, pOld, pNew );
-//    Fraig_PrepareCones( p, pOld, pNew );
-p->timeTrav += clock() - clk;
-
-//    printf( "The number of MUXes detected = %d (%5.2f %% of logic).  ", nMuxes, 300.0*nMuxes/(p->vNodes->nSize - p->vInputs->nSize) );
-//    ABC_PRT( "Time", clock() - clk );
-
-if ( fVerbose )
-    printf( "%d(%d) - ", Fraig_CountPis(p,p->vVarsInt), Msat_IntVecReadSize(p->vVarsInt) );
-
-
-    // prepare variable activity
-    Fraig_SetActivity( p, pOld, pNew );
-
-    // get the complemented attribute
-    fComp = Fraig_NodeComparePhase( pOld, pNew );
-//Msat_SolverPrintClauses( p->pSat );
-
-    ////////////////////////////////////////////
-    // prepare the solver to run incrementally on these variables
-//clk = clock();
-    Msat_SolverPrepare( p->pSat, p->vVarsInt );
-//p->time3 += clock() - clk;
-
-
-    // solve under assumptions
-    // A = 1; B = 0     OR     A = 1; B = 1 
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 0) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, !fComp) );
-
-//Msat_SolverWriteDimacs( p->pSat, "temp_fraig.cnf" );
-
-    // run the solver
-clk = clock();
-    RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, nTimeLimit );
-p->timeSat += clock() - clk;
-
-    if ( RetValue1 == MSAT_FALSE )
-    {
-//p->time1 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "unsat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-
-        // add the clause
-        Msat_IntVecClear( p->vProj );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 1) );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, fComp) );
-        RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-        assert( RetValue );
-        // continue solving the other implication
-    }
-    else if ( RetValue1 == MSAT_TRUE )
-    {
-//p->time2 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "sat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-
-        // record the counter example
-        Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pOld, pNew );
-
-//        if ( pOld->fFailTfo || pNew->fFailTfo )
-//            printf( "*" );
-//        printf( "s(%d)", pNew->Level );
-        if ( fSwitch )
-             printf( "s(%d)", pNew->Level );
-        p->nSatCounter++;
-        return 0;
-    }
-    else // if ( RetValue1 == MSAT_UNKNOWN )
-    {
-p->time3 += clock() - clk;
-
-//        if ( pOld->fFailTfo || pNew->fFailTfo )
-//            printf( "*" );
-//        printf( "T(%d)", pNew->Level );
-
-        // mark the node as the failed node
-        if ( pOld != p->pConst1 ) 
-            pOld->fFailTfo = 1;
-        pNew->fFailTfo = 1;
-//        p->nSatFails++;
-        if ( fSwitch )
-             printf( "T(%d)", pNew->Level );
-        p->nSatFailsReal++;
-        return 0;
-    }
-
-    // if the old node was constant 0, we already know the answer
-    if ( pOld == p->pConst1 )
-        return 1;
-
-    ////////////////////////////////////////////
-    // prepare the solver to run incrementally 
-//clk = clock();
-    Msat_SolverPrepare( p->pSat, p->vVarsInt );
-//p->time3 += clock() - clk;
-    // solve under assumptions
-    // A = 0; B = 1     OR     A = 0; B = 0 
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 1) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, fComp) );
-    // run the solver
-clk = clock();
-    RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, nTimeLimit );
-p->timeSat += clock() - clk;
-
-    if ( RetValue1 == MSAT_FALSE )
-    {
-//p->time1 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "unsat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-
-        // add the clause
-        Msat_IntVecClear( p->vProj );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 0) );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, !fComp) );
-        RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-        assert( RetValue );
-        // continue solving the other implication
-    }
-    else if ( RetValue1 == MSAT_TRUE )
-    {
-//p->time2 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "sat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-
-        // record the counter example
-        Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pOld, pNew );
-        p->nSatCounter++;
-
-//        if ( pOld->fFailTfo || pNew->fFailTfo )
-//            printf( "*" );
-//        printf( "s(%d)", pNew->Level );
-        if ( fSwitch )
-             printf( "s(%d)", pNew->Level );
-        return 0;
-    }
-    else // if ( RetValue1 == MSAT_UNKNOWN )
-    {
-p->time3 += clock() - clk;
-
-//        if ( pOld->fFailTfo || pNew->fFailTfo )
-//            printf( "*" );
-//        printf( "T(%d)", pNew->Level );
-        if ( fSwitch )
-             printf( "T(%d)", pNew->Level );
-
-        // mark the node as the failed node
-        pOld->fFailTfo = 1;
-        pNew->fFailTfo = 1;
-//        p->nSatFails++;
-        p->nSatFailsReal++;
-        return 0;
-    }
-
-    // return SAT proof
-    p->nSatProof++;
-
-//    if ( pOld->fFailTfo || pNew->fFailTfo )
-//        printf( "*" );
-//    printf( "u(%d)", pNew->Level );
-
-    if ( fSwitch )
-         printf( "u(%d)", pNew->Level );
-
-    return 1;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Checks whether pOld => pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsImplication( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew, int nBTLimit )
-{
-    int RetValue, RetValue1, i, fComp, clk;
-    int fVerbose = 0;
-
-    // make sure the nodes are not complemented
-    assert( !Fraig_IsComplement(pNew) );
-    assert( !Fraig_IsComplement(pOld) );
-    assert( pNew != pOld );
-
-    p->nSatCallsImp++;
-
-    // make sure the solver is allocated and has enough variables
-    if ( p->pSat == NULL )
-        Fraig_ManCreateSolver( p );
-    // make sure the SAT solver has enough variables
-    for ( i = Msat_SolverReadVarNum(p->pSat); i < p->vNodes->nSize; i++ )
-        Msat_SolverAddVar( p->pSat, p->vNodes->pArray[i]->Level );
-
-   // get the logic cone
-clk = clock();
-    Fraig_OrderVariables( p, pOld, pNew );
-//    Fraig_PrepareCones( p, pOld, pNew );
-p->timeTrav += clock() - clk;
-
-if ( fVerbose )
-    printf( "%d(%d) - ", Fraig_CountPis(p,p->vVarsInt), Msat_IntVecReadSize(p->vVarsInt) );
-
-
-    // get the complemented attribute
-    fComp = Fraig_NodeComparePhase( pOld, pNew );
-//Msat_SolverPrintClauses( p->pSat );
-
-    ////////////////////////////////////////////
-    // prepare the solver to run incrementally on these variables
-//clk = clock();
-    Msat_SolverPrepare( p->pSat, p->vVarsInt );
-//p->time3 += clock() - clk;
-
-    // solve under assumptions
-    // A = 1; B = 0     OR     A = 1; B = 1 
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 0) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, !fComp) );
-    // run the solver
-clk = clock();
-    RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, 1000000 );
-p->timeSat += clock() - clk;
-
-    if ( RetValue1 == MSAT_FALSE )
-    {
-//p->time1 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "unsat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-
-        // add the clause
-        Msat_IntVecClear( p->vProj );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 1) );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, fComp) );
-        RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-        assert( RetValue );
-//        p->nSatProofImp++;
-        return 1;
-    }
-    else if ( RetValue1 == MSAT_TRUE )
-    {
-//p->time2 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "sat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-        // record the counter example
-        Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pOld, pNew );
-        p->nSatCounterImp++;
-        return 0;
-    }
-    else // if ( RetValue1 == MSAT_UNKNOWN )
-    {
-p->time3 += clock() - clk;
-        p->nSatFailsImp++;
-        return 0;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prepares the SAT solver to run on the two nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManCheckClauseUsingSat( Fraig_Man_t * p, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int nBTLimit )
-{
-    Fraig_Node_t * pNode1R, * pNode2R;
-    int RetValue, RetValue1, i, clk;
-    int fVerbose = 0;
-
-    pNode1R = Fraig_Regular(pNode1);
-    pNode2R = Fraig_Regular(pNode2);
-    assert( pNode1R != pNode2R );
-
-    // make sure the solver is allocated and has enough variables
-    if ( p->pSat == NULL )
-        Fraig_ManCreateSolver( p );
-    // make sure the SAT solver has enough variables
-    for ( i = Msat_SolverReadVarNum(p->pSat); i < p->vNodes->nSize; i++ )
-        Msat_SolverAddVar( p->pSat, p->vNodes->pArray[i]->Level );
-
-   // get the logic cone
-clk = clock();
-    Fraig_OrderVariables( p, pNode1R, pNode2R );
-//    Fraig_PrepareCones( p, pNode1R, pNode2R );
-p->timeTrav += clock() - clk;
-
-    ////////////////////////////////////////////
-    // prepare the solver to run incrementally on these variables
-//clk = clock();
-    Msat_SolverPrepare( p->pSat, p->vVarsInt );
-//p->time3 += clock() - clk;
-
-    // solve under assumptions
-    // A = 1; B = 0     OR     A = 1; B = 1 
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1R->Num, !Fraig_IsComplement(pNode1)) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2R->Num, !Fraig_IsComplement(pNode2)) );
-    // run the solver
-clk = clock();
-    RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, 1000000 );
-p->timeSat += clock() - clk;
-
-    if ( RetValue1 == MSAT_FALSE )
-    {
-//p->time1 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "unsat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-
-        // add the clause
-        Msat_IntVecClear( p->vProj );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1R->Num, Fraig_IsComplement(pNode1)) );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2R->Num, Fraig_IsComplement(pNode2)) );
-        RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-        assert( RetValue );
-//        p->nSatProofImp++;
-        return 1;
-    }
-    else if ( RetValue1 == MSAT_TRUE )
-    {
-//p->time2 += clock() - clk;
-
-if ( fVerbose )
-{
-//    printf( "sat  %d  ", Msat_SolverReadBackTracks(p->pSat) );
-//ABC_PRT( "time", clock() - clk );
-}
-        // record the counter example
-//        Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pNode1R, pNode2R );
-        p->nSatCounterImp++;
-        return 0;
-    }
-    else // if ( RetValue1 == MSAT_UNKNOWN )
-    {
-p->time3 += clock() - clk;
-        p->nSatFailsImp++;
-        return 0;
-    }
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Prepares the SAT solver to run on the two nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_PrepareCones( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-//    Msat_IntVec_t * vAdjs;
-//    int * pVars, nVars, i, k;
-    int nVarsAlloc;
-
-    assert( pOld != pNew );
-    assert( !Fraig_IsComplement(pOld) );
-    assert( !Fraig_IsComplement(pNew) );
-    // clean the variables
-    nVarsAlloc = Msat_IntVecReadSize(pMan->vVarsUsed);
-    Msat_IntVecFill( pMan->vVarsUsed, nVarsAlloc, 0 );
-    Msat_IntVecClear( pMan->vVarsInt );
-
-    pMan->nTravIds++;
-    Fraig_PrepareCones_rec( pMan, pNew );
-    Fraig_PrepareCones_rec( pMan, pOld );
-
-
-/*
-    nVars = Msat_IntVecReadSize( pMan->vVarsInt );
-    pVars = Msat_IntVecReadArray( pMan->vVarsInt );
-    for ( i = 0; i < nVars; i++ )
-    {
-        // process its connections
-        vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
-        printf( "%d=%d { ", pVars[i], Msat_IntVecReadSize(vAdjs) );
-        for ( k = 0; k < Msat_IntVecReadSize(vAdjs); k++ )
-            printf( "%d ", Msat_IntVecReadEntry(vAdjs,k) );
-        printf( "}\n" );
-
-    }
-    i = 0;
-*/
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Traverses the cone, collects the numbers and adds the clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_PrepareCones_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pFanin;
-    Msat_IntVec_t * vAdjs;
-    int fUseMuxes = 1, i;
-    int fItIsTime;
-
-    // skip if the node is aleady visited
-    assert( !Fraig_IsComplement(pNode) );
-    if ( pNode->TravId == pMan->nTravIds )
-        return;
-    pNode->TravId = pMan->nTravIds;
-
-    // collect the node's number (closer to reverse topological order)
-    Msat_IntVecPush( pMan->vVarsInt, pNode->Num );
-    Msat_IntVecWriteEntry( pMan->vVarsUsed, pNode->Num, 1 );
-    if ( !Fraig_NodeIsAnd( pNode ) )
-        return;
-
-    // if the node does not have fanins, create them
-    fItIsTime = 0;
-    if ( pNode->vFanins == NULL )
-    {
-        fItIsTime = 1;
-        // create the fanins of the supergate
-        assert( pNode->fClauses == 0 );
-        if ( fUseMuxes && Fraig_NodeIsMuxType(pNode) )
-        {
-            pNode->vFanins = Fraig_NodeVecAlloc( 4 );
-            Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p1)->p1) );
-            Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p1)->p2) );
-            Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p2)->p1) );
-            Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p2)->p2) );
-            Fraig_SupergateAddClausesMux( pMan, pNode );
-        }
-        else
-        {
-            pNode->vFanins = Fraig_CollectSupergate( pNode, fUseMuxes );
-            Fraig_SupergateAddClauses( pMan, pNode, pNode->vFanins );
-        }
-        assert( pNode->vFanins->nSize > 1 );
-        pNode->fClauses = 1;
-        pMan->nVarsClauses++;
-
-        // add fanins
-        vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pNode->Num );
-        assert( Msat_IntVecReadSize( vAdjs ) == 0 );
-        for ( i = 0; i < pNode->vFanins->nSize; i++ )
-        {
-            pFanin = Fraig_Regular(pNode->vFanins->pArray[i]);
-            Msat_IntVecPush( vAdjs, pFanin->Num );
-        }
-    }
-
-    // recursively visit the fanins
-    for ( i = 0; i < pNode->vFanins->nSize; i++ )
-        Fraig_PrepareCones_rec( pMan, Fraig_Regular(pNode->vFanins->pArray[i]) );
-
-    if ( fItIsTime )
-    {
-        // recursively visit the fanins
-        for ( i = 0; i < pNode->vFanins->nSize; i++ )
-        {
-            pFanin = Fraig_Regular(pNode->vFanins->pArray[i]);
-            vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pFanin->Num );
-            Msat_IntVecPush( vAdjs, pNode->Num );
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collect variables using their proximity from the nodes.]
-
-  Description [This procedure creates a variable order based on collecting
-  first the nodes that are the closest to the given two target nodes.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_OrderVariables( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    Fraig_Node_t * pNode, * pFanin;
-    int i, k, Number, fUseMuxes = 1;
-    int nVarsAlloc;
-
-    assert( pOld != pNew );
-    assert( !Fraig_IsComplement(pOld) );
-    assert( !Fraig_IsComplement(pNew) );
-
-    pMan->nTravIds++;
-
-    // clean the variables
-    nVarsAlloc = Msat_IntVecReadSize(pMan->vVarsUsed);
-    Msat_IntVecFill( pMan->vVarsUsed, nVarsAlloc, 0 );
-    Msat_IntVecClear( pMan->vVarsInt );
-
-    // add the first node
-    Msat_IntVecPush( pMan->vVarsInt, pOld->Num );
-    Msat_IntVecWriteEntry( pMan->vVarsUsed, pOld->Num, 1 );
-    pOld->TravId = pMan->nTravIds;
-
-    // add the second node
-    Msat_IntVecPush( pMan->vVarsInt, pNew->Num );
-    Msat_IntVecWriteEntry( pMan->vVarsUsed, pNew->Num, 1 );
-    pNew->TravId = pMan->nTravIds;
-
-    // create the variable order
-    for ( i = 0; i < Msat_IntVecReadSize(pMan->vVarsInt); i++ )
-    {
-        // get the new node on the frontier
-        Number = Msat_IntVecReadEntry(pMan->vVarsInt, i);
-        pNode = pMan->vNodes->pArray[Number];
-        if ( !Fraig_NodeIsAnd(pNode) )
-            continue;
-
-        // if the node does not have fanins, create them
-        if ( pNode->vFanins == NULL )
-        {
-            // create the fanins of the supergate
-            assert( pNode->fClauses == 0 );
-            // detecting a fanout-free cone (experiment only)
-//            Fraig_DetectFanoutFreeCone( pMan, pNode );
-
-            if ( fUseMuxes && Fraig_NodeIsMuxType(pNode) )
-            {
-                pNode->vFanins = Fraig_NodeVecAlloc( 4 );
-                Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p1)->p1) );
-                Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p1)->p2) );
-                Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p2)->p1) );
-                Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p2)->p2) );
-                Fraig_SupergateAddClausesMux( pMan, pNode );
-//                Fraig_DetectFanoutFreeConeMux( pMan, pNode );
-
-                nMuxes++;
-            }
-            else
-            {
-                pNode->vFanins = Fraig_CollectSupergate( pNode, fUseMuxes );
-                Fraig_SupergateAddClauses( pMan, pNode, pNode->vFanins );
-            }
-            assert( pNode->vFanins->nSize > 1 );
-            pNode->fClauses = 1;
-            pMan->nVarsClauses++;
-
-            pNode->fMark2 = 1; // goes together with Fraig_SetupAdjacentMark()
-        }
-
-        // explore the implication fanins of pNode
-        for ( k = 0; k < pNode->vFanins->nSize; k++ )
-        {
-            pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
-            if ( pFanin->TravId == pMan->nTravIds ) // already collected
-                continue;
-            // collect and mark
-            Msat_IntVecPush( pMan->vVarsInt, pFanin->Num );
-            Msat_IntVecWriteEntry( pMan->vVarsUsed, pFanin->Num, 1 );
-            pFanin->TravId = pMan->nTravIds;
-        }
-    }
-
-    // set up the adjacent variable information
-//    Fraig_SetupAdjacent( pMan, pMan->vVarsInt );
-    Fraig_SetupAdjacentMark( pMan, pMan->vVarsInt );
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Set up the adjacent variable information.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_SetupAdjacent( Fraig_Man_t * pMan, Msat_IntVec_t * vConeVars )
-{
-    Fraig_Node_t * pNode, * pFanin;
-    Msat_IntVec_t * vAdjs;
-    int * pVars, nVars, i, k;
-
-    // clean the adjacents for the variables
-    nVars = Msat_IntVecReadSize( vConeVars );
-    pVars = Msat_IntVecReadArray( vConeVars );
-    for ( i = 0; i < nVars; i++ )
-    {
-        // process its connections
-        vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
-        Msat_IntVecClear( vAdjs );
-
-        pNode = pMan->vNodes->pArray[pVars[i]];
-        if ( !Fraig_NodeIsAnd(pNode) )
-            continue;
-
-        // add fanins
-        vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
-        for ( k = 0; k < pNode->vFanins->nSize; k++ )
-//        for ( k = pNode->vFanins->nSize - 1; k >= 0; k-- )
-        {
-            pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
-            Msat_IntVecPush( vAdjs, pFanin->Num );
-//            Msat_IntVecPushUniqueOrder( vAdjs, pFanin->Num );
-        }
-    }
-    // add the fanouts
-    for ( i = 0; i < nVars; i++ )
-    {
-        pNode = pMan->vNodes->pArray[pVars[i]];
-        if ( !Fraig_NodeIsAnd(pNode) )
-            continue;
-
-        // add the edges
-        for ( k = 0; k < pNode->vFanins->nSize; k++ )
-//        for ( k = pNode->vFanins->nSize - 1; k >= 0; k-- )
-        {
-            pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
-            vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pFanin->Num );
-            Msat_IntVecPush( vAdjs, pNode->Num );
-//            Msat_IntVecPushUniqueOrder( vAdjs, pFanin->Num );
-        }
-    }
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Set up the adjacent variable information.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_SetupAdjacentMark( Fraig_Man_t * pMan, Msat_IntVec_t * vConeVars )
-{
-    Fraig_Node_t * pNode, * pFanin;
-    Msat_IntVec_t * vAdjs;
-    int * pVars, nVars, i, k;
-
-    // clean the adjacents for the variables
-    nVars = Msat_IntVecReadSize( vConeVars );
-    pVars = Msat_IntVecReadArray( vConeVars );
-    for ( i = 0; i < nVars; i++ )
-    {
-        pNode = pMan->vNodes->pArray[pVars[i]];
-        if ( pNode->fMark2 == 0 )
-            continue;
-//        pNode->fMark2 = 0;
-
-        // process its connections
-//        vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
-//        Msat_IntVecClear( vAdjs );
-
-        if ( !Fraig_NodeIsAnd(pNode) )
-            continue;
-
-        // add fanins
-        vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
-        for ( k = 0; k < pNode->vFanins->nSize; k++ )
-//        for ( k = pNode->vFanins->nSize - 1; k >= 0; k-- )
-        {
-            pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
-            Msat_IntVecPush( vAdjs, pFanin->Num );
-//            Msat_IntVecPushUniqueOrder( vAdjs, pFanin->Num );
-        }
-    }
-    // add the fanouts
-    for ( i = 0; i < nVars; i++ )
-    {
-        pNode = pMan->vNodes->pArray[pVars[i]];
-        if ( pNode->fMark2 == 0 )
-            continue;
-        pNode->fMark2 = 0;
-
-        if ( !Fraig_NodeIsAnd(pNode) )
-            continue;
-
-        // add the edges
-        for ( k = 0; k < pNode->vFanins->nSize; k++ )
-//        for ( k = pNode->vFanins->nSize - 1; k >= 0; k-- )
-        {
-            pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
-            vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pFanin->Num );
-            Msat_IntVecPush( vAdjs, pNode->Num );
-//            Msat_IntVecPushUniqueOrder( vAdjs, pFanin->Num );
-        }
-    }
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Adds clauses to the solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_SupergateAddClauses( Fraig_Man_t * p, Fraig_Node_t * pNode, Fraig_NodeVec_t * vSuper )
-{
-    int fComp1, RetValue, nVars, Var, Var1, i;
-
-    assert( Fraig_NodeIsAnd( pNode ) );
-    nVars = Msat_SolverReadVarNum(p->pSat);
-
-    Var = pNode->Num;
-    assert( Var  < nVars ); 
-    for ( i = 0; i < vSuper->nSize; i++ )
-    {
-        // get the predecessor nodes
-        // get the complemented attributes of the nodes
-        fComp1 = Fraig_IsComplement(vSuper->pArray[i]);
-        // determine the variable numbers
-        Var1 = Fraig_Regular(vSuper->pArray[i])->Num;
-        // check that the variables are in the SAT manager
-        assert( Var1 < nVars );
-
-        // suppose the AND-gate is A * B = C
-        // add !A => !C   or   A + !C
-    //  fprintf( pFile, "%d %d 0%c", Var1, -Var, 10 );
-        Msat_IntVecClear( p->vProj );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var1, fComp1) );
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var,  1) );
-        RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-        assert( RetValue );
-    }
-
-    // add A & B => C   or   !A + !B + C
-//  fprintf( pFile, "%d %d %d 0%c", -Var1, -Var2, Var, 10 );
-    Msat_IntVecClear( p->vProj );
-    for ( i = 0; i < vSuper->nSize; i++ )
-    {
-        // get the predecessor nodes
-        // get the complemented attributes of the nodes
-        fComp1 = Fraig_IsComplement(vSuper->pArray[i]);
-        // determine the variable numbers
-        Var1 = Fraig_Regular(vSuper->pArray[i])->Num;
-
-        // add this variable to the array
-        Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var1, !fComp1) );
-    }
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var, 0) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds clauses to the solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_SupergateAddClausesExor( Fraig_Man_t * p, Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pNode1, * pNode2;
-    int fComp, RetValue;
-
-    assert( !Fraig_IsComplement( pNode ) );
-    assert( Fraig_NodeIsExorType( pNode ) );
-    // get nodes
-    pNode1 = Fraig_Regular(Fraig_Regular(pNode->p1)->p1);
-    pNode2 = Fraig_Regular(Fraig_Regular(pNode->p1)->p2);
-    // get the complemented attribute of the EXOR/NEXOR gate
-    fComp = Fraig_NodeIsExor( pNode ); // 1 if EXOR, 0 if NEXOR
-
-    // create four clauses
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num,   fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num,  fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num,  fComp) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num,   fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num, !fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num, !fComp) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num,  !fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num,  fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num, !fComp) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num,  !fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num, !fComp) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num,  fComp) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds clauses to the solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_SupergateAddClausesMux( Fraig_Man_t * p, Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pNodeI, * pNodeT, * pNodeE;
-    int RetValue, VarF, VarI, VarT, VarE, fCompT, fCompE;
-
-    assert( !Fraig_IsComplement( pNode ) );
-    assert( Fraig_NodeIsMuxType( pNode ) );
-    // get nodes (I = if, T = then, E = else)
-    pNodeI = Fraig_NodeRecognizeMux( pNode, &pNodeT, &pNodeE );
-    // get the variable numbers
-    VarF = pNode->Num;
-    VarI = pNodeI->Num;
-    VarT = Fraig_Regular(pNodeT)->Num;
-    VarE = Fraig_Regular(pNodeE)->Num;
-    // get the complementation flags
-    fCompT = Fraig_IsComplement(pNodeT);
-    fCompE = Fraig_IsComplement(pNodeE);
-
-    // f = ITE(i, t, e)
-
-    // i' + t' + f
-    // i' + t  + f'
-    // i  + e' + f
-    // i  + e  + f'
-
-    // create four clauses
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI,  1) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT,  1^fCompT) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF,  0) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI,  1) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT,  0^fCompT) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF,  1) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI,  0) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE,  1^fCompE) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF,  0) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI,  0) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE,  0^fCompE) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF,  1) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-
-    // two additional clauses
-    // t' & e' -> f'
-    // t  & e  -> f 
-
-    // t  + e   + f'
-    // t' + e'  + f 
-
-    if ( VarT == VarE )
-    {
-//        assert( fCompT == !fCompE );
-        return;
-    }
-
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT,  0^fCompT) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE,  0^fCompE) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF,  1) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-    Msat_IntVecClear( p->vProj );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT,  1^fCompT) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE,  1^fCompE) );
-    Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF,  0) );
-    RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
-    assert( RetValue );
-
-}
-
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of nodes to be combined into one multi-input AND-gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_DetectFanoutFreeCone_rec( Fraig_Node_t * pNode, Fraig_NodeVec_t * vSuper, Fraig_NodeVec_t * vInside, int fFirst )
-{
-    // make the pointer regular
-    pNode = Fraig_Regular(pNode);
-    // if the new node is complemented or a PI, another gate begins
-    if ( (!fFirst && pNode->nRefs > 1) || Fraig_NodeIsVar(pNode) )
-    {
-        Fraig_NodeVecPushUnique( vSuper, pNode );
-        return;
-    }
-    // go through the branches
-    Fraig_DetectFanoutFreeCone_rec( pNode->p1, vSuper, vInside, 0 );
-    Fraig_DetectFanoutFreeCone_rec( pNode->p2, vSuper, vInside, 0 );
-    // add the node
-    Fraig_NodeVecPushUnique( vInside, pNode );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of nodes to be combined into one multi-input AND-gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-/*
-void Fraig_DetectFanoutFreeCone( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    Fraig_NodeVec_t * vFanins;
-    Fraig_NodeVec_t * vInside;
-    int nCubes;
-    extern int Fraig_CutSopCountCubes( Fraig_Man_t * pMan, Fraig_NodeVec_t * vFanins, Fraig_NodeVec_t * vInside );
-
-    vFanins = Fraig_NodeVecAlloc( 8 );
-    vInside = Fraig_NodeVecAlloc( 8 );
-
-    Fraig_DetectFanoutFreeCone_rec( pNode, vFanins, vInside, 1 );
-    assert( vInside->pArray[vInside->nSize-1] == pNode );
-
-    nCubes = Fraig_CutSopCountCubes( pMan, vFanins, vInside );
-
-printf( "%d(%d)", vFanins->nSize, nCubes );
-    Fraig_NodeVecFree( vFanins );
-    Fraig_NodeVecFree( vInside );
-}
-*/
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of nodes to be combined into one multi-input AND-gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_DetectFanoutFreeConeMux_rec( Fraig_Node_t * pNode, Fraig_NodeVec_t * vSuper, Fraig_NodeVec_t * vInside, int fFirst )
-{
-    // make the pointer regular
-    pNode = Fraig_Regular(pNode);
-    // if the new node is complemented or a PI, another gate begins
-    if ( (!fFirst && pNode->nRefs > 1) || Fraig_NodeIsVar(pNode) || !Fraig_NodeIsMuxType(pNode) )
-    {
-        Fraig_NodeVecPushUnique( vSuper, pNode );
-        return;
-    }
-    // go through the branches
-    Fraig_DetectFanoutFreeConeMux_rec( Fraig_Regular(pNode->p1)->p1, vSuper, vInside, 0 );
-    Fraig_DetectFanoutFreeConeMux_rec( Fraig_Regular(pNode->p1)->p2, vSuper, vInside, 0 );
-    Fraig_DetectFanoutFreeConeMux_rec( Fraig_Regular(pNode->p2)->p1, vSuper, vInside, 0 );
-    Fraig_DetectFanoutFreeConeMux_rec( Fraig_Regular(pNode->p2)->p2, vSuper, vInside, 0 );
-    // add the node
-    Fraig_NodeVecPushUnique( vInside, pNode );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of nodes to be combined into one multi-input AND-gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_DetectFanoutFreeConeMux( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    Fraig_NodeVec_t * vFanins;
-    Fraig_NodeVec_t * vInside;
-    int nCubes;
-    extern int Fraig_CutSopCountCubes( Fraig_Man_t * pMan, Fraig_NodeVec_t * vFanins, Fraig_NodeVec_t * vInside );
-
-    vFanins = Fraig_NodeVecAlloc( 8 );
-    vInside = Fraig_NodeVecAlloc( 8 );
-
-    Fraig_DetectFanoutFreeConeMux_rec( pNode, vFanins, vInside, 1 );
-    assert( vInside->pArray[vInside->nSize-1] == pNode );
-
-//    nCubes = Fraig_CutSopCountCubes( pMan, vFanins, vInside );
-    nCubes = 0;
-
-printf( "%d(%d)", vFanins->nSize, nCubes );
-    Fraig_NodeVecFree( vFanins );
-    Fraig_NodeVecFree( vInside );
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Collect variables using their proximity from the nodes.]
-
-  Description [This procedure creates a variable order based on collecting
-  first the nodes that are the closest to the given two target nodes.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_SetActivity( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    Fraig_Node_t * pNode;
-    int i, Number, MaxLevel;
-    float * pFactors = Msat_SolverReadFactors(pMan->pSat);
-    if ( pFactors == NULL )
-        return;
-    MaxLevel = ABC_MAX( pOld->Level, pNew->Level );
-    // create the variable order
-    for ( i = 0; i < Msat_IntVecReadSize(pMan->vVarsInt); i++ )
-    {
-        // get the new node on the frontier
-        Number = Msat_IntVecReadEntry(pMan->vVarsInt, i);
-        pNode = pMan->vNodes->pArray[Number];
-        pFactors[pNode->Num] = (float)pow( 0.97, MaxLevel - pNode->Level );
-//        if ( pNode->Num % 50 == 0 )
-//        printf( "(%d) %.2f  ", MaxLevel - pNode->Level, pFactors[pNode->Num] );
-    }
-//    printf( "\n" );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigTable.c b/src/sat/fraig/fraigTable.c
deleted file mode 100644
index 79ab7ffc..00000000
--- a/src/sat/fraig/fraigTable.c
+++ /dev/null
@@ -1,662 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigTable.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Structural and functional hash tables.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigTable.c,v 1.7 2005/07/08 01:01:34 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static void Fraig_TableResizeS( Fraig_HashTable_t * p );
-static void Fraig_TableResizeF( Fraig_HashTable_t * p, int fUseSimR );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Allocates the hash table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_HashTable_t * Fraig_HashTableCreate( int nSize )
-{
-    Fraig_HashTable_t * p;
-    // allocate the table
-    p = ABC_ALLOC( Fraig_HashTable_t, 1 );
-    memset( p, 0, sizeof(Fraig_HashTable_t) );
-    // allocate and clean the bins
-    p->nBins = Cudd_PrimeFraig(nSize);
-    p->pBins = ABC_ALLOC( Fraig_Node_t *, p->nBins );
-    memset( p->pBins, 0, sizeof(Fraig_Node_t *) * p->nBins );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Deallocates the supergate hash table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_HashTableFree( Fraig_HashTable_t * p )
-{
-    ABC_FREE( p->pBins );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Looks up an entry in the structural hash table.]
-
-  Description [If the entry with the same children does not exists, 
-  creates it, inserts it into the table, and returns 0. If the entry 
-  with the same children exists, finds it, and return 1. In both cases, 
-  the new/old entry is returned in ppNodeRes.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_HashTableLookupS( Fraig_Man_t * pMan, Fraig_Node_t * p1, Fraig_Node_t * p2, Fraig_Node_t ** ppNodeRes )
-{
-    Fraig_HashTable_t * p = pMan->pTableS;
-    Fraig_Node_t * pEnt;
-    unsigned Key;
-
-    // order the arguments
-    if ( Fraig_Regular(p1)->Num > Fraig_Regular(p2)->Num )
-        pEnt = p1, p1 = p2, p2 = pEnt;
-
-    Key = Fraig_HashKey2( p1, p2, p->nBins );
-    Fraig_TableBinForEachEntryS( p->pBins[Key], pEnt )
-        if ( pEnt->p1 == p1 && pEnt->p2 == p2 )
-        {
-            *ppNodeRes = pEnt;
-            return 1;
-        }
-    // check if it is a good time for table resizing
-    if ( p->nEntries >= 2 * p->nBins )
-    {
-        Fraig_TableResizeS( p );
-        Key = Fraig_HashKey2( p1, p2, p->nBins );
-    }
-    // create the new node
-    pEnt = Fraig_NodeCreate( pMan, p1, p2 );
-    // add the node to the corresponding linked list in the table
-    pEnt->pNextS = p->pBins[Key];
-    p->pBins[Key] = pEnt;
-    *ppNodeRes = pEnt;
-    p->nEntries++;
-    return 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Insert the entry in the functional hash table.]
-
-  Description [If the entry with the same key exists, return it right away.  
-  If the entry with the same key does not exists, inserts it and returns NULL. ]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_HashTableLookupF( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    Fraig_HashTable_t * p = pMan->pTableF;
-    Fraig_Node_t * pEnt, * pEntD;
-    unsigned Key;
-
-    // go through the hash table entries
-    Key = pNode->uHashR % p->nBins;
-    Fraig_TableBinForEachEntryF( p->pBins[Key], pEnt )
-    {
-        // if their simulation info differs, skip
-        if ( !Fraig_CompareSimInfo( pNode, pEnt, pMan->nWordsRand, 1 ) )
-            continue;
-        // equivalent up to the complement
-        Fraig_TableBinForEachEntryD( pEnt, pEntD )
-        {
-            // if their simulation info differs, skip
-            if ( !Fraig_CompareSimInfo( pNode, pEntD, pMan->iWordStart, 0 ) )
-                continue;
-            // found a simulation-equivalent node
-            return pEntD; 
-        }
-        // did not find a simulation equivalent node
-        // add the node to the corresponding linked list
-        pNode->pNextD = pEnt->pNextD;
-        pEnt->pNextD  = pNode;
-        // return NULL, because there is no functional equivalence in this case
-        return NULL;
-    }
-
-    // check if it is a good time for table resizing
-    if ( p->nEntries >= 2 * p->nBins )
-    {
-        Fraig_TableResizeF( p, 1 );
-        Key = pNode->uHashR % p->nBins;
-    }
-
-    // add the node to the corresponding linked list in the table
-    pNode->pNextF = p->pBins[Key];
-    p->pBins[Key] = pNode;
-    p->nEntries++;
-    // return NULL, because there is no functional equivalence in this case
-    return NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Insert the entry in the functional hash table.]
-
-  Description [If the entry with the same key exists, return it right away.  
-  If the entry with the same key does not exists, inserts it and returns NULL. ]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_HashTableLookupF0( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    Fraig_HashTable_t * p = pMan->pTableF0;
-    Fraig_Node_t * pEnt;
-    unsigned Key;
-
-    // go through the hash table entries
-    Key = pNode->uHashD % p->nBins;
-    Fraig_TableBinForEachEntryF( p->pBins[Key], pEnt )
-    {
-        // if their simulation info differs, skip
-        if ( !Fraig_CompareSimInfo( pNode, pEnt, pMan->iWordStart, 0 ) )
-            continue;
-        // found a simulation-equivalent node
-        return pEnt; 
-    }
-
-    // check if it is a good time for table resizing
-    if ( p->nEntries >= 2 * p->nBins )
-    {
-        Fraig_TableResizeF( p, 0 );
-        Key = pNode->uHashD % p->nBins;
-    }
-
-    // add the node to the corresponding linked list in the table
-    pNode->pNextF = p->pBins[Key];
-    p->pBins[Key] = pNode;
-    p->nEntries++;
-    // return NULL, because there is no functional equivalence in this case
-    return NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Insert the entry in the functional hash table.]
-
-  Description [Unconditionally add the node to the corresponding 
-  linked list in the table.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_HashTableInsertF0( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    Fraig_HashTable_t * p = pMan->pTableF0;
-    unsigned Key = pNode->uHashD % p->nBins;
-
-    pNode->pNextF = p->pBins[Key];
-    p->pBins[Key] = pNode;
-    p->nEntries++;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Resizes the table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_TableResizeS( Fraig_HashTable_t * p )
-{
-    Fraig_Node_t ** pBinsNew;
-    Fraig_Node_t * pEnt, * pEnt2;
-    int nBinsNew, Counter, i, clk;
-    unsigned Key;
-
-clk = clock();
-    // get the new table size
-    nBinsNew = Cudd_PrimeFraig(2 * p->nBins); 
-    // allocate a new array
-    pBinsNew = ABC_ALLOC( Fraig_Node_t *, nBinsNew );
-    memset( pBinsNew, 0, sizeof(Fraig_Node_t *) * nBinsNew );
-    // rehash the entries from the old table
-    Counter = 0;
-    for ( i = 0; i < p->nBins; i++ )
-        Fraig_TableBinForEachEntrySafeS( p->pBins[i], pEnt, pEnt2 )
-        {
-            Key = Fraig_HashKey2( pEnt->p1, pEnt->p2, nBinsNew );
-            pEnt->pNextS = pBinsNew[Key];
-            pBinsNew[Key] = pEnt;
-            Counter++;
-        }
-    assert( Counter == p->nEntries );
-//    printf( "Increasing the structural table size from %6d to %6d. ", p->nBins, nBinsNew );
-//    ABC_PRT( "Time", clock() - clk );
-    // replace the table and the parameters
-    ABC_FREE( p->pBins );
-    p->pBins = pBinsNew;
-    p->nBins = nBinsNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Resizes the table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_TableResizeF( Fraig_HashTable_t * p, int fUseSimR )
-{
-    Fraig_Node_t ** pBinsNew;
-    Fraig_Node_t * pEnt, * pEnt2;
-    int nBinsNew, Counter, i, clk;
-    unsigned Key;
-
-clk = clock();
-    // get the new table size
-    nBinsNew = Cudd_PrimeFraig(2 * p->nBins); 
-    // allocate a new array
-    pBinsNew = ABC_ALLOC( Fraig_Node_t *, nBinsNew );
-    memset( pBinsNew, 0, sizeof(Fraig_Node_t *) * nBinsNew );
-    // rehash the entries from the old table
-    Counter = 0;
-    for ( i = 0; i < p->nBins; i++ )
-        Fraig_TableBinForEachEntrySafeF( p->pBins[i], pEnt, pEnt2 )
-        {
-            if ( fUseSimR )
-                Key = pEnt->uHashR % nBinsNew;
-            else
-                Key = pEnt->uHashD % nBinsNew;
-            pEnt->pNextF = pBinsNew[Key];
-            pBinsNew[Key] = pEnt;
-            Counter++;
-        }
-    assert( Counter == p->nEntries );
-//    printf( "Increasing the functional table size from %6d to %6d. ", p->nBins, nBinsNew );
-//    ABC_PRT( "Time", clock() - clk );
-    // replace the table and the parameters
-    ABC_FREE( p->pBins );
-    p->pBins = pBinsNew;
-    p->nBins = nBinsNew;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Compares two pieces of simulation info.]
-
-  Description [Returns 1 if they are equal.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_CompareSimInfo( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int iWordLast, int fUseRand )
-{
-    int i;
-    assert( !Fraig_IsComplement(pNode1) );
-    assert( !Fraig_IsComplement(pNode2) );
-    if ( fUseRand )
-    {
-        // if their signatures differ, skip
-        if ( pNode1->uHashR != pNode2->uHashR )
-            return 0;
-        // check the simulation info
-        for ( i = 0; i < iWordLast; i++ )
-            if ( pNode1->puSimR[i] != pNode2->puSimR[i] )
-                return 0;
-    }
-    else
-    {
-        // if their signatures differ, skip
-        if ( pNode1->uHashD != pNode2->uHashD )
-            return 0;
-        // check the simulation info
-        for ( i = 0; i < iWordLast; i++ )
-            if ( pNode1->puSimD[i] != pNode2->puSimD[i] )
-                return 0;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find the number of the different pattern.]
-
-  Description [Returns -1 if there is no such pattern]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_FindFirstDiff( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int fCompl, int iWordLast, int fUseRand )
-{
-    int i, v;
-    assert( !Fraig_IsComplement(pNode1) );
-    assert( !Fraig_IsComplement(pNode2) );
-    // take into account possible internal complementation
-    fCompl ^= pNode1->fInv;
-    fCompl ^= pNode2->fInv;
-    // find the pattern
-    if ( fCompl )
-    {
-        if ( fUseRand )
-        {
-            for ( i = 0; i < iWordLast; i++ )
-                if ( pNode1->puSimR[i] != ~pNode2->puSimR[i] )
-                    for ( v = 0; v < 32; v++ )
-                        if ( (pNode1->puSimR[i] ^ ~pNode2->puSimR[i]) & (1 << v) )
-                            return i * 32 + v;
-        }
-        else
-        {
-            for ( i = 0; i < iWordLast; i++ )
-                if ( pNode1->puSimD[i] !=  ~pNode2->puSimD[i] )
-                    for ( v = 0; v < 32; v++ )
-                        if ( (pNode1->puSimD[i] ^ ~pNode2->puSimD[i]) & (1 << v) )
-                            return i * 32 + v;
-        }
-    }
-    else
-    {
-        if ( fUseRand )
-        {
-            for ( i = 0; i < iWordLast; i++ )
-                if ( pNode1->puSimR[i] != pNode2->puSimR[i] )
-                    for ( v = 0; v < 32; v++ )
-                        if ( (pNode1->puSimR[i] ^ pNode2->puSimR[i]) & (1 << v) )
-                            return i * 32 + v;
-        }
-        else
-        {
-            for ( i = 0; i < iWordLast; i++ )
-                if ( pNode1->puSimD[i] !=  pNode2->puSimD[i] )
-                    for ( v = 0; v < 32; v++ )
-                        if ( (pNode1->puSimD[i] ^ pNode2->puSimD[i]) & (1 << v) )
-                            return i * 32 + v;
-        }
-    }
-    return -1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compares two pieces of simulation info.]
-
-  Description [Returns 1 if they are equal.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_CompareSimInfoUnderMask( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int iWordLast, int fUseRand, unsigned * puMask )
-{
-    unsigned * pSims1, * pSims2;
-    int i;
-    assert( !Fraig_IsComplement(pNode1) );
-    assert( !Fraig_IsComplement(pNode2) );
-    // get hold of simulation info
-    pSims1 = fUseRand? pNode1->puSimR : pNode1->puSimD;
-    pSims2 = fUseRand? pNode2->puSimR : pNode2->puSimD;    
-    // check the simulation info
-    for ( i = 0; i < iWordLast; i++ )
-        if ( (pSims1[i] & puMask[i]) != (pSims2[i] & puMask[i]) )
-            return 0;
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compares two pieces of simulation info.]
-
-  Description [Returns 1 if they are equal.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_CollectXors( Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int iWordLast, int fUseRand, unsigned * puMask )
-{
-    unsigned * pSims1, * pSims2;
-    int i;
-    assert( !Fraig_IsComplement(pNode1) );
-    assert( !Fraig_IsComplement(pNode2) );
-    // get hold of simulation info
-    pSims1 = fUseRand? pNode1->puSimR : pNode1->puSimD;
-    pSims2 = fUseRand? pNode2->puSimR : pNode2->puSimD;    
-    // check the simulation info
-    for ( i = 0; i < iWordLast; i++ )
-        puMask[i] = ( pSims1[i] ^ pSims2[i] );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Prints stats of the structural table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_TablePrintStatsS( Fraig_Man_t * pMan )
-{
-    Fraig_HashTable_t * pT = pMan->pTableS;
-    Fraig_Node_t * pNode;
-    int i, Counter;
-
-    printf( "Structural table. Table size = %d. Number of entries = %d.\n", pT->nBins, pT->nEntries );
-    for ( i = 0; i < pT->nBins; i++ )
-    {
-        Counter = 0;
-        Fraig_TableBinForEachEntryS( pT->pBins[i], pNode )
-            Counter++;
-        if ( Counter > 1 )
-        {
-            printf( "%d ", Counter );
-            if ( Counter > 50 )
-                printf( "{%d} ", i );
-        }
-    }
-    printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints stats of the structural table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_TablePrintStatsF( Fraig_Man_t * pMan )
-{
-    Fraig_HashTable_t * pT = pMan->pTableF;
-    Fraig_Node_t * pNode;
-    int i, Counter;
-
-    printf( "Functional table. Table size = %d. Number of entries = %d.\n", pT->nBins, pT->nEntries );
-    for ( i = 0; i < pT->nBins; i++ )
-    {
-        Counter = 0;
-        Fraig_TableBinForEachEntryF( pT->pBins[i], pNode )
-            Counter++;
-        if ( Counter > 1 )
-            printf( "{%d} ", Counter );
-    }
-    printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints stats of the structural table.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_TablePrintStatsF0( Fraig_Man_t * pMan )
-{
-    Fraig_HashTable_t * pT = pMan->pTableF0;
-    Fraig_Node_t * pNode;
-    int i, Counter;
-
-    printf( "Zero-node table. Table size = %d. Number of entries = %d.\n", pT->nBins, pT->nEntries );
-    for ( i = 0; i < pT->nBins; i++ )
-    {
-        Counter = 0;
-        Fraig_TableBinForEachEntryF( pT->pBins[i], pNode )
-            Counter++;
-        if ( Counter == 0 )
-            continue;
-/*
-        printf( "\nBin = %4d :  Number of entries = %4d\n", i, Counter );
-        Fraig_TableBinForEachEntryF( pT->pBins[i], pNode )
-            printf( "Node %5d. Hash = %10d.\n", pNode->Num, pNode->uHashD );
-*/
-    }
-    printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Rehashes the table after the simulation info has changed.]
-
-  Description [Assumes that the hash values have been updated after performing
-  additional simulation. Rehashes the table using the new hash values. 
-  Uses pNextF to link the entries in the bins. Uses pNextD to link the entries 
-  with identical hash values. Returns 1 if the identical entries have been found.
-  Note that identical hash values may mean that the simulation data is different.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_TableRehashF0( Fraig_Man_t * pMan, int fLinkEquiv )
-{
-    Fraig_HashTable_t * pT = pMan->pTableF0;
-    Fraig_Node_t ** pBinsNew;
-    Fraig_Node_t * pEntF, * pEntF2, * pEnt, * pEntD2, * pEntN;
-    int ReturnValue, Counter, i;
-    unsigned Key;
-
-    // allocate a new array of bins
-    pBinsNew = ABC_ALLOC( Fraig_Node_t *, pT->nBins );
-    memset( pBinsNew, 0, sizeof(Fraig_Node_t *) * pT->nBins );
-
-    // rehash the entries in the table
-    // go through all the nodes in the F-lists (and possible in D-lists, if used)
-    Counter = 0;
-    ReturnValue = 0;
-    for ( i = 0; i < pT->nBins; i++ )
-        Fraig_TableBinForEachEntrySafeF( pT->pBins[i], pEntF, pEntF2 )
-        Fraig_TableBinForEachEntrySafeD( pEntF, pEnt, pEntD2 )
-        {
-            // decide where to put entry pEnt
-            Key = pEnt->uHashD % pT->nBins;
-            if ( fLinkEquiv )
-            {
-                // go through the entries in the new bin
-                Fraig_TableBinForEachEntryF( pBinsNew[Key], pEntN )
-                {
-                    // if they have different values skip
-                    if ( pEnt->uHashD != pEntN->uHashD )
-                        continue;
-                    // they have the same hash value, add pEnt to the D-list pEnt3
-                    pEnt->pNextD  = pEntN->pNextD;
-                    pEntN->pNextD = pEnt;
-                    ReturnValue = 1;
-                    Counter++;
-                    break;
-                }
-                if ( pEntN != NULL ) // already linked
-                    continue;
-                // we did not find equal entry
-            }
-            // link the new entry
-            pEnt->pNextF  = pBinsNew[Key];
-            pBinsNew[Key] = pEnt;
-            pEnt->pNextD  = NULL;
-            Counter++;
-        }
-    assert( Counter == pT->nEntries );
-    // replace the table and the parameters
-    ABC_FREE( pT->pBins );
-    pT->pBins = pBinsNew;
-    return ReturnValue;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigUtil.c b/src/sat/fraig/fraigUtil.c
deleted file mode 100644
index 0d4cdfaf..00000000
--- a/src/sat/fraig/fraigUtil.c
+++ /dev/null
@@ -1,1039 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigUtil.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Various utilities.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigUtil.c,v 1.15 2005/07/08 01:01:34 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-#include <limits.h>
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static int bit_count[256] = {
-  0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
-  1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-  1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-  2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-  1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-  2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-  2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-  3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
-};
-
-static void Fraig_Dfs_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode, Fraig_NodeVec_t * vNodes, int fEquiv );
-static int  Fraig_CheckTfi_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode, Fraig_Node_t * pOld );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the DFS ordering of the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_Dfs( Fraig_Man_t * pMan, int fEquiv )
-{
-    Fraig_NodeVec_t * vNodes;
-    int i;
-    pMan->nTravIds++;
-    vNodes = Fraig_NodeVecAlloc( 100 );
-    for ( i = 0; i < pMan->vOutputs->nSize; i++ )
-        Fraig_Dfs_rec( pMan, Fraig_Regular(pMan->vOutputs->pArray[i]), vNodes, fEquiv );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the DFS ordering of the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_DfsOne( Fraig_Man_t * pMan, Fraig_Node_t * pNode, int fEquiv )
-{
-    Fraig_NodeVec_t * vNodes;
-    pMan->nTravIds++;
-    vNodes = Fraig_NodeVecAlloc( 100 );
-    Fraig_Dfs_rec( pMan, Fraig_Regular(pNode), vNodes, fEquiv );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the DFS ordering of the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_DfsNodes( Fraig_Man_t * pMan, Fraig_Node_t ** ppNodes, int nNodes, int fEquiv )
-{
-    Fraig_NodeVec_t * vNodes;
-    int i;
-    pMan->nTravIds++;
-    vNodes = Fraig_NodeVecAlloc( 100 );
-    for ( i = 0; i < nNodes; i++ )
-        Fraig_Dfs_rec( pMan, Fraig_Regular(ppNodes[i]), vNodes, fEquiv );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recursively computes the DFS ordering of the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_Dfs_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode, Fraig_NodeVec_t * vNodes, int fEquiv )
-{
-    assert( !Fraig_IsComplement(pNode) );
-    // skip the visited node
-    if ( pNode->TravId == pMan->nTravIds )
-        return;
-    pNode->TravId = pMan->nTravIds;
-    // visit the transitive fanin
-    if ( Fraig_NodeIsAnd(pNode) )
-    {
-        Fraig_Dfs_rec( pMan, Fraig_Regular(pNode->p1), vNodes, fEquiv );
-        Fraig_Dfs_rec( pMan, Fraig_Regular(pNode->p2), vNodes, fEquiv );
-    }
-    if ( fEquiv && pNode->pNextE )
-        Fraig_Dfs_rec( pMan, pNode->pNextE, vNodes, fEquiv );
-    // save the node
-    Fraig_NodeVecPush( vNodes, pNode );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the DFS ordering of the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_CountNodes( Fraig_Man_t * pMan, int fEquiv )
-{
-    Fraig_NodeVec_t * vNodes;
-    int RetValue;
-    vNodes = Fraig_Dfs( pMan, fEquiv );
-    RetValue = vNodes->nSize;
-    Fraig_NodeVecFree( vNodes );
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if pOld is in the TFI of pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_CheckTfi( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    assert( !Fraig_IsComplement(pOld) );
-    assert( !Fraig_IsComplement(pNew) );
-    pMan->nTravIds++;
-    return Fraig_CheckTfi_rec( pMan, pNew, pOld );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if pOld is in the TFI of pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_CheckTfi_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode, Fraig_Node_t * pOld )
-{
-    // check the trivial cases
-    if ( pNode == NULL )
-        return 0;
-    if ( pNode->Num < pOld->Num && !pMan->fChoicing )
-        return 0;
-    if ( pNode == pOld )
-        return 1;
-    // skip the visited node
-    if ( pNode->TravId == pMan->nTravIds )
-        return 0;
-    pNode->TravId = pMan->nTravIds;
-    // check the children
-    if ( Fraig_CheckTfi_rec( pMan, Fraig_Regular(pNode->p1), pOld ) )
-        return 1;
-    if ( Fraig_CheckTfi_rec( pMan, Fraig_Regular(pNode->p2), pOld ) )
-        return 1;
-    // check equivalent nodes
-    return Fraig_CheckTfi_rec( pMan, pNode->pNextE, pOld );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if pOld is in the TFI of pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_CheckTfi2( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    Fraig_NodeVec_t * vNodes;
-    int RetValue;
-    vNodes = Fraig_DfsOne( pMan, pNew, 1 );
-    RetValue = (pOld->TravId == pMan->nTravIds);
-    Fraig_NodeVecFree( vNodes );
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the number of fanouts (none, one, or many).]
-
-  Description [This procedure collects the nodes reachable from
-  the POs of the AIG and sets the type of fanout counter (none, one,
-  or many) for each node. This procedure is useful to determine
-  fanout-free cones of AND-nodes, which is helpful for rebalancing
-  the AIG (see procedure Fraig_ManRebalance, or something like that).]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManMarkRealFanouts( Fraig_Man_t * p )
-{
-    Fraig_NodeVec_t * vNodes;
-    Fraig_Node_t * pNodeR;
-    int i;
-    // collect the nodes reachable
-    vNodes = Fraig_Dfs( p, 0 );
-    // clean the fanouts field
-    for ( i = 0; i < vNodes->nSize; i++ )
-    {
-        vNodes->pArray[i]->nFanouts = 0;
-        vNodes->pArray[i]->pData0 = NULL;
-    }
-    // mark reachable nodes by setting the two-bit counter pNode->nFans
-    for ( i = 0; i < vNodes->nSize; i++ )
-    {
-        pNodeR = Fraig_Regular(vNodes->pArray[i]->p1);
-        if ( pNodeR && ++pNodeR->nFanouts == 3 )
-            pNodeR->nFanouts = 2;
-        pNodeR = Fraig_Regular(vNodes->pArray[i]->p2);
-        if ( pNodeR && ++pNodeR->nFanouts == 3 )
-            pNodeR->nFanouts = 2;
-    }
-    Fraig_NodeVecFree( vNodes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates the constant 1 node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_BitStringCountOnes( unsigned * pString, int nWords )
-{
-    unsigned char * pSuppBytes = (unsigned char *)pString;
-    int i, nOnes, nBytes = sizeof(unsigned) * nWords;
-    // count the number of ones in the simulation vector
-    for ( i = nOnes = 0; i < nBytes; i++ )
-        nOnes += bit_count[pSuppBytes[i]];
-    return nOnes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Verify one useful property.]
-
-  Description [This procedure verifies one useful property. After 
-  the FRAIG construction with choice nodes is over, each primary node 
-  should have fanins that are primary nodes. The primary nodes is the 
-  one that does not have pNode->pRepr set to point to another node.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManCheckConsistency( Fraig_Man_t * p )
-{
-    Fraig_Node_t * pNode;
-    Fraig_NodeVec_t * pVec;
-    int i;
-    pVec = Fraig_Dfs( p, 0 );
-    for ( i = 0; i < pVec->nSize; i++ )
-    {
-        pNode = pVec->pArray[i];
-        if ( Fraig_NodeIsVar(pNode) )
-        {
-            if ( pNode->pRepr )
-                printf( "Primary input %d is a secondary node.\n", pNode->Num );
-        }
-        else if ( Fraig_NodeIsConst(pNode) )
-        {
-            if ( pNode->pRepr )
-                printf( "Constant 1 %d is a secondary node.\n", pNode->Num );
-        }
-        else
-        {
-            if ( pNode->pRepr )
-                printf( "Internal node %d is a secondary node.\n", pNode->Num );
-            if ( Fraig_Regular(pNode->p1)->pRepr )
-                printf( "Internal node %d has first fanin %d that is a secondary node.\n", 
-                    pNode->Num, Fraig_Regular(pNode->p1)->Num );
-            if ( Fraig_Regular(pNode->p2)->pRepr )
-                printf( "Internal node %d has second fanin %d that is a secondary node.\n", 
-                    pNode->Num, Fraig_Regular(pNode->p2)->Num );
-        }
-    }
-    Fraig_NodeVecFree( pVec );
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_PrintNode( Fraig_Man_t * p, Fraig_Node_t * pNode )
-{
-    Fraig_NodeVec_t * vNodes;
-    Fraig_Node_t * pTemp;
-    int fCompl1, fCompl2, i;
-
-    vNodes = Fraig_DfsOne( p, pNode, 0 );
-    for ( i = 0; i < vNodes->nSize; i++ )
-    {
-        pTemp = vNodes->pArray[i];
-        if ( Fraig_NodeIsVar(pTemp) )
-        {
-            printf( "%3d : PI          ", pTemp->Num );
-            Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimR, 20 );
-            printf( "   " );
-            Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimD, 20 );
-            printf( "  %d\n", pTemp->fInv );
-            continue;
-        }
-
-        fCompl1 = Fraig_IsComplement(pTemp->p1);
-        fCompl2 = Fraig_IsComplement(pTemp->p2);
-        printf( "%3d : %c%3d %c%3d   ", pTemp->Num,
-            (fCompl1? '-':'+'), Fraig_Regular(pTemp->p1)->Num,
-            (fCompl2? '-':'+'), Fraig_Regular(pTemp->p2)->Num );
-        Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimR, 20 );
-        printf( "   " );
-        Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimD, 20 );
-        printf( "  %d\n", pTemp->fInv );
-    }
-    Fraig_NodeVecFree( vNodes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints the bit string.]
-
-  Description []
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_PrintBinary( FILE * pFile, unsigned * pSign, int nBits )
-{
-    int Remainder, nWords;
-    int w, i;
-
-    Remainder = (nBits%(sizeof(unsigned)*8));
-    nWords    = (nBits/(sizeof(unsigned)*8)) + (Remainder>0);
-
-    for ( w = nWords-1; w >= 0; w-- )
-        for ( i = ((w == nWords-1 && Remainder)? Remainder-1: 31); i >= 0; i-- )
-            fprintf( pFile, "%c", '0' + (int)((pSign[w] & (1<<i)) > 0) );
-
-//  fprintf( pFile, "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets up the mask.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_GetMaxLevel( Fraig_Man_t * pMan )
-{
-    int nLevelMax, i;
-    nLevelMax = 0;
-    for ( i = 0; i < pMan->vOutputs->nSize; i++ )
-        nLevelMax = nLevelMax > Fraig_Regular(pMan->vOutputs->pArray[i])->Level? 
-                nLevelMax : Fraig_Regular(pMan->vOutputs->pArray[i])->Level;
-    return nLevelMax;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Analyses choice nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_MappingUpdateLevel_rec( Fraig_Man_t * pMan, Fraig_Node_t * pNode, int fMaximum )
-{
-    Fraig_Node_t * pTemp;
-    int Level1, Level2, LevelE;
-    assert( !Fraig_IsComplement(pNode) );
-    if ( !Fraig_NodeIsAnd(pNode) )
-        return pNode->Level;
-    // skip the visited node
-    if ( pNode->TravId == pMan->nTravIds )
-        return pNode->Level;
-    pNode->TravId = pMan->nTravIds;
-    // compute levels of the children nodes
-    Level1 = Fraig_MappingUpdateLevel_rec( pMan, Fraig_Regular(pNode->p1), fMaximum );
-    Level2 = Fraig_MappingUpdateLevel_rec( pMan, Fraig_Regular(pNode->p2), fMaximum );
-    pNode->Level = 1 + ABC_MAX( Level1, Level2 );
-    if ( pNode->pNextE )
-    {
-        LevelE = Fraig_MappingUpdateLevel_rec( pMan, pNode->pNextE, fMaximum );
-        if ( fMaximum )
-        {
-            if ( pNode->Level < LevelE )
-                pNode->Level = LevelE;
-        }
-        else
-        {
-            if ( pNode->Level > LevelE )
-                pNode->Level = LevelE;
-        }
-        // set the level of all equivalent nodes to be the same minimum
-        if ( pNode->pRepr == NULL ) // the primary node
-            for ( pTemp = pNode->pNextE; pTemp; pTemp = pTemp->pNextE )
-                pTemp->Level = pNode->Level;
-    }
-    return pNode->Level;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Resets the levels of the nodes in the choice graph.]
-
-  Description [Makes the level of the choice nodes to be equal to the
-  maximum of the level of the nodes in the equivalence class. This way
-  sorting by level leads to the reverse topological order, which is
-  needed for the required time computation.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_MappingSetChoiceLevels( Fraig_Man_t * pMan, int fMaximum )
-{
-    int i;
-    pMan->nTravIds++;
-    for ( i = 0; i < pMan->vOutputs->nSize; i++ )
-        Fraig_MappingUpdateLevel_rec( pMan, Fraig_Regular(pMan->vOutputs->pArray[i]), fMaximum );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reports statistics on choice nodes.]
-
-  Description [The number of choice nodes is the number of primary nodes,
-  which has pNextE set to a pointer. The number of choices is the number
-  of entries in the equivalent-node lists of the primary nodes.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManReportChoices( Fraig_Man_t * pMan )
-{
-    Fraig_Node_t * pNode, * pTemp;
-    int nChoiceNodes, nChoices;
-    int i, LevelMax1, LevelMax2;
-
-    // report the number of levels
-    LevelMax1 = Fraig_GetMaxLevel( pMan );
-    Fraig_MappingSetChoiceLevels( pMan, 0 );
-    LevelMax2 = Fraig_GetMaxLevel( pMan );
-
-    // report statistics about choices
-    nChoiceNodes = nChoices = 0;
-    for ( i = 0; i < pMan->vNodes->nSize; i++ )
-    {
-        pNode = pMan->vNodes->pArray[i];
-        if ( pNode->pRepr == NULL && pNode->pNextE != NULL )
-        { // this is a choice node = the primary node that has equivalent nodes
-            nChoiceNodes++;
-            for ( pTemp = pNode; pTemp; pTemp = pTemp->pNextE )
-                nChoices++;
-        }
-    }
-    printf( "Maximum level: Original = %d. Reduced due to choices = %d.\n", LevelMax1, LevelMax2 );
-    printf( "Choice stats:  Choice nodes = %d. Total choices = %d.\n", nChoiceNodes, nChoices );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the node is the root of EXOR/NEXOR gate.]
-
-  Description [The node can be complemented.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsExorType( Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pNode1, * pNode2;
-    // make the node regular (it does not matter for EXOR/NEXOR)
-    pNode = Fraig_Regular(pNode);
-    // if the node or its children are not ANDs or not compl, this cannot be EXOR type
-    if ( !Fraig_NodeIsAnd(pNode) )
-        return 0;
-    if ( !Fraig_NodeIsAnd(pNode->p1) || !Fraig_IsComplement(pNode->p1) )
-        return 0;
-    if ( !Fraig_NodeIsAnd(pNode->p2) || !Fraig_IsComplement(pNode->p2) )
-        return 0;
-
-    // get children
-    pNode1 = Fraig_Regular(pNode->p1);
-    pNode2 = Fraig_Regular(pNode->p2);
-    assert( pNode1->Num < pNode2->Num );
-
-    // compare grandchildren
-    return pNode1->p1 == Fraig_Not(pNode2->p1) && pNode1->p2 == Fraig_Not(pNode2->p2);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the node is the root of MUX or EXOR/NEXOR.]
-
-  Description [The node can be complemented.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsMuxType( Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pNode1, * pNode2;
-
-    // make the node regular (it does not matter for EXOR/NEXOR)
-    pNode = Fraig_Regular(pNode);
-    // if the node or its children are not ANDs or not compl, this cannot be EXOR type
-    if ( !Fraig_NodeIsAnd(pNode) )
-        return 0;
-    if ( !Fraig_NodeIsAnd(pNode->p1) || !Fraig_IsComplement(pNode->p1) )
-        return 0;
-    if ( !Fraig_NodeIsAnd(pNode->p2) || !Fraig_IsComplement(pNode->p2) )
-        return 0;
-
-    // get children
-    pNode1 = Fraig_Regular(pNode->p1);
-    pNode2 = Fraig_Regular(pNode->p2);
-    assert( pNode1->Num < pNode2->Num );
-
-    // compare grandchildren
-    // node is an EXOR/NEXOR
-    if ( pNode1->p1 == Fraig_Not(pNode2->p1) && pNode1->p2 == Fraig_Not(pNode2->p2) )
-        return 1; 
-
-    // otherwise the node is MUX iff it has a pair of equal grandchildren
-    return pNode1->p1 == Fraig_Not(pNode2->p1) || 
-           pNode1->p1 == Fraig_Not(pNode2->p2) ||
-           pNode1->p2 == Fraig_Not(pNode2->p1) ||
-           pNode1->p2 == Fraig_Not(pNode2->p2);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the node is EXOR, 0 if it is NEXOR.]
-
-  Description [The node should be EXOR type and not complemented.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsExor( Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pNode1;
-    assert( !Fraig_IsComplement(pNode) );
-    assert( Fraig_NodeIsExorType(pNode) );
-    assert( Fraig_IsComplement(pNode->p1) );
-    // get children
-    pNode1 = Fraig_Regular(pNode->p1);
-    return Fraig_IsComplement(pNode1->p1) == Fraig_IsComplement(pNode1->p2);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recognizes what nodes are control and data inputs of a MUX.]
-
-  Description [If the node is a MUX, returns the control variable C.
-  Assigns nodes T and E to be the then and else variables of the MUX. 
-  Node C is never complemented. Nodes T and E can be complemented.
-  This function also recognizes EXOR/NEXOR gates as MUXes.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeRecognizeMux( Fraig_Node_t * pNode, Fraig_Node_t ** ppNodeT, Fraig_Node_t ** ppNodeE )
-{
-    Fraig_Node_t * pNode1, * pNode2;
-    assert( !Fraig_IsComplement(pNode) );
-    assert( Fraig_NodeIsMuxType(pNode) );
-    // get children
-    pNode1 = Fraig_Regular(pNode->p1);
-    pNode2 = Fraig_Regular(pNode->p2);
-    // find the control variable
-    if ( pNode1->p1 == Fraig_Not(pNode2->p1) )
-    {
-        if ( Fraig_IsComplement(pNode1->p1) )
-        { // pNode2->p1 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode2->p2);
-            *ppNodeE = Fraig_Not(pNode1->p2);
-            return pNode2->p1;
-        }
-        else
-        { // pNode1->p1 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode1->p2);
-            *ppNodeE = Fraig_Not(pNode2->p2);
-            return pNode1->p1;
-        }
-    }
-    else if ( pNode1->p1 == Fraig_Not(pNode2->p2) )
-    {
-        if ( Fraig_IsComplement(pNode1->p1) )
-        { // pNode2->p2 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode2->p1);
-            *ppNodeE = Fraig_Not(pNode1->p2);
-            return pNode2->p2;
-        }
-        else
-        { // pNode1->p1 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode1->p2);
-            *ppNodeE = Fraig_Not(pNode2->p1);
-            return pNode1->p1;
-        }
-    }
-    else if ( pNode1->p2 == Fraig_Not(pNode2->p1) )
-    {
-        if ( Fraig_IsComplement(pNode1->p2) )
-        { // pNode2->p1 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode2->p2);
-            *ppNodeE = Fraig_Not(pNode1->p1);
-            return pNode2->p1;
-        }
-        else
-        { // pNode1->p2 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode1->p1);
-            *ppNodeE = Fraig_Not(pNode2->p2);
-            return pNode1->p2;
-        }
-    }
-    else if ( pNode1->p2 == Fraig_Not(pNode2->p2) )
-    {
-        if ( Fraig_IsComplement(pNode1->p2) )
-        { // pNode2->p2 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode2->p1);
-            *ppNodeE = Fraig_Not(pNode1->p1);
-            return pNode2->p2;
-        }
-        else
-        { // pNode1->p2 is positive phase of C
-            *ppNodeT = Fraig_Not(pNode1->p1);
-            *ppNodeE = Fraig_Not(pNode2->p1);
-            return pNode1->p2;
-        }
-    }
-    assert( 0 ); // this is not MUX
-    return NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of EXOR type nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManCountExors( Fraig_Man_t * pMan )
-{
-    int i, nExors;
-    nExors = 0;
-    for ( i = 0; i < pMan->vNodes->nSize; i++ )
-        nExors += Fraig_NodeIsExorType( pMan->vNodes->pArray[i] );
-    return nExors;
-
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of EXOR type nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManCountMuxes( Fraig_Man_t * pMan )
-{
-    int i, nMuxes;
-    nMuxes = 0;
-    for ( i = 0; i < pMan->vNodes->nSize; i++ )
-        nMuxes += Fraig_NodeIsMuxType( pMan->vNodes->pArray[i] );
-    return nMuxes;
-
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if siminfo of Node1 is contained in siminfo of Node2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeSimsContained( Fraig_Man_t * pMan, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2 )
-{
-    unsigned * pUnsigned1, * pUnsigned2;
-    int i;
-
-    // compare random siminfo
-    pUnsigned1 = pNode1->puSimR;
-    pUnsigned2 = pNode2->puSimR;
-    for ( i = 0; i < pMan->nWordsRand; i++ )
-        if ( pUnsigned1[i] & ~pUnsigned2[i] )
-            return 0;
-
-    // compare systematic siminfo
-    pUnsigned1 = pNode1->puSimD;
-    pUnsigned2 = pNode2->puSimD;
-    for ( i = 0; i < pMan->iWordStart; i++ )
-        if ( pUnsigned1[i] & ~pUnsigned2[i] )
-            return 0;
-
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Count the number of PI variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_CountPis( Fraig_Man_t * p, Msat_IntVec_t * vVarNums )
-{
-    int * pVars, nVars, i, Counter;
-
-    nVars = Msat_IntVecReadSize(vVarNums);
-    pVars = Msat_IntVecReadArray(vVarNums);
-    Counter = 0;
-    for ( i = 0; i < nVars; i++ )
-        Counter += Fraig_NodeIsVar( p->vNodes->pArray[pVars[i]] );
-    return Counter;
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of EXOR type nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_ManPrintRefs( Fraig_Man_t * pMan )
-{
-    Fraig_NodeVec_t * vPivots;
-    Fraig_Node_t * pNode, * pNode2;
-    int i, k, Counter, nProved;
-    int clk;
-
-    vPivots = Fraig_NodeVecAlloc( 1000 );
-    for ( i = 0; i < pMan->vNodes->nSize; i++ )
-    {
-        pNode = pMan->vNodes->pArray[i];
-
-        if ( pNode->nOnes == 0 || pNode->nOnes == (unsigned)pMan->nWordsRand * 32 )
-            continue;
-
-        if ( pNode->nRefs > 5 )
-        {
-            Fraig_NodeVecPush( vPivots, pNode );
-//            printf( "Node %6d : nRefs = %2d   Level = %3d.\n", pNode->Num, pNode->nRefs, pNode->Level );
-        }
-    }
-    printf( "Total nodes = %d. Referenced nodes = %d.\n", pMan->vNodes->nSize, vPivots->nSize );
-
-clk = clock();
-    // count implications
-    Counter = nProved = 0;
-    for ( i = 0; i < vPivots->nSize; i++ )
-        for ( k = i+1; k < vPivots->nSize; k++ )
-        {
-            pNode  = vPivots->pArray[i];
-            pNode2 = vPivots->pArray[k];
-            if ( Fraig_NodeSimsContained( pMan, pNode, pNode2 ) )
-            {
-                if ( Fraig_NodeIsImplication( pMan, pNode, pNode2, -1 ) )
-                    nProved++;
-                Counter++;
-            }
-            else if ( Fraig_NodeSimsContained( pMan, pNode2, pNode ) )
-            {
-                if ( Fraig_NodeIsImplication( pMan, pNode2, pNode, -1 ) )
-                    nProved++;
-                Counter++;
-            }
-        }
-    printf( "Number of candidate pairs = %d.  Proved = %d.\n", Counter, nProved );
-//ABC_PRT( "Time", clock() - clk );
-    return 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Checks if pNew exists among the implication fanins of pOld.]
-
-  Description [If pNew is an implication fanin of pOld, returns 1. 
-  If Fraig_Not(pNew) is an implication fanin of pOld, return -1.
-  Otherwise returns 0.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsInSupergate( Fraig_Node_t * pOld, Fraig_Node_t * pNew )
-{
-    int RetValue1, RetValue2;
-    if ( Fraig_Regular(pOld) == Fraig_Regular(pNew) )
-        return (pOld == pNew)? 1 : -1;
-    if ( Fraig_IsComplement(pOld) || Fraig_NodeIsVar(pOld) )
-        return 0;
-    RetValue1 = Fraig_NodeIsInSupergate( pOld->p1, pNew );
-    RetValue2 = Fraig_NodeIsInSupergate( pOld->p2, pNew );
-    if ( RetValue1 == -1 || RetValue2 == -1 )
-        return -1;
-    if ( RetValue1 ==  1 || RetValue2 ==  1 )
-        return 1;
-    return 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of nodes to be combined into one multi-input AND-gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_CollectSupergate_rec( Fraig_Node_t * pNode, Fraig_NodeVec_t * vSuper, int fFirst, int fStopAtMux )
-{
-    // if the new node is complemented or a PI, another gate begins
-//    if ( Fraig_IsComplement(pNode) || Fraig_NodeIsVar(pNode) || Fraig_NodeIsMuxType(pNode) )
-    if ( (!fFirst && Fraig_Regular(pNode)->nRefs > 1) || 
-          Fraig_IsComplement(pNode) || Fraig_NodeIsVar(pNode) || 
-          (fStopAtMux && Fraig_NodeIsMuxType(pNode)) )
-    {
-        Fraig_NodeVecPushUnique( vSuper, pNode );
-        return;
-    }
-    // go through the branches
-    Fraig_CollectSupergate_rec( pNode->p1, vSuper, 0, fStopAtMux );
-    Fraig_CollectSupergate_rec( pNode->p2, vSuper, 0, fStopAtMux );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of nodes to be combined into one multi-input AND-gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_CollectSupergate( Fraig_Node_t * pNode, int fStopAtMux )
-{
-    Fraig_NodeVec_t * vSuper;
-    vSuper = Fraig_NodeVecAlloc( 8 );
-    Fraig_CollectSupergate_rec( pNode, vSuper, 1, fStopAtMux );
-    return vSuper;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_ManIncrementTravId( Fraig_Man_t * pMan )
-{
-    pMan->nTravIds2++;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeSetTravIdCurrent( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    pNode->TravId2 = pMan->nTravIds2;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsTravIdCurrent( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    return pNode->TravId2 == pMan->nTravIds2;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeIsTravIdPrevious( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
-{
-    return pNode->TravId2 == pMan->nTravIds2 - 1;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/fraigVec.c b/src/sat/fraig/fraigVec.c
deleted file mode 100644
index 25d50bf3..00000000
--- a/src/sat/fraig/fraigVec.c
+++ /dev/null
@@ -1,550 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [fraigVec.c]
-
-  PackageName [FRAIG: Functionally reduced AND-INV graphs.]
-
-  Synopsis    [Vector of FRAIG nodes.]
-
-  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - October 1, 2004]
-
-  Revision    [$Id: fraigVec.c,v 1.7 2005/07/08 01:01:34 alanmi Exp $]
-
-***********************************************************************/
-
-#include "fraigInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Allocates a vector with the given capacity.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_NodeVecAlloc( int nCap )
-{
-    Fraig_NodeVec_t * p;
-    p = ABC_ALLOC( Fraig_NodeVec_t, 1 );
-    if ( nCap > 0 && nCap < 8 )
-        nCap = 8;
-    p->nSize  = 0;
-    p->nCap   = nCap;
-    p->pArray = p->nCap? ABC_ALLOC( Fraig_Node_t *, p->nCap ) : NULL;
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecFree( Fraig_NodeVec_t * p )
-{
-    ABC_FREE( p->pArray );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the integer array.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_NodeVec_t * Fraig_NodeVecDup( Fraig_NodeVec_t * pVec )
-{
-    Fraig_NodeVec_t * p;
-    p = ABC_ALLOC( Fraig_NodeVec_t, 1 );
-    p->nSize  = pVec->nSize;
-    p->nCap   = pVec->nCap;
-    p->pArray = p->nCap? ABC_ALLOC( Fraig_Node_t *, p->nCap ) : NULL;
-    memcpy( p->pArray, pVec->pArray, sizeof(Fraig_Node_t *) * pVec->nSize );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t ** Fraig_NodeVecReadArray( Fraig_NodeVec_t * p )
-{
-    return p->pArray;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecReadSize( Fraig_NodeVec_t * p )
-{
-    return p->nSize;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Resizes the vector to the given capacity.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecGrow( Fraig_NodeVec_t * p, int nCapMin )
-{
-    if ( p->nCap >= nCapMin )
-        return;
-    p->pArray = ABC_REALLOC( Fraig_Node_t *, p->pArray, nCapMin ); 
-    p->nCap   = nCapMin;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecShrink( Fraig_NodeVec_t * p, int nSizeNew )
-{
-    assert( p->nSize >= nSizeNew );
-    p->nSize = nSizeNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecClear( Fraig_NodeVec_t * p )
-{
-    p->nSize = 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecPush( Fraig_NodeVec_t * p, Fraig_Node_t * Entry )
-{
-    if ( p->nSize == p->nCap )
-    {
-        if ( p->nCap < 16 )
-            Fraig_NodeVecGrow( p, 16 );
-        else
-            Fraig_NodeVecGrow( p, 2 * p->nCap );
-    }
-    p->pArray[p->nSize++] = Entry;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Add the element while ensuring uniqueness.]
-
-  Description [Returns 1 if the element was found, and 0 if it was new. ]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecPushUnique( Fraig_NodeVec_t * p, Fraig_Node_t * Entry )
-{
-    int i;
-    for ( i = 0; i < p->nSize; i++ )
-        if ( p->pArray[i] == Entry )
-            return 1;
-    Fraig_NodeVecPush( p, Entry );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Inserts a new node in the order by arrival times.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecPushOrder( Fraig_NodeVec_t * p, Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pNode1, * pNode2;
-    int i;
-    Fraig_NodeVecPush( p, pNode );
-    // find the p of the node
-    for ( i = p->nSize-1; i > 0; i-- )
-    {
-        pNode1 = p->pArray[i  ];
-        pNode2 = p->pArray[i-1];
-        if ( pNode1 >= pNode2 )
-            break;
-        p->pArray[i  ] = pNode2;
-        p->pArray[i-1] = pNode1;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Add the element while ensuring uniqueness in the order.]
-
-  Description [Returns 1 if the element was found, and 0 if it was new. ]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecPushUniqueOrder( Fraig_NodeVec_t * p, Fraig_Node_t * pNode )
-{
-    int i;
-    for ( i = 0; i < p->nSize; i++ )
-        if ( p->pArray[i] == pNode )
-            return 1;
-    Fraig_NodeVecPushOrder( p, pNode );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Inserts a new node in the order by arrival times.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecPushOrderByLevel( Fraig_NodeVec_t * p, Fraig_Node_t * pNode )
-{
-    Fraig_Node_t * pNode1, * pNode2;
-    int i;
-    Fraig_NodeVecPush( p, pNode );
-    // find the p of the node
-    for ( i = p->nSize-1; i > 0; i-- )
-    {
-        pNode1 = p->pArray[i  ];
-        pNode2 = p->pArray[i-1];
-        if ( Fraig_Regular(pNode1)->Level <= Fraig_Regular(pNode2)->Level )
-            break;
-        p->pArray[i  ] = pNode2;
-        p->pArray[i-1] = pNode1;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Add the element while ensuring uniqueness in the order.]
-
-  Description [Returns 1 if the element was found, and 0 if it was new. ]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecPushUniqueOrderByLevel( Fraig_NodeVec_t * p, Fraig_Node_t * pNode )
-{
-    int i;
-    for ( i = 0; i < p->nSize; i++ )
-        if ( p->pArray[i] == pNode )
-            return 1;
-    Fraig_NodeVecPushOrderByLevel( p, pNode );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeVecPop( Fraig_NodeVec_t * p )
-{
-    return p->pArray[--p->nSize];
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecRemove( Fraig_NodeVec_t * p, Fraig_Node_t * Entry )
-{
-    int i;
-    for ( i = 0; i < p->nSize; i++ )
-        if ( p->pArray[i] == Entry )
-            break;
-    assert( i < p->nSize );
-    for ( i++; i < p->nSize; i++ )
-        p->pArray[i-1] = p->pArray[i];
-    p->nSize--;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecWriteEntry( Fraig_NodeVec_t * p, int i, Fraig_Node_t * Entry )
-{
-    assert( i >= 0 && i < p->nSize );
-    p->pArray[i] = Entry;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Fraig_Node_t * Fraig_NodeVecReadEntry( Fraig_NodeVec_t * p, int i )
-{
-    assert( i >= 0 && i < p->nSize );
-    return p->pArray[i];
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Comparison procedure for two clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecCompareLevelsIncreasing( Fraig_Node_t ** pp1, Fraig_Node_t ** pp2 )
-{
-    int Level1 = Fraig_Regular(*pp1)->Level;
-    int Level2 = Fraig_Regular(*pp2)->Level;
-    if ( Level1 < Level2 )
-        return -1;
-    if ( Level1 > Level2 )
-        return 1;
-    return 0; 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Comparison procedure for two clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecCompareLevelsDecreasing( Fraig_Node_t ** pp1, Fraig_Node_t ** pp2 )
-{
-    int Level1 = Fraig_Regular(*pp1)->Level;
-    int Level2 = Fraig_Regular(*pp2)->Level;
-    if ( Level1 > Level2 )
-        return -1;
-    if ( Level1 < Level2 )
-        return 1;
-    return 0; 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Comparison procedure for two clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecCompareNumbers( Fraig_Node_t ** pp1, Fraig_Node_t ** pp2 )
-{
-    int Num1 = Fraig_Regular(*pp1)->Num;
-    int Num2 = Fraig_Regular(*pp2)->Num;
-    if ( Num1 < Num2 )
-        return -1;
-    if ( Num1 > Num2 )
-        return 1;
-    return 0; 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Comparison procedure for two clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Fraig_NodeVecCompareRefCounts( Fraig_Node_t ** pp1, Fraig_Node_t ** pp2 )
-{
-    int nRefs1 = Fraig_Regular(*pp1)->nRefs;
-    int nRefs2 = Fraig_Regular(*pp2)->nRefs;
-
-    if ( nRefs1 < nRefs2 )
-        return -1;
-    if ( nRefs1 > nRefs2 )
-        return 1;
-
-    nRefs1 = Fraig_Regular(*pp1)->Level;
-    nRefs2 = Fraig_Regular(*pp2)->Level;
-
-    if ( nRefs1 < nRefs2 )
-        return -1;
-    if ( nRefs1 > nRefs2 )
-        return 1;
-    return 0; 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sorting the entries by their integer value.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecSortByLevel( Fraig_NodeVec_t * p, int fIncreasing )
-{
-    if ( fIncreasing )
-        qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
-                (int (*)(const void *, const void *)) Fraig_NodeVecCompareLevelsIncreasing );
-    else 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
-                (int (*)(const void *, const void *)) Fraig_NodeVecCompareLevelsDecreasing );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sorting the entries by their integer value.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecSortByNumber( Fraig_NodeVec_t * p )
-{
-    qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
-            (int (*)(const void *, const void *)) Fraig_NodeVecCompareNumbers );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sorting the entries by their integer value.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Fraig_NodeVecSortByRefCount( Fraig_NodeVec_t * p )
-{
-    qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
-            (int (*)(const void *, const void *)) Fraig_NodeVecCompareRefCounts );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/fraig/module.make b/src/sat/fraig/module.make
deleted file mode 100644
index cc6eb9d3..00000000
--- a/src/sat/fraig/module.make
+++ /dev/null
@@ -1,12 +0,0 @@
-SRC +=  src/sat/fraig/fraigApi.c \
-    src/sat/fraig/fraigCanon.c \
-    src/sat/fraig/fraigFanout.c \
-    src/sat/fraig/fraigFeed.c \
-    src/sat/fraig/fraigMan.c \
-    src/sat/fraig/fraigMem.c \
-    src/sat/fraig/fraigNode.c \
-    src/sat/fraig/fraigPrime.c \
-    src/sat/fraig/fraigSat.c \
-    src/sat/fraig/fraigTable.c \
-    src/sat/fraig/fraigUtil.c \
-    src/sat/fraig/fraigVec.c
diff --git a/src/sat/lsat/solver.h b/src/sat/lsat/solver.h
index a50c4abe..2baff658 100644
--- a/src/sat/lsat/solver.h
+++ b/src/sat/lsat/solver.h
@@ -18,8 +18,8 @@ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 **************************************************************************************************/
 
-#ifndef Minisat_solver_h
-#define Minisat_solver_h
+#ifndef ABC__sat__lsat__solver_h
+#define ABC__sat__lsat__solver_h
 
 
 ABC_NAMESPACE_HEADER_START
diff --git a/src/sat/msat/msat.h b/src/sat/msat/msat.h
index 6dc68cf8..4830b12e 100644
--- a/src/sat/msat/msat.h
+++ b/src/sat/msat/msat.h
@@ -18,8 +18,8 @@
 
 ***********************************************************************/
 
-#ifndef __MSAT_H__
-#define __MSAT_H__
+#ifndef ABC__sat__msat__msat_h
+#define ABC__sat__msat__msat_h
 
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/sat/msat/msatInt.h b/src/sat/msat/msatInt.h
index b4b5ff77..58baa7b4 100644
--- a/src/sat/msat/msatInt.h
+++ b/src/sat/msat/msatInt.h
@@ -18,8 +18,8 @@
 
 ***********************************************************************/
  
-#ifndef __MSAT_INT_H__
-#define __MSAT_INT_H__
+#ifndef ABC__sat__msat__msatInt_h
+#define ABC__sat__msat__msatInt_h
 
 
 ////////////////////////////////////////////////////////////////////////
@@ -33,7 +33,7 @@
 #include <time.h>
 #include <math.h>
 
-#include "abc_global.h"
+#include "src/misc/util/abc_global.h"
 #include "msat.h"
 
 ABC_NAMESPACE_HEADER_START
diff --git a/src/sat/pdr/module.make b/src/sat/pdr/module.make
deleted file mode 100644
index 5cf4491c..00000000
--- a/src/sat/pdr/module.make
+++ /dev/null
@@ -1,8 +0,0 @@
-SRC +=    src/sat/pdr/pdr.c \
-    src/sat/pdr/pdrCnf.c \
-    src/sat/pdr/pdrCore.c \
-    src/sat/pdr/pdrInv.c \
-    src/sat/pdr/pdrMan.c \
-    src/sat/pdr/pdrSat.c \
-    src/sat/pdr/pdrTsim.c \
-    src/sat/pdr/pdrUtil.c 
diff --git a/src/sat/pdr/pdr.h b/src/sat/pdr/pdr.h
deleted file mode 100644
index 03854509..00000000
--- a/src/sat/pdr/pdr.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdr.h]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [External declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdr.h,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
- 
-#ifndef __PDR_H__
-#define __PDR_H__
-
-
-ABC_NAMESPACE_HEADER_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                         BASIC TYPES                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Pdr_Par_t_ Pdr_Par_t;
-struct Pdr_Par_t_
-{
-    int iOutput;      // zero-based number of primary output to solve
-    int nRecycle;     // limit on vars for recycling
-    int nFrameMax;    // limit on frame count
-    int nConfLimit;   // limit on SAT solver conflicts
-    int nTimeOut;     // timeout in seconds
-    int fTwoRounds;   // use two rounds for generalization
-    int fMonoCnf;     // monolythic CNF
-    int fDumpInv;     // dump inductive invariant
-    int fShortest;    // forces bug traces to be shortest
-    int fSkipGeneral; // skips expensive generalization step
-    int fVerbose;     // verbose output
-    int fVeryVerbose; // very verbose output
-    int iFrame;       // explored up to this frame
-};
-
-////////////////////////////////////////////////////////////////////////
-///                      MACRO DEFINITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DECLARATIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== pdrCore.c ==========================================================*/
-extern void            Pdr_ManSetDefaultParams( Pdr_Par_t * pPars );
-extern int             Pdr_ManSolve( Aig_Man_t * p, Pdr_Par_t * pPars, Abc_Cex_t ** ppCex );
-
-
-ABC_NAMESPACE_HEADER_END
-
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/sat/pdr/pdrClass.c b/src/sat/pdr/pdrClass.c
deleted file mode 100644
index 3e990958..00000000
--- a/src/sat/pdr/pdrClass.c
+++ /dev/null
@@ -1,223 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrClass.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [Equivalence classes of register outputs.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrClass.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "pdrInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Performs duplication with the variable map.]
-
-  Description [Var map contains -1 if const0 and <reg_num> otherwise.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Aig_Man_t * Pdr_ManRehashWithMap( Aig_Man_t * pAig, Vec_Int_t * vMap )
-{
-    Aig_Man_t * pFrames;
-    Aig_Obj_t * pObj;
-    int i, iReg;
-    assert( Vec_IntSize(vMap) == Aig_ManRegNum(pAig) );
-    // start the fraig package
-    pFrames = Aig_ManStart( Aig_ManObjNumMax(pAig) );
-    pFrames->pName = Aig_UtilStrsav( pAig->pName );
-    pFrames->pSpec = Aig_UtilStrsav( pAig->pSpec );
-    // create CI mapping
-    Aig_ManCleanData( pAig );
-    Aig_ManConst1(pAig)->pData = Aig_ManConst1(pFrames);
-    Aig_ManForEachPi( pAig, pObj, i )
-        pObj->pData = Aig_ObjCreatePi(pFrames);
-    Saig_ManForEachLo( pAig, pObj, i )
-    {
-        iReg = Vec_IntEntry(vMap, i);
-        if ( iReg == -1 )
-            pObj->pData = Aig_ManConst0(pFrames);
-        else
-            pObj->pData = Saig_ManLo(pAig, iReg)->pData;
-    }
-    // add internal nodes of this frame
-    Aig_ManForEachNode( pAig, pObj, i )
-        pObj->pData = Aig_And( pFrames, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
-    // add output nodes
-    Aig_ManForEachPo( pAig, pObj, i )
-        pObj->pData = Aig_ObjCreatePo( pFrames, Aig_ObjChild0Copy(pObj) );
-    // finish off
-    Aig_ManCleanup( pFrames );
-    Aig_ManSetRegNum( pFrames, Aig_ManRegNum(pAig) );
-    return pFrames;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates mapping of registers.]
-
-  Description [Var map contains -1 if const0 and <reg_num> otherwise.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Pdr_ManCreateMap( Aig_Man_t * p )
-{
-    Aig_Obj_t * pObj;
-    Vec_Int_t * vMap;
-    int * pLit2Id, Lit, i;
-    pLit2Id = ABC_ALLOC( int, Aig_ManObjNumMax(p) * 2 );
-    for ( i = 0; i < Aig_ManObjNumMax(p) * 2; i++ )
-        pLit2Id[i] = -1;
-    vMap = Vec_IntAlloc( Aig_ManRegNum(p) );
-    Saig_ManForEachLi( p, pObj, i )
-    {
-        if ( Aig_ObjChild0(pObj) == Aig_ManConst0(p) )
-        {
-            Vec_IntPush( vMap, -1 );
-            continue;
-        }
-        Lit = 2 * Aig_ObjFaninId0(pObj) + Aig_ObjFaninC0(pObj);
-        if ( pLit2Id[Lit] < 0 ) // the first time
-            pLit2Id[Lit] = i;
-        Vec_IntPush( vMap, pLit2Id[Lit] );
-    }
-    ABC_FREE( pLit2Id );
-    return vMap;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts reduced registers.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManCountMap( Vec_Int_t * vMap )
-{
-    int i, Entry, Counter = 0;
-    Vec_IntForEachEntry( vMap, Entry, i )
-        if ( Entry != i )
-            Counter++;
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts reduced registers.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManPrintMap( Vec_Int_t * vMap )
-{
-    Vec_Int_t * vMarks;
-    int f, i, iClass, Entry, Counter = 0;
-    printf( "    Consts: " );
-    Vec_IntForEachEntry( vMap, Entry, i )
-        if ( Entry == -1 )
-            printf( "%d ", i );
-    printf( "\n" );
-    vMarks = Vec_IntAlloc( 100 );
-    Vec_IntForEachEntry( vMap, iClass, f )
-    {
-        if ( iClass == -1 )
-            continue;
-        if ( iClass == f )
-            continue;
-        // check previous classes
-        if ( Vec_IntFind( vMarks, iClass ) >= 0 )
-            continue;
-        Vec_IntPush( vMarks, iClass );
-        // print class
-        printf( "    Class %d : ", iClass );
-        Vec_IntForEachEntry( vMap, Entry, i )
-            if ( Entry == iClass )
-                printf( "%d ", i );
-        printf( "\n" );
-    }
-    Vec_IntFree( vMarks );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManEquivClasses( Aig_Man_t * pAig )
-{
-    Vec_Int_t * vMap;
-    Aig_Man_t * pTemp;
-    int f, nFrames = 100;
-    assert( Saig_ManRegNum(pAig) > 0 );
-    // start the map
-    vMap = Vec_IntAlloc( 0 );
-    Vec_IntFill( vMap, Aig_ManRegNum(pAig), -1 );
-    // iterate and print changes
-    for ( f = 0; f < nFrames; f++ )
-    {
-        // implement variable map
-        pTemp = Pdr_ManRehashWithMap( pAig, vMap );
-        // report the result
-        printf( "F =%4d : Total = %6d. Nodes = %6d. RedRegs = %6d. Prop = %s\n", 
-            f+1, Aig_ManNodeNum(pAig), Aig_ManNodeNum(pTemp), Pdr_ManCountMap(vMap), 
-            Aig_ObjChild0(Aig_ManPo(pTemp,0)) == Aig_ManConst0(pTemp) ? "proof" : "unknown" );
-        // recreate the map
-        Pdr_ManPrintMap( vMap );
-        Vec_IntFree( vMap );
-        vMap = Pdr_ManCreateMap( pTemp );
-        Aig_ManStop( pTemp );
-        if ( Pdr_ManCountMap(vMap) == 0 )
-            break;
-    }
-    Vec_IntFree( vMap );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/pdr/pdrCnf.c b/src/sat/pdr/pdrCnf.c
deleted file mode 100644
index fddd292b..00000000
--- a/src/sat/pdr/pdrCnf.c
+++ /dev/null
@@ -1,357 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrCnf.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [CNF computation on demand.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrCnf.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "pdrInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-/*
-    The CNF (p->pCnf2) is expressed in terms of object IDs.
-    Each node in the CNF is marked if it has clauses (p->pCnf2->pObj2Count[Id] > 0).
-    Each node in the CNF has the first clause (p->pCnf2->pObj2Clause) 
-    and the number of clauses (p->pCnf2->pObj2Count).
-    Each node used in a CNF of any timeframe has its SAT var recorded.
-    Each frame has a reserve mapping of SAT variables into ObjIds.
-*/
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Returns SAT variable of the given object.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Pdr_ObjSatVar1( Pdr_Man_t * p, int k, Aig_Obj_t * pObj )
-{
-    return p->pCnf1->pVarNums[ Aig_ObjId(pObj) ];
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns SAT variable of the given object.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Pdr_ObjSatVar2FindOrAdd( Pdr_Man_t * p, int k, Aig_Obj_t * pObj )
-{ 
-    assert( p->pCnf2->pObj2Count[Aig_ObjId(pObj)] >= 0 );
-    if ( p->pvId2Vars[Aig_ObjId(pObj)] == NULL )
-        p->pvId2Vars[Aig_ObjId(pObj)] = Vec_IntStart( 16 );
-    if ( Vec_IntGetEntry( p->pvId2Vars[Aig_ObjId(pObj)], k ) == 0 )
-    {
-        sat_solver * pSat = Pdr_ManSolver(p, k);
-        Vec_Int_t * vVar2Ids = (Vec_Int_t *)Vec_PtrEntry(p->vVar2Ids, k);
-        int iVarNew = Vec_IntSize( vVar2Ids );
-        assert( iVarNew > 0 );
-        Vec_IntPush( vVar2Ids, Aig_ObjId(pObj) );
-        Vec_IntWriteEntry( p->pvId2Vars[Aig_ObjId(pObj)], k, iVarNew );
-        sat_solver_setnvars( pSat, iVarNew + 1 );
-        if ( k == 0 && Saig_ObjIsLo(p->pAig, pObj) ) // initialize the register output
-        {
-            int Lit = toLitCond( iVarNew, 1 );
-            int RetValue = sat_solver_addclause( pSat, &Lit, &Lit + 1 );
-            assert( RetValue == 1 );
-            sat_solver_compress( pSat );
-        }
-    }
-    return Vec_IntEntry( p->pvId2Vars[Aig_ObjId(pObj)], k );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recursively adds CNF for the given object.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ObjSatVar2( Pdr_Man_t * p, int k, Aig_Obj_t * pObj )
-{
-    sat_solver * pSat;
-    Vec_Int_t * vLits;
-    Vec_Int_t * vVar2Ids = (Vec_Int_t *)Vec_PtrEntry(p->vVar2Ids, k);
-    int nVarCount = Vec_IntSize(vVar2Ids);
-    int iVarThis  = Pdr_ObjSatVar2FindOrAdd( p, k, pObj );
-    int * pLit, i, iVar, nClauses, iFirstClause, RetValue;
-    if ( nVarCount == Vec_IntSize(vVar2Ids) )
-        return iVarThis;
-    assert( nVarCount + 1 == Vec_IntSize(vVar2Ids) );
-    if ( Aig_ObjIsPi(pObj) )
-        return iVarThis;
-    nClauses = p->pCnf2->pObj2Count[Aig_ObjId(pObj)];
-    iFirstClause = p->pCnf2->pObj2Clause[Aig_ObjId(pObj)];
-    assert( nClauses > 0 );
-    pSat = Pdr_ManSolver(p, k);
-    vLits = Vec_IntAlloc( 16 );
-    for ( i = iFirstClause; i < iFirstClause + nClauses; i++ )
-    {
-        Vec_IntClear( vLits );
-        for ( pLit = p->pCnf2->pClauses[i]; pLit < p->pCnf2->pClauses[i+1]; pLit++ )
-        {
-            iVar = Pdr_ObjSatVar2( p, k, Aig_ManObj(p->pAig, lit_var(*pLit)) );
-            Vec_IntPush( vLits, toLitCond( iVar, lit_sign(*pLit) ) );
-        }
-        RetValue = sat_solver_addclause( pSat, Vec_IntArray(vLits), Vec_IntArray(vLits)+Vec_IntSize(vLits) );
-        assert( RetValue );
-    }
-    Vec_IntFree( vLits );
-    return iVarThis;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns SAT variable of the given object.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ObjSatVar( Pdr_Man_t * p, int k, Aig_Obj_t * pObj )
-{
-    if ( p->pPars->fMonoCnf )
-        return Pdr_ObjSatVar1( p, k, pObj );
-    else
-        return Pdr_ObjSatVar2( p, k, pObj );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns register number for the given SAT variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Pdr_ObjRegNum1( Pdr_Man_t * p, int k, int iSatVar )
-{
-    int RegId;
-    assert( iSatVar >= 0 );
-    // consider the case of auxiliary variable
-    if ( iSatVar >= p->pCnf1->nVars )
-        return -1;
-    // consider the case of register output
-    RegId = Vec_IntEntry( p->vVar2Reg, iSatVar );
-    assert( RegId >= 0 && RegId < Aig_ManRegNum(p->pAig) );
-    return RegId;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns register number for the given SAT variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Pdr_ObjRegNum2( Pdr_Man_t * p, int k, int iSatVar )
-{
-    Aig_Obj_t * pObj;
-    int ObjId;
-    Vec_Int_t * vVar2Ids = (Vec_Int_t *)Vec_PtrEntry(p->vVar2Ids, k);
-    assert( iSatVar > 0 && iSatVar < Vec_IntSize(vVar2Ids) );
-    ObjId = Vec_IntEntry( vVar2Ids, iSatVar );
-    if ( ObjId == -1 ) // activation variable
-        return -1;
-    pObj = Aig_ManObj( p->pAig, ObjId );
-    if ( Saig_ObjIsLi( p->pAig, pObj ) )
-        return Aig_ObjPioNum(pObj)-Saig_ManPoNum(p->pAig);
-    assert( 0 ); // should be called for register inputs only
-    return -1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns register number for the given SAT variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ObjRegNum( Pdr_Man_t * p, int k, int iSatVar )
-{
-    if ( p->pPars->fMonoCnf )
-        return Pdr_ObjRegNum1( p, k, iSatVar );
-    else
-        return Pdr_ObjRegNum2( p, k, iSatVar );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the index of unused SAT variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManFreeVar( Pdr_Man_t * p, int k )
-{
-    if ( p->pPars->fMonoCnf )
-        return sat_solver_nvars( Pdr_ManSolver(p, k) );
-    else
-    {
-        Vec_Int_t * vVar2Ids = (Vec_Int_t *)Vec_PtrEntry( p->vVar2Ids, k );
-        Vec_IntPush( vVar2Ids, -1 );
-        return Vec_IntSize( vVar2Ids ) - 1;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates SAT solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline sat_solver * Pdr_ManNewSolver1( sat_solver * pSat, Pdr_Man_t * p, int k, int fInit )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    assert( pSat );
-    if ( p->pCnf1 == NULL )
-    {
-        int nRegs = p->pAig->nRegs;
-        p->pAig->nRegs = Aig_ManPoNum(p->pAig);
-        p->pCnf1 = Cnf_Derive( p->pAig, Aig_ManPoNum(p->pAig) );
-        p->pAig->nRegs = nRegs;
-        assert( p->vVar2Reg == NULL );
-        p->vVar2Reg = Vec_IntStartFull( p->pCnf1->nVars );
-        Saig_ManForEachLi( p->pAig, pObj, i )
-            Vec_IntWriteEntry( p->vVar2Reg, Pdr_ObjSatVar(p, k, pObj), i );
-    }
-    pSat = (sat_solver *)Cnf_DataWriteIntoSolverInt( pSat, p->pCnf1, 1, fInit );
-    sat_solver_set_runtime_limit( pSat, p->timeToStop );
-    return pSat;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates SAT solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline sat_solver * Pdr_ManNewSolver2( sat_solver * pSat, Pdr_Man_t * p, int k, int fInit )
-{
-    Vec_Int_t * vVar2Ids;
-    int i, Entry;
-    assert( pSat );
-    if ( p->pCnf2 == NULL )
-    {
-        p->pCnf2     = Cnf_DeriveOther( p->pAig );
-        p->pvId2Vars = ABC_CALLOC( Vec_Int_t *, Aig_ManObjNumMax(p->pAig) );
-        p->vVar2Ids  = Vec_PtrAlloc( 256 );
-    }
-    // update the variable mapping
-    vVar2Ids = (Vec_Int_t *)Vec_PtrGetEntry( p->vVar2Ids, k );
-    if ( vVar2Ids == NULL )
-    {
-        vVar2Ids = Vec_IntAlloc( 500 );
-        Vec_PtrWriteEntry( p->vVar2Ids, k, vVar2Ids );
-    }
-    Vec_IntForEachEntry( vVar2Ids, Entry, i )
-    {
-        if ( Entry == -1 )
-            continue;
-        assert( Vec_IntEntry( p->pvId2Vars[Entry], k ) > 0 );
-        Vec_IntWriteEntry( p->pvId2Vars[Entry], k, 0 );
-    }
-    Vec_IntClear( vVar2Ids );
-    Vec_IntPush( vVar2Ids, -1 );
-    // start the SAT solver
-//    pSat = sat_solver_new();
-    sat_solver_setnvars( pSat, 500 );
-    sat_solver_set_runtime_limit( pSat, p->timeToStop );
-    return pSat;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates SAT solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-sat_solver * Pdr_ManNewSolver( sat_solver * pSat, Pdr_Man_t * p, int k, int fInit )
-{
-    assert( pSat != NULL );
-    if ( p->pPars->fMonoCnf )
-        return Pdr_ManNewSolver1( pSat, p, k, fInit );
-    else
-        return Pdr_ManNewSolver2( pSat, p, k, fInit );
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/pdr/pdrCore.c b/src/sat/pdr/pdrCore.c
deleted file mode 100644
index 025ada06..00000000
--- a/src/sat/pdr/pdrCore.c
+++ /dev/null
@@ -1,722 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrCore.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [Core procedures.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrCore.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "pdrInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the state could be blocked.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManSetDefaultParams( Pdr_Par_t * pPars )
-{
-    memset( pPars, 0, sizeof(Pdr_Par_t) );
-    pPars->iOutput       =      -1;  // zero-based output number
-    pPars->nRecycle      =     300;  // limit on vars for recycling
-    pPars->nFrameMax     =    5000;  // limit on number of timeframes
-    pPars->nTimeOut      =       0;  // timeout in seconds
-    pPars->nConfLimit    =  100000;  // limit on SAT solver conflicts
-    pPars->fTwoRounds    =       0;  // use two rounds for generalization
-    pPars->fMonoCnf      =       0;  // monolythic CNF
-    pPars->fDumpInv      =       0;  // dump inductive invariant
-    pPars->fShortest     =       0;  // forces bug traces to be shortest
-    pPars->fVerbose      =       0;  // verbose output
-    pPars->fVeryVerbose  =       0;  // very verbose output
-    pPars->iFrame        =      -1;  // explored up to this frame
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reduces clause using analyzeFinal.]
-
-  Description [Assumes that the SAT solver just terminated an UNSAT call.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_ManReduceClause( Pdr_Man_t * p, int k, Pdr_Set_t * pCube )
-{
-    Pdr_Set_t * pCubeMin;
-    Vec_Int_t * vLits;
-    int i, Entry, nCoreLits, * pCoreLits;
-    // get relevant SAT literals
-    nCoreLits = sat_solver_final(Pdr_ManSolver(p, k), &pCoreLits);
-    // translate them into register literals and remove auxiliary
-    vLits = Pdr_ManLitsToCube( p, k, pCoreLits, nCoreLits );
-    // skip if there is no improvement
-    if ( Vec_IntSize(vLits) == pCube->nLits )
-        return NULL;
-    assert( Vec_IntSize(vLits) < pCube->nLits );
-    // if the cube overlaps with init, add any literal
-    Vec_IntForEachEntry( vLits, Entry, i )
-        if ( lit_sign(Entry) == 0 ) // positive literal
-            break;
-    if ( i == Vec_IntSize(vLits) ) // only negative literals
-    {
-        // add the first positive literal
-        for ( i = 0; i < pCube->nLits; i++ )
-            if ( lit_sign(pCube->Lits[i]) == 0 ) // positive literal
-            {
-                Vec_IntPush( vLits, pCube->Lits[i] );
-                break;
-            }
-        assert( i < pCube->nLits );
-    }
-    // generate a starting cube
-    pCubeMin  = Pdr_SetCreateSubset( pCube, Vec_IntArray(vLits), Vec_IntSize(vLits) );
-    assert( !Pdr_SetIsInit(pCubeMin, -1) );
-/*
-    // make sure the cube works
-    {
-    int RetValue;
-    RetValue = Pdr_ManCheckCube( p, k, pCubeMin, NULL, 0 );
-    assert( RetValue );
-    }
-*/
-    return pCubeMin;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the state could be blocked.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManPushClauses( Pdr_Man_t * p )
-{
-    Pdr_Set_t * pTemp, * pCubeK, * pCubeK1;
-    Vec_Ptr_t * vArrayK, * vArrayK1;
-    int i, j, k, m, RetValue = 0, RetValue2, kMax = Vec_PtrSize(p->vSolvers)-1;
-    int Counter = 0;
-    int clk = clock();
-    Vec_VecForEachLevelStartStop( p->vClauses, vArrayK, k, 1, kMax )
-    {
-        Vec_PtrSort( vArrayK, (int (*)(void))Pdr_SetCompare );
-        vArrayK1 = Vec_VecEntry( p->vClauses, k+1 );
-        Vec_PtrForEachEntry( Pdr_Set_t *, vArrayK, pCubeK, j )
-        {
-            Counter++;
-
-            // remove cubes in the same frame that are contained by pCubeK
-            Vec_PtrForEachEntryStart( Pdr_Set_t *, vArrayK, pTemp, m, j+1 )
-            {
-                if ( !Pdr_SetContains( pTemp, pCubeK ) ) // pCubeK contains pTemp
-                    continue;
-                Pdr_SetDeref( pTemp );
-                Vec_PtrWriteEntry( vArrayK, m, Vec_PtrEntryLast(vArrayK) );
-                Vec_PtrPop(vArrayK);
-                m--;
-            }
-
-            // check if the clause can be moved to the next frame
-            RetValue2 = Pdr_ManCheckCube( p, k, pCubeK, NULL, 0 );
-            if ( RetValue2 == -1 )
-                return -1;
-            if ( !RetValue2 )
-                continue;
-
-            {
-                Pdr_Set_t * pCubeMin;
-                pCubeMin = Pdr_ManReduceClause( p, k, pCubeK );
-                if ( pCubeMin != NULL )
-                {
-//                printf( "%d ", pCubeK->nLits - pCubeMin->nLits );
-                    Pdr_SetDeref( pCubeK );
-                    pCubeK = pCubeMin;
-                }
-            }
-
-            // if it can be moved, add it to the next frame
-            Pdr_ManSolverAddClause( p, k+1, pCubeK );
-            // check if the clause subsumes others
-            Vec_PtrForEachEntry( Pdr_Set_t *, vArrayK1, pCubeK1, i )
-            {
-                if ( !Pdr_SetContains( pCubeK1, pCubeK ) ) // pCubeK contains pCubeK1
-                    continue;
-                Pdr_SetDeref( pCubeK1 );
-                Vec_PtrWriteEntry( vArrayK1, i, Vec_PtrEntryLast(vArrayK1) );
-                Vec_PtrPop(vArrayK1);
-                i--;
-            }
-            // add the last clause
-            Vec_PtrPush( vArrayK1, pCubeK );
-            Vec_PtrWriteEntry( vArrayK, j, Vec_PtrEntryLast(vArrayK) );
-            Vec_PtrPop(vArrayK);
-            j--;
-        }
-        if ( Vec_PtrSize(vArrayK) == 0 )
-            RetValue = 1;
-    }
-
-    // clean up the last one
-    vArrayK = Vec_VecEntry( p->vClauses, kMax );
-    Vec_PtrSort( vArrayK, (int (*)(void))Pdr_SetCompare );
-    Vec_PtrForEachEntry( Pdr_Set_t *, vArrayK, pCubeK, j )
-    {
-        // remove cubes in the same frame that are contained by pCubeK
-        Vec_PtrForEachEntryStart( Pdr_Set_t *, vArrayK, pTemp, m, j+1 )
-        {
-            if ( !Pdr_SetContains( pTemp, pCubeK ) ) // pCubeK contains pTemp
-                continue;
-/*
-            printf( "===\n" );
-            Pdr_SetPrint( stdout, pCubeK, Aig_ManRegNum(p->pAig), NULL );
-            printf( "\n" );
-            Pdr_SetPrint( stdout, pTemp, Aig_ManRegNum(p->pAig), NULL );
-            printf( "\n" );
-*/
-            Pdr_SetDeref( pTemp );
-            Vec_PtrWriteEntry( vArrayK, m, Vec_PtrEntryLast(vArrayK) );
-            Vec_PtrPop(vArrayK);
-            m--;
-        }
-    }
-    p->tPush += clock() - clk;
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the clause is contained in higher clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManCheckContainment( Pdr_Man_t * p, int k, Pdr_Set_t * pSet )
-{
-    Pdr_Set_t * pThis;
-    Vec_Ptr_t * vArrayK;
-    int i, j, kMax = Vec_PtrSize(p->vSolvers)-1;
-    Vec_VecForEachLevelStartStop( p->vClauses, vArrayK, i, k, kMax+1 )
-        Vec_PtrForEachEntry( Pdr_Set_t *, vArrayK, pThis, j )
-            if ( Pdr_SetContains( pSet, pThis ) )
-                return 1;
-    return 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Sorts literals by priority.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int * Pdr_ManSortByPriority( Pdr_Man_t * p, Pdr_Set_t * pCube )
-{
-    int * pPrios = Vec_IntArray(p->vPrio);
-    int * pArray = p->pOrder;
-    int temp, i, j, best_i, nSize = pCube->nLits;
-    // initialize variable order
-    for ( i = 0; i < nSize; i++ )
-        pArray[i] = i;
-    for ( i = 0; i < nSize-1; i++ )
-    {
-        best_i = i;
-        for ( j = i+1; j < nSize; j++ )
-//            if ( pArray[j] < pArray[best_i] )
-            if ( pPrios[pCube->Lits[pArray[j]]>>1] < pPrios[pCube->Lits[pArray[best_i]]>>1] )
-                best_i = j;
-        temp = pArray[i]; 
-        pArray[i] = pArray[best_i]; 
-        pArray[best_i] = temp;
-    }
-/*
-    for ( i = 0; i < pCube->nLits; i++ )
-        printf( "%2d : %5d    %5d  %5d\n", i, pArray[i], pCube->Lits[pArray[i]]>>1, pPrios[pCube->Lits[pArray[i]]>>1] );
-    printf( "\n" );
-*/
-    return pArray;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the state could be blocked.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManGeneralize( Pdr_Man_t * p, int k, Pdr_Set_t * pCube, Pdr_Set_t ** ppPred, Pdr_Set_t ** ppCubeMin )
-{
-    Pdr_Set_t * pCubeMin, * pCubeTmp = NULL;
-    int i, j, n, Lit, RetValue,  clk = clock();
-    int * pOrder;
-    // if there is no induction, return
-    *ppCubeMin = NULL;
-    RetValue = Pdr_ManCheckCube( p, k, pCube, ppPred, p->pPars->nConfLimit );
-    if ( RetValue == -1 )
-        return -1;
-    if ( RetValue == 0 )
-    {
-        p->tGeneral += clock() - clk;
-        return 0;
-    }
-
-    // reduce clause using assumptions
-//    pCubeMin = Pdr_SetDup( pCube );
-    pCubeMin = Pdr_ManReduceClause( p, k, pCube );
-    if ( pCubeMin == NULL )
-        pCubeMin = Pdr_SetDup( pCube );
-
-    // perform generalization
-    if ( !p->pPars->fSkipGeneral )
-    {
-        // sort literals by their occurences
-        pOrder = Pdr_ManSortByPriority( p, pCubeMin );
-        // try removing literals
-        for ( j = 0; j < pCubeMin->nLits; j++ )
-        {
-            // use ordering
-    //        i = j;
-            i = pOrder[j];
-
-            // check init state
-            assert( pCubeMin->Lits[i] != -1 );
-            if ( Pdr_SetIsInit(pCubeMin, i) )
-                continue;
-            // try removing this literal
-            Lit = pCubeMin->Lits[i]; pCubeMin->Lits[i] = -1; 
-            RetValue = Pdr_ManCheckCube( p, k, pCubeMin, NULL, p->pPars->nConfLimit );
-            if ( RetValue == -1 )
-            {
-                Pdr_SetDeref( pCubeMin );
-                return -1;
-            }
-            pCubeMin->Lits[i] = Lit;
-            if ( RetValue == 0 )
-                continue;
-
-            // remove j-th entry
-            for ( n = j; n < pCubeMin->nLits-1; n++ )
-                pOrder[n] = pOrder[n+1];
-            j--;
-
-            // success - update the cube
-            pCubeMin = Pdr_SetCreateFrom( pCubeTmp = pCubeMin, i );
-            Pdr_SetDeref( pCubeTmp );
-            assert( pCubeMin->nLits > 0 );
-            i--;
-
-            // get the ordering by decreasing priorit
-            pOrder = Pdr_ManSortByPriority( p, pCubeMin );
-        }
-
-        if ( p->pPars->fTwoRounds )
-        for ( j = 0; j < pCubeMin->nLits; j++ )
-        {
-            // use ordering
-    //        i = j;
-            i = pOrder[j];
-
-            // check init state
-            assert( pCubeMin->Lits[i] != -1 );
-            if ( Pdr_SetIsInit(pCubeMin, i) )
-                continue;
-            // try removing this literal
-            Lit = pCubeMin->Lits[i]; pCubeMin->Lits[i] = -1; 
-            RetValue = Pdr_ManCheckCube( p, k, pCubeMin, NULL, p->pPars->nConfLimit );
-            if ( RetValue == -1 )
-            {
-                Pdr_SetDeref( pCubeMin );
-                return -1;
-            }
-            pCubeMin->Lits[i] = Lit;
-            if ( RetValue == 0 )
-                continue;
-
-            // remove j-th entry
-            for ( n = j; n < pCubeMin->nLits-1; n++ )
-                pOrder[n] = pOrder[n+1];
-            j--;
-
-            // success - update the cube
-            pCubeMin = Pdr_SetCreateFrom( pCubeTmp = pCubeMin, i );
-            Pdr_SetDeref( pCubeTmp );
-            assert( pCubeMin->nLits > 0 );
-            i--;
-
-            // get the ordering by decreasing priorit
-            pOrder = Pdr_ManSortByPriority( p, pCubeMin );
-        }
-    }
-
-    assert( ppCubeMin != NULL );
-    *ppCubeMin = pCubeMin;
-    p->tGeneral += clock() - clk;
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the state could be blocked.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManBlockCube( Pdr_Man_t * p, Pdr_Set_t * pCube )
-{
-    Pdr_Obl_t * pThis;
-    Pdr_Set_t * pPred, * pCubeMin;
-    int i, k, RetValue, Prio = ABC_INFINITY, Counter = 0;
-    int kMax = Vec_PtrSize(p->vSolvers)-1, clk;
-    p->nBlocks++;
-    // create first proof obligation
-    assert( p->pQueue == NULL );
-    pThis = Pdr_OblStart( kMax, Prio--, pCube, NULL ); // consume ref
-    Pdr_QueuePush( p, pThis );
-    // try to solve it recursively
-    while ( !Pdr_QueueIsEmpty(p) )
-    {
-        Counter++;
-        pThis = Pdr_QueueHead( p );
-        if ( pThis->iFrame == 0 )
-            return 0; // SAT
-        pThis = Pdr_QueuePop( p );
-        assert( pThis->iFrame > 0 );
-        assert( !Pdr_SetIsInit(pThis->pState, -1) );
-
-        clk = clock();
-        if ( Pdr_ManCheckContainment( p, pThis->iFrame, pThis->pState ) )
-        {
-            p->tContain += clock() - clk;
-            Pdr_OblDeref( pThis );
-            continue;
-        }
-        p->tContain += clock() - clk;
-
-        // check if the cube is already contained
-        RetValue = Pdr_ManCheckCubeCs( p, pThis->iFrame, pThis->pState );
-        if ( RetValue == -1 ) // cube is blocked by clauses in this frame
-        {
-            Pdr_OblDeref( pThis );
-            return -1;
-        }
-        if ( RetValue ) // cube is blocked by clauses in this frame
-        {
-            Pdr_OblDeref( pThis );
-            continue;
-        }
-
-        // check if the cube holds with relative induction
-        pCubeMin = NULL;
-        RetValue = Pdr_ManGeneralize( p, pThis->iFrame-1, pThis->pState, &pPred, &pCubeMin );
-        if ( RetValue == -1 )
-        {
-            Pdr_OblDeref( pThis );
-            return -1;
-        }
-        if ( RetValue ) // cube is blocked inductively in this frame
-        {
-            assert( pCubeMin != NULL );
-
-            // k is the last frame where pCubeMin holds
-            k = pThis->iFrame;
-
-            // check other frames
-            assert( pPred == NULL );
-            for ( k = pThis->iFrame; k < kMax; k++ )
-                if ( !Pdr_ManCheckCube( p, k, pCubeMin, NULL, 0 ) )
-                    break;
-
-            // add new clause
-            if ( p->pPars->fVeryVerbose )
-            {
-            printf( "Adding cube " );
-            Pdr_SetPrint( stdout, pCubeMin, Aig_ManRegNum(p->pAig), NULL );
-            printf( " to frame %d.\n", k );
-            }
-            // set priority flops
-            for ( i = 0; i < pCubeMin->nLits; i++ )
-            {
-                assert( pCubeMin->Lits[i] >= 0 );
-                assert( (pCubeMin->Lits[i] / 2) < Aig_ManRegNum(p->pAig) );
-                Vec_IntAddToEntry( p->vPrio, pCubeMin->Lits[i] / 2, 1 );
-            }
-
-            Vec_VecPush( p->vClauses, k, pCubeMin );   // consume ref
-            p->nCubes++;
-            // add clause
-            for ( i = 1; i <= k; i++ )
-                Pdr_ManSolverAddClause( p, i, pCubeMin );
-            // schedule proof obligation
-            if ( k < kMax && !p->pPars->fShortest )
-            {
-                pThis->iFrame = k+1;
-                pThis->prio   = Prio--;
-                Pdr_QueuePush( p, pThis );
-            }
-            else
-            {
-                Pdr_OblDeref( pThis );
-            }
-        }
-        else
-        {
-            assert( pCubeMin == NULL );
-            assert( pPred != NULL );
-            pThis->prio = Prio--;
-            Pdr_QueuePush( p, pThis );
-
-            pThis = Pdr_OblStart( pThis->iFrame-1, Prio--, pPred, Pdr_OblRef(pThis) );
-            Pdr_QueuePush( p, pThis );
-        }
-
-        // check the timeout
-        if ( p->timeToStop && time(NULL) > p->timeToStop )
-            return -1;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManSolveInt( Pdr_Man_t * p )
-{
-    int fPrintClauses = 0;
-    Pdr_Set_t * pCube;
-    int k, RetValue = -1;
-    int clkTotal = clock();
-    int clkStart = clock();
-    p->timeToStop = p->pPars->nTimeOut ? time(NULL) + p->pPars->nTimeOut : 0;
-    assert( Vec_PtrSize(p->vSolvers) == 0 );
-    // create the first timeframe
-    Pdr_ManCreateSolver( p, (k = 0) );
-    while ( 1 )
-    {
-        p->nFrames = k;
-        assert( k == Vec_PtrSize(p->vSolvers)-1 );
-        RetValue = Pdr_ManCheckCube( p, k, NULL, &pCube, p->pPars->nConfLimit );
-        if ( RetValue == -1 )
-        {
-            if ( p->pPars->fVerbose ) 
-                Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-            printf( "Reached conflict limit (%d).\n",  p->pPars->nConfLimit );
-            p->pPars->iFrame = k;
-            return -1;
-        }
-        if ( RetValue == 0 )
-        {
-            RetValue = Pdr_ManBlockCube( p, pCube );
-            if ( RetValue == -1 )
-            {
-                if ( p->pPars->fVerbose ) 
-                    Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-                printf( "Reached conflict limit (%d).\n",  p->pPars->nConfLimit );
-                p->pPars->iFrame = k;
-                return -1;
-            }
-            if ( RetValue == 0 )
-            {
-                if ( fPrintClauses )
-                {
-                    printf( "*** Clauses after frame %d:\n", k );
-                    Pdr_ManPrintClauses( p, 0 );
-                }
-                if ( p->pPars->fVerbose ) 
-                    Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-                p->pPars->iFrame = k;
-                return 0; // SAT
-            }
-        }
-        else
-        {
-            if ( p->pPars->fVerbose ) 
-                Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-            // open a new timeframe
-            assert( pCube == NULL );
-            Pdr_ManSetPropertyOutput( p, k );
-            Pdr_ManCreateSolver( p, ++k );
-            if ( fPrintClauses )
-            {
-                printf( "*** Clauses after frame %d:\n", k );
-                Pdr_ManPrintClauses( p, 0 );
-            }
-            // push clauses into this timeframe
-            RetValue = Pdr_ManPushClauses( p );
-            if ( RetValue == -1 )
-            {
-                if ( p->pPars->fVerbose ) 
-                    Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-                printf( "Reached conflict limit (%d).\n",  p->pPars->nConfLimit );
-                p->pPars->iFrame = k;
-                return -1;
-            }
-            if ( RetValue )
-            {
-                if ( p->pPars->fVerbose ) 
-                    Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-                Pdr_ManReportInvariant( p );
-                Pdr_ManVerifyInvariant( p );
-                p->pPars->iFrame = k;
-                return 1; // UNSAT
-            }
-            if ( p->pPars->fVerbose ) 
-                Pdr_ManPrintProgress( p, 0, clock() - clkStart );
-            clkStart = clock();
-        }
-
-        // check the timeout
-        if ( p->timeToStop && time(NULL) > p->timeToStop )
-        {
-            if ( fPrintClauses )
-            {
-                printf( "*** Clauses after frame %d:\n", k );
-                Pdr_ManPrintClauses( p, 0 );
-            }
-            if ( p->pPars->fVerbose ) 
-                Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-            printf( "Reached timeout (%d seconds).\n",  p->pPars->nTimeOut );
-            p->pPars->iFrame = k;
-            return -1;
-        }
-        if ( p->pPars->nFrameMax && k >= p->pPars->nFrameMax )
-        {
-            if ( p->pPars->fVerbose ) 
-                Pdr_ManPrintProgress( p, 1, clock() - clkStart );
-            printf( "Reached limit on the number of timeframes (%d).\n", p->pPars->nFrameMax );
-            p->pPars->iFrame = k;
-            return -1;
-        } 
-    }
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManSolve_( Aig_Man_t * pAig, Pdr_Par_t * pPars, Vec_Int_t ** pvPrioInit, Abc_Cex_t ** ppCex )
-{
-    Pdr_Man_t * p;
-    int RetValue;
-    int clk = clock();
-    p = Pdr_ManStart( pAig, pPars, pvPrioInit? *pvPrioInit : NULL );
-    RetValue = Pdr_ManSolveInt( p );
-    *ppCex = RetValue ? NULL : Pdr_ManDeriveCex( p );
-    if ( p->pPars->fDumpInv )
-        Pdr_ManDumpClauses( p, (char *)"inv.pla", RetValue==1 );
-
-//    if ( *ppCex && pPars->fVerbose )
-//        printf( "Found counter-example in frame %d after exploring %d frames.\n", 
-//            (*ppCex)->iFrame, p->nFrames );
-    p->tTotal += clock() - clk;
-    if ( pvPrioInit )
-    {
-        *pvPrioInit = p->vPrio;
-        p->vPrio = NULL;
-    }
-    Pdr_ManStop( p );
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManSolve( Aig_Man_t * pAig, Pdr_Par_t * pPars, Abc_Cex_t ** ppCex )
-{
-/*
-    Vec_Int_t * vPrioInit = NULL;
-    int RetValue, nTimeOut;
-    if ( pPars->nTimeOut > 0 )
-        return Pdr_ManSolve_( pAig, pPars, NULL, ppCex );
-    nTimeOut = pPars->nTimeOut;
-    pPars->nTimeOut = 10;
-    RetValue = Pdr_ManSolve_( pAig, pPars, &vPrioInit, ppCex );
-    pPars->nTimeOut = nTimeOut;
-    if ( RetValue == -1 )
-        RetValue = Pdr_ManSolve_( pAig, pPars, &vPrioInit, ppCex );
-    Vec_IntFree( vPrioInit );
-    return RetValue;
-*/
-    return Pdr_ManSolve_( pAig, pPars, NULL, ppCex );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/pdr/pdrInt.h b/src/sat/pdr/pdrInt.h
deleted file mode 100644
index f49ee7d0..00000000
--- a/src/sat/pdr/pdrInt.h
+++ /dev/null
@@ -1,198 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrInt.h]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [Internal declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrInt.h,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
- 
-#ifndef __PDR_INT_H__
-#define __PDR_INT_H__
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-#include "saig.h"
-#include "cnf.h"
-#include "satSolver.h"
-#include "pdr.h" 
-
-ABC_NAMESPACE_HEADER_START
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-             
-////////////////////////////////////////////////////////////////////////
-///                         BASIC TYPES                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Pdr_Set_t_ Pdr_Set_t;
-struct Pdr_Set_t_
-{
-    word        Sign;      // signature
-    int         nRefs;     // ref counter
-    int         nTotal;    // total literals
-    int         nLits;     // num flop literals
-    int         Lits[0];
-};
-
-typedef struct Pdr_Obl_t_ Pdr_Obl_t;
-struct Pdr_Obl_t_
-{
-    int         iFrame;    // time frame
-    int         prio;      // priority
-    int         nRefs;     // reference counter
-    Pdr_Set_t * pState;    // state cube
-    Pdr_Obl_t * pNext;     // next one
-    Pdr_Obl_t * pLink;     // queue link
-};
-
-typedef struct Pdr_Man_t_ Pdr_Man_t;
-struct Pdr_Man_t_
-{
-    // input problem
-    Pdr_Par_t * pPars;     // parameters
-    Aig_Man_t * pAig;      // user's AIG
-    // static CNF representation
-    Cnf_Dat_t * pCnf1;     // CNF for this AIG
-    Vec_Int_t * vVar2Reg;  // mapping of SAT var into registers
-    // dynamic CNF representation
-    Cnf_Dat_t * pCnf2;     // CNF for this AIG
-    Vec_Int_t** pvId2Vars; // for each used ObjId, maps frame into SAT var
-    Vec_Ptr_t * vVar2Ids;  // for each used frame, maps SAT var into ObjId
-    // data representation
-    Vec_Ptr_t * vSolvers;  // SAT solvers
-    Vec_Vec_t * vClauses;  // clauses by timeframe
-    Pdr_Obl_t * pQueue;    // proof obligations
-    int *       pOrder;    // ordering of the lits
-    Vec_Int_t * vActVars;  // the counter of activation variables
-    // internal use
-    Vec_Int_t * vPrio;     // priority flops
-    Vec_Int_t * vLits;     // array of literals
-    Vec_Int_t * vCiObjs;   // cone leaves
-    Vec_Int_t * vCoObjs;   // cone roots
-    Vec_Int_t * vCiVals;   // cone leaf values
-    Vec_Int_t * vCoVals;   // cone root values
-    Vec_Int_t * vNodes;    // cone nodes
-    Vec_Int_t * vUndo;     // cone undos
-    Vec_Int_t * vVisits;   // intermediate
-    Vec_Int_t * vCi2Rem;   // CIs to be removed
-    Vec_Int_t * vRes;      // final result
-    Vec_Int_t * vSuppLits; // support literals
-    Pdr_Set_t * pCubeJust; // justification
-    // statistics
-    int         nBlocks;   // the number of times blockState was called
-    int         nObligs;   // the number of proof obligations derived
-    int         nCubes;    // the number of cubes derived
-    int         nCalls;    // the number of SAT calls
-    int         nCallsS;   // the number of SAT calls (sat)
-    int         nCallsU;   // the number of SAT calls (unsat)
-    int         nStarts;   // the number of SAT solver restarts
-    int         nFrames;   // frames explored
-    int         nCasesSS;
-    int         nCasesSU;
-    int         nCasesUS;
-    int         nCasesUU;
-    // runtime
-    int         timeStart;
-    int         timeToStop;
-    // time stats
-    int         tSat;
-    int         tSatSat;
-    int         tSatUnsat;
-    int         tGeneral;
-    int         tPush;
-    int         tTsim;
-    int         tContain;
-    int         tCnf;
-    int         tTotal;
-};
-
-////////////////////////////////////////////////////////////////////////
-///                      MACRO DEFINITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-static inline sat_solver * Pdr_ManSolver( Pdr_Man_t * p, int k )  { return (sat_solver *)Vec_PtrEntry(p->vSolvers, k); }
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DECLARATIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== pdrCex.c ==========================================================*/
-extern Abc_Cex_t *     Pdr_ManDeriveCex( Pdr_Man_t * p );
-/*=== pdrCnf.c ==========================================================*/
-extern int             Pdr_ObjSatVar( Pdr_Man_t * p, int k, Aig_Obj_t * pObj );
-extern int             Pdr_ObjRegNum( Pdr_Man_t * p, int k, int iSatVar );
-extern int             Pdr_ManFreeVar( Pdr_Man_t * p, int k );
-extern sat_solver *    Pdr_ManNewSolver( sat_solver * pSat, Pdr_Man_t * p, int k, int fInit );
-/*=== pdrCore.c ==========================================================*/
-extern int             Pdr_ManCheckContainment( Pdr_Man_t * p, int k, Pdr_Set_t * pSet );
-/*=== pdrInv.c ==========================================================*/
-extern void            Pdr_ManPrintProgress( Pdr_Man_t * p, int fClose, int Time );
-extern void            Pdr_ManPrintClauses( Pdr_Man_t * p, int kStart );
-extern void            Pdr_ManDumpClauses( Pdr_Man_t * p, char * pFileName, int fProved );
-extern void            Pdr_ManReportInvariant( Pdr_Man_t * p );
-extern void            Pdr_ManVerifyInvariant( Pdr_Man_t * p );
-/*=== pdrMan.c ==========================================================*/
-extern Pdr_Man_t *     Pdr_ManStart( Aig_Man_t * pAig, Pdr_Par_t * pPars, Vec_Int_t * vPrioInit );
-extern void            Pdr_ManStop( Pdr_Man_t * p );
-extern Abc_Cex_t *     Pdr_ManDeriveCex( Pdr_Man_t * p );
-/*=== pdrSat.c ==========================================================*/
-extern sat_solver *    Pdr_ManCreateSolver( Pdr_Man_t * p, int k );
-extern sat_solver *    Pdr_ManFetchSolver( Pdr_Man_t * p, int k );
-extern void            Pdr_ManSetPropertyOutput( Pdr_Man_t * p, int k );
-extern Vec_Int_t *     Pdr_ManCubeToLits( Pdr_Man_t * p, int k, Pdr_Set_t * pCube, int fCompl, int fNext );
-extern Vec_Int_t *     Pdr_ManLitsToCube( Pdr_Man_t * p, int k, int * pArray, int nArray );
-extern void            Pdr_ManSolverAddClause( Pdr_Man_t * p, int k, Pdr_Set_t * pCube );
-extern void            Pdr_ManCollectValues( Pdr_Man_t * p, int k, Vec_Int_t * vObjIds, Vec_Int_t * vValues );
-extern int             Pdr_ManCheckCubeCs( Pdr_Man_t * p, int k, Pdr_Set_t * pCube );
-extern int             Pdr_ManCheckCube( Pdr_Man_t * p, int k, Pdr_Set_t * pCube, Pdr_Set_t ** ppPred, int nConfLimit );
-/*=== pdrTsim.c ==========================================================*/
-extern Pdr_Set_t *     Pdr_ManTernarySim( Pdr_Man_t * p, int k, Pdr_Set_t * pCube );
-/*=== pdrUtil.c ==========================================================*/
-extern Pdr_Set_t *     Pdr_SetAlloc( int nSize );
-extern Pdr_Set_t *     Pdr_SetCreate( Vec_Int_t * vLits, Vec_Int_t * vPiLits );
-extern Pdr_Set_t *     Pdr_SetCreateFrom( Pdr_Set_t * pSet, int iRemove );
-extern Pdr_Set_t *     Pdr_SetCreateSubset( Pdr_Set_t * pSet, int * pLits, int nLits );
-extern Pdr_Set_t *     Pdr_SetDup( Pdr_Set_t * pSet );
-extern Pdr_Set_t *     Pdr_SetRef( Pdr_Set_t * p );
-extern void            Pdr_SetDeref( Pdr_Set_t * p );
-extern int             Pdr_SetContains( Pdr_Set_t * pOld, Pdr_Set_t * pNew );
-extern int             Pdr_SetContainsSimple( Pdr_Set_t * pOld, Pdr_Set_t * pNew );
-extern int             Pdr_SetIsInit( Pdr_Set_t * p, int iRemove );
-extern void            Pdr_SetPrint( FILE * pFile, Pdr_Set_t * p, int nRegs, Vec_Int_t * vFlopCounts );
-extern int             Pdr_SetCompare( Pdr_Set_t ** pp1, Pdr_Set_t ** pp2 );
-extern Pdr_Obl_t *     Pdr_OblStart( int k, int prio, Pdr_Set_t * pState, Pdr_Obl_t * pNext );
-extern Pdr_Obl_t *     Pdr_OblRef( Pdr_Obl_t * p );
-extern void            Pdr_OblDeref( Pdr_Obl_t * p );
-extern int             Pdr_QueueIsEmpty( Pdr_Man_t * p );
-extern Pdr_Obl_t *     Pdr_QueueHead( Pdr_Man_t * p );
-extern Pdr_Obl_t *     Pdr_QueuePop( Pdr_Man_t * p );
-extern void            Pdr_QueuePush( Pdr_Man_t * p, Pdr_Obl_t * pObl );
-extern void            Pdr_QueuePrint( Pdr_Man_t * p );
-extern void            Pdr_QueueStop( Pdr_Man_t * p );
-extern int             Pdr_ManCubeJust( Pdr_Man_t * p, int k, Pdr_Set_t * pCube );
-
-ABC_NAMESPACE_HEADER_END
-
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/sat/pdr/pdrInv.c b/src/sat/pdr/pdrInv.c
deleted file mode 100644
index 2f630e28..00000000
--- a/src/sat/pdr/pdrInv.c
+++ /dev/null
@@ -1,376 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrInv.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [Invariant computation, printing, verification.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrInv.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "abc.h"  // for Abc_NtkCollectCioNames()
-#include "main.h" // for Abc_FrameReadGlobalFrame()
-
-#include "pdrInt.h"
-#include "extra.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManPrintProgress( Pdr_Man_t * p, int fClose, int Time )
-{
-    static int PastSize;
-    Vec_Ptr_t * vVec;
-    int i, ThisSize, Length, LengthStart;
-    if ( Vec_PtrSize(p->vSolvers) < 2 )
-        return;
-    // count the total length of the printout
-    Length = 0;
-    Vec_VecForEachLevel( p->vClauses, vVec, i )
-        Length += 1 + Extra_Base10Log(Vec_PtrSize(vVec)+1);
-    // determine the starting point
-    LengthStart = ABC_MAX( 0, Length - 70 );
-    printf( "%3d :", Vec_PtrSize(p->vSolvers)-1 );
-    ThisSize = 6;
-    if ( LengthStart > 0 )
-    {
-        printf( " ..." );
-        ThisSize += 4;
-    }
-    Length = 0;
-    Vec_VecForEachLevel( p->vClauses, vVec, i )
-    {
-        if ( Length < LengthStart )
-        {
-            Length += 1 + Extra_Base10Log(Vec_PtrSize(vVec)+1);
-            continue;
-        }
-        printf( " %d", Vec_PtrSize(vVec) );
-        Length += 1 + Extra_Base10Log(Vec_PtrSize(vVec)+1);
-        ThisSize += 1 + Extra_Base10Log(Vec_PtrSize(vVec)+1);
-    }
-    if ( fClose )
-    {
-        for ( i = 0; i < PastSize - ThisSize; i++ )
-            printf( " " );
-        printf( "\n" );
-    }
-    else
-    {
-        printf( "\r" );
-        PastSize = ThisSize;
-    }
-//    printf(" %.2f sec", (float)(Time)/(float)(CLOCKS_PER_SEC));
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts how many times each flop appears in the set of cubes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Pdr_ManCountFlops( Pdr_Man_t * p, Vec_Ptr_t * vCubes )
-{
-    Vec_Int_t * vFlopCount;
-    Pdr_Set_t * pCube;
-    int i, n;
-    vFlopCount = Vec_IntStart( Aig_ManRegNum(p->pAig) );
-    Vec_PtrForEachEntry( Pdr_Set_t *, vCubes, pCube, i )
-        for ( n = 0; n < pCube->nLits; n++ )
-        {
-            assert( pCube->Lits[n] >= 0 && pCube->Lits[n] < 2*Aig_ManRegNum(p->pAig) );
-            Vec_IntAddToEntry( vFlopCount, pCube->Lits[n] >> 1, 1 );
-        }
-    return vFlopCount;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManFindInvariantStart( Pdr_Man_t * p )
-{
-    Vec_Ptr_t * vArrayK;
-    int k, kMax = Vec_PtrSize(p->vSolvers)-1;
-    Vec_VecForEachLevelStartStop( p->vClauses, vArrayK, k, 1, kMax+1 )
-        if ( Vec_PtrSize(vArrayK) == 0 )
-            return k;
-//    return -1;
-    // if there is no starting point (as in case of SAT or undecided), return the last frame
-//    printf( "The last timeframe contains %d clauses.\n", Vec_PtrSize(Vec_VecEntry(p->vClauses, kMax)) );
-    return kMax;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of variables used in the clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Pdr_ManCollectCubes( Pdr_Man_t * p, int kStart )
-{
-    Vec_Ptr_t * vResult;
-    Vec_Ptr_t * vArrayK;
-    Pdr_Set_t * pSet;
-    int i, j;
-    vResult = Vec_PtrAlloc( 100 );
-    Vec_VecForEachLevelStart( p->vClauses, vArrayK, i, kStart )
-        Vec_PtrForEachEntry( Pdr_Set_t *, vArrayK, pSet, j )
-            Vec_PtrPush( vResult, pSet );
-    return vResult;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of variables used in the clauses.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManCountVariables( Pdr_Man_t * p, int kStart )
-{
-    Vec_Int_t * vFlopCounts;
-    Vec_Ptr_t * vCubes;
-    int i, Entry, Counter = 0;
-    vCubes = Pdr_ManCollectCubes( p, kStart );
-    vFlopCounts = Pdr_ManCountFlops( p, vCubes );
-    Vec_IntForEachEntry( vFlopCounts, Entry, i )
-        Counter += (Entry > 0);
-    Vec_IntFreeP( &vFlopCounts );
-    Vec_PtrFree( vCubes );
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManPrintClauses( Pdr_Man_t * p, int kStart )
-{
-    Vec_Ptr_t * vArrayK;
-    Pdr_Set_t * pCube;
-    int i, k, Counter = 0;
-    Vec_VecForEachLevelStart( p->vClauses, vArrayK, k, kStart )
-    {
-        Vec_PtrSort( vArrayK, (int (*)(void))Pdr_SetCompare );
-        Vec_PtrForEachEntry( Pdr_Set_t *, vArrayK, pCube, i )
-        {
-            printf( "C=%4d. F=%4d ", Counter++, k );
-            Pdr_SetPrint( stdout, pCube, Aig_ManRegNum(p->pAig), NULL );  
-            printf( "\n" ); 
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     [] 
-
-***********************************************************************/
-void Pdr_ManDumpClauses( Pdr_Man_t * p, char * pFileName, int fProved )
-{
-    int fUseSupp = 1;
-    FILE * pFile;
-    Vec_Int_t * vFlopCounts;
-    Vec_Ptr_t * vCubes;
-    Pdr_Set_t * pCube;
-    char ** pNamesCi;
-    int i, kStart;
-    // create file
-    pFile = fopen( pFileName, "w" );
-    if ( pFile == NULL )
-    {
-        printf( "Cannot open file \"%s\" for writing invariant.\n", pFileName );
-        return;
-    } 
-    // collect cubes
-    kStart = Pdr_ManFindInvariantStart( p );
-    vCubes = Pdr_ManCollectCubes( p, kStart );
-    Vec_PtrSort( vCubes, (int (*)(void))Pdr_SetCompare );
-    // collect variable appearances
-    vFlopCounts = fUseSupp ? Pdr_ManCountFlops( p, vCubes ) : NULL; 
-    // output the header
-    if ( fProved )
-        fprintf( pFile, "# Inductive invariant for \"%s\"\n", p->pAig->pName );
-    else
-        fprintf( pFile, "# Clauses of the last timeframe for \"%s\"\n", p->pAig->pName );
-    fprintf( pFile, "# generated by PDR in ABC on %s\n", Aig_TimeStamp() );
-    fprintf( pFile, ".i %d\n", fUseSupp ? Pdr_ManCountVariables(p, kStart) : Aig_ManRegNum(p->pAig) );
-    fprintf( pFile, ".o 1\n" );
-    fprintf( pFile, ".p %d\n", Vec_PtrSize(vCubes) );
-    // output flop names
-    pNamesCi = Abc_NtkCollectCioNames( Abc_FrameReadNtk( Abc_FrameReadGlobalFrame() ), 0 );
-    if ( pNamesCi )
-    {
-        fprintf( pFile, ".ilb" );
-        for ( i = 0; i < Aig_ManRegNum(p->pAig); i++ )
-            if ( !fUseSupp || Vec_IntEntry( vFlopCounts, i ) )
-                fprintf( pFile, " %s", pNamesCi[Saig_ManPiNum(p->pAig) + i] );
-        fprintf( pFile, "\n" );
-        ABC_FREE( pNamesCi );
-        fprintf( pFile, ".ob inv\n" );
-    }
-    // output cubes
-    Vec_PtrForEachEntry( Pdr_Set_t *, vCubes, pCube, i )
-    {
-        Pdr_SetPrint( pFile, pCube, Aig_ManRegNum(p->pAig), vFlopCounts );  
-        fprintf( pFile, " 1\n" ); 
-    }
-    fprintf( pFile, ".e\n\n" );
-    fclose( pFile );
-    Vec_IntFreeP( &vFlopCounts );
-    Vec_PtrFree( vCubes );
-    if ( fProved )
-        printf( "Inductive invariant was written into file \"%s\".\n", pFileName );
-    else
-        printf( "Clauses of the last timeframe were written into file \"%s\".\n", pFileName );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManReportInvariant( Pdr_Man_t * p )
-{
-    Vec_Ptr_t * vCubes;
-    int kStart = Pdr_ManFindInvariantStart( p );
-    vCubes = Pdr_ManCollectCubes( p, kStart );
-    printf( "Invariant F[%d] : %d clauses with %d flops (out of %d)\n", 
-        kStart, Vec_PtrSize(vCubes), Pdr_ManCountVariables(p, kStart), Aig_ManRegNum(p->pAig) );
-    Vec_PtrFree( vCubes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManVerifyInvariant( Pdr_Man_t * p )
-{
-    sat_solver * pSat;
-    Vec_Int_t * vLits;
-    Vec_Ptr_t * vCubes;
-    Pdr_Set_t * pCube;
-    int i, kStart, kThis, RetValue, Counter = 0, clk = clock();
-    // collect cubes used in the inductive invariant
-    kStart = Pdr_ManFindInvariantStart( p );
-    vCubes = Pdr_ManCollectCubes( p, kStart );
-    // create solver with the cubes
-    kThis = Vec_PtrSize(p->vSolvers);
-    pSat  = Pdr_ManCreateSolver( p, kThis );
-    // add the property output
-    Pdr_ManSetPropertyOutput( p, kThis );
-    // add the clauses
-    Vec_PtrForEachEntry( Pdr_Set_t *, vCubes, pCube, i )
-    {
-        vLits = Pdr_ManCubeToLits( p, kThis, pCube, 1, 0 );
-        RetValue = sat_solver_addclause( pSat, Vec_IntArray(vLits), Vec_IntArray(vLits) + Vec_IntSize(vLits) );
-        assert( RetValue );
-        sat_solver_compress( pSat );
-    }
-    // check each clause
-    Vec_PtrForEachEntry( Pdr_Set_t *, vCubes, pCube, i )
-    {
-        vLits = Pdr_ManCubeToLits( p, kThis, pCube, 0, 1 );
-        RetValue = sat_solver_solve( pSat, Vec_IntArray(vLits), Vec_IntArray(vLits) + Vec_IntSize(vLits), 0, 0, 0, 0 );
-        if ( RetValue != l_False )
-        {
-            printf( "Verification of clause %d failed.\n", i );
-            Counter++;
-        }
-    }
-    if ( Counter )
-        printf( "Verification of %d clauses has failed.\n", Counter );
-    else
-    {
-        printf( "Verification of invariant with %d clauses was successful.  ", Vec_PtrSize(vCubes) );
-        Abc_PrintTime( 1, "Time", clock() - clk );
-    }
-//    sat_solver_delete( pSat );
-    Vec_PtrFree( vCubes );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/pdr/pdrMan.c b/src/sat/pdr/pdrMan.c
deleted file mode 100644
index 95a38efb..00000000
--- a/src/sat/pdr/pdrMan.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrMan.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [Manager procedures.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrMan.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "pdrInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Creates manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Man_t * Pdr_ManStart( Aig_Man_t * pAig, Pdr_Par_t * pPars, Vec_Int_t * vPrioInit )
-{
-    Pdr_Man_t * p;
-    p = ABC_CALLOC( Pdr_Man_t, 1 );
-    p->pPars    = pPars;
-    p->pAig     = pAig;
-    p->vSolvers = Vec_PtrAlloc( 0 );
-    p->vClauses = Vec_VecAlloc( 0 );
-    p->pQueue   = NULL;
-    p->pOrder   = ABC_ALLOC( int, Aig_ManRegNum(pAig) );
-    p->vActVars = Vec_IntAlloc( 256 );
-    // internal use
-    p->vPrio    = vPrioInit ? vPrioInit : Vec_IntStart( Aig_ManRegNum(pAig) );  // priority flops
-    p->vLits    = Vec_IntAlloc( 100 );  // array of literals
-    p->vCiObjs  = Vec_IntAlloc( 100 );  // cone leaves
-    p->vCoObjs  = Vec_IntAlloc( 100 );  // cone roots
-    p->vCiVals  = Vec_IntAlloc( 100 );  // cone leaf values
-    p->vCoVals  = Vec_IntAlloc( 100 );  // cone root values
-    p->vNodes   = Vec_IntAlloc( 100 );  // cone nodes
-    p->vUndo    = Vec_IntAlloc( 100 );  // cone undos
-    p->vVisits  = Vec_IntAlloc( 100 );  // intermediate
-    p->vCi2Rem  = Vec_IntAlloc( 100 );  // CIs to be removed
-    p->vRes     = Vec_IntAlloc( 100 );  // final result
-    p->vSuppLits= Vec_IntAlloc( 100 );  // support literals
-    p->pCubeJust= Pdr_SetAlloc( Saig_ManRegNum(pAig) );
-    // additional AIG data-members
-    if ( pAig->pFanData == NULL )
-        Aig_ManFanoutStart( pAig );
-    if ( pAig->pTerSimData == NULL )
-        pAig->pTerSimData = ABC_CALLOC( unsigned, 1 + (Aig_ManObjNumMax(pAig) / 16) );
-    p->timeStart = clock();
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Frees manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManStop( Pdr_Man_t * p )
-{
-    Pdr_Set_t * pCla;
-    sat_solver * pSat;
-    int i, k;
-    Aig_ManCleanMarkAB( p->pAig );
-    if ( p->pPars->fVerbose ) 
-    {
-        printf( "Block =%5d  Oblig =%6d  Clause =%6d  Call =%6d (sat=%.1f%%)  Start =%4d\n", 
-            p->nBlocks, p->nObligs, p->nCubes, p->nCalls, 100.0 * p->nCallsS / p->nCalls, p->nStarts );
-        ABC_PRTP( "SAT solving", p->tSat,       p->tTotal );
-        ABC_PRTP( "  unsat    ", p->tSatUnsat,  p->tTotal );
-        ABC_PRTP( "  sat      ", p->tSatSat,    p->tTotal );
-        ABC_PRTP( "Generalize ", p->tGeneral,   p->tTotal );
-        ABC_PRTP( "Push clause", p->tPush,      p->tTotal );
-        ABC_PRTP( "Ternary sim", p->tTsim,      p->tTotal );
-        ABC_PRTP( "Containment", p->tContain,   p->tTotal );
-        ABC_PRTP( "CNF compute", p->tCnf,       p->tTotal );
-        ABC_PRTP( "TOTAL      ", p->tTotal,     p->tTotal );
-    }
-//    printf( "SS =%6d. SU =%6d. US =%6d. UU =%6d.\n", p->nCasesSS, p->nCasesSU, p->nCasesUS, p->nCasesUU );
-    Vec_PtrForEachEntry( sat_solver *, p->vSolvers, pSat, i )
-        sat_solver_delete( pSat );
-    Vec_PtrFree( p->vSolvers );
-    Vec_VecForEachEntry( Pdr_Set_t *, p->vClauses, pCla, i, k )
-        Pdr_SetDeref( pCla );
-    Vec_VecFree( p->vClauses );
-    Pdr_QueueStop( p );
-    ABC_FREE( p->pOrder );
-    Vec_IntFree( p->vActVars );
-    // static CNF
-    Cnf_DataFree( p->pCnf1 );
-    Vec_IntFreeP( &p->vVar2Reg );
-    // dynamic CNF
-    Cnf_DataFree( p->pCnf2 );
-    if ( p->pvId2Vars )
-    for ( i = 0; i < Aig_ManObjNumMax(p->pAig); i++ )
-        Vec_IntFreeP( &p->pvId2Vars[i] );
-    ABC_FREE( p->pvId2Vars );
-    Vec_VecFreeP( (Vec_Vec_t **)&p->vVar2Ids );
-    // internal use
-    Vec_IntFreeP( &p->vPrio   );  // priority flops
-    Vec_IntFree( p->vLits     );  // array of literals
-    Vec_IntFree( p->vCiObjs   );  // cone leaves
-    Vec_IntFree( p->vCoObjs   );  // cone roots
-    Vec_IntFree( p->vCiVals   );  // cone leaf values
-    Vec_IntFree( p->vCoVals   );  // cone root values
-    Vec_IntFree( p->vNodes    );  // cone nodes
-    Vec_IntFree( p->vUndo     );  // cone undos
-    Vec_IntFree( p->vVisits   );  // intermediate
-    Vec_IntFree( p->vCi2Rem   );  // CIs to be removed
-    Vec_IntFree( p->vRes      );  // final result
-    Vec_IntFree( p->vSuppLits );  // support literals
-    ABC_FREE( p->pCubeJust );
-    // additional AIG data-members
-    if ( p->pAig->pFanData != NULL )
-        Aig_ManFanoutStop( p->pAig );
-    if ( p->pAig->pTerSimData != NULL )
-        ABC_FREE( p->pAig->pTerSimData );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives counter-example.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Cex_t * Pdr_ManDeriveCex( Pdr_Man_t * p )
-{
-    Abc_Cex_t * pCex;
-    Pdr_Obl_t * pObl;
-    int i, f, Lit, nFrames = 0;
-    // count the number of frames
-    for ( pObl = p->pQueue; pObl; pObl = pObl->pNext )
-        nFrames++;
-    // create the counter-example
-    pCex = Abc_CexAlloc( Aig_ManRegNum(p->pAig), Saig_ManPiNum(p->pAig), nFrames );
-    pCex->iPo    = (p->pPars->iOutput==-1)? 0 : p->pPars->iOutput;
-    pCex->iFrame = nFrames-1;
-    for ( pObl = p->pQueue, f = 0; pObl; pObl = pObl->pNext, f++ )
-        for ( i = pObl->pState->nLits; i < pObl->pState->nTotal; i++ )
-        {
-            Lit = pObl->pState->Lits[i];
-            if ( lit_sign(Lit) )
-                continue;
-            assert( lit_var(Lit) < pCex->nPis );
-            Aig_InfoSetBit( pCex->pData, pCex->nRegs + f * pCex->nPis + lit_var(Lit) );
-        }
-    assert( f == nFrames );
-    return pCex;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/pdr/pdrSat.c b/src/sat/pdr/pdrSat.c
deleted file mode 100644
index cc4c2b1b..00000000
--- a/src/sat/pdr/pdrSat.c
+++ /dev/null
@@ -1,373 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrSat.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [SAT solver procedures.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrSat.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "pdrInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Creates new SAT solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-sat_solver * Pdr_ManCreateSolver( Pdr_Man_t * p, int k )
-{
-    sat_solver * pSat;
-    assert( Vec_PtrSize(p->vSolvers) == k );
-    assert( Vec_VecSize(p->vClauses) == k );
-    assert( Vec_IntSize(p->vActVars) == k );
-    // create new solver
-    pSat = sat_solver_new();
-    pSat = Pdr_ManNewSolver( pSat, p, k, (int)(k == 0) );
-    Vec_PtrPush( p->vSolvers, pSat );
-    Vec_VecExpand( p->vClauses, k );
-    Vec_IntPush( p->vActVars, 0 );
-    // add property cone
-    Pdr_ObjSatVar( p, k, Aig_ManPo(p->pAig, (p->pPars->iOutput==-1)?0:p->pPars->iOutput ) );
-    return pSat;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns old or restarted solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-sat_solver * Pdr_ManFetchSolver( Pdr_Man_t * p, int k )
-{
-    sat_solver * pSat;
-    Vec_Ptr_t * vArrayK;
-    Pdr_Set_t * pCube;
-    int i, j;
-    pSat = Pdr_ManSolver(p, k);
-    if ( Vec_IntEntry(p->vActVars, k) < p->pPars->nRecycle )
-        return pSat;
-    assert( k < Vec_PtrSize(p->vSolvers) - 1 );
-    p->nStarts++;
-//    sat_solver_delete( pSat );
-//    pSat = sat_solver_new();
-    sat_solver_rollback( pSat );
-    // create new SAT solver
-    pSat = Pdr_ManNewSolver( pSat, p, k, (int)(k == 0) );
-    // write new SAT solver
-    Vec_PtrWriteEntry( p->vSolvers, k, pSat );
-    Vec_IntWriteEntry( p->vActVars, k, 0 );
-    // set the property output
-    Pdr_ManSetPropertyOutput( p, k );
-    // add the clauses
-    Vec_VecForEachLevelStart( p->vClauses, vArrayK, i, k )
-        Vec_PtrForEachEntry( Pdr_Set_t *, vArrayK, pCube, j )
-            Pdr_ManSolverAddClause( p, k, pCube );
-    return pSat;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Converts SAT variables into register IDs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Pdr_ManLitsToCube( Pdr_Man_t * p, int k, int * pArray, int nArray )
-{
-    int i, RegId;
-    Vec_IntClear( p->vLits );
-    for ( i = 0; i < nArray; i++ )
-    {
-        RegId = Pdr_ObjRegNum( p, k, lit_var(pArray[i]) );
-        if ( RegId == -1 )
-            continue;
-        assert( RegId >= 0 && RegId < Aig_ManRegNum(p->pAig) );
-        Vec_IntPush( p->vLits, toLitCond(RegId, !lit_sign(pArray[i])) );
-    }
-    assert( Vec_IntSize(p->vLits) >= 0 && Vec_IntSize(p->vLits) <= nArray );
-    return p->vLits;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Converts the cube in terms of RO numbers into array of CNF literals.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Pdr_ManCubeToLits( Pdr_Man_t * p, int k, Pdr_Set_t * pCube, int fCompl, int fNext )
-{
-    Aig_Obj_t * pObj;
-    int i, iVar, iVarMax = 0;
-    int clk = clock();
-    Vec_IntClear( p->vLits );
-    for ( i = 0; i < pCube->nLits; i++ )
-    {
-        if ( pCube->Lits[i] == -1 )
-            continue;
-        if ( fNext )
-            pObj = Saig_ManLi( p->pAig, lit_var(pCube->Lits[i]) );
-        else
-            pObj = Saig_ManLo( p->pAig, lit_var(pCube->Lits[i]) );
-        iVar = Pdr_ObjSatVar( p, k, pObj ); assert( iVar >= 0 );
-        iVarMax = ABC_MAX( iVarMax, iVar );
-        Vec_IntPush( p->vLits, toLitCond( iVar, fCompl ^ lit_sign(pCube->Lits[i]) ) );
-    }
-//    sat_solver_setnvars( Pdr_ManSolver(p, k), iVarMax + 1 );
-    p->tCnf += clock() - clk;
-    return p->vLits;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the property output to 0 (sat) forever.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManSetPropertyOutput( Pdr_Man_t * p, int k )
-{
-    sat_solver * pSat;
-    int Lit, RetValue;
-    pSat = Pdr_ManSolver(p, k);
-    Lit = toLitCond( Pdr_ObjSatVar(p, k, Aig_ManPo(p->pAig, (p->pPars->iOutput==-1)?0:p->pPars->iOutput)), 1 ); // neg literal
-    RetValue = sat_solver_addclause( pSat, &Lit, &Lit + 1 );
-    assert( RetValue == 1 );
-    sat_solver_compress( pSat );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds one clause in terms of ROs to the k-th SAT solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManSolverAddClause( Pdr_Man_t * p, int k, Pdr_Set_t * pCube )
-{
-    sat_solver * pSat;
-    Vec_Int_t * vLits;
-    int RetValue;
-    pSat  = Pdr_ManSolver(p, k);
-    vLits = Pdr_ManCubeToLits( p, k, pCube, 1, 0 );
-    RetValue = sat_solver_addclause( pSat, Vec_IntArray(vLits), Vec_IntArray(vLits) + Vec_IntSize(vLits) );
-    assert( RetValue == 1 );
-    sat_solver_compress( pSat );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects values of the RO/RI variables in k-th SAT solver.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManCollectValues( Pdr_Man_t * p, int k, Vec_Int_t * vObjIds, Vec_Int_t * vValues )
-{
-    sat_solver * pSat;
-    Aig_Obj_t * pObj;
-    int iVar, i;
-    Vec_IntClear( vValues );
-    pSat = Pdr_ManSolver(p, k);
-    Aig_ManForEachObjVec( vObjIds, p->pAig, pObj, i )
-    {
-        iVar = Pdr_ObjSatVar( p, k, pObj ); assert( iVar >= 0 );
-        Vec_IntPush( vValues, sat_solver_var_value(pSat, iVar) );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks if the cube holds (UNSAT) in the given timeframe.]
- 
-  Description [Return 1/0 if cube or property are proved to hold/fail
-  in k-th timeframe.  Returns the predecessor bad state in ppPred.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManCheckCubeCs( Pdr_Man_t * p, int k, Pdr_Set_t * pCube )
-{ 
-    sat_solver * pSat;
-    Vec_Int_t * vLits;
-    int RetValue;
-    pSat = Pdr_ManFetchSolver( p, k );
-    vLits = Pdr_ManCubeToLits( p, k, pCube, 0, 0 );
-    RetValue = sat_solver_solve( pSat, Vec_IntArray(vLits), Vec_IntArray(vLits) + Vec_IntSize(vLits), 0, 0, 0, 0 );
-    if ( RetValue == l_Undef )
-        return -1;
-    return (RetValue == l_False);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks if the cube holds (UNSAT) in the given timeframe.]
- 
-  Description [Return 1/0 if cube or property are proved to hold/fail
-  in k-th timeframe.  Returns the predecessor bad state in ppPred.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManCheckCube( Pdr_Man_t * p, int k, Pdr_Set_t * pCube, Pdr_Set_t ** ppPred, int nConfLimit )
-{ 
-    int fUseLit = 1;
-    int fLitUsed = 0;
-    sat_solver * pSat;
-    Vec_Int_t * vLits;
-    int Lit, RetValue, clk;
-    p->nCalls++;
-    pSat = Pdr_ManFetchSolver( p, k );
-    if ( pCube == NULL ) // solve the property
-    {
-        clk = clock();
-        Lit = toLit( Pdr_ObjSatVar(p, k, Aig_ManPo(p->pAig, (p->pPars->iOutput==-1)?0:p->pPars->iOutput)) ); // pos literal (property fails)
-        RetValue = sat_solver_solve( pSat, &Lit, &Lit + 1, nConfLimit, 0, 0, 0 );
-        if ( RetValue == l_Undef )
-            return -1;
-    }
-    else // check relative containment in terms of next states
-    {
-        if ( fUseLit )
-        {
-            fLitUsed = 1;
-            Vec_IntAddToEntry( p->vActVars, k, 1 );
-            // add the cube in terms of current state variables
-            vLits = Pdr_ManCubeToLits( p, k, pCube, 1, 0 );
-            // add activation literal
-            Lit = toLit( Pdr_ManFreeVar(p, k) );
-            // add activation literal
-            Vec_IntPush( vLits, Lit );
-            RetValue = sat_solver_addclause( pSat, Vec_IntArray(vLits), Vec_IntArray(vLits) + Vec_IntSize(vLits) );
-            assert( RetValue == 1 );
-            sat_solver_compress( pSat );
-            // create assumptions
-            vLits = Pdr_ManCubeToLits( p, k, pCube, 0, 1 );
-            // add activation literal
-            Vec_IntPush( vLits, lit_neg(Lit) );
-        }
-        else
-            vLits = Pdr_ManCubeToLits( p, k, pCube, 0, 1 );
-
-        // solve 
-        clk = clock();
-        RetValue = sat_solver_solve( pSat, Vec_IntArray(vLits), Vec_IntArray(vLits) + Vec_IntSize(vLits), nConfLimit, 0, 0, 0 );
-        if ( RetValue == l_Undef )
-            return -1;
-/*
-        if ( RetValue == l_True )
-        {
-            int RetValue2 = Pdr_ManCubeJust( p, k, pCube );
-            if ( RetValue2 )
-                p->nCasesSS++;
-            else
-                p->nCasesSU++;
-        }
-        else
-        {
-            int RetValue2 = Pdr_ManCubeJust( p, k, pCube );
-            if ( RetValue2 )
-                p->nCasesUS++;
-            else
-                p->nCasesUU++;
-        }
-*/
-    }
-    clk = clock() - clk;
-    p->tSat += clk;
-    assert( RetValue != l_Undef );
-    if ( RetValue == l_False )
-    {
-        p->tSatUnsat += clk;
-        p->nCallsU++;
-        if ( ppPred )
-            *ppPred = NULL;
-        RetValue = 1;
-    }
-    else // if ( RetValue == l_True )
-    {
-        p->tSatSat += clk;
-        p->nCallsS++;
-        if ( ppPred )
-            *ppPred = Pdr_ManTernarySim( p, k, pCube );
-        RetValue = 0;
-    }
-
-/* // for some reason, it does not work...
-    if ( fLitUsed )
-    {
-        int RetValue;
-        Lit = lit_neg(Lit);
-        RetValue = sat_solver_addclause( pSat, &Lit, &Lit + 1 );
-        assert( RetValue == 1 );
-        sat_solver_compress( pSat );
-    }
-*/
-    return RetValue;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/pdr/pdrTsim.c b/src/sat/pdr/pdrTsim.c
deleted file mode 100644
index 6fec1605..00000000
--- a/src/sat/pdr/pdrTsim.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrTsim.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [Ternary simulation.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrTsim.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "pdrInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-#define PDR_ZER 1
-#define PDR_ONE 2
-#define PDR_UND 3
-
-static inline int Pdr_ManSimInfoNot( int Value )
-{
-    if ( Value == PDR_ZER )
-        return PDR_ONE;
-    if ( Value == PDR_ONE )
-        return PDR_ZER;
-    return PDR_UND;
-}
-
-static inline int Pdr_ManSimInfoAnd( int Value0, int Value1 )
-{
-    if ( Value0 == PDR_ZER || Value1 == PDR_ZER )
-        return PDR_ZER;
-    if ( Value0 == PDR_ONE && Value1 == PDR_ONE )
-        return PDR_ONE;
-    return PDR_UND;
-}
-
-static inline int Pdr_ManSimInfoGet( Aig_Man_t * p, Aig_Obj_t * pObj )
-{
-    return 3 & (p->pTerSimData[Aig_ObjId(pObj) >> 4] >> ((Aig_ObjId(pObj) & 15) << 1));
-}
-
-static inline void Pdr_ManSimInfoSet( Aig_Man_t * p, Aig_Obj_t * pObj, int Value )
-{
-    assert( Value >= PDR_ZER && Value <= PDR_UND );
-    Value ^= Pdr_ManSimInfoGet( p, pObj );
-    p->pTerSimData[Aig_ObjId(pObj) >> 4] ^= (Value << ((Aig_ObjId(pObj) & 15) << 1));
-}
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Marks the TFI cone and collects CIs and nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManCollectCone_rec( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Int_t * vCiObjs, Vec_Int_t * vNodes )
-{
-    assert( !Aig_IsComplement(pObj) );
-    if ( Aig_ObjIsTravIdCurrent(pAig, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent(pAig, pObj);
-    if ( Aig_ObjIsPi(pObj) )
-    {
-        Vec_IntPush( vCiObjs, Aig_ObjId(pObj) );
-        return;
-    }
-    Pdr_ManCollectCone_rec( pAig, Aig_ObjFanin0(pObj), vCiObjs, vNodes );
-    if ( Aig_ObjIsPo(pObj) )
-        return;
-    Pdr_ManCollectCone_rec( pAig, Aig_ObjFanin1(pObj), vCiObjs, vNodes );
-    Vec_IntPush( vNodes, Aig_ObjId(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Marks the TFI cone and collects CIs and nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManCollectCone( Aig_Man_t * pAig, Vec_Int_t * vCoObjs, Vec_Int_t * vCiObjs, Vec_Int_t * vNodes )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    Vec_IntClear( vCiObjs );
-    Vec_IntClear( vNodes );
-    Aig_ManIncrementTravId( pAig );
-    Aig_ObjSetTravIdCurrent( pAig, Aig_ManConst1(pAig) );
-    Aig_ManForEachObjVec( vCoObjs, pAig, pObj, i )
-        Pdr_ManCollectCone_rec( pAig, pObj, vCiObjs, vNodes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs ternary simulation for one node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManExtendOneEval( Aig_Man_t * pAig, Aig_Obj_t * pObj )
-{
-    int Value0, Value1, Value;
-    Value0 = Pdr_ManSimInfoGet( pAig, Aig_ObjFanin0(pObj) );
-    if ( Aig_ObjFaninC0(pObj) )
-        Value0 = Pdr_ManSimInfoNot( Value0 );
-    if ( Aig_ObjIsPo(pObj) )
-    {
-        Pdr_ManSimInfoSet( pAig, pObj, Value0 );
-        return Value0;
-    }
-    assert( Aig_ObjIsNode(pObj) );
-    Value1 = Pdr_ManSimInfoGet( pAig, Aig_ObjFanin1(pObj) );
-    if ( Aig_ObjFaninC1(pObj) )
-        Value1 = Pdr_ManSimInfoNot( Value1 );
-    Value = Pdr_ManSimInfoAnd( Value0, Value1 );
-    Pdr_ManSimInfoSet( pAig, pObj, Value );
-    return Value;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs ternary simulation for one design.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManSimDataInit( Aig_Man_t * pAig, 
-    Vec_Int_t * vCiObjs, Vec_Int_t * vCiVals, Vec_Int_t * vNodes, 
-    Vec_Int_t * vCoObjs, Vec_Int_t * vCoVals, Vec_Int_t * vCi2Rem )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    // set the CI values
-    Pdr_ManSimInfoSet( pAig, Aig_ManConst1(pAig), PDR_ONE );
-    Aig_ManForEachObjVec( vCiObjs, pAig, pObj, i )
-        Pdr_ManSimInfoSet( pAig, pObj, (Vec_IntEntry(vCiVals, i)?PDR_ONE:PDR_ZER) );
-    // set the FOs to remove
-    if ( vCi2Rem != NULL )
-    Aig_ManForEachObjVec( vCi2Rem, pAig, pObj, i )
-        Pdr_ManSimInfoSet( pAig, pObj, PDR_UND );
-    // perform ternary simulation
-    Aig_ManForEachObjVec( vNodes, pAig, pObj, i )
-        Pdr_ManExtendOneEval( pAig, pObj );
-    // transfer results to the output
-    Aig_ManForEachObjVec( vCoObjs, pAig, pObj, i )
-        Pdr_ManExtendOneEval( pAig, pObj );
-    // check the results
-    Aig_ManForEachObjVec( vCoObjs, pAig, pObj, i )
-        if ( Pdr_ManSimInfoGet( pAig, pObj ) != (Vec_IntEntry(vCoVals, i)?PDR_ONE:PDR_ZER) )
-            return 0;
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Tries to assign ternary value to one of the CIs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManExtendOne( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Int_t * vUndo, Vec_Int_t * vVis )
-{
-    Aig_Obj_t * pFanout;
-    int i, k, iFanout, Value, Value2;
-    assert( Saig_ObjIsLo(pAig, pObj) );
-    assert( Aig_ObjIsTravIdCurrent(pAig, pObj) );
-    // save original value
-    Value = Pdr_ManSimInfoGet( pAig, pObj );
-    assert( Value == PDR_ZER || Value == PDR_ONE );
-    Vec_IntPush( vUndo, Aig_ObjId(pObj) );
-    Vec_IntPush( vUndo, Value );
-    // update original value
-    Pdr_ManSimInfoSet( pAig, pObj, PDR_UND );
-    // traverse
-    Vec_IntClear( vVis );
-    Vec_IntPush( vVis, Aig_ObjId(pObj) );
-    Aig_ManForEachObjVec( vVis, pAig, pObj, i )
-    {
-        Aig_ObjForEachFanout( pAig, pObj, pFanout, iFanout, k )
-        {
-            if ( !Aig_ObjIsTravIdCurrent(pAig, pFanout) )
-                continue;
-            assert( Aig_ObjId(pObj) < Aig_ObjId(pFanout) );
-            Value = Pdr_ManSimInfoGet( pAig, pFanout );
-            if ( Value == PDR_UND )
-                continue;
-            Value2 = Pdr_ManExtendOneEval( pAig, pFanout );
-            if ( Value2 == Value )
-                continue;
-            assert( Value2 == PDR_UND );
-            Vec_IntPush( vUndo, Aig_ObjId(pFanout) );
-            Vec_IntPush( vUndo, Value );
-            if ( Aig_ObjIsPo(pFanout) )
-                return 0;
-            assert( Aig_ObjIsNode(pFanout) );
-            Vec_IntPushOrder( vVis, Aig_ObjId(pFanout) );
-        }
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Undoes the partial results of ternary simulation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManExtendUndo( Aig_Man_t * pAig, Vec_Int_t * vUndo )
-{
-    Aig_Obj_t * pObj;
-    int i, Value;
-    Aig_ManForEachObjVec( vUndo, pAig, pObj, i )
-    {
-        Value  = Vec_IntEntry(vUndo, ++i);
-        assert( Pdr_ManSimInfoGet(pAig, pObj) == PDR_UND );
-        Pdr_ManSimInfoSet( pAig, pObj, Value );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the resulting cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManDeriveResult( Aig_Man_t * pAig, Vec_Int_t * vCiObjs, Vec_Int_t * vCiVals, Vec_Int_t * vCi2Rem, Vec_Int_t * vRes, Vec_Int_t * vPiLits )
-{
-    Aig_Obj_t * pObj;
-    int i, Lit;
-    // mark removed flop outputs
-    Aig_ManIncrementTravId( pAig );
-    Aig_ManForEachObjVec( vCi2Rem, pAig, pObj, i )
-    {
-        assert( Saig_ObjIsLo( pAig, pObj ) );
-        Aig_ObjSetTravIdCurrent(pAig, pObj);
-    }
-    // collect flop outputs that are not marked
-    Vec_IntClear( vRes );
-    Vec_IntClear( vPiLits );
-    Aig_ManForEachObjVec( vCiObjs, pAig, pObj, i )
-    {
-        if ( Saig_ObjIsPi(pAig, pObj) )
-        {
-            Lit = toLitCond( Aig_ObjPioNum(pObj), (Vec_IntEntry(vCiVals, i) == 0) );
-            Vec_IntPush( vPiLits, Lit );
-            continue;
-        }
-        assert( Saig_ObjIsLo(pAig, pObj) );
-        if ( Aig_ObjIsTravIdCurrent(pAig, pObj) )
-            continue;
-        Lit = toLitCond( Aig_ObjPioNum(pObj) - Saig_ManPiNum(pAig), (Vec_IntEntry(vCiVals, i) == 0) );
-        Vec_IntPush( vRes, Lit );
-    }
-    if ( Vec_IntSize(vRes) == 0 )
-        Vec_IntPush(vRes, 0);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the resulting cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_ManPrintCex( Aig_Man_t * pAig, Vec_Int_t * vCiObjs, Vec_Int_t * vCiVals, Vec_Int_t * vCi2Rem )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    char * pBuff = ABC_ALLOC( char, Aig_ManPiNum(pAig)+1 );
-    for ( i = 0; i < Aig_ManPiNum(pAig); i++ )
-        pBuff[i] = '-';
-    pBuff[i] = 0;
-    Aig_ManForEachObjVec( vCiObjs, pAig, pObj, i )
-        pBuff[Aig_ObjPioNum(pObj)] = (Vec_IntEntry(vCiVals, i)? '1':'0');
-    if ( vCi2Rem )
-    Aig_ManForEachObjVec( vCi2Rem, pAig, pObj, i )
-        pBuff[Aig_ObjPioNum(pObj)] = 'x';
-    printf( "%s\n", pBuff );
-    ABC_FREE( pBuff );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Shrinks values using ternary simulation.]
-
-  Description [The cube contains the set of flop index literals which,
-  when converted into a clause and applied to the combinational outputs, 
-  led to a satisfiable SAT run in frame k (values stored in the SAT solver).
-  If the cube is NULL, it is assumed that the first property output was
-  asserted and failed.
-  The resulting array is a set of flop index literals that asserts the COs.
-  Priority contains 0 for i-th entry if the i-th FF is desirable to remove.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_ManTernarySim( Pdr_Man_t * p, int k, Pdr_Set_t * pCube )
-{
-    Vec_Int_t * vPrio   = p->vPrio;    // priority flops (flop indices)
-    Vec_Int_t * vPiLits = p->vLits;    // array of literals (0/1 PI values)
-    Vec_Int_t * vCiObjs = p->vCiObjs;  // cone leaves (CI obj IDs)
-    Vec_Int_t * vCoObjs = p->vCoObjs;  // cone roots (CO obj IDs)
-    Vec_Int_t * vCiVals = p->vCiVals;  // cone leaf values (0/1 CI values)
-    Vec_Int_t * vCoVals = p->vCoVals;  // cone root values (0/1 CO values)
-    Vec_Int_t * vNodes  = p->vNodes;   // cone nodes (node obj IDs)
-    Vec_Int_t * vUndo   = p->vUndo;    // cone undos (node obj IDs)
-    Vec_Int_t * vVisits = p->vVisits;  // intermediate (obj IDs)
-    Vec_Int_t * vCi2Rem = p->vCi2Rem;  // CIs to be removed (CI obj IDs)
-    Vec_Int_t * vRes    = p->vRes;     // final result (flop literals)
-    Aig_Obj_t * pObj;
-    int i, Entry, RetValue;
-    int clk = clock();
-
-    // collect CO objects
-    Vec_IntClear( vCoObjs );
-    if ( pCube == NULL ) // the target is the property output
-        Vec_IntPush( vCoObjs, Aig_ObjId(Aig_ManPo(p->pAig, (p->pPars->iOutput==-1)?0:p->pPars->iOutput)) ); 
-    else // the target is the cube
-    {
-        for ( i = 0; i < pCube->nLits; i++ )
-        {
-            if ( pCube->Lits[i] == -1 )
-                continue;
-            pObj = Saig_ManLi(p->pAig, (pCube->Lits[i] >> 1));
-            Vec_IntPush( vCoObjs, Aig_ObjId(pObj) );
-        }
-    }
-if ( p->pPars->fVeryVerbose )
-{
-printf( "Trying to justify cube " );
-if ( pCube )
-    Pdr_SetPrint( stdout, pCube, Aig_ManRegNum(p->pAig), NULL );
-else
-    printf( "<prop=fail>" );
-printf( " in frame %d.\n", k );
-}
-
-    // collect CI objects
-    Pdr_ManCollectCone( p->pAig, vCoObjs, vCiObjs, vNodes );
-    // collect values
-    Pdr_ManCollectValues( p, k, vCiObjs, vCiVals );
-    Pdr_ManCollectValues( p, k, vCoObjs, vCoVals );
-    // simulate for the first time
-if ( p->pPars->fVeryVerbose )
-Pdr_ManPrintCex( p->pAig, vCiObjs, vCiVals, NULL );
-    RetValue = Pdr_ManSimDataInit( p->pAig, vCiObjs, vCiVals, vNodes, vCoObjs, vCoVals, NULL );
-    assert( RetValue );
-
-    // try removing high-priority flops
-    Vec_IntClear( vCi2Rem );
-    Aig_ManForEachObjVec( vCiObjs, p->pAig, pObj, i )
-    {
-        if ( !Saig_ObjIsLo( p->pAig, pObj ) )
-            continue;
-        Entry = Aig_ObjPioNum(pObj) - Saig_ManPiNum(p->pAig);
-        if ( vPrio != NULL && Vec_IntEntry( vPrio, Entry ) != 0 )
-            continue;
-        Vec_IntClear( vUndo );
-        if ( Pdr_ManExtendOne( p->pAig, pObj, vUndo, vVisits ) )
-            Vec_IntPush( vCi2Rem, Aig_ObjId(pObj) );
-        else
-            Pdr_ManExtendUndo( p->pAig, vUndo );
-    }
-    // try removing low-priority flops
-    Aig_ManForEachObjVec( vCiObjs, p->pAig, pObj, i )
-    {
-        if ( !Saig_ObjIsLo( p->pAig, pObj ) )
-            continue;
-        Entry = Aig_ObjPioNum(pObj) - Saig_ManPiNum(p->pAig);
-        if ( vPrio == NULL || Vec_IntEntry( vPrio, Entry ) == 0 )
-            continue;
-        Vec_IntClear( vUndo );
-        if ( Pdr_ManExtendOne( p->pAig, pObj, vUndo, vVisits ) )
-            Vec_IntPush( vCi2Rem, Aig_ObjId(pObj) );
-        else
-            Pdr_ManExtendUndo( p->pAig, vUndo );
-    }
-if ( p->pPars->fVeryVerbose )
-Pdr_ManPrintCex( p->pAig, vCiObjs, vCiVals, vCi2Rem );
-    RetValue = Pdr_ManSimDataInit( p->pAig, vCiObjs, vCiVals, vNodes, vCoObjs, vCoVals, vCi2Rem );
-    assert( RetValue ); 
-
-    // derive the set of resulting registers
-    Pdr_ManDeriveResult( p->pAig, vCiObjs, vCiVals, vCi2Rem, vRes, vPiLits );
-    assert( Vec_IntSize(vRes) > 0 );
-    p->tTsim += clock() - clk;
-    return Pdr_SetCreate( vRes, vPiLits );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/pdr/pdrUtil.c b/src/sat/pdr/pdrUtil.c
deleted file mode 100644
index 1107aec7..00000000
--- a/src/sat/pdr/pdrUtil.c
+++ /dev/null
@@ -1,719 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [pdrUtil.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Property driven reachability.]
-
-  Synopsis    [Various utilities.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - November 20, 2010.]
-
-  Revision    [$Id: pdrUtil.c,v 1.00 2010/11/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "pdrInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_SetAlloc( int nSize )
-{
-    Pdr_Set_t * p;
-    assert( nSize >= 0 && nSize < (1<<30) );
-    p = (Pdr_Set_t *)ABC_CALLOC( char, sizeof(Pdr_Set_t) + nSize * sizeof(int) );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_SetCreate( Vec_Int_t * vLits, Vec_Int_t * vPiLits )
-{
-    Pdr_Set_t * p;
-    int i;
-    assert( Vec_IntSize(vLits) + Vec_IntSize(vPiLits) < (1<<30) );
-    p = (Pdr_Set_t *)ABC_ALLOC( char, sizeof(Pdr_Set_t) + (Vec_IntSize(vLits) + Vec_IntSize(vPiLits)) * sizeof(int) );
-    p->nLits  = Vec_IntSize(vLits);
-    p->nTotal = Vec_IntSize(vLits) + Vec_IntSize(vPiLits);
-    p->nRefs  = 1;
-    p->Sign   = 0;
-    for ( i = 0; i < p->nLits; i++ )
-    {
-        p->Lits[i] = Vec_IntEntry(vLits, i);
-        p->Sign   |= ((word)1 << (p->Lits[i] % 63));
-    }
-    Vec_IntSelectSort( p->Lits, p->nLits );
-/*
-    for ( i = 0; i < p->nLits; i++ )
-        printf( "%d ", p->Lits[i] );
-    printf( "\n" );
-*/
-    // remember PI literals 
-    for ( i = p->nLits; i < p->nTotal; i++ )
-        p->Lits[i] = Vec_IntEntry(vPiLits, i-p->nLits);
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_SetCreateFrom( Pdr_Set_t * pSet, int iRemove )
-{
-    Pdr_Set_t * p;
-    int i, k = 0;
-    assert( iRemove >= 0 && iRemove < pSet->nLits );
-    p = (Pdr_Set_t *)ABC_ALLOC( char, sizeof(Pdr_Set_t) + (pSet->nTotal - 1) * sizeof(int) );
-    p->nLits  = pSet->nLits - 1;
-    p->nTotal = pSet->nTotal - 1;
-    p->nRefs  = 1;
-    p->Sign   = 0;
-    for ( i = 0; i < pSet->nTotal; i++ )
-    {
-        if ( i == iRemove )
-            continue;
-        p->Lits[k++] = pSet->Lits[i];
-        if ( i >= pSet->nLits )
-            continue;
-        p->Sign   |= ((word)1 << (pSet->Lits[i] % 63));
-    }
-    assert( k == p->nTotal );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_SetCreateSubset( Pdr_Set_t * pSet, int * pLits, int nLits )
-{
-    Pdr_Set_t * p;
-    int i, k = 0;
-    assert( nLits >= 0 && nLits <= pSet->nLits );
-    p = (Pdr_Set_t *)ABC_ALLOC( char, sizeof(Pdr_Set_t) + (nLits + pSet->nTotal - pSet->nLits) * sizeof(int) );
-    p->nLits  = nLits;
-    p->nTotal = nLits + pSet->nTotal - pSet->nLits;
-    p->nRefs  = 1;
-    p->Sign   = 0;
-    for ( i = 0; i < nLits; i++ )
-    {
-        assert( pLits[i] >= 0 );
-        p->Lits[k++] = pLits[i];
-        p->Sign   |= ((word)1 << (pLits[i] % 63));
-    }
-    Vec_IntSelectSort( p->Lits, p->nLits );
-    for ( i = pSet->nLits; i < pSet->nTotal; i++ )
-        p->Lits[k++] = pSet->Lits[i];
-    assert( k == p->nTotal );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_SetDup( Pdr_Set_t * pSet )
-{
-    Pdr_Set_t * p;
-    int i;
-    p = (Pdr_Set_t *)ABC_ALLOC( char, sizeof(Pdr_Set_t) + pSet->nTotal * sizeof(int) );
-    p->nLits  = pSet->nLits;
-    p->nTotal = pSet->nTotal;
-    p->nRefs  = 1;
-    p->Sign   = pSet->Sign;
-    for ( i = 0; i < pSet->nTotal; i++ )
-        p->Lits[i] = pSet->Lits[i];
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Set_t * Pdr_SetRef( Pdr_Set_t * p )
-{
-    p->nRefs++;
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_SetDeref( Pdr_Set_t * p )
-{
-    if ( --p->nRefs == 0 )
-        ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_SetPrint( FILE * pFile, Pdr_Set_t * p, int nRegs, Vec_Int_t * vFlopCounts )
-{
-    char * pBuff;
-    int i, k, Entry;
-    pBuff = ABC_ALLOC( char, nRegs + 1 );
-    for ( i = 0; i < nRegs; i++ )
-        pBuff[i] = '-';
-    pBuff[i] = 0;
-    for ( i = 0; i < p->nLits; i++ )
-    {
-        if ( p->Lits[i] == -1 )
-            continue;
-        pBuff[lit_var(p->Lits[i])] = (lit_sign(p->Lits[i])? '0':'1');
-    }
-    if ( vFlopCounts )
-    {
-        // skip some literals
-        k = 0;
-        Vec_IntForEachEntry( vFlopCounts, Entry, i )
-            if ( Entry ) 
-                pBuff[k++] = pBuff[i];
-        pBuff[k] = 0;
-    }
-    fprintf( pFile, "%s", pBuff );
-    ABC_FREE( pBuff );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Return 1 if pOld set-theoretically contains pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_SetContains( Pdr_Set_t * pOld, Pdr_Set_t * pNew )
-{
-    int * pOldInt, * pNewInt;
-    assert( pOld->nLits > 0 );
-    assert( pNew->nLits > 0 );
-    if ( pOld->nLits < pNew->nLits )
-        return 0;
-    if ( (pOld->Sign & pNew->Sign) != pNew->Sign )
-        return 0;
-    pOldInt = pOld->Lits + pOld->nLits - 1;
-    pNewInt = pNew->Lits + pNew->nLits - 1;
-    while ( pNew->Lits <= pNewInt )
-    {
-        if ( pOld->Lits > pOldInt )
-            return 0;
-        assert( *pNewInt != -1 );
-        assert( *pOldInt != -1 );
-        if ( *pNewInt == *pOldInt )
-            pNewInt--, pOldInt--;
-        else if ( *pNewInt < *pOldInt )
-            pOldInt--;
-        else
-            return 0;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Return 1 if pOld set-theoretically contains pNew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_SetContainsSimple( Pdr_Set_t * pOld, Pdr_Set_t * pNew )
-{
-    int * pOldInt, * pNewInt;
-    assert( pOld->nLits > 0 );
-    assert( pNew->nLits > 0 );
-    pOldInt = pOld->Lits + pOld->nLits - 1;
-    pNewInt = pNew->Lits + pNew->nLits - 1;
-    while ( pNew->Lits <= pNewInt )
-    {
-        assert( *pOldInt != -1 );
-        if ( *pNewInt == -1 )
-        {
-            pNewInt--;
-            continue;
-        }
-        if ( pOld->Lits > pOldInt )
-            return 0;
-        assert( *pNewInt != -1 );
-        assert( *pOldInt != -1 );
-        if ( *pNewInt == *pOldInt )
-            pNewInt--, pOldInt--;
-        else if ( *pNewInt < *pOldInt )
-            pOldInt--;
-        else
-            return 0;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Return 1 if the state cube contains init state (000...0).]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_SetIsInit( Pdr_Set_t * pCube, int iRemove )
-{
-    int i;
-    for ( i = 0; i < pCube->nLits; i++ )
-    {
-        assert( pCube->Lits[i] != -1 );
-        if ( i == iRemove )
-            continue;
-        if ( lit_sign( pCube->Lits[i] ) == 0 )
-            return 0;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_SetCompare( Pdr_Set_t ** pp1, Pdr_Set_t ** pp2 )
-{
-    Pdr_Set_t * p1 = *pp1;
-    Pdr_Set_t * p2 = *pp2;
-    int i;
-    for ( i = 0; i < p1->nLits && i < p2->nLits; i++ )
-    {
-        if ( p1->Lits[i] > p2->Lits[i] )
-            return -1;
-        if ( p1->Lits[i] < p2->Lits[i] )
-            return 1;
-    }
-    if ( i == p1->nLits && i < p2->nLits )
-        return -1;
-    if ( i < p1->nLits && i == p2->nLits )
-        return 1;
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Obl_t * Pdr_OblStart( int k, int prio, Pdr_Set_t * pState, Pdr_Obl_t * pNext )
-{
-    Pdr_Obl_t * p;
-    p = ABC_ALLOC( Pdr_Obl_t, 1 );
-    p->iFrame = k;
-    p->prio   = prio;
-    p->nRefs  = 1;
-    p->pState = pState;
-    p->pNext  = pNext;
-    p->pLink  = NULL;
-    return p;    
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Obl_t * Pdr_OblRef( Pdr_Obl_t * p )
-{
-    p->nRefs++;
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_OblDeref( Pdr_Obl_t * p )
-{
-    if ( --p->nRefs == 0 )
-    {
-        if ( p->pNext )
-            Pdr_OblDeref( p->pNext );
-        Pdr_SetDeref( p->pState );
-        ABC_FREE( p );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_QueueIsEmpty( Pdr_Man_t * p )
-{
-    return p->pQueue == NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Obl_t * Pdr_QueueHead( Pdr_Man_t * p )
-{
-    return p->pQueue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Pdr_Obl_t * Pdr_QueuePop( Pdr_Man_t * p )
-{
-    Pdr_Obl_t * pRes = p->pQueue;
-    if ( p->pQueue == NULL )
-        return NULL;
-    p->pQueue = p->pQueue->pLink;
-    Pdr_OblDeref( pRes );
-    return pRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_QueuePush( Pdr_Man_t * p, Pdr_Obl_t * pObl )
-{
-    Pdr_Obl_t * pTemp, ** ppPrev;
-    p->nObligs++;
-    Pdr_OblRef( pObl );
-    if ( p->pQueue == NULL )
-    {
-        p->pQueue = pObl;
-        return;
-    }
-    for ( ppPrev = &p->pQueue, pTemp = p->pQueue; pTemp; ppPrev = &pTemp->pLink, pTemp = pTemp->pLink )
-        if ( pTemp->iFrame > pObl->iFrame || (pTemp->iFrame == pObl->iFrame && pTemp->prio > pObl->prio) )
-            break;
-    *ppPrev = pObl;
-    pObl->pLink = pTemp;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_QueuePrint( Pdr_Man_t * p )
-{
-    Pdr_Obl_t * pObl;
-    for ( pObl = p->pQueue; pObl; pObl = pObl->pLink )
-        printf( "Frame = %2d.  Prio = %8d.\n", pObl->iFrame, pObl->prio );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Pdr_QueueStop( Pdr_Man_t * p )
-{
-    Pdr_Obl_t * pObl;
-    while ( !Pdr_QueueIsEmpty(p) )
-    {
-        pObl = Pdr_QueuePop(p);
-        Pdr_OblDeref( pObl );
-    }
-    p->pQueue = NULL;
-}
-
-
-#define PDR_VAL0  1
-#define PDR_VAL1  2
-#define PDR_VALX  3
-
-/**Function*************************************************************
-
-  Synopsis    [Returns value (0 or 1) or X if unassigned.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Pdr_ObjSatValue( Aig_Man_t * pAig, Aig_Obj_t * pNode, int fCompl )
-{
-    if ( Aig_ObjIsTravIdCurrent(pAig, pNode) )
-        return (pNode->fMarkA ^ fCompl) ? PDR_VAL1 : PDR_VAL0;
-    return PDR_VALX;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recursively searched for a satisfying assignment.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_NtkFindSatAssign_rec( Aig_Man_t * pAig, Aig_Obj_t * pNode, int Value, Pdr_Set_t * pCube, int Heur )
-{
-    int Value0, Value1;
-    if ( Aig_ObjIsConst1(pNode) )
-        return 1;
-    if ( Aig_ObjIsTravIdCurrent(pAig, pNode) )
-        return ((int)pNode->fMarkA == Value);
-    Aig_ObjSetTravIdCurrent(pAig, pNode);
-    pNode->fMarkA = Value;
-    if ( Aig_ObjIsPi(pNode) )
-    {
-//        if ( vSuppLits )
-//            Vec_IntPush( vSuppLits, Aig_Var2Lit( Aig_ObjPioNum(pNode), !Value ) );
-        if ( Saig_ObjIsLo(pAig, pNode) )
-        {
-//            pCube->Lits[pCube->nLits++] = Aig_Var2Lit( Aig_ObjPioNum(pNode) - Saig_ManPiNum(pAig), !Value );
-            pCube->Lits[pCube->nLits++] = Aig_Var2Lit( Aig_ObjPioNum(pNode) - Saig_ManPiNum(pAig), Value );
-            pCube->Sign |= ((word)1 << (pCube->Lits[pCube->nLits-1] % 63));
-        }
-        return 1;
-    }
-    assert( Aig_ObjIsNode(pNode) );
-    // propagation
-    if ( Value ) 
-    {
-        if ( !Pdr_NtkFindSatAssign_rec(pAig, Aig_ObjFanin0(pNode), !Aig_ObjFaninC0(pNode), pCube, Heur) )
-            return 0;
-        return Pdr_NtkFindSatAssign_rec(pAig, Aig_ObjFanin1(pNode), !Aig_ObjFaninC1(pNode), pCube, Heur);
-    }
-    // justification
-    Value0 = Pdr_ObjSatValue( pAig, Aig_ObjFanin0(pNode), Aig_ObjFaninC0(pNode) );
-    if ( Value0 == PDR_VAL0 )
-        return 1;
-    Value1 = Pdr_ObjSatValue( pAig, Aig_ObjFanin1(pNode), Aig_ObjFaninC1(pNode) );
-    if ( Value1 == PDR_VAL0 )
-        return 1;
-    if ( Value0 == PDR_VAL1 && Value1 == PDR_VAL1 )
-        return 0;
-    if ( Value0 == PDR_VAL1 )
-        return Pdr_NtkFindSatAssign_rec(pAig, Aig_ObjFanin1(pNode), Aig_ObjFaninC1(pNode), pCube, Heur);
-    if ( Value1 == PDR_VAL1 )
-        return Pdr_NtkFindSatAssign_rec(pAig, Aig_ObjFanin0(pNode), Aig_ObjFaninC0(pNode), pCube, Heur);
-    assert( Value0 == PDR_VALX && Value1 == PDR_VALX );
-    // decision making
-//    if ( rand() % 10 == Heur )
-    if ( Aig_ObjId(pNode) % 4 == Heur )
-        return Pdr_NtkFindSatAssign_rec(pAig, Aig_ObjFanin1(pNode), Aig_ObjFaninC1(pNode), pCube, Heur);
-    else
-        return Pdr_NtkFindSatAssign_rec(pAig, Aig_ObjFanin0(pNode), Aig_ObjFaninC0(pNode), pCube, Heur);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if SAT assignment is found; 0 otherwise.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Pdr_ManCubeJust( Pdr_Man_t * p, int k, Pdr_Set_t * pCube )
-{
-    Aig_Obj_t * pNode;
-    int i, v, fCompl;
-//    return 0;
-    for ( i = 0; i < 4; i++ )
-    {
-        // derive new assignment
-        p->pCubeJust->nLits = 0;
-        p->pCubeJust->Sign  = 0;
-        Aig_ManIncrementTravId( p->pAig );
-        for ( v = 0; v < pCube->nLits; v++ )
-        {
-            if ( pCube->Lits[v] == -1 )
-                continue;
-            pNode  = Saig_ManLi( p->pAig, lit_var(pCube->Lits[v]) );
-            fCompl = lit_sign(pCube->Lits[v]) ^ Aig_ObjFaninC0(pNode);
-            if ( !Pdr_NtkFindSatAssign_rec( p->pAig, Aig_ObjFanin0(pNode), !fCompl, p->pCubeJust, i ) )
-                break;
-        }
-        if ( v < pCube->nLits )
-            continue;
-        // figure this out!!!
-        if ( p->pCubeJust->nLits == 0 )
-            continue;
-        // successfully derived new assignment
-        Vec_IntSelectSort( p->pCubeJust->Lits, p->pCubeJust->nLits );
-        // check assignment against this cube
-        if ( Pdr_SetContainsSimple( p->pCubeJust, pCube ) )
-            continue;
-//printf( "\n" );
-//Pdr_SetPrint( stdout, pCube,        Saig_ManRegNum(p->pAig), NULL ); printf( "\n" );
-//Pdr_SetPrint( stdout, p->pCubeJust, Saig_ManRegNum(p->pAig), NULL ); printf( "\n" );
-        // check assignment against the clauses
-        if ( Pdr_ManCheckContainment( p, k, p->pCubeJust ) )
-            continue;
-        // find good assignment
-        return 1;
-    }
-    return 0;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/sat/proof/pr.c b/src/sat/proof/pr.c
index 0da16eaf..45bc2e33 100644
--- a/src/sat/proof/pr.c
+++ b/src/sat/proof/pr.c
@@ -25,7 +25,7 @@
 #include <time.h>
 
 //#include "vec.h"
-#include "abc_global.h"
+#include "src/misc/util/abc_global.h"
 #include "pr.h"
 
 ABC_NAMESPACE_IMPL_START
diff --git a/src/sat/proof/pr.h b/src/sat/proof/pr.h
index 9088c89b..b060b52b 100644
--- a/src/sat/proof/pr.h
+++ b/src/sat/proof/pr.h
@@ -18,8 +18,8 @@
 
 ***********************************************************************/
  
-#ifndef __PR_H__
-#define __PR_H__
+#ifndef ABC__sat__proof__pr_h
+#define ABC__sat__proof__pr_h
 
 
 #ifdef _WIN32
diff --git a/src/sat/psat/m114p.h b/src/sat/psat/m114p.h
index 9319d918..12f98135 100644
--- a/src/sat/psat/m114p.h
+++ b/src/sat/psat/m114p.h
@@ -1,7 +1,7 @@
 // C-language header for MiniSat 1.14p
 
-#ifndef m114p_h
-#define m114p_h
+#ifndef ABC__sat__psat__m114p_h
+#define ABC__sat__psat__m114p_h
 
 
 #include "m114p_types.h"
diff --git a/src/sat/psat/m114p_types.h b/src/sat/psat/m114p_types.h
index 29d70a87..770cd417 100644
--- a/src/sat/psat/m114p_types.h
+++ b/src/sat/psat/m114p_types.h
@@ -1,7 +1,7 @@
 // C-language header for MiniSat 1.14p
 
-#ifndef m114p_types_h
-#define m114p_types_h
+#ifndef ABC__sat__psat__m114p_types_h
+#define ABC__sat__psat__m114p_types_h
 
 
 ABC_NAMESPACE_HEADER_START