Bug fix in 'dsat <file.cnf>' when the number of classes in listed incorrectly.

abclib.dsp

@@ -1938,6 +1938,54 @@ SOURCE=.\src\sat\bmc\bmcUnroll.c
 
 # PROP Default_Filter ""
 # End Group
+# Begin Group "xsat"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsat.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatBQueue.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatClause.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatCnfReader.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatHeap.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatMemory.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatSolver.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatSolver.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatSolverAPI.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\xsat\xsatWatchList.h
+# End Source File
+# End Group
 # End Group
 # Begin Group "opt"
 

src/aig/gia/giaShow.c

@@ -52,9 +52,9 @@ void Gia_WriteDotAigSimple( Gia_Man_t * p, char * pFileName, Vec_Int_t * vBold )
     int LevelMax, Prev, Level, i;
     int fConstIsUsed = 0;
 
-    if ( Gia_ManAndNum(p) > 200 )
+    if ( Gia_ManAndNum(p) > 500 )
     {
-        fprintf( stdout, "Cannot visualize AIG with more than 200 nodes.\n" );
+        fprintf( stdout, "Cannot visualize AIG with more than 500 nodes.\n" );
         return;
     }
     if ( (pFile = fopen( pFileName, "w" )) == NULL )
@@ -378,7 +378,7 @@ int Gia_ShowAddOut( Vec_Int_t * vAdds, Vec_Int_t * vMapAdds, int Node )
 {
     int iBox = Vec_IntEntry( vMapAdds, Node );
     if ( iBox >= 0 )
-        return Vec_IntEntry( vAdds, 6*iBox+3 );
+        return Vec_IntEntry( vAdds, 6*iBox+4 );
     return Node;
 }
 void Gia_WriteDotAig( Gia_Man_t * p, char * pFileName, Vec_Int_t * vAdds, Vec_Int_t * vXors, Vec_Int_t * vMapAdds, Vec_Int_t * vMapXors, Vec_Int_t * vOrder )
@@ -388,9 +388,9 @@ void Gia_WriteDotAig( Gia_Man_t * p, char * pFileName, Vec_Int_t * vAdds, Vec_In
     int LevelMax, Prev, Level, i;
     int fConstIsUsed = 0;
 
-    if ( Gia_ManAndNum(p) > 500 )
+    if ( Gia_ManAndNum(p) > 1000 )
     {
-        fprintf( stdout, "Cannot visualize AIG with more than 200 nodes.\n" );
+        fprintf( stdout, "Cannot visualize AIG with more than 1000 nodes.\n" );
         return;
     }
     if ( (pFile = fopen( pFileName, "w" )) == NULL )
@@ -750,7 +750,7 @@ int Gia_ShowCollectObjs_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vAdds,
         Level = 1 + Abc_MaxInt( Abc_MaxInt(Level0, Level1), Level2 );
         Gia_ObjSetLevelId( p, Vec_IntEntry(vAdds, 6*iBox+3), Level );
         Gia_ObjSetLevelId( p, Vec_IntEntry(vAdds, 6*iBox+4), Level );
-        pObj = Gia_ManObj( p, Vec_IntEntry(vAdds, 6*iBox+3) );
+        pObj = Gia_ManObj( p, Vec_IntEntry(vAdds, 6*iBox+4) );
     }
     else if ( Vec_IntEntry(vMapXors, Gia_ObjId(p, pObj)) >= 0 )
     {

src/proof/acec/acecCl.c

@@ -45,6 +45,210 @@ ABC_NAMESPACE_IMPL_START
   SeeAlso     []
 
 ***********************************************************************/
+void Acec_ManDerive_rec( Gia_Man_t * pNew, Gia_Man_t * p, int Node, Vec_Int_t * vMirrors )
+{
+    Gia_Obj_t * pObj;
+    int Obj = Node;
+    if ( Vec_IntEntry(vMirrors, Node) >= 0 )
+        Obj = Abc_Lit2Var( Vec_IntEntry(vMirrors, Node) );
+    pObj = Gia_ManObj( p, Obj );
+    if ( !~pObj->Value )
+    {
+        assert( Gia_ObjIsAnd(pObj) );
+        Acec_ManDerive_rec( pNew, p, Gia_ObjFaninId0(pObj, Obj), vMirrors );
+        Acec_ManDerive_rec( pNew, p, Gia_ObjFaninId1(pObj, Obj), vMirrors );
+        if ( Gia_ObjIsXor(pObj) )
+            pObj->Value = Gia_ManAppendXorReal( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+        else
+            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+    }
+    // set the original node as well
+    if ( Obj != Node )
+        Gia_ManObj(p, Node)->Value = Abc_LitNotCond( pObj->Value, Abc_LitIsCompl(Vec_IntEntry(vMirrors, Node)) );
+} 
+Gia_Man_t * Acec_ManDerive( Gia_Man_t * p, Vec_Int_t * vMirrors )
+{
+    Gia_Man_t * pNew;
+    Gia_Obj_t * pObj;
+    int i;
+    assert( p->pMuxes == NULL );
+    Gia_ManFillValue( p );
+    pNew = Gia_ManStart( Gia_ManObjNum(p) );
+    pNew->pName = Abc_UtilStrsav( p->pName );
+    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
+    Gia_ManConst0(p)->Value = 0;
+    Gia_ManHashAlloc( pNew );
+    Gia_ManForEachCi( p, pObj, i )
+        pObj->Value = Gia_ManAppendCi(pNew);
+    Gia_ManForEachCo( p, pObj, i )
+        Acec_ManDerive_rec( pNew, p, Gia_ObjFaninId0p(p, pObj), vMirrors );
+    Gia_ManForEachCo( p, pObj, i )
+        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
+    Gia_ManHashStop( pNew );
+    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
+    return pNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Acec_CollectXorTops( Gia_Man_t * p )
+{
+    Vec_Int_t * vRootXorSet = Vec_IntAlloc( Gia_ManCoNum(p) );
+    Gia_Obj_t * pObj, * pFan0, * pFan1, * pFan00, * pFan01, * pFan10, * pFan11;
+    int i, fXor0, fXor1, fFirstXor = 0;
+    Gia_ManForEachCoDriver( p, pObj, i )
+    {
+        if ( !Gia_ObjRecognizeExor(pObj, &pFan0, &pFan1) )
+        {
+            if ( fFirstXor )
+            {
+                printf( "XORs do not form a continuous sequence\n" );
+                Vec_IntFreeP( &vRootXorSet );
+                break;
+            }
+            continue;
+        }
+        fFirstXor = 1;
+        fXor0 = Gia_ObjRecognizeExor(Gia_Regular(pFan0), &pFan00, &pFan01);
+        fXor1 = Gia_ObjRecognizeExor(Gia_Regular(pFan1), &pFan10, &pFan11);
+        if ( fXor0 == fXor1 )
+        {
+            printf( "Both inputs of top level XOR have XOR/non-XOR\n" );
+            Vec_IntFreeP( &vRootXorSet );
+            break;
+        }
+        Vec_IntPush( vRootXorSet, Gia_ObjId(p, pObj) );
+        Vec_IntPush( vRootXorSet, fXor1 ? Gia_ObjId(p, Gia_Regular(pFan1))  : Gia_ObjId(p, Gia_Regular(pFan0)) );
+        Vec_IntPush( vRootXorSet, fXor1 ? Gia_ObjId(p, Gia_Regular(pFan10)) : Gia_ObjId(p, Gia_Regular(pFan00)) );
+        Vec_IntPush( vRootXorSet, fXor1 ? Gia_ObjId(p, Gia_Regular(pFan11)) : Gia_ObjId(p, Gia_Regular(pFan01)) );
+    }
+    for ( i = 0; 4*i < Vec_IntSize(vRootXorSet); i++ )
+    {
+        printf( "%2d : ", i );
+        printf( "%4d <- ", Vec_IntEntry(vRootXorSet, 4*i) );
+        printf( "%4d ", Vec_IntEntry(vRootXorSet, 4*i+1) );
+        printf( "%4d ", Vec_IntEntry(vRootXorSet, 4*i+2) );
+        printf( "%4d ", Vec_IntEntry(vRootXorSet, 4*i+3) );
+        printf( "\n" );
+    }
+    return vRootXorSet;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Acec_DetectLitPolarity( Gia_Man_t * p, int Node, int Leaf )
+{
+    Gia_Obj_t * pNode;
+    int Lit0, Lit1;
+    if ( Node < Leaf )
+        return -1;
+    if ( Node == Leaf )
+        return Abc_Var2Lit(Node, 0);
+    pNode = Gia_ManObj( p, Node );
+    Lit0 = Acec_DetectLitPolarity( p, Gia_ObjFaninId0(pNode, Node), Leaf );
+    Lit1 = Acec_DetectLitPolarity( p, Gia_ObjFaninId1(pNode, Node), Leaf );
+    Lit0 = Lit0 == -1 ? Lit0 : Abc_LitNotCond( Lit0, Gia_ObjFaninC0(pNode) );
+    Lit1 = Lit1 == -1 ? Lit1 : Abc_LitNotCond( Lit1, Gia_ObjFaninC1(pNode) );
+    if ( Lit0 == -1 && Lit1 == -1 )
+        return -1;
+    assert( Lit0 != -1 || Lit1 != -1 );
+    if ( Lit0 != -1 && Lit1 != -1 )
+    {
+        assert( Lit0 == Lit1 );
+        return Lit0;
+    }
+    return Lit0 != -1 ? Lit0 : Lit1;
+}
+Gia_Man_t * Acec_DetectXorBuildNew( Gia_Man_t * p, Vec_Int_t * vRootXorSet )
+{
+    Gia_Man_t * pNew;
+    int i, k, iOr1, iAnd1, iAnd2, pLits[3]; // carry, in1, in2
+    Vec_Int_t * vMirrors = Vec_IntStart( Gia_ManObjNum(p) );
+    for ( i = 0; 4*i < Vec_IntSize(vRootXorSet); i++ )
+    {
+        pLits[0] = Acec_DetectLitPolarity( p, Vec_IntEntry(vRootXorSet, 4*i), Vec_IntEntry(vRootXorSet, 4*i+1) );
+        // get polarity of two new ones
+        for ( k = 1; k < 3; k++ )
+            pLits[k] = Acec_DetectLitPolarity( p, Vec_IntEntry(vRootXorSet, 4*i), Vec_IntEntry(vRootXorSet, 4*i+k+1) );
+        // create the gate
+        iOr1  = Gia_ManAppendOr( p, pLits[1], pLits[2] );
+        iAnd1 = Gia_ManAppendAnd( p, pLits[0], iOr1 );
+        iAnd2 = Gia_ManAppendAnd( p, pLits[1], pLits[2] );
+        pLits[0] = Gia_ManAppendOr( p, iAnd1, iAnd2 );
+        Vec_IntWriteEntry( vMirrors, Vec_IntEntry(vRootXorSet, 4*i+1), pLits[0] );
+    }
+    // remap the AIG using map
+    pNew = Acec_ManDerive( p, vMirrors );
+    Vec_IntFree( vMirrors );
+    return pNew;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Gia_Man_t * Acec_DetectAdditional( Gia_Man_t * p, int fVerbose )
+{
+    extern Vec_Int_t * Ree_ManComputeCuts( Gia_Man_t * p, Vec_Int_t ** pvXors, int fVerbose );
+    extern void Ree_ManRemoveTrivial( Gia_Man_t * p, Vec_Int_t * vAdds );
+    extern void Ree_ManRemoveContained( Gia_Man_t * p, Vec_Int_t * vAdds );
+    extern int Ree_ManCountFadds( Vec_Int_t * vAdds );
+    extern void Ree_ManPrintAdders( Vec_Int_t * vAdds, int fVerbose );
+
+    abctime clk = Abc_Clock();
+    Gia_Man_t * pNew;
+    Vec_Int_t * vRootXorSet;
+//    Vec_Int_t * vXors, * vAdds = Ree_ManComputeCuts( p, &vXors, 0 );
+//    Ree_ManRemoveTrivial( p, vAdds );
+//    Ree_ManRemoveContained( p, vAdds );
+
+    //Ree_ManPrintAdders( vAdds, 1 );
+//    printf( "Detected %d full-adders and %d half-adders.  Found %d XOR-cuts.  ", Ree_ManCountFadds(vAdds), Vec_IntSize(vAdds)/6-Ree_ManCountFadds(vAdds), Vec_IntSize(vXors)/4 );
+//    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+
+    clk = Abc_Clock();
+    vRootXorSet = Acec_CollectXorTops( p );
+    if ( vRootXorSet )
+    {
+        pNew = Acec_DetectXorBuildNew( p, vRootXorSet );
+        Vec_IntFree( vRootXorSet );
+    }
+    else
+        pNew = Gia_ManDup( p );
+
+    printf( "Detected %d top XORs.  ", Vec_IntSize(vRootXorSet)/4 );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+
+//    Vec_IntFree( vXors );
+//    Vec_IntFree( vAdds );
+    return pNew;
+}
 
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///

src/sat/cnf/cnfUtil.c

@@ -374,7 +374,7 @@ Cnf_Dat_t * Cnf_DataReadFromFile( char * pFileName )
     // create
     pCnf = ABC_CALLOC( Cnf_Dat_t, 1 );
     pCnf->nVars     = nVars;
-    pCnf->nClauses  = nClas;
+    pCnf->nClauses  = Vec_IntSize(vClas)-1;
     pCnf->nLiterals = Vec_IntSize(vLits);
     pCnf->pClauses  = ABC_ALLOC( int *, Vec_IntSize(vClas) );
     pCnf->pClauses[0] = Vec_IntReleaseArray(vLits);

src/sat/xsat/xsatBQueue.h

@@ -24,6 +24,7 @@
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
+
 #include "misc/util/abc_global.h"
 
 ABC_NAMESPACE_HEADER_START
@@ -31,6 +32,7 @@ ABC_NAMESPACE_HEADER_START
 ////////////////////////////////////////////////////////////////////////
 ///                    STRUCTURE DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
+
 typedef struct xSAT_BQueue_t_ xSAT_BQueue_t;
 struct xSAT_BQueue_t_
 {
@@ -38,13 +40,14 @@ struct xSAT_BQueue_t_
     int nCap;
     int iFirst;
     int iEmpty;
-    uint64_t nSum;
-    uint32_t * pData;
+    word nSum;
+    word * pData;
 };
 
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DECLARATIONS                        ///
 ////////////////////////////////////////////////////////////////////////
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -60,7 +63,7 @@ static inline xSAT_BQueue_t * xSAT_BQueueNew( int nCap )
 {
     xSAT_BQueue_t * p = ABC_CALLOC( xSAT_BQueue_t, 1 );
     p->nCap = nCap;
-    p->pData = ABC_CALLOC( uint32_t, nCap );
+    p->pData = ABC_CALLOC( word, nCap );
     return p;
 }
 
@@ -92,7 +95,7 @@ static inline void xSAT_BQueueFree( xSAT_BQueue_t * p )
   SeeAlso     []
 
 ***********************************************************************/
-static inline void xSAT_BQueuePush( xSAT_BQueue_t * p, uint32_t Value )
+static inline void xSAT_BQueuePush( xSAT_BQueue_t * p, word Value )
 {
     if ( p->nSize == p->nCap )
     {
@@ -125,8 +128,8 @@ static inline void xSAT_BQueuePush( xSAT_BQueue_t * p, uint32_t Value )
 ***********************************************************************/
 static inline int xSAT_BQueuePop( xSAT_BQueue_t * p )
 {
-    assert( p->nSize >= 1 );
     int RetValue = p->pData[p->iFirst];
+    assert( p->nSize >= 1 );
     p->nSum -= RetValue;
     p->iFirst = ( p->iFirst + 1 ) % p->nCap;
     p->nSize--;
@@ -144,9 +147,9 @@ static inline int xSAT_BQueuePop( xSAT_BQueue_t * p )
   SeeAlso     []
 
 ***********************************************************************/
-static inline uint32_t xSAT_BQueueAvg( xSAT_BQueue_t * p )
+static inline word xSAT_BQueueAvg( xSAT_BQueue_t * p )
 {
-    return ( uint32_t )( p->nSum / ( ( uint64_t ) p->nSize ) );
+    return ( word )( p->nSum / ( ( word ) p->nSize ) );
 }
 
 /**Function*************************************************************

src/sat/xsat/xsatClause.h

@@ -96,7 +96,7 @@ static void xSAT_ClausePrint( xSAT_Clause_t * pCla )
     int i;
 
     printf("{ ");
-    for ( i = 0; i < pCla->nSize; i++ )
+    for ( i = 0; i < (int)pCla->nSize; i++ )
         printf("%d ", pCla->pData[i].Lit );
     printf("}\n");
 }

src/sat/xsat/xsatMemory.h

@@ -36,10 +36,10 @@ ABC_NAMESPACE_HEADER_START
 typedef struct xSAT_Mem_t_ xSAT_Mem_t;
 struct xSAT_Mem_t_
 {
-    uint32_t   nSize;
-    uint32_t   nCap;
-    uint32_t   nWasted;
-    uint32_t * pData;
+    unsigned   nSize;
+    unsigned   nCap;
+    unsigned   nWasted;
+    unsigned * pData;
 };
 
 ////////////////////////////////////////////////////////////////////////
@@ -58,7 +58,7 @@ struct xSAT_Mem_t_
 ***********************************************************************/
 static inline xSAT_Clause_t *  xSAT_MemClauseHand( xSAT_Mem_t * p, int h )
 {
-    return h != UINT32_MAX ? ( xSAT_Clause_t * )( p->pData + h ) : NULL;
+    return h != 0xFFFFFFFF ? ( xSAT_Clause_t * )( p->pData + h ) : NULL;
 }
 
 /**Function*************************************************************
@@ -72,21 +72,21 @@ static inline xSAT_Clause_t *  xSAT_MemClauseHand( xSAT_Mem_t * p, int h )
   SeeAlso     []
 
 ***********************************************************************/
-static inline void xSAT_MemGrow( xSAT_Mem_t * p, uint32_t nCap )
+static inline void xSAT_MemGrow( xSAT_Mem_t * p, unsigned nCap )
 {
+    unsigned nPrevCap = p->nCap;
     if ( p->nCap >= nCap )
         return;
 
-    uint32_t nPrevCap = p->nCap;
     while (p->nCap < nCap)
     {
-        uint32_t delta = ((p->nCap >> 1) + (p->nCap >> 3) + 2) & ~1;
+        unsigned delta = ((p->nCap >> 1) + (p->nCap >> 3) + 2) & ~1;
         p->nCap += delta;
         assert(p->nCap >= nPrevCap);
     }
 
     assert(p->nCap > 0);
-    p->pData = ABC_REALLOC(uint32_t, p->pData, p->nCap);
+    p->pData = ABC_REALLOC(unsigned, p->pData, p->nCap);
 }
 
 /**Function*************************************************************
@@ -156,12 +156,13 @@ static inline void xSAT_MemFree( xSAT_Mem_t * p )
   SeeAlso     []
 
 ***********************************************************************/
-static inline uint32_t xSAT_MemAppend( xSAT_Mem_t * p, int nSize )
+static inline unsigned xSAT_MemAppend( xSAT_Mem_t * p, int nSize )
 {
+    unsigned nPrevSize;
     assert(nSize > 0);
     xSAT_MemGrow(p, p->nSize + nSize);
 
-    uint32_t nPrevSize = p->nSize;
+    nPrevSize = p->nSize;
     p->nSize += nSize;
     assert(p->nSize > nPrevSize);
 
@@ -179,9 +180,9 @@ static inline uint32_t xSAT_MemAppend( xSAT_Mem_t * p, int nSize )
   SeeAlso     []
 
 ***********************************************************************/
-static inline uint32_t xSAT_MemCRef( xSAT_Mem_t * p, uint32_t * pC )
+static inline unsigned xSAT_MemCRef( xSAT_Mem_t * p, unsigned * pC )
 {
-    return ( uint32_t )( pC - &(p->pData[0]) );
+    return ( unsigned )( pC - &(p->pData[0]) );
 }
 
 /**Function*************************************************************
@@ -195,7 +196,7 @@ static inline uint32_t xSAT_MemCRef( xSAT_Mem_t * p, uint32_t * pC )
   SeeAlso     []
 
 ***********************************************************************/
-static inline uint32_t xSAT_MemCap( xSAT_Mem_t * p )
+static inline unsigned xSAT_MemCap( xSAT_Mem_t * p )
 {
     return p->nCap;
 }
@@ -211,7 +212,7 @@ static inline uint32_t xSAT_MemCap( xSAT_Mem_t * p )
   SeeAlso     []
 
 ***********************************************************************/
-static inline uint32_t xSAT_MemWastedCap( xSAT_Mem_t * p )
+static inline unsigned xSAT_MemWastedCap( xSAT_Mem_t * p )
 {
     return p->nWasted;
 }

src/sat/xsat/xsatSolver.h

@@ -70,7 +70,7 @@ enum
     LitUndef = -2
 };
 
-#define CRefUndef UINT32_MAX
+#define CRefUndef 0xFFFFFFFF
 
 ////////////////////////////////////////////////////////////////////////
 ///                    STRUCTURE DEFINITIONS                         ///
@@ -81,8 +81,8 @@ struct xSAT_SolverOptions_t_
     char fVerbose;
 
     // Limits
-    ABC_INT64_T nConfLimit;    // external limit on the number of conflicts
-    ABC_INT64_T nInsLimit;     // external limit on the number of implications
+    word nConfLimit;    // external limit on the number of conflicts
+    word nInsLimit;     // external limit on the number of implications
     abctime     nRuntimeLimit; // external limit on runtime
 
     // Constants used for restart heuristic
@@ -105,13 +105,13 @@ struct xSAT_Stats_t_
     unsigned nStarts;
     unsigned nReduceDB;
 
-    ABC_INT64_T nDecisions;
-    ABC_INT64_T nPropagations;
-    ABC_INT64_T nInspects;
-    ABC_INT64_T nConflicts;
+    word nDecisions;
+    word nPropagations;
+    word nInspects;
+    word nConflicts;
 
-    ABC_INT64_T nClauseLits;
-    ABC_INT64_T nLearntLits;
+    word nClauseLits;
+    word nLearntLits;
 };
 
 struct xSAT_Solver_t_
@@ -143,7 +143,7 @@ struct xSAT_Solver_t_
 
     int     nAssignSimplify; /* Number of top-level assignments since last
                               * execution of 'simplify()'. */
-    int64_t nPropSimplify;   /* Remaining number of propagations that must be
+    word nPropSimplify;   /* Remaining number of propagations that must be
                               * made before next execution of 'simplify()'. */
 
     /* Temporary data used by Search method */
@@ -195,16 +195,17 @@ static inline int xSAT_SolverDecisionLevel( xSAT_Solver_t * s )
     return Vec_IntSize( s->vTrailLim );
 }
 
-static inline xSAT_Clause_t * xSAT_SolverReadClause( xSAT_Solver_t * s, uint32_t h )
+static inline xSAT_Clause_t * xSAT_SolverReadClause( xSAT_Solver_t * s, unsigned h )
 {
     return xSAT_MemClauseHand( s->pMemory, h );
 }
 
 static inline int xSAT_SolverIsClauseSatisfied( xSAT_Solver_t * s, xSAT_Clause_t * pCla )
 {
+    int i;
     int * lits = &( pCla->pData[0].Lit );
 
-    for ( int i = 0; i < pCla->nSize; i++ )
+    for ( i = 0; i < (int)pCla->nSize; i++ )
         if ( Vec_StrEntry( s->vAssigns, xSAT_Lit2Var( lits[i] ) ) == xSAT_LitSign( ( lits[i] ) ) )
             return true;
 
@@ -232,14 +233,14 @@ static inline void xSAT_SolverPrintState( xSAT_Solver_t * s )
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DECLARATIONS                        ///
 ////////////////////////////////////////////////////////////////////////
-extern uint32_t xSAT_SolverClaNew( xSAT_Solver_t* s, Vec_Int_t * vLits, int fLearnt );
+extern unsigned xSAT_SolverClaNew( xSAT_Solver_t* s, Vec_Int_t * vLits, int fLearnt );
 extern char    xSAT_SolverSearch( xSAT_Solver_t * s );
 
 extern void xSAT_SolverGarbageCollect( xSAT_Solver_t * s );
 
-extern int xSAT_SolverEnqueue( xSAT_Solver_t* s, int Lit, uint32_t From );
+extern int xSAT_SolverEnqueue( xSAT_Solver_t* s, int Lit, unsigned From );
 extern void xSAT_SolverCancelUntil( xSAT_Solver_t* s, int Level);
-extern uint32_t xSAT_SolverPropagate( xSAT_Solver_t* s );
+extern unsigned xSAT_SolverPropagate( xSAT_Solver_t* s );
 extern void xSAT_SolverRebuildOrderHeap( xSAT_Solver_t* s );
 
 ABC_NAMESPACE_HEADER_END

src/sat/xsat/xsatSolverAPI.c

@@ -32,23 +32,23 @@ ABC_NAMESPACE_IMPL_START
 
 xSAT_SolverOptions_t DefaultConfig =
 {
-    .fVerbose = 1,
+    1,     //.fVerbose = 1,
 
-    .nConfLimit = 0,
-    .nInsLimit = 0,
-    .nRuntimeLimit = 0,
+    0,     //.nConfLimit = 0,
+    0,     //.nInsLimit = 0,
+    0,     //.nRuntimeLimit = 0,
 
-    .K = 0.8,
-    .R = 1.4,
-    .nFirstBlockRestart = 10000,
-    .nSizeLBDQueue = 50,
-    .nSizeTrailQueue = 5000,
+    0.8,   //.K = 0.8,
+    1.4,   //.R = 1.4,
+    10000, //.nFirstBlockRestart = 10000,
+    50,    //.nSizeLBDQueue = 50,
+    5000,  //.nSizeTrailQueue = 5000,
 
-    .nConfFirstReduce = 2000,
-    .nIncReduce = 300,
-    .nSpecialIncReduce = 1000,
+    2000,  //.nConfFirstReduce = 2000,
+    300,   //.nIncReduce = 300,
+    1000,  //.nSpecialIncReduce = 1000,
 
-    .nLBDFrozenClause = 30
+    30     //.nLBDFrozenClause = 30
 };
 
 /**Function*************************************************************
@@ -142,6 +142,7 @@ void xSAT_SolverDestroy( xSAT_Solver_t * s )
     Vec_StrFree( s->vAssigns );
     Vec_IntFree( s->vLevels );
     Vec_IntFree( s->vReasons );
+    Vec_IntFree( s->vStamp );
 
     xSAT_BQueueFree(s->bqLBD);
     xSAT_BQueueFree(s->bqTrail);
@@ -163,7 +164,7 @@ void xSAT_SolverDestroy( xSAT_Solver_t * s )
 int xSAT_SolverSimplify( xSAT_Solver_t * s )
 {
     int i, j;
-    uint32_t CRef;
+    unsigned CRef;
     assert( xSAT_SolverDecisionLevel(s) == 0 );
 
     if ( xSAT_SolverPropagate(s) != CRefUndef )

src/sat/xsat/xsatWatchList.h

@@ -34,7 +34,7 @@ ABC_NAMESPACE_HEADER_START
 typedef struct xSAT_Watcher_t_ xSAT_Watcher_t;
 struct xSAT_Watcher_t_
 {
-    uint32_t CRef;
+    unsigned CRef;
     int Blocker;
 };
 
@@ -162,7 +162,7 @@ static inline xSAT_Watcher_t* xSAT_WatchListArray( xSAT_WatchList_t * v )
   SeeAlso     []
 
 ***********************************************************************/
-static inline void xSAT_WatchListRemove( xSAT_WatchList_t * v, uint32_t CRef )
+static inline void xSAT_WatchListRemove( xSAT_WatchList_t * v, unsigned CRef )
 {
     xSAT_Watcher_t* ws = xSAT_WatchListArray(v);
     int j = 0;
@@ -207,7 +207,8 @@ static inline xSAT_VecWatchList_t * xSAT_VecWatchListAlloc( int nCap )
 ***********************************************************************/
 static inline void xSAT_VecWatchListFree( xSAT_VecWatchList_t* v )
 {
-    for( int i = 0; i < v->nSize; i++ )
+    int i;
+    for( i = 0; i < v->nSize; i++ )
         xSAT_WatchListFree( v->pArray + i );
 
     ABC_FREE( v->pArray );