Fixing some warnings by adding cast from 'int' to 'size_t' in memset, memcpy, etc.

114 files changed, 263 insertions, 263 deletions

diff --git a/src/aig/aig/aigCanon.c b/src/aig/aig/aigCanon.c
index 5ae3cd65..02c9ab8f 100644
--- a/src/aig/aig/aigCanon.c
+++ b/src/aig/aig/aigCanon.c
@@ -631,7 +631,7 @@ void Aig_RManRecord( unsigned * pTruth, int nVarsInit )
     // compute the number of words
     nWords = Abc_TruthWordNum( nVars );
     // copy the function
-    memcpy( s_pRMan->pTruthInit, Kit_DsdObjTruth(pObj), 4*nWords );
+    memcpy( s_pRMan->pTruthInit, Kit_DsdObjTruth(pObj), (size_t)(4*nWords) );
     Kit_DsdNtkFree( pNtk );
     // canonicize the output
     if ( s_pRMan->pTruthInit[0] & 1 )
diff --git a/src/aig/gia/giaAiger.c b/src/aig/gia/giaAiger.c
index 47986faa..6cf3e2e7 100644
--- a/src/aig/gia/giaAiger.c
+++ b/src/aig/gia/giaAiger.c
@@ -525,7 +525,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
             {
                 pCur++;
                 vStr = Vec_StrStart( Gia_AigerReadInt(pCur) );             pCur += 4;
-                memcpy( Vec_StrArray(vStr), pCur, Vec_StrSize(vStr) );
+                memcpy( Vec_StrArray(vStr), pCur, (size_t)Vec_StrSize(vStr) );
                 pCur += Vec_StrSize(vStr);
                 pNew->pAigExtra = Gia_AigerReadFromMemory( Vec_StrArray(vStr), Vec_StrSize(vStr), 0, 0, 0 );
                 Vec_StrFree( vStr );
@@ -552,7 +552,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
                 pCur++;
                 nInputs = Gia_AigerReadInt(pCur)/4;                        pCur += 4;
                 pNew->vInArrs  = Vec_FltStart( nInputs );
-                memcpy( Vec_FltArray(pNew->vInArrs),  pCur, 4*nInputs );   pCur += 4*nInputs;
+                memcpy( Vec_FltArray(pNew->vInArrs),  pCur, (size_t)4*nInputs );   pCur += 4*nInputs;
                 if ( fVerbose ) printf( "Finished reading extension \"i\".\n" );
             }
             else if ( *pCur == 'o' )
@@ -560,7 +560,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
                 pCur++;
                 nOutputs = Gia_AigerReadInt(pCur)/4;                       pCur += 4;
                 pNew->vOutReqs  = Vec_FltStart( nOutputs );
-                memcpy( Vec_FltArray(pNew->vOutReqs),  pCur, 4*nOutputs ); pCur += 4*nOutputs;
+                memcpy( Vec_FltArray(pNew->vOutReqs),  pCur, (size_t)4*nOutputs ); pCur += 4*nOutputs;
                 if ( fVerbose ) printf( "Finished reading extension \"o\".\n" );
             }
             // read equivalence classes
@@ -580,7 +580,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
                 pCur++;
                 assert( Gia_AigerReadInt(pCur) == 4*Gia_ManRegNum(pNew) );   pCur += 4;
                 pNew->vFlopClasses  = Vec_IntStart( Gia_ManRegNum(pNew) );
-                memcpy( Vec_IntArray(pNew->vFlopClasses),  pCur, 4*Gia_ManRegNum(pNew) );   pCur += 4*Gia_ManRegNum(pNew);
+                memcpy( Vec_IntArray(pNew->vFlopClasses),  pCur, (size_t)4*Gia_ManRegNum(pNew) );   pCur += 4*Gia_ManRegNum(pNew);
                 if ( fVerbose ) printf( "Finished reading extension \"f\".\n" );
             }
             // read gate classes
@@ -589,7 +589,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
                 pCur++;
                 assert( Gia_AigerReadInt(pCur) == 4*Gia_ManObjNum(pNew) );   pCur += 4;
                 pNew->vGateClasses  = Vec_IntStart( Gia_ManObjNum(pNew) );
-                memcpy( Vec_IntArray(pNew->vGateClasses),  pCur, 4*Gia_ManObjNum(pNew) );   pCur += 4*Gia_ManObjNum(pNew);
+                memcpy( Vec_IntArray(pNew->vGateClasses),  pCur, (size_t)4*Gia_ManObjNum(pNew) );   pCur += 4*Gia_ManObjNum(pNew);
                 if ( fVerbose ) printf( "Finished reading extension \"g\".\n" );
             }
             // read hierarchy information
@@ -597,7 +597,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
             {
                 pCur++;
                 vStr = Vec_StrStart( Gia_AigerReadInt(pCur) );          pCur += 4;
-                memcpy( Vec_StrArray(vStr), pCur, Vec_StrSize(vStr) );
+                memcpy( Vec_StrArray(vStr), pCur, (size_t)Vec_StrSize(vStr) );
                 pCur += Vec_StrSize(vStr);
                 pNew->pManTime = Tim_ManLoad( vStr, 1 );
                 Vec_StrFree( vStr );
@@ -653,7 +653,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
                 pCur++;
                 pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                 pPlacement = ABC_ALLOC( Gia_Plc_t, Gia_ManObjNum(pNew) );
-                memcpy( pPlacement, pCur, 4*Gia_ManObjNum(pNew) );      pCur += 4*Gia_ManObjNum(pNew);
+                memcpy( pPlacement, pCur, (size_t)4*Gia_ManObjNum(pNew) );      pCur += 4*Gia_ManObjNum(pNew);
                 assert( pCur == pCurTemp );
                 pNew->pPlacement = pPlacement;
                 if ( fVerbose ) printf( "Finished reading extension \"p\".\n" );
@@ -696,7 +696,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
                 nSize = nSize - strlen(pNew->pCellStr) - 1;
                 assert( nSize % 4 == 0 );
                 pNew->vConfigs = Vec_IntAlloc(nSize / 4);
-//                memcpy(Vec_IntArray(pNew->vConfigs), pCur, nSize);      pCur += nSize;
+//                memcpy(Vec_IntArray(pNew->vConfigs), pCur, (size_t)nSize);      pCur += nSize;
                 for ( i = 0; i < nSize / 4; i++ )
                     Vec_IntPush( pNew->vConfigs, Gia_AigerReadInt(pCur) ), pCur += 4;
                 assert( pCur == pCurTemp );
@@ -728,7 +728,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
                 pCur++;
                 pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                 pSwitching = ABC_ALLOC( unsigned char, Gia_ManObjNum(pNew) );
-                memcpy( pSwitching, pCur, Gia_ManObjNum(pNew) );        pCur += Gia_ManObjNum(pNew);
+                memcpy( pSwitching, pCur, (size_t)Gia_ManObjNum(pNew) );        pCur += Gia_ManObjNum(pNew);
                 assert( pCur == pCurTemp );
                 if ( fVerbose ) printf( "Finished reading extension \"s\".\n" );
             }
@@ -737,7 +737,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
             {
                 pCur++;
                 vStr = Vec_StrStart( Gia_AigerReadInt(pCur) );          pCur += 4;
-                memcpy( Vec_StrArray(vStr), pCur, Vec_StrSize(vStr) );  pCur += Vec_StrSize(vStr);
+                memcpy( Vec_StrArray(vStr), pCur, (size_t)Vec_StrSize(vStr) );  pCur += Vec_StrSize(vStr);
                 pNew->pManTime = Tim_ManLoad( vStr, 0 );
                 Vec_StrFree( vStr );
                 if ( fVerbose ) printf( "Finished reading extension \"t\".\n" );
@@ -747,7 +747,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
             {
                 pCur++;
                 pNew->vObjClasses = Vec_IntStart( Gia_AigerReadInt(pCur)/4 ); pCur += 4;
-                memcpy( Vec_IntArray(pNew->vObjClasses), pCur, 4*Vec_IntSize(pNew->vObjClasses) );
+                memcpy( Vec_IntArray(pNew->vObjClasses), pCur, (size_t)4*Vec_IntSize(pNew->vObjClasses) );
                 pCur += 4*Vec_IntSize(pNew->vObjClasses);
                 if ( fVerbose ) printf( "Finished reading extension \"v\".\n" );
             }
diff --git a/src/aig/gia/giaAigerExt.c b/src/aig/gia/giaAigerExt.c
index 7b7758ff..50c3588d 100644
--- a/src/aig/gia/giaAigerExt.c
+++ b/src/aig/gia/giaAigerExt.c
@@ -218,7 +218,7 @@ Vec_Str_t * Gia_AigerWriteMapping( Gia_Man_t * p )
 ***********************************************************************/
 int * Gia_AigerReadMappingSimple( unsigned char ** ppPos, int nSize )
 {
-    int * pMapping = ABC_ALLOC( int, nSize/4 );
+    int * pMapping = ABC_ALLOC( int, (size_t)nSize/4 );
     memcpy( pMapping, *ppPos, nSize );
     assert( nSize % 4 == 0 );
     return pMapping;
@@ -226,7 +226,7 @@ int * Gia_AigerReadMappingSimple( unsigned char ** ppPos, int nSize )
 Vec_Str_t * Gia_AigerWriteMappingSimple( Gia_Man_t * p )
 {
     unsigned char * pBuffer = ABC_ALLOC( unsigned char, 4*Vec_IntSize(p->vMapping) );
-    memcpy( pBuffer, Vec_IntArray(p->vMapping), 4*Vec_IntSize(p->vMapping) );
+    memcpy( pBuffer, Vec_IntArray(p->vMapping), (size_t)4*Vec_IntSize(p->vMapping) );
     assert( Vec_IntSize(p->vMapping) >= Gia_ManObjNum(p) );
     return Vec_StrAllocArray( (char *)pBuffer, 4*Vec_IntSize(p->vMapping) );
 }
diff --git a/src/aig/gia/giaSort.c b/src/aig/gia/giaSort.c
index 7586be65..d64a80c5 100644
--- a/src/aig/gia/giaSort.c
+++ b/src/aig/gia/giaSort.c
@@ -165,7 +165,7 @@ void Gia_SortTest()
     printf( "Sorting %d integers\n", nSize );
     pArray = Gia_SortGetTest( nSize );
 clk = Abc_Clock();
-    qsort( pArray, nSize, 4, (int (*)(const void *, const void *)) num_cmp1 );
+    qsort( pArray, (size_t)nSize, 4, (int (*)(const void *, const void *)) num_cmp1 );
 ABC_PRT( "qsort  ", Abc_Clock() - clk );
     Gia_SortVerifySorted( pArray, nSize );
     ABC_FREE( pArray );
diff --git a/src/aig/gia/giaStg.c b/src/aig/gia/giaStg.c
index 9588d51c..9b6d49b6 100644
--- a/src/aig/gia/giaStg.c
+++ b/src/aig/gia/giaStg.c
@@ -53,7 +53,7 @@ void Gia_ManPrintStateEncoding( Vec_Vec_t * vCodes, int nBits )
     Vec_VecForEachLevelInt( vCodes, vVec, i )
     {
         printf( "%6d : ", i+1 );
-        memset( pBuffer, '-', nBits );
+        memset( pBuffer, '-', (size_t)nBits );
         Vec_IntForEachEntry( vVec, Bit, k )
         {
             assert( Bit < nBits );
diff --git a/src/aig/gia/giaUnate.c b/src/aig/gia/giaUnate.c
index b627641e..cf8d9104 100644
--- a/src/aig/gia/giaUnate.c
+++ b/src/aig/gia/giaUnate.c
@@ -178,7 +178,7 @@ void Gia_ManCheckUnateVecTest( Gia_Man_t * p, int fVerbose )
     for ( o = 0; o < Gia_ManCoNum(p); o++ )
     {
         Vec_Int_t * vUnate = Vec_WecEntry( vUnates, o );
-        memset( pBuffer, ' ', nVars );
+        memset( pBuffer, ' ', (size_t)nVars );
         Vec_IntForEachEntry( vUnate, Var, i )
             if ( i+1 < Vec_IntSize(vUnate) && Abc_Lit2Var(Var) == Abc_Lit2Var(Vec_IntEntry(vUnate, i+1)) ) // both lits are present
                 pBuffer[Abc_Lit2Var(Var)] = '.', i++, nNonUnate++; // does not depend on this var
diff --git a/src/aig/ivy/ivyCutTrav.c b/src/aig/ivy/ivyCutTrav.c
index 75acd260..74212b10 100644
--- a/src/aig/ivy/ivyCutTrav.c
+++ b/src/aig/ivy/ivyCutTrav.c
@@ -142,7 +142,7 @@ unsigned * Ivy_NodeCutElementary( Vec_Int_t * vStore, int nWords, int NodeId )
 {
     unsigned * pBitCut;
     pBitCut = Vec_IntFetch( vStore, nWords );
-    memset( pBitCut, 0, 4 * nWords );
+    memset( pBitCut, 0, (size_t)(4 * nWords) );
     Extra_TruthSetBit( pBitCut, NodeId );
     return pBitCut;
 }
diff --git a/src/aig/ivy/ivyFraig.c b/src/aig/ivy/ivyFraig.c
index b51902bb..0bf05ee8 100644
--- a/src/aig/ivy/ivyFraig.c
+++ b/src/aig/ivy/ivyFraig.c
@@ -572,7 +572,7 @@ Ivy_FraigMan_t * Ivy_FraigStart( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParam
 //    p->pSimWords    = ABC_ALLOC( unsigned, Ivy_ManObjNum(pManAig) * p->nSimWords ); 
     EntrySize    = sizeof(Ivy_FraigSim_t) + sizeof(unsigned) * p->nSimWords;
     p->pSimWords = (char *)ABC_ALLOC( char, Ivy_ManObjNum(pManAig) * EntrySize ); 
-    memset( p->pSimWords, 0, EntrySize );
+    memset( p->pSimWords, 0, (size_t)EntrySize );
     k = 0;
     Ivy_ManForEachObj( pManAig, pObj, i )
     {
diff --git a/src/aig/miniaig/ndr.h b/src/aig/miniaig/ndr.h
index c854debe..fa076896 100644
--- a/src/aig/miniaig/ndr.h
+++ b/src/aig/miniaig/ndr.h
@@ -201,8 +201,8 @@ static inline void Ndr_DataPushArray( Ndr_Data_t * p, int Type, int nArray, int
         return;
     assert( nArray > 0 );
     Ndr_DataResize( p, nArray );
-    memset( p->pHead + p->nSize, Type, nArray );
-    memcpy( p->pBody + p->nSize, pArray, 4*nArray );
+    memset( p->pHead + p->nSize, Type, (size_t)nArray );
+    memcpy( p->pBody + p->nSize, pArray, (size_t)4*nArray );
     p->nSize += nArray;
 }
 static inline void Ndr_DataPushString( Ndr_Data_t * p, int Type, char * pFunc )
diff --git a/src/base/abc/abcFanOrder.c b/src/base/abc/abcFanOrder.c
index bfd99f38..8e2ed10d 100644
--- a/src/base/abc/abcFanOrder.c
+++ b/src/base/abc/abcFanOrder.c
@@ -66,7 +66,7 @@ void Abc_NtkOrderFaninsById( Abc_Ntk_t * pNtk )
         Vec_IntSelectSortCost( pOrder, nVars, &pNode->vFanins );
         // copy the cover
         Vec_StrGrow( vStore, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
-        memcpy( Vec_StrArray(vStore), pSop, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
+        memcpy( Vec_StrArray(vStore), pSop, (size_t)(Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1) );
         pSopNew = pCubeNew = pSop;
         pSop = Vec_StrArray(vStore);
         // generate permuted one
@@ -168,7 +168,7 @@ void Abc_NtkOrderFaninsBySortingColumns( Abc_Ntk_t * pNtk )
         pOrder = Vec_IntArray(vOrder);
         // copy the cover
         Vec_StrGrow( vStore, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
-        memcpy( Vec_StrArray(vStore), pSop, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
+        memcpy( Vec_StrArray(vStore), pSop, (size_t)(Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1) );
         pSopNew = pCubeNew = pSop;
         pSop = Vec_StrArray(vStore);
         // generate permuted one
@@ -272,7 +272,7 @@ void Abc_NtkOrderFaninsByLitCount( Abc_Ntk_t * pNtk )
 */
         // copy the cover
         Vec_StrGrow( vStore, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
-        memcpy( Vec_StrArray(vStore), pSop, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
+        memcpy( Vec_StrArray(vStore), pSop, (size_t)(Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1) );
         pSopNew = pCubeNew = pSop;
         pSop = Vec_StrArray(vStore);
         // generate permuted one
@@ -353,7 +353,7 @@ void Abc_NtkOrderFaninsByLitCountAndCubeCount( Abc_Ntk_t * pNtk )
         Vec_IntSelectSortCost( pOrder, nVars, vCounts );
         // copy the cover
         Vec_StrGrow( vStore, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
-        memcpy( Vec_StrArray(vStore), pSop, Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1 );
+        memcpy( Vec_StrArray(vStore), pSop, (size_t)(Abc_SopGetCubeNum(pSop) * (nVars + 3) + 1) );
         pSopNew = pCubeNew = pSop;
         pSop = Vec_StrArray(vStore);
         // generate permuted one
@@ -485,10 +485,10 @@ void Abc_NodeSortCubes( Abc_Obj_t * pNode, Vec_Ptr_t * vCubes, Vec_Str_t * vStor
     {
         assert( pCube[nVars] == 0 );
         pCube[nVars] = ' ';
-        memcpy( pPivot, pCube, nVars + 3 );
+        memcpy( pPivot, pCube, (size_t)(nVars + 3) );
         pPivot += nVars + 3;
     }
-    memcpy( pSop, Vec_StrArray(vStore), Vec_PtrSize(vCubes) * (nVars + 3) );
+    memcpy( pSop, Vec_StrArray(vStore), (size_t)(Vec_PtrSize(vCubes) * (nVars + 3)) );
 }
 void Abc_NtkSortCubes( Abc_Ntk_t * pNtk, int fWeight )
 {
@@ -581,7 +581,7 @@ int Abc_NodeMakeSCCFree( Abc_Obj_t * pNode )
     {
         if ( pCube[0] == 'z' )
             continue;
-        memcpy( pSopNew, pCube, nVars + 3 );
+        memcpy( pSopNew, pCube, (size_t)(nVars + 3) );
         pSopNew += nVars + 3;
     }
     *pSopNew = 0;
diff --git a/src/base/abc/abcNames.c b/src/base/abc/abcNames.c
index b32093e9..fe9b3dca 100644
--- a/src/base/abc/abcNames.c
+++ b/src/base/abc/abcNames.c
@@ -334,13 +334,13 @@ void Abc_NtkOrderObjsByName( Abc_Ntk_t * pNtk, int fComb )
     Abc_NtkForEachBox( pNtk, pObj, i )
         pObj->pCopy = (Abc_Obj_t *)Abc_ObjName(Abc_ObjFanout0(pObj));
     // order objects alphabetically
-    qsort( (void *)Vec_PtrArray(pNtk->vPis), Vec_PtrSize(pNtk->vPis), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(pNtk->vPis), (size_t)Vec_PtrSize(pNtk->vPis), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareNames );
-    qsort( (void *)Vec_PtrArray(pNtk->vPos), Vec_PtrSize(pNtk->vPos), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(pNtk->vPos), (size_t)Vec_PtrSize(pNtk->vPos), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareNames );
     // if the comparison if combinational (latches as PIs/POs), order them too
     if ( fComb )
-        qsort( (void *)Vec_PtrArray(pNtk->vBoxes), Vec_PtrSize(pNtk->vBoxes), sizeof(Abc_Obj_t *), 
+        qsort( (void *)Vec_PtrArray(pNtk->vBoxes), (size_t)Vec_PtrSize(pNtk->vBoxes), sizeof(Abc_Obj_t *), 
             (int (*)(const void *, const void *)) Abc_NodeCompareNames );
     // order CIs/COs first PIs/POs(Asserts) then latches
     Abc_NtkOrderCisCos( pNtk );
@@ -428,14 +428,14 @@ void Abc_NtkTransferOrder( Abc_Ntk_t * pNtkOld, Abc_Ntk_t * pNtkNew )
     Abc_NamDeref( pStrsCi );
     Abc_NamDeref( pStrsCo );
     // order PI/PO 
-    qsort( (void *)Vec_PtrArray(pNtkNew->vPis), Vec_PtrSize(pNtkNew->vPis), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(pNtkNew->vPis), (size_t)Vec_PtrSize(pNtkNew->vPis), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareIndexes );
-    qsort( (void *)Vec_PtrArray(pNtkNew->vPos), Vec_PtrSize(pNtkNew->vPos), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(pNtkNew->vPos), (size_t)Vec_PtrSize(pNtkNew->vPos), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareIndexes );
     // order CI/CO 
-    qsort( (void *)Vec_PtrArray(pNtkNew->vCis), Vec_PtrSize(pNtkNew->vCis), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(pNtkNew->vCis), (size_t)Vec_PtrSize(pNtkNew->vCis), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareIndexes );
-    qsort( (void *)Vec_PtrArray(pNtkNew->vCos), Vec_PtrSize(pNtkNew->vCos), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(pNtkNew->vCos), (size_t)Vec_PtrSize(pNtkNew->vCos), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareIndexes );
     // order CIs/COs first PIs/POs(Asserts) then latches
     //Abc_NtkOrderCisCos( pNtk );
diff --git a/src/base/abc/abcNtk.c b/src/base/abc/abcNtk.c
index a62542b9..8e10ab3b 100644
--- a/src/base/abc/abcNtk.c
+++ b/src/base/abc/abcNtk.c
@@ -2091,7 +2091,7 @@ int Abc_NodeCompareByFanoutCount( Abc_Obj_t ** pp1, Abc_Obj_t ** pp2 )
 void Abc_NtkPermutePiUsingFanout( Abc_Ntk_t * pNtk )
 {
     Abc_Obj_t * pNode; int i;
-    qsort( (void *)Vec_PtrArray(pNtk->vPis), Vec_PtrSize(pNtk->vPis), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(pNtk->vPis), (size_t)Vec_PtrSize(pNtk->vPis), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareByFanoutCount );
     Vec_PtrClear( pNtk->vCis );
     Vec_PtrForEachEntry( Abc_Obj_t *, pNtk->vPis, pNode, i )
diff --git a/src/base/abc/abcSop.c b/src/base/abc/abcSop.c
index af758970..b0ce2ab7 100644
--- a/src/base/abc/abcSop.c
+++ b/src/base/abc/abcSop.c
@@ -81,7 +81,7 @@ char * Abc_SopStart( Mem_Flex_t * pMan, int nCubes, int nVars )
 
     Length = nCubes * (nVars + 3);
     pSopCover = Mem_FlexEntryFetch( pMan, Length + 1 );
-    memset( pSopCover, '-', Length );
+    memset( pSopCover, '-', (size_t)Length );
     pSopCover[Length] = 0;
 
     for ( i = 0; i < nCubes; i++ )
diff --git a/src/base/abc/abcUtil.c b/src/base/abc/abcUtil.c
index a63abb9e..038079e8 100644
--- a/src/base/abc/abcUtil.c
+++ b/src/base/abc/abcUtil.c
@@ -2139,7 +2139,7 @@ void Abc_NtkCompareCones( Abc_Ntk_t * pNtk )
         pSupps[i] = Vec_PtrSize(vSupp);
         Vec_PtrFree( vSupp );
     }
-    qsort( (void *)pPerms, Abc_NtkCoNum(pNtk), sizeof(int), (int (*)(const void *, const void *)) Abc_NtkCompareConesCompare );
+    qsort( (void *)pPerms, (size_t)Abc_NtkCoNum(pNtk), sizeof(int), (int (*)(const void *, const void *)) Abc_NtkCompareConesCompare );
 
     // consider COs in this order
     Iter = 0;
diff --git a/src/base/abci/abcCollapse.c b/src/base/abci/abcCollapse.c
index caeea3a1..ca54d542 100644
--- a/src/base/abci/abcCollapse.c
+++ b/src/base/abci/abcCollapse.c
@@ -375,7 +375,7 @@ Vec_Ptr_t * Abc_NtkCreateCoOrder( Abc_Ntk_t * pNtk, Vec_Wec_t * vSupps )
         Vec_PtrPush( vNodes, pNode );
     }
     // order objects alphabetically
-    qsort( (void *)Vec_PtrArray(vNodes), Vec_PtrSize(vNodes), sizeof(Abc_Obj_t *), 
+    qsort( (void *)Vec_PtrArray(vNodes), (size_t)Vec_PtrSize(vNodes), sizeof(Abc_Obj_t *), 
         (int (*)(const void *, const void *)) Abc_NodeCompareByTemp );
     // cleanup
 //    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
diff --git a/src/base/abci/abcIf.c b/src/base/abci/abcIf.c
index 08e2a560..ab88c5e2 100644
--- a/src/base/abci/abcIf.c
+++ b/src/base/abci/abcIf.c
@@ -755,7 +755,7 @@ Vec_Ptr_t * Abc_NtkFindGoodOrder( Abc_Ntk_t * pNtk )
     }
 
     // sort nodes in the increasing order of the flow
-    qsort( (Abc_Obj_t **)Vec_PtrArray(vCos), Abc_NtkCoNum(pNtk), 
+    qsort( (Abc_Obj_t **)Vec_PtrArray(vCos), (size_t)Abc_NtkCoNum(pNtk), 
         sizeof(Abc_Obj_t *), (int (*)(const void *, const void *))Abc_ObjCompareFlow );
     // verify sorting
     pFanin0 = (Abc_Obj_t *)Vec_PtrEntry(vCos, 0);
diff --git a/src/base/abci/abcLut.c b/src/base/abci/abcLut.c
index 66db8e97..edc2b7de 100644
--- a/src/base/abci/abcLut.c
+++ b/src/base/abci/abcLut.c
@@ -678,7 +678,7 @@ int Abc_NodeDecomposeStep( Abc_ManScl_t * p )
 /*
     for ( v = 0; v < nVars; v++ )
         p->pBSet[v] = v;
-    qsort( (void *)p->pBSet, nVars, sizeof(int), 
+    qsort( (void *)p->pBSet, (size_t)nVars, sizeof(int), 
             (int (*)(const void *, const void *)) Abc_NodeCompareLevelsInc );
 */
     Abc_NodeDecomposeSort( (Abc_Obj_t **)Vec_PtrArray(p->vLeaves), Vec_PtrSize(p->vLeaves), p->pBSet, p->nLutSize );
diff --git a/src/base/abci/abcNpn.c b/src/base/abci/abcNpn.c
index 744b6443..4f8019b1 100644
--- a/src/base/abci/abcNpn.c
+++ b/src/base/abci/abcNpn.c
@@ -132,7 +132,7 @@ int Abc_TruthNpnCountUniqueSort( Abc_TtStore_t * p )
     // sort them by value
     nWords = p->nWords;
     assert( nWords > 0 );
-    qsort( (void *)p->pFuncs, p->nFuncs, sizeof(word *), (int(*)(const void *,const void *))Abc_TruthCompare );
+    qsort( (void *)p->pFuncs, (size_t)p->nFuncs, sizeof(word *), (int(*)(const void *,const void *))Abc_TruthCompare );
     // count the number of unqiue functions
     for ( i = k = 1; i < p->nFuncs; i++ )
         if ( memcmp( p->pFuncs[i-1], p->pFuncs[i], sizeof(word) * nWords ) )
diff --git a/src/base/abci/abcRec3.c b/src/base/abci/abcRec3.c
index 3e5f29af..a17ecc2e 100644
--- a/src/base/abci/abcRec3.c
+++ b/src/base/abci/abcRec3.c
@@ -1356,7 +1356,7 @@ void Abc_NtkRecDumpTt3( char * pFileName, int fBinary )
     Vec_MemForEachEntry( p->vTtMem, pTruth, i )
         Vec_StrPush( p->vSupps, (char)Abc_TtSupportSize(pTruth, nVars) );
     vEntries = Vec_IntStartNatural( nEntries );
-    qsort( (void *)Vec_IntArray(vEntries), nEntries, sizeof(int), (int(*)(const void *,const void *))Abc_NtkRecTruthCompare );
+    qsort( (void *)Vec_IntArray(vEntries), (size_t)nEntries, sizeof(int), (int(*)(const void *,const void *))Abc_NtkRecTruthCompare );
     Vec_StrFreeP( &p->vSupps );
     // write the file
     Vec_IntForEachEntry( vEntries, Entry, i )
diff --git a/src/base/acb/acbMfs.c b/src/base/acb/acbMfs.c
index 9fce00f8..e89545a4 100644
--- a/src/base/acb/acbMfs.c
+++ b/src/base/acb/acbMfs.c
@@ -98,7 +98,7 @@ void Acb_DeriveCnfForWindowOne( Acb_Ntk_t * p, int iObj )
     assert( Vec_WecSize(vCnfs) == Acb_NtkObjNumMax(p) );
     Acb_DeriveCnfFromTruth( Acb_ObjTruth(p, iObj), Acb_ObjFaninNum(p, iObj), &p->vCover, &p->vCnf );
     Vec_StrGrow( vCnfBase, Vec_StrSize(&p->vCnf) );
-    memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(&p->vCnf), Vec_StrSize(&p->vCnf) );
+    memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(&p->vCnf), (size_t)Vec_StrSize(&p->vCnf) );
     vCnfBase->nSize = Vec_StrSize(&p->vCnf);
 }
 Vec_Wec_t * Acb_DeriveCnfForWindow( Acb_Ntk_t * p, Vec_Int_t * vWin, int PivotVar )
diff --git a/src/base/bac/bacBac.c b/src/base/bac/bacBac.c
index 4f2971a5..94c52fdb 100644
--- a/src/base/bac/bacBac.c
+++ b/src/base/bac/bacBac.c
@@ -87,14 +87,14 @@ int BacManReadBacNameAndNums( char * pBuffer, int * Num1, int * Num2, int * Num3
 }
 void Bac_ManReadBacVecStr( Vec_Str_t * vOut, int * pPos, Vec_Str_t * p, int nSize )
 {
-    memcpy( Vec_StrArray(p), Vec_StrArray(vOut) + *pPos, nSize );
+    memcpy( Vec_StrArray(p), Vec_StrArray(vOut) + *pPos, (size_t)nSize );
     *pPos += nSize;
     p->nSize = nSize;
     assert( Vec_StrSize(p) == Vec_StrCap(p) );
 }
 void Bac_ManReadBacVecInt( Vec_Str_t * vOut, int * pPos, Vec_Int_t * p, int nSize )
 {
-    memcpy( Vec_IntArray(p), Vec_StrArray(vOut) + *pPos, nSize );
+    memcpy( Vec_IntArray(p), Vec_StrArray(vOut) + *pPos, (size_t)nSize );
     *pPos += nSize;
     p->nSize = nSize / 4;
     assert( Vec_IntSize(p) == Vec_IntCap(p) );
diff --git a/src/base/cmd/cmdUtils.c b/src/base/cmd/cmdUtils.c
index 3d4d91bb..3409543f 100644
--- a/src/base/cmd/cmdUtils.c
+++ b/src/base/cmd/cmdUtils.c
@@ -576,7 +576,7 @@ void CmdCommandPrint( Abc_Frame_t * pAbc, int fPrintAll, int fDetails )
     nCommands = i;
 
     // sort command by group and then by name, alphabetically
-    qsort( (void *)ppCommands, nCommands, sizeof(Abc_Command *), 
+    qsort( (void *)ppCommands, (size_t)nCommands, sizeof(Abc_Command *), 
             (int (*)(const void *, const void *)) CmdCommandPrintCompare );
     assert( CmdCommandPrintCompare( ppCommands, ppCommands + nCommands - 1 ) <= 0 );
 
@@ -734,7 +734,7 @@ void CmdPrintTable( st__table * tTable, int fAliases )
         ppNames[nNames++] = key;
 
     // sort array by name
-    qsort( (void *)ppNames, nNames, sizeof(char *), 
+    qsort( (void *)ppNames, (size_t)nNames, sizeof(char *), 
         (int (*)(const void *, const void *))CmdNamePrintCompare );
 
     // print in this order
diff --git a/src/base/exor/exorCubes.c b/src/base/exor/exorCubes.c
index c8b40a82..197099d5 100644
--- a/src/base/exor/exorCubes.c
+++ b/src/base/exor/exorCubes.c
@@ -113,7 +113,7 @@ int AllocateCover( int nCubes, int nWordsIn, int nWordsOut )
     pp[0] = (Cube *)ABC_ALLOC( char, TotalSize );
     if ( pp[0] == NULL )
         return 0;
-    memset( pp[0], 0, TotalSize );
+    memset( pp[0], 0, (size_t)TotalSize );
 
     // assign pointers to cubes and bit strings inside this piece
     pp[0]->pCubeDataIn  = (unsigned*)(pp[0] + 1);
diff --git a/src/base/io/ioReadAiger.c b/src/base/io/ioReadAiger.c
index 1d9ca877..f87d971f 100644
--- a/src/base/io/ioReadAiger.c
+++ b/src/base/io/ioReadAiger.c
@@ -153,7 +153,7 @@ static char * Ioa_ReadLoadFileBz2Aig( char * pFileName, int * pFileSize )
         p = pContents = ABC_ALLOC( char, nFileSize + 10 );
         buf = bufHead;
         do {
-            memcpy(p+nBytes,buf->buf,buf->nBuf);
+            memcpy(p+nBytes,buf->buf,(size_t)buf->nBuf);
             nBytes += buf->nBuf;
 //        } while((buf = buf->next));
             pNext = buf->next;
diff --git a/src/base/io/ioReadBlifMv.c b/src/base/io/ioReadBlifMv.c
index d78f567a..df7a67af 100644
--- a/src/base/io/ioReadBlifMv.c
+++ b/src/base/io/ioReadBlifMv.c
@@ -585,7 +585,7 @@ char * Io_MvLoadFileBz2( char * pFileName, int * pnFileSize )
         p = pContents = ABC_ALLOC( char, nFileSize + 10 );
         buf = bufHead;
         do {
-            memcpy(p+nBytes,buf->buf,buf->nBuf);
+            memcpy(p+nBytes,buf->buf,(size_t)buf->nBuf);
             nBytes += buf->nBuf;
 //        } while((buf = buf->next));
             pNext = buf->next;
diff --git a/src/base/io/ioWritePla.c b/src/base/io/ioWritePla.c
index 8aa9ee19..aa6a933d 100644
--- a/src/base/io/ioWritePla.c
+++ b/src/base/io/ioWritePla.c
@@ -76,8 +76,8 @@ int Io_WritePlaOne( FILE * pFile, Abc_Ntk_t * pNtk )
     nOutputs = Abc_NtkCoNum(pNtk);
     pCubeIn  = ABC_ALLOC( char, nInputs + 1 );
     pCubeOut = ABC_ALLOC( char, nOutputs + 1 );
-    memset( pCubeIn,  '-', nInputs );     pCubeIn[nInputs]   = 0;
-    memset( pCubeOut, '0', nOutputs );    pCubeOut[nOutputs] = 0;
+    memset( pCubeIn,  '-', (size_t)nInputs );     pCubeIn[nInputs]   = 0;
+    memset( pCubeOut, '0', (size_t)nOutputs );    pCubeOut[nOutputs] = 0;
 
     // write the header
     fprintf( pFile, ".i %d\n", nInputs );
diff --git a/src/base/ver/verStream.c b/src/base/ver/verStream.c
index 59706311..b1051a77 100644
--- a/src/base/ver/verStream.c
+++ b/src/base/ver/verStream.c
@@ -131,7 +131,7 @@ void Ver_StreamReload( Ver_Stream_t * p )
     // figure out how many chars are still not processed
     nCharsUsed = p->pBufferEnd - p->pBufferCur;
     // move the remaining data to the beginning of the buffer
-    memmove( p->pBuffer, p->pBufferCur, nCharsUsed );
+    memmove( p->pBuffer, p->pBufferCur, (size_t)nCharsUsed );
     p->pBufferCur = p->pBuffer;
     // determine how many chars we will read
     nCharsToRead = VER_MINIMUM( p->nBufferSize - nCharsUsed, p->nFileSize - p->nFileRead );
diff --git a/src/bdd/cas/casCore.c b/src/bdd/cas/casCore.c
index 42c04c02..b283d6f0 100644
--- a/src/bdd/cas/casCore.c
+++ b/src/bdd/cas/casCore.c
@@ -524,9 +524,9 @@ DdNode * GetSingleOutputFunction( DdManager * dd, DdNode ** pbOuts, int nOuts, D
     }
     
     // order the outputs
-    qsort( (void*)Order,     nOuts, sizeof(int), (int(*)(const void*, const void*)) CompareSupports );
+    qsort( (void*)Order,     (size_t)nOuts, sizeof(int), (int(*)(const void*, const void*)) CompareSupports );
     // order the outputs
-//  qsort( (void*)OrderMint, nOuts, sizeof(int), (int(*)(const void*, const void*)) CompareMinterms );
+//  qsort( (void*)OrderMint, (size_t)nOuts, sizeof(int), (int(*)(const void*, const void*)) CompareMinterms );
 
 
     bResult = b0;   Cudd_Ref( bResult );
diff --git a/src/bdd/cudd/cuddGroup.c b/src/bdd/cudd/cuddGroup.c
index e0b9ccf5..d916ed5a 100644
--- a/src/bdd/cudd/cuddGroup.c
+++ b/src/bdd/cudd/cuddGroup.c
@@ -755,7 +755,7 @@ ddGroupSifting(
         }
     }
 
-    qsort((void *)var,classes,sizeof(int),
+    qsort((void *)var,(size_t)classes,sizeof(int),
           (DD_QSFP) ddUniqueCompareGroup);
 
     if (lazyFlag) {
diff --git a/src/bdd/cudd/cuddLCache.c b/src/bdd/cudd/cuddLCache.c
index f5bcfd66..1c3330ca 100644
--- a/src/bdd/cudd/cuddLCache.c
+++ b/src/bdd/cudd/cuddLCache.c
@@ -219,7 +219,7 @@ cuddLocalCacheInit(
     manager->memused += cacheSize * cache->itemsize + sizeof(DdLocalCache);
 
     /* Initialize the cache. */
-    memset(cache->item, 0, cacheSize * cache->itemsize);
+    memset(cache->item, 0, (size_t)(cacheSize * cache->itemsize));
 
     /* Add to manager's list of local caches for GC. */
     cuddLocalCacheAddToList(cache);
@@ -407,7 +407,7 @@ cuddLocalCacheClearAll(
     DdLocalCache *cache = manager->localCaches;
 
     while (cache != NULL) {
-        memset(cache->item, 0, cache->slots * cache->itemsize);
+        memset(cache->item, 0, (size_t)(cache->slots * cache->itemsize));
         cache = cache->next;
     }
     return;
@@ -569,7 +569,7 @@ cuddHashTableInit(
         ABC_FREE(hash);
         return(NULL);
     }
-    memset(hash->bucket, 0, hash->numBuckets * sizeof(DdHashItem *));
+    memset(hash->bucket, 0, (size_t)(hash->numBuckets * sizeof(DdHashItem *)));
     hash->size = 0;
     hash->maxsize = hash->numBuckets * DD_MAX_HASHTABLE_DENSITY;
 #ifdef __osf__
@@ -1140,7 +1140,7 @@ cuddLocalCacheResize(
     cache->manager->memused += (slots - oldslots) * cache->itemsize;
 
     /* Clear new cache. */
-    memset(item, 0, slots * cache->itemsize);
+    memset(item, 0, (size_t)(slots * cache->itemsize));
 
     /* Copy from old cache to new one. */
     for (i = 0; (unsigned) i < oldslots; i++) {
diff --git a/src/bdd/cudd/cuddLevelQ.c b/src/bdd/cudd/cuddLevelQ.c
index 5a88b772..822ea21c 100644
--- a/src/bdd/cudd/cuddLevelQ.c
+++ b/src/bdd/cudd/cuddLevelQ.c
@@ -304,7 +304,7 @@ cuddLevelQueueEnqueue(
         queue->freelist = item->next;
     }
     /* Initialize. */
-    memset(item, 0, queue->itemsize);
+    memset(item, 0, (size_t)queue->itemsize);
     item->key = key;
     /* Update stats. */
     queue->size++;
diff --git a/src/bdd/cudd/cuddLinear.c b/src/bdd/cudd/cuddLinear.c
index 0dd688f2..7a0bf8db 100644
--- a/src/bdd/cudd/cuddLinear.c
+++ b/src/bdd/cudd/cuddLinear.c
@@ -295,7 +295,7 @@ cuddLinearAndSifting(
         var[i] = i;
     }
 
-    qsort((void *)var,size,sizeof(int),(DD_QSFP)ddLinearUniqueCompare);
+    qsort((void *)var,(size_t)size,sizeof(int),(DD_QSFP)ddLinearUniqueCompare);
 
     /* Now sift. */
     for (i = 0; i < ddMin(table->siftMaxVar,size); i++) {
diff --git a/src/bdd/cudd/cuddReorder.c b/src/bdd/cudd/cuddReorder.c
index a68cef28..c48b0c13 100644
--- a/src/bdd/cudd/cuddReorder.c
+++ b/src/bdd/cudd/cuddReorder.c
@@ -541,7 +541,7 @@ cuddSifting(
         var[i] = i;
     }
 
-    qsort((void *)var,size,sizeof(int),(DD_QSFP)ddUniqueCompare);
+    qsort((void *)var,(size_t)size,sizeof(int),(DD_QSFP)ddUniqueCompare);
 
     /* Now sift. */
     for (i = 0; i < ddMin(table->siftMaxVar,size); i++) {
diff --git a/src/bdd/cudd/cuddSymmetry.c b/src/bdd/cudd/cuddSymmetry.c
index e6f49da4..310286c4 100644
--- a/src/bdd/cudd/cuddSymmetry.c
+++ b/src/bdd/cudd/cuddSymmetry.c
@@ -356,7 +356,7 @@ cuddSymmSifting(
         var[i] = i;
     }
 
-    qsort((void *)var,size,sizeof(int),(DD_QSFP)ddSymmUniqueCompare);
+    qsort((void *)var,(size_t)size,sizeof(int),(DD_QSFP)ddSymmUniqueCompare);
 
     /* Initialize the symmetry of each subtable to itself. */
     for (i = lower; i <= upper; i++) {
@@ -480,7 +480,7 @@ cuddSymmSiftingConv(
         var[i] = i;
     }
 
-    qsort((void *)var,size,sizeof(int),(DD_QSFP)ddSymmUniqueCompare);
+    qsort((void *)var,(size_t)size,sizeof(int),(DD_QSFP)ddSymmUniqueCompare);
 
     /* Initialize the symmetry of each subtable to itself
     ** for first pass of converging symmetric sifting.
@@ -535,7 +535,7 @@ cuddSymmSiftingConv(
             var[classes] = i;
         }
 
-        qsort((void *)var,classes,sizeof(int),(DD_QSFP)ddSymmUniqueCompare);
+        qsort((void *)var,(size_t)classes,sizeof(int),(DD_QSFP)ddSymmUniqueCompare);
 
         /* Now sift. */
         for (i = 0; i < ddMin(table->siftMaxVar,classes); i++) {
diff --git a/src/bdd/cudd/cuddZddGroup.c b/src/bdd/cudd/cuddZddGroup.c
index f5972292..67f9472f 100644
--- a/src/bdd/cudd/cuddZddGroup.c
+++ b/src/bdd/cudd/cuddZddGroup.c
@@ -682,7 +682,7 @@ zddGroupSifting(
         }
     }
 
-    qsort((void *)var,classes,sizeof(int),(DD_QSFP)zddUniqueCompareGroup);
+    qsort((void *)var,(size_t)classes,sizeof(int),(DD_QSFP)zddUniqueCompareGroup);
 
     /* Now sift. */
     for (i = 0; i < ddMin(table->siftMaxVar,classes); i++) {
diff --git a/src/bdd/cudd/cuddZddLin.c b/src/bdd/cudd/cuddZddLin.c
index 0e2e3c3a..a711e9a6 100644
--- a/src/bdd/cudd/cuddZddLin.c
+++ b/src/bdd/cudd/cuddZddLin.c
@@ -189,7 +189,7 @@ cuddZddLinearSifting(
         var[i] = i;
     }
 
-    qsort((void *)var, size, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
+    qsort((void *)var, (size_t)size, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
 
     /* Now sift. */
     for (i = 0; i < ddMin(table->siftMaxVar, size); i++) {
diff --git a/src/bdd/cudd/cuddZddReord.c b/src/bdd/cudd/cuddZddReord.c
index 3a6ea8ed..c195f5b5 100644
--- a/src/bdd/cudd/cuddZddReord.c
+++ b/src/bdd/cudd/cuddZddReord.c
@@ -899,7 +899,7 @@ cuddZddSifting(
         var[i] = i;
     }
 
-    qsort((void *)var, size, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
+    qsort((void *)var, (size_t)size, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
 
     /* Now sift. */
     for (i = 0; i < ddMin(table->siftMaxVar, size); i++) {
diff --git a/src/bdd/cudd/cuddZddSymm.c b/src/bdd/cudd/cuddZddSymm.c
index bdc5e656..92970002 100644
--- a/src/bdd/cudd/cuddZddSymm.c
+++ b/src/bdd/cudd/cuddZddSymm.c
@@ -337,7 +337,7 @@ cuddZddSymmSifting(
         var[i] = i;
     }
 
-    qsort((void *)var, nvars, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
+    qsort((void *)var, (size_t)nvars, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
 
     /* Initialize the symmetry of each subtable to itself. */
     for (i = lower; i <= upper; i++)
@@ -462,7 +462,7 @@ cuddZddSymmSiftingConv(
         var[i] = i;
     }
 
-    qsort((void *)var, nvars, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
+    qsort((void *)var, (size_t)nvars, sizeof(int), (DD_QSFP)cuddZddUniqueCompare);
 
     /* Initialize the symmetry of each subtable to itself
     ** for first pass of converging symmetric sifting.
@@ -519,7 +519,7 @@ cuddZddSymmSiftingConv(
             var[classes] = i;
         }
 
-        qsort((void *)var,classes,sizeof(int),(DD_QSFP)cuddZddUniqueCompare);
+        qsort((void *)var,(size_t)classes,sizeof(int),(DD_QSFP)cuddZddUniqueCompare);
 
         /* Now sift. */
         iteration = ddMin(table->siftMaxVar, nvars);
diff --git a/src/bdd/extrab/extraBddUnate.c b/src/bdd/extrab/extraBddUnate.c
index 9ebdd4e5..a8affc4f 100644
--- a/src/bdd/extrab/extraBddUnate.c
+++ b/src/bdd/extrab/extraBddUnate.c
@@ -197,7 +197,7 @@ void Extra_UnateInfoPrint( Extra_UnateInfo_t * p )
     char * pBuffer;
     int i;
     pBuffer = ABC_ALLOC( char, p->nVarsMax+1 );
-    memset( pBuffer, ' ', p->nVarsMax );
+    memset( pBuffer, ' ', (size_t)p->nVarsMax );
     pBuffer[p->nVarsMax] = 0;
     for ( i = 0; i < p->nVars; i++ )
         if ( p->pVars[i].Neg )
diff --git a/src/bool/kit/kitDsd.c b/src/bool/kit/kitDsd.c
index 07c16f12..7d85214b 100644
--- a/src/bool/kit/kitDsd.c
+++ b/src/bool/kit/kitDsd.c
@@ -95,7 +95,7 @@ Kit_DsdObj_t * Kit_DsdObjAlloc( Kit_DsdNtk_t * pNtk, Kit_Dsd_t Type, int nFans )
     Kit_DsdObj_t * pObj;
     int nSize = sizeof(Kit_DsdObj_t) + sizeof(unsigned) * (Kit_DsdObjOffset(nFans) + (Type == KIT_DSD_PRIME) * Kit_TruthWordNum(nFans));
     pObj = (Kit_DsdObj_t *)ABC_ALLOC( char, nSize );
-    memset( pObj, 0, nSize );
+    memset( pObj, 0, (size_t)nSize );
     pObj->Id = pNtk->nVars + pNtk->nNodes;
     pObj->Type = Type;
     pObj->nFans = nFans;
diff --git a/src/bool/kit/kitPla.c b/src/bool/kit/kitPla.c
index 9ae2b2c0..a9c7f573 100644
--- a/src/bool/kit/kitPla.c
+++ b/src/bool/kit/kitPla.c
@@ -216,7 +216,7 @@ char * Kit_PlaStart( void * p, int nCubes, int nVars )
 
     Length = nCubes * (nVars + 3);
     pSopCover = Aig_MmFlexEntryFetch( pMan, Length + 1 );
-    memset( pSopCover, '-', Length );
+    memset( pSopCover, '-', (size_t)Length );
     pSopCover[Length] = 0;
 
     for ( i = 0; i < nCubes; i++ )
diff --git a/src/bool/lucky/lucky.c b/src/bool/lucky/lucky.c
index 7db08b9a..c70f4145 100644
--- a/src/bool/lucky/lucky.c
+++ b/src/bool/lucky/lucky.c
@@ -47,7 +47,7 @@ int memCompare(word* x, word*  y, int nVars)
  {
      int i, count=1, WordsN = p->nFuncs;
      word tempWord;
-     qsort(a,WordsN,sizeof(word),compareWords1);
+     qsort(a,(size_t)WordsN,sizeof(word),compareWords1);
      tempWord = a[0];
      for(i=1;i<WordsN;i++)  
          if(tempWord != a[i])
@@ -302,25 +302,25 @@ int minimalFlip1(word* pInOut, word* pMinimal, word* PDuplicat, int  nVars)
 {
     int i;
     int blockSize = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
-    memcpy(pMinimal, pInOut, blockSize);
-    memcpy(PDuplicat, pInOut, blockSize);
+    memcpy(pMinimal, pInOut, (size_t)blockSize);
+    memcpy(PDuplicat, pInOut, (size_t)blockSize);
     Kit_TruthChangePhase_64bit( pInOut, nVars, 0 );
     for(i=1;i<nVars;i++)
     {
         if( memCompare(pMinimal,pInOut,nVars) == 1)
         {
-            memcpy(pMinimal, pInOut, blockSize);
+            memcpy(pMinimal, pInOut, (size_t)blockSize);
             Kit_TruthChangePhase_64bit( pInOut, nVars, i );
         }
         else
         {
-            memcpy(pInOut, pMinimal, blockSize);
+            memcpy(pInOut, pMinimal, (size_t)blockSize);
             Kit_TruthChangePhase_64bit( pInOut, nVars, i );
         }
     }
     if( memCompare(pMinimal,pInOut,nVars) == -1)
-        memcpy(pInOut, pMinimal, blockSize);
-    if(memcmp(pInOut,PDuplicat,blockSize) == 0)
+        memcpy(pInOut, pMinimal, (size_t)blockSize);
+    if(memcmp(pInOut,PDuplicat,(size_t)blockSize) == 0)
         return 0;
     else
         return 1;
@@ -333,25 +333,25 @@ int minimalSwap1(word* pInOut, word* pMinimal, word* PDuplicat, int  nVars)
 {
     int i;
     int blockSize = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
-    memcpy(pMinimal, pInOut, blockSize);
-    memcpy(PDuplicat, pInOut, blockSize);
+    memcpy(pMinimal, pInOut, (size_t)blockSize);
+    memcpy(PDuplicat, pInOut, (size_t)blockSize);
     Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, 0 );
     for(i=1;i<nVars-1;i++)
     {
         if( memCompare(pMinimal,pInOut,nVars) == 1)
         {
-            memcpy(pMinimal, pInOut, blockSize);
+            memcpy(pMinimal, pInOut, (size_t)blockSize);
             Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );
         }
         else
         {
-            memcpy(pInOut, pMinimal, blockSize);
+            memcpy(pInOut, pMinimal, (size_t)blockSize);
             Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );
         }
     }
     if( memCompare(pMinimal,pInOut,nVars) == -1)
-        memcpy(pInOut, pMinimal, blockSize);
-    if(memcmp(pInOut,PDuplicat,blockSize) == 0)
+        memcpy(pInOut, pMinimal, (size_t)blockSize);
+    if(memcmp(pInOut,PDuplicat,(size_t)blockSize) == 0)
         return 0;
     else
         return 1;
@@ -380,20 +380,20 @@ int minimalFlip(word* pInOut, word* pMinimal, word* PDuplicat, int  nVars, unsig
     int i;
     unsigned minTemp = *p_uCanonPhase;
     int blockSize = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
-    memcpy(pMinimal, pInOut, blockSize);
-    memcpy(PDuplicat, pInOut, blockSize);       //////////////need one more unsigned!!!!!!!!!!!!!
+    memcpy(pMinimal, pInOut, (size_t)blockSize);
+    memcpy(PDuplicat, pInOut, (size_t)blockSize);       //////////////need one more unsigned!!!!!!!!!!!!!
     Kit_TruthChangePhase_64bit( pInOut, nVars, 0 );
     *p_uCanonPhase ^= (unsigned)1;
     for(i=1;i<nVars;i++)
     {
         if( memCompare(pMinimal,pInOut,nVars) == 1)
         {
-            memcpy(pMinimal, pInOut, blockSize);
+            memcpy(pMinimal, pInOut, (size_t)blockSize);
             minTemp = *p_uCanonPhase;
         }
         else
         {
-            memcpy(pInOut, pMinimal, blockSize);
+            memcpy(pInOut, pMinimal, (size_t)blockSize);
             *p_uCanonPhase = minTemp;
         }
         Kit_TruthChangePhase_64bit( pInOut, nVars, i );
@@ -401,10 +401,10 @@ int minimalFlip(word* pInOut, word* pMinimal, word* PDuplicat, int  nVars, unsig
     }
     if( memCompare(pMinimal,pInOut,nVars) == -1)
     {
-        memcpy(pInOut, pMinimal, blockSize);
+        memcpy(pInOut, pMinimal, (size_t)blockSize);
         *p_uCanonPhase = minTemp;
     }
-    if(memcmp(pInOut,PDuplicat,blockSize) == 0) 
+    if(memcmp(pInOut,PDuplicat,(size_t)blockSize) == 0) 
         return 0;
     else
         return 1;
@@ -478,24 +478,24 @@ int minimalSwap(word* pInOut, word* pMinimal, word* PDuplicat, int  nVars, char
     int blockSizeWord = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
     int blockSizeChar = nVars *sizeof(char);
     unsigned TempuCanonPhase = *p_uCanonPhase;
-    memcpy(pMinimal, pInOut, blockSizeWord);
-    memcpy(PDuplicat, pInOut, blockSizeWord);
-    memcpy(tempArray, pCanonPerm, blockSizeChar);  
+    memcpy(pMinimal, pInOut, (size_t)blockSizeWord);
+    memcpy(PDuplicat, pInOut, (size_t)blockSizeWord);
+    memcpy(tempArray, pCanonPerm, (size_t)blockSizeChar);  
     Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, 0 );
     swapInfoAdjacentVars(0, pCanonPerm, p_uCanonPhase);
     for(i=1;i<nVars-1;i++)
     {
         if( memCompare(pMinimal,pInOut,nVars) == 1)
         {
-            memcpy(pMinimal, pInOut, blockSizeWord);
-            memcpy(tempArray, pCanonPerm, blockSizeChar);
+            memcpy(pMinimal, pInOut, (size_t)blockSizeWord);
+            memcpy(tempArray, pCanonPerm, (size_t)blockSizeChar);
             TempuCanonPhase = *p_uCanonPhase;
             
         }
         else
         {
-            memcpy(pInOut, pMinimal, blockSizeWord);
-            memcpy(pCanonPerm, tempArray, blockSizeChar);
+            memcpy(pInOut, pMinimal, (size_t)blockSizeWord);
+            memcpy(pCanonPerm, tempArray, (size_t)blockSizeChar);
             *p_uCanonPhase = TempuCanonPhase;
         }
         Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );
@@ -503,11 +503,11 @@ int minimalSwap(word* pInOut, word* pMinimal, word* PDuplicat, int  nVars, char
     }
     if( memCompare(pMinimal,pInOut,nVars) == -1)
     {
-        memcpy(pInOut, pMinimal, blockSizeWord);
-        memcpy(pCanonPerm, tempArray, blockSizeChar);
+        memcpy(pInOut, pMinimal, (size_t)blockSizeWord);
+        memcpy(pCanonPerm, tempArray, (size_t)blockSizeChar);
         *p_uCanonPhase = TempuCanonPhase;
     }
-    if(memcmp(pInOut,PDuplicat,blockSizeWord) == 0)
+    if(memcmp(pInOut,PDuplicat,(size_t)blockSizeWord) == 0)
         return 0;
     else
         return 1;
diff --git a/src/bool/lucky/luckyFast16.c b/src/bool/lucky/luckyFast16.c
index 84ec3bae..69c32442 100644
--- a/src/bool/lucky/luckyFast16.c
+++ b/src/bool/lucky/luckyFast16.c
@@ -285,13 +285,13 @@ void arrangeQuoters_superFast_iVar5(unsigned* pInOut, unsigned* temp, int start,
     for(i=start-1;i>0;i-=shiftSize)
     {       
         tempPtr -= 1;       
-        memcpy(tempPtr, pInOut+i-iQ, blockSize);
+        memcpy(tempPtr, pInOut+i-iQ, (size_t)blockSize);
         tempPtr -= 1;
-        memcpy(tempPtr, pInOut+i-jQ, blockSize);
+        memcpy(tempPtr, pInOut+i-jQ, (size_t)blockSize);
         tempPtr -= 1;
-        memcpy(tempPtr, pInOut+i-kQ, blockSize);
+        memcpy(tempPtr, pInOut+i-kQ, (size_t)blockSize);
         tempPtr -= 1;
-        memcpy(tempPtr, pInOut+i-lQ, blockSize);        
+        memcpy(tempPtr, pInOut+i-lQ, (size_t)blockSize);        
     }   
     memcpy(pInOut, temp, start*sizeof(unsigned));
     updataInfo(iQ, jQ, 5, pCanonPerm, pCanonPhase);
@@ -462,13 +462,13 @@ void arrangeQuoters_superFast_moreThen5(word* pInOut, word* temp, int start,  in
     for(i=start-wordBlock;i>0;i-=shiftSize)
     {       
         tempPtr -= wordBlock;       
-        memcpy(tempPtr, pInOut+i-iQ*wordBlock, blockSize);
+        memcpy(tempPtr, pInOut+i-iQ*wordBlock, (size_t)blockSize);
         tempPtr -= wordBlock;
-        memcpy(tempPtr, pInOut+i-jQ*wordBlock, blockSize);
+        memcpy(tempPtr, pInOut+i-jQ*wordBlock, (size_t)blockSize);
         tempPtr -= wordBlock;
-        memcpy(tempPtr, pInOut+i-kQ*wordBlock, blockSize);
+        memcpy(tempPtr, pInOut+i-kQ*wordBlock, (size_t)blockSize);
         tempPtr -= wordBlock;
-        memcpy(tempPtr, pInOut+i-lQ*wordBlock, blockSize);      
+        memcpy(tempPtr, pInOut+i-lQ*wordBlock, (size_t)blockSize);      
     }   
     memcpy(pInOut, temp, start*sizeof(word));
     updataInfo(iQ, jQ, iVar, pCanonPerm, pCanonPhase);
diff --git a/src/bool/lucky/luckySwap.c b/src/bool/lucky/luckySwap.c
index 0b7493d8..bfa58697 100644
--- a/src/bool/lucky/luckySwap.c
+++ b/src/bool/lucky/luckySwap.c
@@ -115,9 +115,9 @@ void Kit_TruthChangePhase_64bit( word * pInOut, int nVars, int iVar )
         SizeOfBlock = sizeof(word)*Step;
         for ( i = 0; i < nWords; i += 2*Step )
         {   
-            memcpy(Temp,pInOut,SizeOfBlock);
-            memcpy(pInOut,pInOut+Step,SizeOfBlock);
-            memcpy(pInOut+Step,Temp,SizeOfBlock);
+            memcpy(Temp,pInOut,(size_t)SizeOfBlock);
+            memcpy(pInOut,pInOut+Step,(size_t)SizeOfBlock);
+            memcpy(pInOut+Step,Temp,(size_t)SizeOfBlock);
             //          Temp = pInOut[i];
             //          pInOut[i] = pInOut[Step+i];
             //          pInOut[Step+i] = Temp;          
@@ -165,9 +165,9 @@ void Kit_TruthSwapAdjacentVars_64bit( word * pInOut, int nVars, int iVar )
         pInOut += 2*Step;
         for(i=2*Step; i<nWords; i+=4*Step)
         {           
-            memcpy(temp,pInOut-Step,SizeOfBlock);
-            memcpy(pInOut-Step,pInOut,SizeOfBlock);
-            memcpy(pInOut,temp,SizeOfBlock);
+            memcpy(temp,pInOut-Step,(size_t)SizeOfBlock);
+            memcpy(pInOut-Step,pInOut,(size_t)SizeOfBlock);
+            memcpy(pInOut,temp,(size_t)SizeOfBlock);
             pInOut += 4*Step;
         }
     }
diff --git a/src/bool/lucky/luckySwapIJ.c b/src/bool/lucky/luckySwapIJ.c
index 44144564..fcedbb93 100644
--- a/src/bool/lucky/luckySwapIJ.c
+++ b/src/bool/lucky/luckySwapIJ.c
@@ -80,9 +80,9 @@ void swap_ij_case3( word* f,int totalVars, int i, int j)
     for(y=wwj/2; y<WORDS_IN_TT; y+=wwj)
         for(x=y-shift; x<y; x+=wwi)
         {
-            memcpy(temp,&f[x],SizeOfBlock);
-            memcpy(&f[x],&f[x+shift],SizeOfBlock);
-            memcpy(&f[x+shift],temp,SizeOfBlock);
+            memcpy(temp,&f[x],(size_t)SizeOfBlock);
+            memcpy(&f[x],&f[x+shift],(size_t)SizeOfBlock);
+            memcpy(&f[x+shift],temp,(size_t)SizeOfBlock);
         }
 }
 void swap_ij( word* f,int totalVars, int varI, int varJ)
diff --git a/src/map/amap/amapLib.c b/src/map/amap/amapLib.c
index 26ef639f..ca8404e1 100644
--- a/src/map/amap/amapLib.c
+++ b/src/map/amap/amapLib.c
@@ -221,7 +221,7 @@ Vec_Ptr_t * Amap_LibSortGatesByArea( Amap_Lib_t * pLib )
 {
     Vec_Ptr_t * vSorted;
     vSorted = Vec_PtrDup( pLib->vGates );
-    qsort( (void *)Vec_PtrArray(vSorted), Vec_PtrSize(vSorted), sizeof(void *), 
+    qsort( (void *)Vec_PtrArray(vSorted), (size_t)Vec_PtrSize(vSorted), sizeof(void *), 
             (int (*)(const void *, const void *)) Amap_LibCompareGatesByArea );
     return vSorted;
 }
diff --git a/src/map/amap/amapMatch.c b/src/map/amap/amapMatch.c
index 85e03056..2276cfc2 100644
--- a/src/map/amap/amapMatch.c
+++ b/src/map/amap/amapMatch.c
@@ -47,7 +47,7 @@ Amap_Cut_t * Amap_ManDupCut( Amap_Man_t * p, Amap_Cut_t * pCut )
     Amap_Cut_t * pNew;
     int nBytes = sizeof(Amap_Cut_t) + sizeof(int) * pCut->nFans;
     pNew = (Amap_Cut_t *)Aig_MmFlexEntryFetch( p->pMemCutBest, nBytes );
-    memcpy( pNew, pCut, nBytes );
+    memcpy( pNew, pCut, (size_t)nBytes );
     return pNew;
 }
 
diff --git a/src/map/amap/amapRule.c b/src/map/amap/amapRule.c
index 94c5bb9f..e906dd9e 100644
--- a/src/map/amap/amapRule.c
+++ b/src/map/amap/amapRule.c
@@ -396,7 +396,7 @@ if ( pLib->fVerbose )
                 pSet2->iGate = pGate->Id;
                 pSet2->fInv  = Abc_LitIsCompl(iNod);
                 pSet2->nIns  = pGate->nPins;
-                memcpy( pSet2->Ins, pSet->Ins, pGate->nPins );
+                memcpy( pSet2->Ins, pSet->Ins, (size_t)pGate->nPins );
                 // update inputs
                 pSet2->Ins[iThis] = Abc_Var2Lit( Abc_Lit2Var(pSet->Ins[iThat]), Abc_LitIsCompl(pSet->Ins[iThis]) );
                 pSet2->Ins[iThat] = Abc_Var2Lit( Abc_Lit2Var(pSet->Ins[iThis]), Abc_LitIsCompl(pSet->Ins[iThat]) );
diff --git a/src/map/fpga/fpgaCut.c b/src/map/fpga/fpgaCut.c
index 75007888..09edcae9 100644
--- a/src/map/fpga/fpgaCut.c
+++ b/src/map/fpga/fpgaCut.c
@@ -1112,7 +1112,7 @@ Fpga_Cut_t * Fpga_CutSortCuts( Fpga_Man_t * pMan, Fpga_CutTable_t * p, Fpga_Cut_
     nCuts = Fpga_CutList2Array( p->pCuts1, pList );
     assert( nCuts <= FPGA_CUTS_MAX_COMPUTE );
     // sort the cuts
-    qsort( (void *)p->pCuts1, nCuts, sizeof(void *), 
+    qsort( (void *)p->pCuts1, (size_t)nCuts, sizeof(void *), 
             (int (*)(const void *, const void *)) Fpga_CutSortCutsCompare );
     // move them back into the list
     if ( nCuts > FPGA_CUTS_MAX_USE - 1 )
diff --git a/src/map/fpga/fpgaUtils.c b/src/map/fpga/fpgaUtils.c
index f10971ad..aa34bc04 100644
--- a/src/map/fpga/fpgaUtils.c
+++ b/src/map/fpga/fpgaUtils.c
@@ -584,10 +584,10 @@ int Fpga_CompareNodesByLevelIncreasing( Fpga_Node_t ** ppS1, Fpga_Node_t ** ppS2
 void Fpga_MappingSortByLevel( Fpga_Man_t * pMan, Fpga_NodeVec_t * vNodes, int fIncreasing )
 {
     if ( fIncreasing )
-        qsort( (void *)vNodes->pArray, vNodes->nSize, sizeof(Fpga_Node_t *), 
+        qsort( (void *)vNodes->pArray, (size_t)vNodes->nSize, sizeof(Fpga_Node_t *), 
                 (int (*)(const void *, const void *)) Fpga_CompareNodesByLevelIncreasing );
     else
-        qsort( (void *)vNodes->pArray, vNodes->nSize, sizeof(Fpga_Node_t *), 
+        qsort( (void *)vNodes->pArray, (size_t)vNodes->nSize, sizeof(Fpga_Node_t *), 
                 (int (*)(const void *, const void *)) Fpga_CompareNodesByLevelDecreasing );
 //    assert( Fpga_CompareNodesByLevel( vNodes->pArray, vNodes->pArray + vNodes->nSize - 1 ) <= 0 );
 }
diff --git a/src/map/fpga/fpgaVec.c b/src/map/fpga/fpgaVec.c
index 35260029..e7948365 100644
--- a/src/map/fpga/fpgaVec.c
+++ b/src/map/fpga/fpgaVec.c
@@ -288,7 +288,7 @@ int Fpga_NodeVecCompareLevels( Fpga_Node_t ** pp1, Fpga_Node_t ** pp2 )
 ***********************************************************************/
 void Fpga_NodeVecSortByLevel( Fpga_NodeVec_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(Fpga_Node_t *), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Fpga_Node_t *), 
             (int (*)(const void *, const void *)) Fpga_NodeVecCompareLevels );
 }
 
@@ -325,7 +325,7 @@ int Fpga_NodeVecCompareArrivals( Fpga_Node_t ** ppS1, Fpga_Node_t ** ppS2 )
 ***********************************************************************/
 void Fpga_SortNodesByArrivalTimes( Fpga_NodeVec_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(Fpga_Node_t *), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Fpga_Node_t *), 
             (int (*)(const void *, const void *)) Fpga_NodeVecCompareArrivals );
 //    assert( Fpga_CompareNodesByLevel( p->pArray, p->pArray + p->nSize - 1 ) <= 0 );
 }
diff --git a/src/map/if/if.h b/src/map/if/if.h
index 6ae8b30b..669b3c24 100644
--- a/src/map/if/if.h
+++ b/src/map/if/if.h
@@ -411,8 +411,8 @@ static inline int        If_CutTruthWords( int nVarsMax )                    { r
 static inline int        If_CutPermWords( int nVarsMax )                     { return nVarsMax / sizeof(int) + ((nVarsMax % sizeof(int)) > 0); }
 static inline int        If_CutLeafBit( If_Cut_t * pCut, int i )             { return (pCut->uMaskFunc >> i) & 1;                }
 static inline char *     If_CutPerm( If_Cut_t * pCut )                       { return (char *)(pCut->pLeaves + pCut->nLeaves);   }
-static inline void       If_CutCopy( If_Man_t * p, If_Cut_t * pDst, If_Cut_t * pSrc ) { memcpy( pDst, pSrc, p->nCutBytes );      }
-static inline void       If_CutSetup( If_Man_t * p, If_Cut_t * pCut        ) { memset(pCut, 0, p->nCutBytes); pCut->nLimit = p->pPars->nLutSize; }
+static inline void       If_CutCopy( If_Man_t * p, If_Cut_t * pDst, If_Cut_t * pSrc ) { memcpy( pDst, pSrc, (size_t)p->nCutBytes );      }
+static inline void       If_CutSetup( If_Man_t * p, If_Cut_t * pCut        ) { memset(pCut, 0, (size_t)p->nCutBytes); pCut->nLimit = p->pPars->nLutSize; }
 
 static inline If_Cut_t * If_ObjCutBest( If_Obj_t * pObj )                    { return &pObj->CutBest;                }
 static inline unsigned   If_ObjCutSign( unsigned ObjId )                     { return (1 << (ObjId % 31));           }
diff --git a/src/map/if/ifDsd.c b/src/map/if/ifDsd.c
index 2094a5d9..802e6892 100644
--- a/src/map/if/ifDsd.c
+++ b/src/map/if/ifDsd.c
@@ -2074,7 +2074,7 @@ int If_DsdManCompute( If_DsdMan_t * p, word * pTruth, int nLeaves, unsigned char
 //p->timeDsd += Abc_Clock() - clk;
     if ( nSizeNonDec > 0 )
         Abc_TtStretch6( pCopy, nSizeNonDec, p->nVars );
-    memset( pPerm, 0xFF, nLeaves );
+    memset( pPerm, 0xFF, (size_t)nLeaves );
 //clk = Abc_Clock();
     iDsd = If_DsdManAddDsd( p, pDsd, pCopy, pPerm, &nSupp );
 //p->timeCanon += Abc_Clock() - clk;
diff --git a/src/map/mapper/mapperCut.c b/src/map/mapper/mapperCut.c
index 681625ac..cbb061f2 100644
--- a/src/map/mapper/mapperCut.c
+++ b/src/map/mapper/mapperCut.c
@@ -1007,7 +1007,7 @@ Map_Cut_t * Map_CutSortCuts( Map_Man_t * pMan, Map_CutTable_t * p, Map_Cut_t * p
     assert( nCuts <= MAP_CUTS_MAX_COMPUTE );
     // sort the cuts
 //clk = Abc_Clock();
-    qsort( (void *)p->pCuts1, nCuts, sizeof(Map_Cut_t *), 
+    qsort( (void *)p->pCuts1, (size_t)nCuts, sizeof(Map_Cut_t *), 
             (int (*)(const void *, const void *)) Map_CutSortCutsCompare );
 //pMan->time2 += Abc_Clock() - clk;
     // move them back into the list
diff --git a/src/map/mapper/mapperTable.c b/src/map/mapper/mapperTable.c
index 7e12d8dc..b7dff4dd 100644
--- a/src/map/mapper/mapperTable.c
+++ b/src/map/mapper/mapperTable.c
@@ -328,7 +328,7 @@ void Map_SuperTableSortSupergates( Map_HashTable_t * p, int nSupersMax )
                 ppSupers[nSupers++] = pSuper;
 
     // sort by usage
-    qsort( (void *)ppSupers, nSupers, sizeof(Map_Super_t *), 
+    qsort( (void *)ppSupers, (size_t)nSupers, sizeof(Map_Super_t *), 
             (int (*)(const void *, const void *)) Map_SuperTableCompareSupergates );
     assert( Map_SuperTableCompareSupergates( ppSupers, ppSupers + nSupers - 1 ) <= 0 );
 
@@ -383,7 +383,7 @@ void Map_SuperTableSortSupergatesByDelay( Map_HashTable_t * p, int nSupersMax )
             if ( nSupers == 0 )
                 continue;
             // sort the gates by delay
-            qsort( (void *)ppSupers, nSupers, sizeof(Map_Super_t *), 
+            qsort( (void *)ppSupers, (size_t)nSupers, sizeof(Map_Super_t *), 
                     (int (*)(const void *, const void *)) Map_SuperTableCompareGatesInList );
             assert( Map_SuperTableCompareGatesInList( ppSupers, ppSupers + nSupers - 1 ) <= 0 );
             // link them in the reverse order
diff --git a/src/map/mapper/mapperUtils.c b/src/map/mapper/mapperUtils.c
index 7ea60ec9..ea6ab065 100644
--- a/src/map/mapper/mapperUtils.c
+++ b/src/map/mapper/mapperUtils.c
@@ -543,7 +543,7 @@ int Map_CompareNodesByLevel( Map_Node_t ** ppS1, Map_Node_t ** ppS2 )
 ***********************************************************************/
 void Map_MappingSortByLevel( Map_Man_t * pMan, Map_NodeVec_t * vNodes )
 {
-    qsort( (void *)vNodes->pArray, vNodes->nSize, sizeof(Map_Node_t *), 
+    qsort( (void *)vNodes->pArray, (size_t)vNodes->nSize, sizeof(Map_Node_t *), 
             (int (*)(const void *, const void *)) Map_CompareNodesByLevel );
 //    assert( Map_CompareNodesByLevel( vNodes->pArray, vNodes->pArray + vNodes->nSize - 1 ) <= 0 );
 }
diff --git a/src/map/mapper/mapperVec.c b/src/map/mapper/mapperVec.c
index 8316072a..d2cd2bc0 100644
--- a/src/map/mapper/mapperVec.c
+++ b/src/map/mapper/mapperVec.c
@@ -306,7 +306,7 @@ Map_Node_t * Map_NodeVecReadEntry( Map_NodeVec_t * p, int i )
 ***********************************************************************/
 void Map_NodeVecSortByLevel( Map_NodeVec_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(Map_Node_t *), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Map_Node_t *), 
             (int (*)(const void *, const void *)) Map_NodeVecCompareLevels );
 }
 
diff --git a/src/map/mio/mioRead.c b/src/map/mio/mioRead.c
index d23f77f0..c0a83cfd 100644
--- a/src/map/mio/mioRead.c
+++ b/src/map/mio/mioRead.c
@@ -595,7 +595,7 @@ void Mio_LibrarySortGates( Mio_Library_t * pLib )
     pLib->ppGates0 = ABC_ALLOC( Mio_Gate_t *, pLib->nGates );
     for ( i = 0; i < pLib->nGates; i++ )
         pLib->ppGates0[i] = ppGates[i];
-    qsort( (void *)ppGates, pLib->nGates, sizeof(void *), 
+    qsort( (void *)ppGates, (size_t)pLib->nGates, sizeof(void *), 
             (int (*)(const void *, const void *)) Mio_LibraryCompareGatesByName );
     for ( i = 0; i < pLib->nGates; i++ )
         ppGates[i]->pNext = (i < pLib->nGates-1)? ppGates[i+1] : NULL;
diff --git a/src/map/mio/mioUtils.c b/src/map/mio/mioUtils.c
index b2ee8ab9..9cd44cba 100644
--- a/src/map/mio/mioUtils.c
+++ b/src/map/mio/mioUtils.c
@@ -462,7 +462,7 @@ Mio_Gate_t ** Mio_CollectRoots( Mio_Library_t * pLib, int nInputs, float tDelay,
     // sort by delay
     if ( iGate > 0 ) 
     {
-        qsort( (void *)ppGates, iGate, sizeof(Mio_Gate_t *), 
+        qsort( (void *)ppGates, (size_t)iGate, sizeof(Mio_Gate_t *), 
                 (int (*)(const void *, const void *)) Mio_DelayCompare );
         assert( Mio_DelayCompare( ppGates, ppGates + iGate - 1 ) <= 0 );
     }
@@ -572,7 +572,7 @@ Mio_Cell_t * Mio_CollectRootsNew( Mio_Library_t * pLib, int nInputs, int * pnGat
     // sort by delay
     if ( iCell > 5 ) 
     {
-        qsort( (void *)(ppCells + 4), iCell - 4, sizeof(Mio_Cell_t), 
+        qsort( (void *)(ppCells + 4), (size_t)(iCell - 4), sizeof(Mio_Cell_t), 
                 (int (*)(const void *, const void *)) Mio_AreaCompare );
         assert( Mio_AreaCompare( ppCells + 4, ppCells + iCell - 1 ) <= 0 );
     }
@@ -729,7 +729,7 @@ Mio_Cell2_t * Mio_CollectRootsNew2( Mio_Library_t * pLib, int nInputs, int * pnG
     // sort by delay
     if ( iCell > 5 ) 
     {
-        qsort( (void *)(ppCells + 4), iCell - 4, sizeof(Mio_Cell2_t), 
+        qsort( (void *)(ppCells + 4), (size_t)(iCell - 4), sizeof(Mio_Cell2_t), 
                 (int (*)(const void *, const void *)) Mio_AreaCompare2 );
         assert( Mio_AreaCompare2( ppCells + 4, ppCells + iCell - 1 ) <= 0 );
     }
@@ -818,7 +818,7 @@ int Mio_CollectRootsNewDefault3( int nInputs, Vec_Ptr_t ** pvNames, Vec_Wrd_t **
             pTruth[1] = pTruth[3] = pGate0->pTruth[1];
         }
         else if ( pGate0->nInputs == 8 )
-            memcpy( pTruth, pGate0->pTruth, 4*sizeof(word) );
+            memcpy( pTruth, pGate0->pTruth, (size_t)(4*sizeof(word)) );
     }
     assert( iGate == nGates );
     assert( Vec_WrdEntry(*pvTruths,  0) ==        0 );
diff --git a/src/map/scl/sclLibUtil.c b/src/map/scl/sclLibUtil.c
index ebd9cbc7..f57669b7 100644
--- a/src/map/scl/sclLibUtil.c
+++ b/src/map/scl/sclLibUtil.c
@@ -292,7 +292,7 @@ void Abc_SclLinkCells( SC_Lib * p )
         Vec_PtrClear( vList );
         SC_RingForEachCell( pRepr, pCell, i )
             Vec_PtrPush( vList, pCell );
-        qsort( (void *)Vec_PtrArray(vList), Vec_PtrSize(vList), sizeof(void *), (int(*)(const void *,const void *))Abc_SclCompareCells );
+        qsort( (void *)Vec_PtrArray(vList), (size_t)Vec_PtrSize(vList), sizeof(void *), (int(*)(const void *,const void *))Abc_SclCompareCells );
         // create new representative
         pRepr = (SC_Cell *)Vec_PtrEntry( vList, 0 );
         pRepr->pNext = pRepr->pPrev = pRepr;
diff --git a/src/map/super/superAnd.c b/src/map/super/superAnd.c
index 3e55d0f5..9b0ffca1 100644
--- a/src/map/super/superAnd.c
+++ b/src/map/super/superAnd.c
@@ -475,7 +475,7 @@ clk = Abc_Clock();
     // sort the supergates by truth table
     s_uMaskBit = pLib->uMaskBit;
     s_uMaskAll = SUPER_MASK(pLib->nMints);
-    qsort( (void *)pLib->pGates, pLib->nGates, sizeof(Super2_Gate_t *), 
+    qsort( (void *)pLib->pGates, (size_t)pLib->nGates, sizeof(Super2_Gate_t *), 
             (int (*)(const void *, const void *)) Super2_LibCompareGates );
     assert( Super2_LibCompareGates( pLib->pGates, pLib->pGates + pLib->nGates - 1 ) < 0 );
 ABC_PRT( "Sorting", Abc_Clock() - clk );
diff --git a/src/map/super/superGate.c b/src/map/super/superGate.c
index c96c9526..82c928a7 100644
--- a/src/map/super/superGate.c
+++ b/src/map/super/superGate.c
@@ -368,7 +368,7 @@ Super_Man_t * Super_Compute( Super_Man_t * pMan, Mio_Gate_t ** ppGates, int nGat
         printf( "Sorting array of %d supergates...\r", pMan->nGates );
         fflush( stdout );
     }
-    qsort( (void *)pMan->pGates, pMan->nGates, sizeof(Super_Gate_t *), 
+    qsort( (void *)pMan->pGates, (size_t)pMan->nGates, sizeof(Super_Gate_t *), 
             (int (*)(const void *, const void *)) Super_DelayCompare );
     assert( Super_DelayCompare( pMan->pGates, pMan->pGates + pMan->nGates - 1 ) <= 0 );
     if ( pMan->nGates > 10000 )
@@ -424,7 +424,7 @@ Super_Man_t * Super_Compute( Super_Man_t * pMan, Mio_Gate_t ** ppGates, int nGat
         // all the gates beyond this point can be skipped because their area can be only larger
         if ( nGatesLimit > 10000 )
             printf( "Sorting array of %d supergates...\r", nGatesLimit );
-        qsort( (void *)ppGatesLimit, nGatesLimit, sizeof(Super_Gate_t *), 
+        qsort( (void *)ppGatesLimit, (size_t)nGatesLimit, sizeof(Super_Gate_t *), 
                 (int (*)(const void *, const void *)) Super_AreaCompare );
         assert( Super_AreaCompare( ppGatesLimit, ppGatesLimit + nGatesLimit - 1 ) <= 0 );
         if ( nGatesLimit > 10000 )
@@ -1021,7 +1021,7 @@ Vec_Str_t * Super_Write( Super_Man_t * pMan )
 
 clk = Abc_Clock();
     // sort the supergates by truth table
-    qsort( (void *)pMan->pGates, pMan->nGates, sizeof(Super_Gate_t *), 
+    qsort( (void *)pMan->pGates, (size_t)pMan->nGates, sizeof(Super_Gate_t *), 
             (int (*)(const void *, const void *)) Super_WriteCompare );
     assert( Super_WriteCompare( pMan->pGates, pMan->pGates + pMan->nGates - 1 ) <= 0 );
 if ( pMan->fVerbose )
diff --git a/src/misc/bbl/bblif.c b/src/misc/bbl/bblif.c
index 1f0dbaeb..8b315210 100644
--- a/src/misc/bbl/bblif.c
+++ b/src/misc/bbl/bblif.c
@@ -844,7 +844,7 @@ void Bbl_ManSortCubes( char ** pCubes, int nCubes, int nVars )
     {
         best_i = i;
         for (j = i+1; j < nCubes; j++)
-            if ( memcmp( pCubes[j], pCubes[best_i], nVars ) < 0 )
+            if ( memcmp( pCubes[j], pCubes[best_i], (size_t)nVars ) < 0 )
                 best_i = j;
         pTemp = pCubes[i]; pCubes[i] = pCubes[best_i]; pCubes[best_i] = pTemp;
     }
@@ -871,7 +871,7 @@ char * Bbl_ManSortSop( char * pSop, int nVars )
     if ( nCubes < 2 )
     {
         pSopNew = BBLIF_ALLOC( char, Length + 1 );
-        memcpy( pSopNew, pSop, Length + 1 );
+        memcpy( pSopNew, pSop, (size_t)(Length + 1) );
         return pSopNew;
     }
     pCubes = BBLIF_ALLOC( char *, nCubes );
@@ -881,7 +881,7 @@ char * Bbl_ManSortSop( char * pSop, int nVars )
         Bbl_ManSortCubes( pCubes, nCubes, nVars );
     pSopNew = BBLIF_ALLOC( char, Length + 1 );
     for ( c = 0; c < nCubes; c++ )
-        memcpy( pSopNew + c * (nVars + 3), pCubes[c], nVars + 3 );
+        memcpy( pSopNew + c * (nVars + 3), pCubes[c], (size_t)(nVars + 3) );
     BBLIF_FREE( pCubes );
     pSopNew[nCubes * (nVars + 3)] = 0;
     return pSopNew;
@@ -933,7 +933,7 @@ int Bbl_ManSopCheckUnique( Bbl_Man_t * p, char * pSop, int nVars, int nCubes, in
         pEnt = Bbl_VecEnt( p->pEnts, h );
         pFnc = Bbl_VecFnc( p->pFncs, pEnt->iFunc );
         assert( nVars == 16 || nCubes == 16 || pFnc->nWords == nWords );
-        if ( pFnc->nWords == nWords && memcmp( pFnc->pWords, pSop, Length ) == 0 )
+        if ( pFnc->nWords == nWords && memcmp( pFnc->pWords, pSop, (size_t)Length ) == 0 )
             return pEnt->iFunc;
     }
     p->SopMap[nVars][nCubes] = Bbl_ManCreateEntry( p, iFunc, p->SopMap[nVars][nCubes] );
diff --git a/src/misc/espresso/cofactor.c b/src/misc/espresso/cofactor.c
index fec36afd..04b211dd 100644
--- a/src/misc/espresso/cofactor.c
+++ b/src/misc/espresso/cofactor.c
@@ -372,7 +372,7 @@ pcube *T;
     (void) set_copy(cube.temp[0], T[0]);        /* retrieve cofactor */
 
     ncubes = CUBELISTSIZE(T);
-    qsort((char *) (T+2), ncubes, sizeof(pset), (int (*)()) d1_order);
+    qsort((char *) (T+2), (size_t)ncubes, sizeof(pset), (int (*)()) d1_order);
 
     Tdest = T+2;
     /*   *Tdest++ = T[2];   */
diff --git a/src/misc/espresso/compl.c b/src/misc/espresso/compl.c
index a17eb278..1f49577a 100644
--- a/src/misc/espresso/compl.c
+++ b/src/misc/espresso/compl.c
@@ -200,8 +200,8 @@ int lifting;            /* whether to perform lifting or not */
 
     /* Sort the arrays for a distance-1 merge */
     (void) set_copy(cube.temp[0], cube.var_mask[var]);
-    qsort((char *) (L1 = sf_list(L)), L->count, sizeof(pset), (int (*)()) d1_order);
-    qsort((char *) (R1 = sf_list(R)), R->count, sizeof(pset), (int (*)()) d1_order);
+    qsort((char *) (L1 = sf_list(L)), (size_t)L->count, sizeof(pset), (int (*)()) d1_order);
+    qsort((char *) (R1 = sf_list(R)), (size_t)R->count, sizeof(pset), (int (*)()) d1_order);
 
     /* Perform distance-1 merge */
     compl_d1merge(L1, R1);
diff --git a/src/misc/espresso/contain.c b/src/misc/espresso/contain.c
index e6073076..63eba8b2 100644
--- a/src/misc/espresso/contain.c
+++ b/src/misc/espresso/contain.c
@@ -342,7 +342,7 @@ IN int (*compare)();
     *pdest = NULL;                      /* Sentinel -- never seen by sort */
 
     /* Sort cubes by size */
-    qsort((char *) A1, A->count, sizeof(pset), compare);
+    qsort((char *) A1, (size_t)A->count, sizeof(pset), compare);
     return A1;
 }
 
diff --git a/src/misc/espresso/cvrm.c b/src/misc/espresso/cvrm.c
index 2a573ae0..8fe4837d 100644
--- a/src/misc/espresso/cvrm.c
+++ b/src/misc/espresso/cvrm.c
@@ -161,7 +161,7 @@ int (*compare)();
     FREE(count);
 
     /* use qsort to sort the array */
-    qsort((char *) (F1 = sf_list(F)), F->count, sizeof(pcube), compare);
+    qsort((char *) (F1 = sf_list(F)), (size_t)F->count, sizeof(pcube), compare);
     F_sorted = sf_unlist(F1, F->count, F->sf_size);
     free_cover(F);
 
@@ -189,7 +189,7 @@ IN pcover T;
     foreach_set(T, last, p)
     PUTSIZE(p, ((n - cdist(largest,p)) << 7) + MIN(set_ord(p),127));
 
-    qsort((char *) (T1 = sf_list(T)), T->count, sizeof(pcube), (int (*)()) descend);
+    qsort((char *) (T1 = sf_list(T)), (size_t)T->count, sizeof(pcube), (int (*)()) descend);
     T_sorted = sf_unlist(T1, T->count, T->sf_size);
     free_cover(T);
 
diff --git a/src/misc/extra/extraUtilFile.c b/src/misc/extra/extraUtilFile.c
index 8f60f421..0af78ac4 100644
--- a/src/misc/extra/extraUtilFile.c
+++ b/src/misc/extra/extraUtilFile.c
@@ -808,7 +808,7 @@ void Extra_FileSort( char * pFileName, char * pFileNameOut )
             Begin = i + 1;
         }
     // sort the lines
-    qsort( pLines, nLines, sizeof(char *), (int(*)(const void *,const void *))Extra_StringCompare );
+    qsort( pLines, (size_t)nLines, sizeof(char *), (int(*)(const void *,const void *))Extra_StringCompare );
     // write a new file
     pFile = fopen( pFileNameOut, "wb" );
     for ( i = 0; i < nLines; i++ )
diff --git a/src/misc/extra/extraUtilMisc.c b/src/misc/extra/extraUtilMisc.c
index 1b14e07f..db24a418 100644
--- a/src/misc/extra/extraUtilMisc.c
+++ b/src/misc/extra/extraUtilMisc.c
@@ -2493,7 +2493,7 @@ void Extra_NpnTest()
     // read functions
     pFuncs = Extra_NpnRead( "C:\\_projects\\abc\\_TEST\\allan\\lib6var5M.txt", nFuncs );
 //    pFuncs = Extra_NpnRead( "C:\\_projects\\abc\\_TEST\\allan\\lib6var5M_out_Total_minimal.txt", nFuncs );
-    qsort( (void *)pFuncs, nFuncs, sizeof(word), (int(*)(const void *,const void *))CompareWords );
+    qsort( (void *)pFuncs, (size_t)nFuncs, sizeof(word), (int(*)(const void *,const void *))CompareWords );
 
     // count unique
     k = 1;
@@ -2517,7 +2517,7 @@ void Extra_NpnTest()
     printf( "Finished deriving minimum form\n" );
 /*
     // sort them by value
-    qsort( (void *)pFuncs, nFuncs, sizeof(word), (int(*)(const void *,const void *))CompareWords );
+    qsort( (void *)pFuncs, (size_t)nFuncs, sizeof(word), (int(*)(const void *,const void *))CompareWords );
     // count unique
     nUnique = nFuncs;
     for ( i = 1; i < nFuncs; i++ )
diff --git a/src/misc/extra/extraUtilReader.c b/src/misc/extra/extraUtilReader.c
index 732402d4..db604396 100644
--- a/src/misc/extra/extraUtilReader.c
+++ b/src/misc/extra/extraUtilReader.c
@@ -369,7 +369,7 @@ void Extra_FileReaderReload( Extra_FileReader_t * p )
     // figure out how many chars are still not processed
     nCharsUsed = p->pBufferEnd - p->pBufferCur;
     // move the remaining data to the beginning of the buffer
-    memmove( p->pBuffer, p->pBufferCur, nCharsUsed );
+    memmove( p->pBuffer, p->pBufferCur, (size_t)nCharsUsed );
     p->pBufferCur = p->pBuffer;
     // determine how many chars we will read
     nCharsToRead = EXTRA_MINIMUM( p->nBufferSize - nCharsUsed, p->nFileSize - p->nFileRead );
diff --git a/src/misc/util/abc_global.h b/src/misc/util/abc_global.h
index c27b907e..28f0dd57 100644
--- a/src/misc/util/abc_global.h
+++ b/src/misc/util/abc_global.h
@@ -256,13 +256,13 @@ typedef ABC_INT64_T iword;
 #define ABC_PRMn(a,f)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB  ",    1.0*(f)/(1<<20)))
 #define ABC_PRMP(a,f,F) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB (%6.2f %%)\n",  (1.0*(f)/(1<<20)), ((F)? 100.0*(f)/(F) : 0.0) ) )
 
-#define ABC_ALLOC(type, num)     ((type *) malloc(sizeof(type) * (num)))
-#define ABC_CALLOC(type, num)    ((type *) calloc((num), sizeof(type)))
-#define ABC_FALLOC(type, num)    ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))
+#define ABC_ALLOC(type, num)     ((type *) malloc(sizeof(type) * (size_t)(num)))
+#define ABC_CALLOC(type, num)    ((type *) calloc((size_t)(num), sizeof(type)))
+#define ABC_FALLOC(type, num)    ((type *) memset(malloc(sizeof(type) * (size_t)(num)), 0xff, sizeof(type) * (size_t)(num)))
 #define ABC_FREE(obj)            ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
 #define ABC_REALLOC(type, obj, num) \
-        ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
-         ((type *) malloc(sizeof(type) * (num))))
+        ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (size_t)(num))) : \
+         ((type *) malloc(sizeof(type) * (size_t)(num))))
 
 static inline int      Abc_AbsInt( int a        )             { return a < 0 ? -a : a; }
 static inline int      Abc_MaxInt( int a, int b )             { return a > b ?  a : b; }
diff --git a/src/misc/util/utilMem.c b/src/misc/util/utilMem.c
index 0bce119b..302d9008 100644
--- a/src/misc/util/utilMem.c
+++ b/src/misc/util/utilMem.c
@@ -153,7 +153,7 @@ static void Vec_MemSort( Vec_Mem_t * p, int (*Vec_MemSortCompare)() )
 {
     if ( p->nSize < 2 )
         return;
-    qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
             (int (*)(const void *, const void *)) Vec_MemSortCompare );
 }
 
diff --git a/src/misc/util/utilSort.c b/src/misc/util/utilSort.c
index 4dca700c..32154a7d 100644
--- a/src/misc/util/utilSort.c
+++ b/src/misc/util/utilSort.c
@@ -434,7 +434,7 @@ void Abc_SortTest()
     else
     {
         clk = Abc_Clock();
-        qsort( (void *)pArray, nSize, sizeof(int), (int (*)(const void *, const void *)) Abc_SortNumCompare );
+        qsort( (void *)pArray, (size_t)nSize, sizeof(int), (int (*)(const void *, const void *)) Abc_SortNumCompare );
         Abc_PrintTime( 1, "Old sort", Abc_Clock() - clk );
         // check
         for ( i = 1; i < nSize; i++ )
@@ -479,14 +479,14 @@ void Abc_QuickSort1( word * pData, int nSize, int fDecrease )
     int i, fVerify = 0;
     if ( fDecrease )
     {
-        qsort( (void *)pData, nSize, sizeof(word), (int (*)(const void *, const void *))Abc_QuickSort1CompareDec );
+        qsort( (void *)pData, (size_t)nSize, sizeof(word), (int (*)(const void *, const void *))Abc_QuickSort1CompareDec );
         if ( fVerify )
             for ( i = 1; i < nSize; i++ )
                 assert( (unsigned)pData[i-1] >= (unsigned)pData[i] );
     }
     else
     {
-        qsort( (void *)pData, nSize, sizeof(word), (int (*)(const void *, const void *))Abc_QuickSort1CompareInc );
+        qsort( (void *)pData, (size_t)nSize, sizeof(word), (int (*)(const void *, const void *))Abc_QuickSort1CompareInc );
         if ( fVerify )
             for ( i = 1; i < nSize; i++ )
                 assert( (unsigned)pData[i-1] <= (unsigned)pData[i] );
diff --git a/src/misc/vec/vecFlt.h b/src/misc/vec/vecFlt.h
index 9988deae..b5c5e498 100644
--- a/src/misc/vec/vecFlt.h
+++ b/src/misc/vec/vecFlt.h
@@ -807,10 +807,10 @@ static int Vec_FltSortCompare2( float * pp1, float * pp2 )
 static inline void Vec_FltSort( Vec_Flt_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(float), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(float), 
                 (int (*)(const void *, const void *)) Vec_FltSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(float), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(float), 
                 (int (*)(const void *, const void *)) Vec_FltSortCompare1 );
 }
 
diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index dd478a1c..76c0aca2 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -1381,20 +1381,20 @@ static int Vec_IntSortCompare2( int * pp1, int * pp2 )
 static inline void Vec_IntSort( Vec_Int_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
 }
 static inline void Vec_IntSortMulti( Vec_Int_t * p, int nMulti, int fReverse )
 {
     assert( Vec_IntSize(p) % nMulti == 0 );
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)(p->nSize/nMulti), nMulti*sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)(p->nSize/nMulti), nMulti*sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
 }
 
@@ -1638,7 +1638,7 @@ static inline int Vec_IntSortCompareUnsigned( unsigned * pp1, unsigned * pp2 )
 ***********************************************************************/
 static inline void Vec_IntSortUnsigned( Vec_Int_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
             (int (*)(const void *, const void *)) Vec_IntSortCompareUnsigned );
 }
 
diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h
index 015aa1be..3cdd25d6 100644
--- a/src/misc/vec/vecPtr.h
+++ b/src/misc/vec/vecPtr.h
@@ -910,10 +910,10 @@ static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
     if ( p->nSize < 2 )
         return;
     if ( Vec_PtrSortCompare == NULL )
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_PtrSortComparePtr );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_PtrSortCompare );
 }
 
@@ -1067,7 +1067,7 @@ static inline void Vec_PtrDoubleSimInfo( Vec_Ptr_t * vInfo )
     nWords = (unsigned *)Vec_PtrEntry(vInfo,1) - (unsigned *)Vec_PtrEntry(vInfo,0);
     vInfoNew = Vec_PtrAllocSimInfo( 2*Vec_PtrSize(vInfo), nWords );
     // copy the simulation info
-    memcpy( Vec_PtrEntry(vInfoNew,0), Vec_PtrEntry(vInfo,0), Vec_PtrSize(vInfo) * nWords * 4 );
+    memcpy( Vec_PtrEntry(vInfoNew,0), Vec_PtrEntry(vInfo,0), (size_t)(Vec_PtrSize(vInfo) * nWords * 4) );
     // replace the array
     ABC_FREE( vInfo->pArray );
     vInfo->pArray = vInfoNew->pArray;
@@ -1099,7 +1099,7 @@ static inline void Vec_PtrReallocSimInfo( Vec_Ptr_t * vInfo )
     vInfoNew = Vec_PtrAllocSimInfo( Vec_PtrSize(vInfo), 2*nWords );
     // copy the simulation info
     for ( i = 0; i < vInfo->nSize; i++ )
-        memcpy( Vec_PtrEntry(vInfoNew,i), Vec_PtrEntry(vInfo,i), nWords * 4 );
+        memcpy( Vec_PtrEntry(vInfoNew,i), Vec_PtrEntry(vInfo,i), (size_t)(nWords * 4) );
     // replace the array
     ABC_FREE( vInfo->pArray );
     vInfo->pArray = vInfoNew->pArray;
diff --git a/src/misc/vec/vecStr.h b/src/misc/vec/vecStr.h
index ef5e9a41..8c8f7e6e 100644
--- a/src/misc/vec/vecStr.h
+++ b/src/misc/vec/vecStr.h
@@ -565,7 +565,7 @@ static inline void Vec_StrPushBuffer( Vec_Str_t * p, char * pBuffer, int nSize )
 {
     if ( p->nSize + nSize > p->nCap )
         Vec_StrGrow( p, 2 * (p->nSize + nSize) );
-    memcpy( p->pArray + p->nSize, pBuffer, nSize );
+    memcpy( p->pArray + p->nSize, pBuffer, (size_t)nSize );
     p->nSize += nSize;
 }
 
@@ -916,10 +916,10 @@ static int Vec_StrSortCompare2( char * pp1, char * pp2 )
 static inline void Vec_StrSort( Vec_Str_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(char), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(char), 
                 (int (*)(const void *, const void *)) Vec_StrSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(char), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(char), 
                 (int (*)(const void *, const void *)) Vec_StrSortCompare1 );
 }
 
@@ -940,7 +940,7 @@ static inline int Vec_StrCompareVec( Vec_Str_t * p1, Vec_Str_t * p2 )
         return (p1 != NULL) - (p2 != NULL);
     if ( Vec_StrSize(p1) != Vec_StrSize(p2) )
         return Vec_StrSize(p1) - Vec_StrSize(p2);
-    return memcmp( Vec_StrArray(p1), Vec_StrArray(p2), Vec_StrSize(p1) );
+    return memcmp( Vec_StrArray(p1), Vec_StrArray(p2), (size_t)Vec_StrSize(p1) );
 }
 
 
diff --git a/src/misc/vec/vecVec.h b/src/misc/vec/vecVec.h
index 157b887c..1d90d11c 100644
--- a/src/misc/vec/vecVec.h
+++ b/src/misc/vec/vecVec.h
@@ -554,10 +554,10 @@ static int Vec_VecSortCompare2( Vec_Ptr_t ** pp1, Vec_Ptr_t ** pp2 )
 static inline void Vec_VecSort( Vec_Vec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare1 );
 }
 
@@ -603,10 +603,10 @@ static int Vec_VecSortCompare4( Vec_Int_t ** pp1, Vec_Int_t ** pp2 )
 static inline void Vec_VecSortByFirstInt( Vec_Vec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare4 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare3 );
 }
 
diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index c8c89701..e4c3d292 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -454,10 +454,10 @@ static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 )
 static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare1 );
 }
 
@@ -492,10 +492,10 @@ static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 )
 static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare4 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare3 );
 }
 
@@ -529,10 +529,10 @@ static int Vec_WecSortCompare6( Vec_Int_t * p1, Vec_Int_t * p2 )
 static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare6 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
 }
 
diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index d286baf3..eb0c137c 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -1084,10 +1084,10 @@ static int Vec_WrdSortCompare2( word * pp1, word * pp2 )
 static inline void Vec_WrdSort( Vec_Wrd_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(word), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(word), 
                 (int (*)(const void *, const void *)) Vec_WrdSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(word), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(word), 
                 (int (*)(const void *, const void *)) Vec_WrdSortCompare1 );
 }
 
@@ -1171,7 +1171,7 @@ static int Vec_WrdSortCompareUnsigned( word * pp1, word * pp2 )
 ***********************************************************************/
 static inline void Vec_WrdSortUnsigned( Vec_Wrd_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(word), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(word), 
             (int (*)(const void *, const void *)) Vec_WrdSortCompareUnsigned );
 }
 
diff --git a/src/misc/zlib/deflate.c b/src/misc/zlib/deflate.c
index 04dcbf09..934196c8 100644
--- a/src/misc/zlib/deflate.c
+++ b/src/misc/zlib/deflate.c
@@ -1232,7 +1232,7 @@ local void check_match(deflate_state *s, IPos start, IPos match, int length)
 {
     /* check that the match is indeed a match */
     if (zmemcmp(s->window + match,
-                s->window + start, length) != EQUAL) {
+                s->window + start, (size_t)length) != EQUAL) {
         fprintf(stderr, " start %u, match %u, length %d\n",
                 start, match, length);
         do {
diff --git a/src/misc/zlib/gzwrite.c b/src/misc/zlib/gzwrite.c
index 44e116de..19015b44 100644
--- a/src/misc/zlib/gzwrite.c
+++ b/src/misc/zlib/gzwrite.c
@@ -128,7 +128,7 @@ local int gz_zero(gz_statep state, z_off64_t len)
         n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
             (unsigned)len : state->size;
         if (first) {
-            memset(state->in, 0, n);
+            memset(state->in, 0, (size_t)n);
             first = 0;
         }
         strm->avail_in = n;
diff --git a/src/misc/zlib/zutil.h b/src/misc/zlib/zutil.h
index ad5dc411..26e37f31 100644
--- a/src/misc/zlib/zutil.h
+++ b/src/misc/zlib/zutil.h
@@ -239,11 +239,11 @@ ABC_NAMESPACE_HEADER_START
 #  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
 #    define zmemcpy _fmemcpy
 #    define zmemcmp _fmemcmp
-#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#    define zmemzero(dest, len) _fmemset(dest, 0, (size_t)len)
 #  else
 #    define zmemcpy memcpy
 #    define zmemcmp memcmp
-#    define zmemzero(dest, len) memset(dest, 0, len)
+#    define zmemzero(dest, len) memset(dest, 0, (size_t)len)
 #  endif
 #else
    void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
diff --git a/src/opt/cut/cutCut.c b/src/opt/cut/cutCut.c
index bd0a70b1..4f9089d9 100644
--- a/src/opt/cut/cutCut.c
+++ b/src/opt/cut/cutCut.c
@@ -126,7 +126,7 @@ Cut_Cut_t * Cut_CutDupList( Cut_Man_t * p, Cut_Cut_t * pList )
     Cut_ListForEachCut( pList, pTemp )
     {
         pCopy = (Cut_Cut_t *)Extra_MmFixedEntryFetch( p->pMmCuts );
-        memcpy( pCopy, pTemp, p->EntrySize );
+        memcpy( pCopy, pTemp, (size_t)p->EntrySize );
         *ppTail = pCopy;
         ppTail = &pCopy->pNext;
     }
diff --git a/src/opt/dau/dauCanon.c b/src/opt/dau/dauCanon.c
index ce0d1857..739dd373 100644
--- a/src/opt/dau/dauCanon.c
+++ b/src/opt/dau/dauCanon.c
@@ -1456,7 +1456,7 @@ unsigned Abc_TtCanonicizeWrap(TtCanonicizeFunc func, Abc_TtHieMan_t * p, word *
     if (Abc_TtCompareRev(pTruth, pTruth2, nWords) <= 0)
         return uCanonPhase1;
     Abc_TtCopy(pTruth, pTruth2, nWords, 0);
-    memcpy(pCanonPerm, pCanonPerm2, nVars);
+    memcpy(pCanonPerm, pCanonPerm2, (size_t)nVars);
     return uCanonPhase2;
 }
 
diff --git a/src/opt/dau/dauDsd.c b/src/opt/dau/dauDsd.c
index 8469da4b..b1e7e0d8 100644
--- a/src/opt/dau/dauDsd.c
+++ b/src/opt/dau/dauDsd.c
@@ -237,7 +237,7 @@ void Dau_DsdNormalize_rec( char * pStr, char ** p, int * pMatches )
         for ( i = 0; i < nMarks; i++ )
             pStore = Dau_DsdNormalizeCopy( pStore, pStr, pMarks, pPerm[i] );
         assert( pStore - pBuffer == *p - pOld );
-        memcpy( pOld, pBuffer, pStore - pBuffer );
+        memcpy( pOld, pBuffer, (size_t)(pStore - pBuffer) );
         return;
     }
     if ( **p == '<' || **p == '{' ) // mux
diff --git a/src/opt/dau/dauDsd2.c b/src/opt/dau/dauDsd2.c
index cf7dea0b..69c91a09 100644
--- a/src/opt/dau/dauDsd2.c
+++ b/src/opt/dau/dauDsd2.c
@@ -524,9 +524,9 @@ word Dua_DsdRangeVars( word * pTruth, int nVars, int iVar, int jVar, int fPerfor
             pCof0 = pCof1 = NULL;
             for ( Mint = 0; Mint < nMints; Mint++, iWord += nWordsF )
             {
-                if ( !pCof0 || !memcmp(pCof0, pTruth + iWord, nBytes) )
+                if ( !pCof0 || !memcmp(pCof0, pTruth + iWord, (size_t)nBytes) )
                     pCof0 = pTruth + iWord;
-                else if ( !pCof1 || !memcmp(pCof1, pTruth + iWord, nBytes) )
+                else if ( !pCof1 || !memcmp(pCof1, pTruth + iWord, (size_t)nBytes) )
                 {
                     pCof1 = pTruth + iWord;
                     MaskOne |= ((word)1) << Mint;
@@ -541,8 +541,8 @@ word Dua_DsdRangeVars( word * pTruth, int nVars, int iVar, int jVar, int fPerfor
             if ( fPerform )
             {
                 assert( pCof0 && pCof1 );
-                memcpy( pTruth + (2 * Part + 0) * nWordsF, pCof0, nBytes );
-                memcpy( pTruth + (2 * Part + 1) * nWordsF, pCof1, nBytes );
+                memcpy( pTruth + (2 * Part + 0) * nWordsF, pCof0, (size_t)nBytes );
+                memcpy( pTruth + (2 * Part + 1) * nWordsF, pCof1, (size_t)nBytes );
             }
         }
     }
diff --git a/src/opt/dau/dauTree.c b/src/opt/dau/dauTree.c
index f8508d53..81bd51bc 100644
--- a/src/opt/dau/dauTree.c
+++ b/src/opt/dau/dauTree.c
@@ -860,7 +860,7 @@ unsigned * Dss_ObjHashLookup( Dss_Man_t * p, int Type, Vec_Int_t * vFaninLits, w
         if ( (int)pObj->Type == Type && 
              (int)pObj->nFans == Vec_IntSize(vFaninLits) && 
              !memcmp(pObj->pFans, Vec_IntArray(vFaninLits), sizeof(int)*pObj->nFans) &&
-             (pTruth == NULL || !memcmp(Dss_ObjTruth(pObj), pTruth, Abc_TtByteNum(pObj->nFans))) ) // equal
+             (pTruth == NULL || !memcmp(Dss_ObjTruth(pObj), pTruth, (size_t)Abc_TtByteNum(pObj->nFans))) ) // equal
             return pSpot;
     }
     return pSpot;
diff --git a/src/opt/fxu/fxuCreate.c b/src/opt/fxu/fxuCreate.c
index 31228dfd..8d5b2f54 100644
--- a/src/opt/fxu/fxuCreate.c
+++ b/src/opt/fxu/fxuCreate.c
@@ -152,7 +152,7 @@ Fxu_Matrix * Fxu_CreateMatrix( Fxu_Data_t * pData )
         for ( v = 0; v < nFanins; v++ )
             pOrder[v] = v;
         // reorder the fanins
-        qsort( (void *)pOrder, nFanins, sizeof(int),(int (*)(const void *, const void *))Fxu_CreateMatrixLitCompare);
+        qsort( (void *)pOrder, (size_t)nFanins, sizeof(int),(int (*)(const void *, const void *))Fxu_CreateMatrixLitCompare);
         assert( s_pLits[ pOrder[0] ] < s_pLits[ pOrder[nFanins-1] ] );
         // create the corresponding cubes in the matrix
         pCubeFirst = NULL;
diff --git a/src/opt/fxu/fxuUpdate.c b/src/opt/fxu/fxuUpdate.c
index b48961e1..511ac955 100644
--- a/src/opt/fxu/fxuUpdate.c
+++ b/src/opt/fxu/fxuUpdate.c
@@ -588,7 +588,7 @@ void Fxu_UpdatePairsSort( Fxu_Matrix * p, Fxu_Double * pDouble )
     if ( p->vPairs->nSize < 2 )
         return;
     // sort
-    qsort( (void *)p->vPairs->pArray, p->vPairs->nSize, sizeof(Fxu_Pair *), 
+    qsort( (void *)p->vPairs->pArray, (size_t)p->vPairs->nSize, sizeof(Fxu_Pair *), 
         (int (*)(const void *, const void *)) Fxu_UpdatePairCompare );
     assert( Fxu_UpdatePairCompare( (Fxu_Pair**)p->vPairs->pArray, (Fxu_Pair**)p->vPairs->pArray + p->vPairs->nSize - 1 ) < 0 );
 }
diff --git a/src/opt/res/resSim.c b/src/opt/res/resSim.c
index d4088e7b..2d77d9af 100644
--- a/src/opt/res/resSim.c
+++ b/src/opt/res/resSim.c
@@ -314,7 +314,7 @@ void Res_SimSetDerivedBytes( Res_Sim_t * p, int fUseWalk )
             if ( i == p->nTruePis )
                 break;
             pInfo = (unsigned char *)Vec_PtrEntry( p->vPats, pObj->Id );
-            memset( pInfo + nPats, 0, p->nBytesIn - nPats );
+            memset( pInfo + nPats, 0, (size_t)(p->nBytesIn - nPats) );
         }
     }
 /*
diff --git a/src/opt/rwr/rwrEva.c b/src/opt/rwr/rwrEva.c
index 463e9bd7..1856f7b7 100644
--- a/src/opt/rwr/rwrEva.c
+++ b/src/opt/rwr/rwrEva.c
@@ -566,7 +566,7 @@ void Rwr_ScoresReport( Rwr_Man_t * p )
             Gains[i] += pNode->nGain;
     }
     // sort the gains
-    qsort( Perm, 222, sizeof(int), (int (*)(const void *, const void *))Rwr_ScoresCompare );
+    qsort( Perm, (size_t)222, sizeof(int), (int (*)(const void *, const void *))Rwr_ScoresCompare );
 
     // print classes
     for ( i = 0; i < p->vClasses->nSize; i++ )
diff --git a/src/opt/rwr/rwrTemp.c b/src/opt/rwr/rwrTemp.c
index b32709e5..4eb652d7 100644
--- a/src/opt/rwr/rwrTemp.c
+++ b/src/opt/rwr/rwrTemp.c
@@ -89,7 +89,7 @@ void Rwr_Temp()
     for ( i = 0; i < 13719; i++ )
         pPerm[i] = i;
 
-    qsort( (void *)pPerm, 13719, sizeof(int), 
+    qsort( (void *)pPerm, (size_t)13719, sizeof(int), 
             (int (*)(const void *, const void *)) Rwr_TempCompare );
 
 
diff --git a/src/opt/sfm/sfmCnf.c b/src/opt/sfm/sfmCnf.c
index b4dd11f8..ce2f34b8 100644
--- a/src/opt/sfm/sfmCnf.c
+++ b/src/opt/sfm/sfmCnf.c
@@ -132,7 +132,7 @@ Vec_Wec_t * Sfm_CreateCnf( Sfm_Ntk_t * p )
         nCubes = Sfm_TruthToCnf( uTruth, Sfm_ObjFaninNum(p, i), p->vCover, vCnf );
         vCnfBase = (Vec_Str_t *)Vec_WecEntry( vCnfs, i );
         Vec_StrGrow( vCnfBase, Vec_StrSize(vCnf) );
-        memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(vCnf), Vec_StrSize(vCnf) );
+        memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(vCnf), (size_t)Vec_StrSize(vCnf) );
         vCnfBase->nSize = Vec_StrSize(vCnf);
     }
     Vec_StrFree( vCnf );
diff --git a/src/opt/sfm/sfmLib.c b/src/opt/sfm/sfmLib.c
index e9a3b322..afb4a48d 100644
--- a/src/opt/sfm/sfmLib.c
+++ b/src/opt/sfm/sfmLib.c
@@ -110,7 +110,7 @@ void Sfm_DecCreateCnf( Vec_Int_t * vGateSizes, Vec_Wrd_t * vGateFuncs, Vec_Wec_t
         nCubes = Sfm_TruthToCnf( uTruth, Vec_IntEntry(vGateSizes, i), vCover, vCnf );
         vCnfBase = (Vec_Str_t *)Vec_WecEntry( vGateCnfs, i );
         Vec_StrGrow( vCnfBase, Vec_StrSize(vCnf) );
-        memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(vCnf), Vec_StrSize(vCnf) );
+        memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(vCnf), (size_t)Vec_StrSize(vCnf) );
         vCnfBase->nSize = Vec_StrSize(vCnf);
     }
     Vec_IntFree( vCover );
diff --git a/src/phys/place/place_bin.c b/src/phys/place/place_bin.c
index 92b283cc..01bcf461 100644
--- a/src/phys/place/place_bin.c
+++ b/src/phys/place/place_bin.c
@@ -82,7 +82,7 @@ void spreadDensityX(int numBins, float maxMovement) {
   }
   
   // spread X
-  qsort(allCells, moveableCells, sizeof(ConcreteCell*), cellSortByY);
+  qsort(allCells, (size_t)moveableCells, sizeof(ConcreteCell*), cellSortByY);
 
   y = 0;
 
@@ -96,7 +96,7 @@ void spreadDensityX(int numBins, float maxMovement) {
     // have we filled up a y-bin?
     if (yCumArea >= totalArea*(y+1)/numBins && yBinArea > 0) {
       memcpy(binCells, &(allCells[yBinStart]), sizeof(ConcreteCell*)*yBinCount);
-      qsort(binCells, yBinCount, sizeof(ConcreteCell*), cellSortByX);
+      qsort(binCells, (size_t)yBinCount, sizeof(ConcreteCell*), cellSortByX);
 
 #if defined(DEBUG)
       printf("y-bin %d count=%d area=%f\n",y,yBinCount, yBinArea);
@@ -217,7 +217,7 @@ void spreadDensityY(int numBins, float maxMovement) {
     // have we filled up an x-bin?
     if (xCumArea >= totalArea*(x+1)/numBins && xBinArea > 0) {
       memcpy(binCells, &(allCells[xBinStart]), sizeof(ConcreteCell*)*xBinCount);
-      qsort(binCells, xBinCount, sizeof(ConcreteCell*), cellSortByY);
+      qsort(binCells, (size_t)xBinCount, sizeof(ConcreteCell*), cellSortByY);
 
       // printf("x-bin %d count=%d area=%f\n",y,yBinCount, yBinArea);
 
diff --git a/src/phys/place/place_partition.c b/src/phys/place/place_partition.c
index eeef7037..477364df 100644
--- a/src/phys/place/place_partition.c
+++ b/src/phys/place/place_partition.c
@@ -107,14 +107,14 @@ void presortNets() {
   allNetsR2 = (ConcreteNet**)realloc(allNetsR2, sizeof(ConcreteNet*)*g_place_numNets);
   allNetsB2 = (ConcreteNet**)realloc(allNetsB2, sizeof(ConcreteNet*)*g_place_numNets);
   allNetsT2 = (ConcreteNet**)realloc(allNetsT2, sizeof(ConcreteNet*)*g_place_numNets);
-  memcpy(allNetsL2, g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
-  memcpy(allNetsR2, g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
-  memcpy(allNetsB2, g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
-  memcpy(allNetsT2, g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
-  qsort(allNetsL2, g_place_numNets, sizeof(ConcreteNet*), netSortByL);
-  qsort(allNetsR2, g_place_numNets, sizeof(ConcreteNet*), netSortByR);
-  qsort(allNetsB2, g_place_numNets, sizeof(ConcreteNet*), netSortByB);
-  qsort(allNetsT2, g_place_numNets, sizeof(ConcreteNet*), netSortByT);
+  memcpy(allNetsL2, (size_t)g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
+  memcpy(allNetsR2, (size_t)g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
+  memcpy(allNetsB2, (size_t)g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
+  memcpy(allNetsT2, (size_t)g_place_concreteNets, sizeof(ConcreteNet*)*g_place_numNets);
+  qsort(allNetsL2, (size_t)g_place_numNets, sizeof(ConcreteNet*), netSortByL);
+  qsort(allNetsR2, (size_t)g_place_numNets, sizeof(ConcreteNet*), netSortByR);
+  qsort(allNetsB2, (size_t)g_place_numNets, sizeof(ConcreteNet*), netSortByB);
+  qsort(allNetsT2, (size_t)g_place_numNets, sizeof(ConcreteNet*), netSortByT);
 }
 
 // --------------------------------------------------------------------
@@ -838,10 +838,10 @@ void partitionEqualArea(Partition *parent) {
   // which way to sort?
   if (parent->m_vertical)
     // sort by X position
-    qsort(parent->m_members, parent->m_numMembers, sizeof(ConcreteCell*), cellSortByX);
+    qsort(parent->m_members, (size_t)parent->m_numMembers, sizeof(ConcreteCell*), cellSortByX);
   else
     // sort by Y position
-    qsort(parent->m_members, parent->m_numMembers, sizeof(ConcreteCell*), cellSortByY);
+    qsort(parent->m_members, (size_t)parent->m_numMembers, sizeof(ConcreteCell*), cellSortByY);
 
   // split the list
   halfArea = parent->m_area*0.5;
@@ -1109,9 +1109,9 @@ void incrementalPartition() {
   assert(g_place_rootPartition);
 
   // update cell list of root partition
-  memcpy(allCells, g_place_concreteCells, sizeof(ConcreteCell*)*g_place_numCells);
-  qsort(allCells, g_place_numCells, sizeof(ConcreteCell*), cellSortByID);
-  qsort(g_place_rootPartition->m_members, g_place_rootPartition->m_numMembers,
+  memcpy(allCells, (size_t)g_place_concreteCells, sizeof(ConcreteCell*)*g_place_numCells);
+  qsort(allCells, (size_t)g_place_numCells, sizeof(ConcreteCell*), cellSortByID);
+  qsort(g_place_rootPartition->m_members, (size_t)g_place_rootPartition->m_numMembers,
         sizeof(ConcreteCell*), cellSortByID);
 
   // scan sorted lists and collect cells not in partitions
diff --git a/src/proof/acec/acecFadds.c b/src/proof/acec/acecFadds.c
index 7f6dcd53..d55eefe2 100644
--- a/src/proof/acec/acecFadds.c
+++ b/src/proof/acec/acecFadds.c
@@ -438,10 +438,10 @@ Vec_Int_t * Gia_ManDetectFullAdders( Gia_Man_t * p, int fVerbose, Vec_Int_t ** p
 {
     Vec_Int_t * vCutsXor, * vCutsMaj, * vFadds;
     Dtc_ManComputeCuts( p, pvCutsXor2, &vCutsXor, &vCutsMaj, fVerbose );
-    qsort( Vec_IntArray(vCutsXor), Vec_IntSize(vCutsXor)/4, 16, (int (*)(const void *, const void *))Dtc_ManCompare );
-    qsort( Vec_IntArray(vCutsMaj), Vec_IntSize(vCutsMaj)/4, 16, (int (*)(const void *, const void *))Dtc_ManCompare );
+    qsort( Vec_IntArray(vCutsXor), (size_t)(Vec_IntSize(vCutsXor)/4), 16, (int (*)(const void *, const void *))Dtc_ManCompare );
+    qsort( Vec_IntArray(vCutsMaj), (size_t)(Vec_IntSize(vCutsMaj)/4), 16, (int (*)(const void *, const void *))Dtc_ManCompare );
     vFadds = Dtc_ManFindCommonCuts( p, vCutsXor, vCutsMaj );
-    qsort( Vec_IntArray(vFadds), Vec_IntSize(vFadds)/5, 20, (int (*)(const void *, const void *))Dtc_ManCompare2 );
+    qsort( Vec_IntArray(vFadds), (size_t)(Vec_IntSize(vFadds)/5), 20, (int (*)(const void *, const void *))Dtc_ManCompare2 );
     if ( fVerbose )
         printf( "XOR3 cuts = %d.  MAJ cuts = %d.  Full-adders = %d.\n", Vec_IntSize(vCutsXor)/4, Vec_IntSize(vCutsMaj)/4, Vec_IntSize(vFadds)/5 );
     if ( fVerbose )
diff --git a/src/proof/acec/acecPo.c b/src/proof/acec/acecPo.c
index 91f6d5aa..36362efc 100644
--- a/src/proof/acec/acecPo.c
+++ b/src/proof/acec/acecPo.c
@@ -361,7 +361,7 @@ Vec_Wec_t * Gia_PolynGetResult( Hsh_VecMan_t * pHashC, Hsh_VecMan_t * pHashM, Ve
     Vec_WecForEachLevel( vSorted, vClass, i )
     {
         // sort monomials by the index of the first variable
-        qsort( Vec_IntArray(vClass), Vec_IntSize(vClass)/3, 12, (int (*)(const void *, const void *))Gia_PolynGetResultCompare );
+        qsort( Vec_IntArray(vClass), (size_t)(Vec_IntSize(vClass)/3), 12, (int (*)(const void *, const void *))Gia_PolynGetResultCompare );
         Vec_IntForEachEntryTriple( vClass, iConst, iMono, iFirst, k )
         {
             vArray = Hsh_VecReadEntry( pHashC, iConst );
diff --git a/src/proof/acec/acecPolyn.c b/src/proof/acec/acecPolyn.c
index 53ddf710..9fcc0136 100644
--- a/src/proof/acec/acecPolyn.c
+++ b/src/proof/acec/acecPolyn.c
@@ -139,7 +139,7 @@ void Pln_ManPrintFinal( Pln_Man_t * p, int fVerbose, int fVeryVerbose )
         Vec_IntPushTwo( vPairs, iConst, iMono );
     }
     // sort triples
-    qsort( Vec_IntArray(vPairs), Vec_IntSize(vPairs)/4, 16, (int (*)(const void *, const void *))Pln_ManCompare3 );
+    qsort( Vec_IntArray(vPairs), (size_t)(Vec_IntSize(vPairs)/4), 16, (int (*)(const void *, const void *))Pln_ManCompare3 );
     // print
     if ( fVerbose )
     Vec_IntForEachEntryDouble( vPairs, iConst, iMono, i )
diff --git a/src/proof/acec/acecPool.c b/src/proof/acec/acecPool.c
index 0868545e..49b7ce39 100644
--- a/src/proof/acec/acecPool.c
+++ b/src/proof/acec/acecPool.c
@@ -223,8 +223,8 @@ void Acec_ManCollectInsOuts( Gia_Man_t * p, Vec_Int_t * vAdds, Vec_Int_t * vBoxe
     Vec_IntForEachEntryDouble( vResOuts, iObj, Rank, k )
         Vec_IntWriteEntry( vResOuts, k+1, 1 + RankMax - Rank );
     // sort by rank
-    qsort( Vec_IntArray(vResIns),  Vec_IntSize(vResIns)/2,  8, (int (*)(const void *, const void *))Acec_ManCompareTwo );
-    qsort( Vec_IntArray(vResOuts), Vec_IntSize(vResOuts)/2, 8, (int (*)(const void *, const void *))Acec_ManCompareTwo );
+    qsort( Vec_IntArray(vResIns),  (size_t)(Vec_IntSize(vResIns)/2),  8, (int (*)(const void *, const void *))Acec_ManCompareTwo );
+    qsort( Vec_IntArray(vResOuts), (size_t)(Vec_IntSize(vResOuts)/2), 8, (int (*)(const void *, const void *))Acec_ManCompareTwo );
 }
 void Acec_ManCollectBoxSets_rec( Gia_Man_t * p, int Carry, int iRank, Vec_Int_t * vAdds, Vec_Int_t * vCarryMap, Vec_Int_t * vBoxes, Vec_Int_t * vBoxRanks )
 {
diff --git a/src/proof/acec/acecRe.c b/src/proof/acec/acecRe.c
index 5e5ca688..785058db 100644
--- a/src/proof/acec/acecRe.c
+++ b/src/proof/acec/acecRe.c
@@ -442,7 +442,7 @@ Vec_Int_t * Ree_ManComputeCuts( Gia_Man_t * p, Vec_Int_t ** pvXors, int fVerbose
     Vec_IntFree( vTemp );
     Vec_IntFree( vCuts );
     vAdds = Ree_ManDeriveAdds( pHash, vData, fVerbose );
-    qsort( Vec_IntArray(vAdds), Vec_IntSize(vAdds)/6, 24, (int (*)(const void *, const void *))Ree_ManCompare );
+    qsort( Vec_IntArray(vAdds), (size_t)(Vec_IntSize(vAdds)/6), 24, (int (*)(const void *, const void *))Ree_ManCompare );
     if ( fVerbose )
         printf( "Adders = %d.  Total cuts = %d.  Hashed cuts = %d.  Hashed/Adders = %.2f.\n", 
             Vec_IntSize(vAdds)/6, Vec_IntSize(vData)/3, Hash_IntManEntryNum(pHash), 6.0*Hash_IntManEntryNum(pHash)/Vec_IntSize(vAdds) );
diff --git a/src/proof/fra/fraImp.c b/src/proof/fra/fraImp.c
index 027d8eb2..4581e0a1 100644
--- a/src/proof/fra/fraImp.c
+++ b/src/proof/fra/fraImp.c
@@ -395,7 +395,7 @@ finish:
     }
     Vec_PtrFree( vNodes );
     // reorder implications topologically
-    qsort( (void *)Vec_IntArray(vImps), Vec_IntSize(vImps), sizeof(int), 
+    qsort( (void *)Vec_IntArray(vImps), (size_t)Vec_IntSize(vImps), sizeof(int), 
             (int (*)(const void *, const void *)) Sml_CompareMaxId );
 if ( p->pPars->fVerbose )
 {
diff --git a/src/proof/fraig/fraigVec.c b/src/proof/fraig/fraigVec.c
index 25d50bf3..5670c112 100644
--- a/src/proof/fraig/fraigVec.c
+++ b/src/proof/fraig/fraigVec.c
@@ -501,10 +501,10 @@ int Fraig_NodeVecCompareRefCounts( Fraig_Node_t ** pp1, Fraig_Node_t ** pp2 )
 void Fraig_NodeVecSortByLevel( Fraig_NodeVec_t * p, int fIncreasing )
 {
     if ( fIncreasing )
-        qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Fraig_Node_t *), 
                 (int (*)(const void *, const void *)) Fraig_NodeVecCompareLevelsIncreasing );
     else 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Fraig_Node_t *), 
                 (int (*)(const void *, const void *)) Fraig_NodeVecCompareLevelsDecreasing );
 }
 
@@ -521,7 +521,7 @@ void Fraig_NodeVecSortByLevel( Fraig_NodeVec_t * p, int fIncreasing )
 ***********************************************************************/
 void Fraig_NodeVecSortByNumber( Fraig_NodeVec_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Fraig_Node_t *), 
             (int (*)(const void *, const void *)) Fraig_NodeVecCompareNumbers );
 }
 
@@ -538,7 +538,7 @@ void Fraig_NodeVecSortByNumber( Fraig_NodeVec_t * p )
 ***********************************************************************/
 void Fraig_NodeVecSortByRefCount( Fraig_NodeVec_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(Fraig_Node_t *), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Fraig_Node_t *), 
             (int (*)(const void *, const void *)) Fraig_NodeVecCompareRefCounts );
 }
 
diff --git a/src/sat/cnf/cnfData.c b/src/sat/cnf/cnfData.c
index 3d3cdf37..797066e7 100644
--- a/src/sat/cnf/cnfData.c
+++ b/src/sat/cnf/cnfData.c
@@ -4737,7 +4737,7 @@ int Aig_ManDeriveCnfTest2()
         Counter += CountCur;
         pNums[uTruth] = CountCur;
         pSops[uTruth] = ALLOC( char, CountCur );
-        memcpy( pSops[uTruth], Sop, CountCur );
+        memcpy( pSops[uTruth], Sop, (size_t)CountCur );
         pLines[nLines++] = Counter;
     }
     fclose( pFile );
diff --git a/src/sat/msat/msatVec.c b/src/sat/msat/msatVec.c
index 7144b213..d443cb0a 100644
--- a/src/sat/msat/msatVec.c
+++ b/src/sat/msat/msatVec.c
@@ -442,10 +442,10 @@ int Msat_IntVecPop( Msat_IntVec_t * p )
 void Msat_IntVecSort( Msat_IntVec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
                 (int (*)(const void *, const void *)) Msat_IntVecSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
                 (int (*)(const void *, const void *)) Msat_IntVecSortCompare1 );
 }
 
diff --git a/src/sat/satoko/solver.c b/src/sat/satoko/solver.c
index b1596345..8f7dd875 100644
--- a/src/sat/satoko/solver.c
+++ b/src/sat/satoko/solver.c
@@ -173,7 +173,7 @@ static inline void clause_realloc(struct cdb *dest, struct cdb *src, unsigned *c
     }
     new_cref = cdb_append(dest, 3 + old_clause->f_learnt + old_clause->size);
     new_clause = cdb_handler(dest, new_cref);
-    memcpy(new_clause, old_clause, (3 + old_clause->f_learnt + old_clause->size) * 4);
+    memcpy(new_clause, old_clause, (size_t)((3 + old_clause->f_learnt + old_clause->size) * 4));
     old_clause->f_reallocd = 1;
     old_clause->size = (unsigned) new_cref;
     *cref = new_cref;
diff --git a/src/sat/satoko/solver_api.c b/src/sat/satoko/solver_api.c
index 0193b1c3..4775e445 100644
--- a/src/sat/satoko/solver_api.c
+++ b/src/sat/satoko/solver_api.c
@@ -259,7 +259,7 @@ int satoko_add_clause(solver_t *s, int *lits, int size)
     unsigned max_var;
     unsigned cref;
 
-    qsort((void *) lits, size, sizeof(unsigned), stk_uint_compare);
+    qsort((void *) lits, (size_t)size, sizeof(unsigned), stk_uint_compare);
     max_var = lit2var(lits[size - 1]);
     while (max_var >= vec_act_size(s->activity))
         satoko_add_variable(s, SATOKO_LIT_FALSE);
diff --git a/src/sat/satoko/utils/vec/vec_char.h b/src/sat/satoko/utils/vec/vec_char.h
index 7d5732ec..4d780b22 100644
--- a/src/sat/satoko/utils/vec/vec_char.h
+++ b/src/sat/satoko/utils/vec/vec_char.h
@@ -233,10 +233,10 @@ static inline int vec_char_desc_compare(const void *p1, const void *p2)
 static inline void vec_char_sort(vec_char_t *p, int ascending)
 {
     if (ascending)
-        qsort((void *) p->data, p->size, sizeof(char),
+        qsort((void *) p->data, (size_t)p->size, sizeof(char),
               (int (*)(const void *, const void *)) vec_char_asc_compare);
     else
-        qsort((void*) p->data, p->size, sizeof(char),
+        qsort((void*) p->data, (size_t)p->size, sizeof(char),
               (int (*)(const void *, const void *)) vec_char_desc_compare);
 }
 
diff --git a/src/sat/satoko/utils/vec/vec_flt.h b/src/sat/satoko/utils/vec/vec_flt.h
index d7c896d9..8dd7b2ac 100644
--- a/src/sat/satoko/utils/vec/vec_flt.h
+++ b/src/sat/satoko/utils/vec/vec_flt.h
@@ -220,10 +220,10 @@ static inline int vec_flt_desc_compare(const void* p1, const void* p2)
 static inline void vec_flt_sort(vec_flt_t* p, int ascending)
 {
     if (ascending)
-        qsort((void *) p->data, p->size, sizeof(float),
+        qsort((void *) p->data, (size_t)p->size, sizeof(float),
               (int (*)(const void*, const void*)) vec_flt_asc_compare);
     else
-        qsort((void *) p->data, p->size, sizeof(float),
+        qsort((void *) p->data, (size_t)p->size, sizeof(float),
               (int (*)(const void*, const void*)) vec_flt_desc_compare);
 }
 
diff --git a/src/sat/satoko/utils/vec/vec_int.h b/src/sat/satoko/utils/vec/vec_int.h
index 75c5d134..d310fd45 100755
--- a/src/sat/satoko/utils/vec/vec_int.h
+++ b/src/sat/satoko/utils/vec/vec_int.h
@@ -214,10 +214,10 @@ static inline int vec_int_desc_compare(const void* p1, const void* p2)
 static inline void vec_int_sort(vec_int_t* p, int ascending)
 {
     if (ascending)
-        qsort((void *) p->data, p->size, sizeof(int),
+        qsort((void *) p->data, (size_t)p->size, sizeof(int),
               (int (*)(const void*, const void*)) vec_int_asc_compare);
     else
-        qsort((void *) p->data, p->size, sizeof(int),
+        qsort((void *) p->data, (size_t)p->size, sizeof(int),
               (int (*)(const void*, const void*)) vec_int_desc_compare);
 }
 
diff --git a/src/sat/satoko/utils/vec/vec_sdbl.h b/src/sat/satoko/utils/vec/vec_sdbl.h
index ec1c731c..89127412 100755
--- a/src/sat/satoko/utils/vec/vec_sdbl.h
+++ b/src/sat/satoko/utils/vec/vec_sdbl.h
@@ -227,10 +227,10 @@ static inline int vec_sdbl_desc_compare(const void* p1, const void* p2)
 static inline void vec_sdbl_sort(vec_sdbl_t* p, int ascending)
 {
     if (ascending)
-        qsort((void *) p->data, p->size, sizeof(sdbl_t),
+        qsort((void *) p->data, (size_t)p->size, sizeof(sdbl_t),
               (int (*)(const void*, const void*)) vec_sdbl_asc_compare);
     else
-        qsort((void *) p->data, p->size, sizeof(sdbl_t),
+        qsort((void *) p->data, (size_t)p->size, sizeof(sdbl_t),
               (int (*)(const void*, const void*)) vec_sdbl_desc_compare);
 }
 
diff --git a/src/sat/satoko/utils/vec/vec_uint.h b/src/sat/satoko/utils/vec/vec_uint.h
index e6719ca3..ef094236 100755
--- a/src/sat/satoko/utils/vec/vec_uint.h
+++ b/src/sat/satoko/utils/vec/vec_uint.h
@@ -242,10 +242,10 @@ static inline int vec_uint_desc_compare(const void *p1, const void *p2)
 static inline void vec_uint_sort(vec_uint_t *p, int ascending)
 {
     if (ascending)
-        qsort((void *) p->data, p->size, sizeof(unsigned),
+        qsort((void *) p->data, (size_t)p->size, sizeof(unsigned),
               (int (*)(const void *, const void *)) vec_uint_asc_compare);
     else
-        qsort((void*) p->data, p->size, sizeof(unsigned),
+        qsort((void*) p->data, (size_t)p->size, sizeof(unsigned),
               (int (*)(const void *, const void *)) vec_uint_desc_compare);
 }
 
diff --git a/src/sat/xsat/xsatSolver.c b/src/sat/xsat/xsatSolver.c
index 4844ca1d..abf0809a 100644
--- a/src/sat/xsat/xsatSolver.c
+++ b/src/sat/xsat/xsatSolver.c
@@ -944,7 +944,7 @@ void xSAT_SolverClaRealloc( xSAT_Mem_t * pDest, xSAT_Mem_t * pSrc, unsigned * pC
     }
     nNewCRef = xSAT_MemAppend( pDest, 3 + pOldCla->fLearnt + pOldCla->nSize );
     pNewCla = xSAT_MemClauseHand( pDest, nNewCRef );
-    memcpy( pNewCla, pOldCla, ( 3 + pOldCla->fLearnt + pOldCla->nSize ) * 4 );
+    memcpy( pNewCla, pOldCla, (size_t)(( 3 + pOldCla->fLearnt + pOldCla->nSize ) * 4) );
     pOldCla->fReallocd = 1;
     pOldCla->nSize = ( unsigned ) nNewCRef;
     *pCRef = nNewCRef;