Index: extsrc/cson_amalgamation.c
==================================================================
--- extsrc/cson_amalgamation.c
+++ extsrc/cson_amalgamation.c
@@ -5389,11 +5389,11 @@
     cson_string * colName = NULL;
     int i = 0;
     int rc = 0;
     cson_value * currentValue = NULL;
     int const colCount = sqlite3_column_count(st);
-    if( !colCount || (colCount>cson_array_length_get(colNames)) ) {
+    if( !colCount || (colCount>(int)cson_array_length_get(colNames)) ) {
         return NULL;
     }
     rootV = cson_value_new_object();
     if(!rootV) return NULL;
     root = cson_value_get_object(rootV);

Index: src/backoffice.c
==================================================================
--- src/backoffice.c
+++ src/backoffice.c
@@ -541,11 +541,11 @@
         backofficeTrace("/***** Backoffice Interrupt %d *****/\n", GETPID());
         db_end_transaction(0);
         break;
       }
     }else{
-      if( lastWarning+warningDelay < tmNow ){
+      if( (sqlite3_uint64)(lastWarning+warningDelay) < tmNow ){
         fossil_warning(
            "backoffice process %lld still running after %d seconds",
            x.idCurrent, (int)(BKOFCE_LEASE_TIME + tmNow - x.tmCurrent));
         lastWarning = tmNow;
         warningDelay *= 2;

Index: src/bag.c
==================================================================
--- src/bag.c
+++ src/bag.c
@@ -101,11 +101,11 @@
     int e = old.a[i];
     if( e>0 ){
       unsigned h = bag_hash(e)%newSize;
       while( p->a[h] ){
         h++;
-        if( h==newSize ) h = 0;
+        if( (int)h==newSize ) h = 0;
       }
       p->a[h] = e;
       nLive++;
     }else if( e<0 ){
       nDel++;
@@ -131,11 +131,11 @@
     bag_resize(p,  n + 20 );
   }
   h = bag_hash(e)%p->sz;
   while( p->a[h]>0 && p->a[h]!=e ){
     h++;
-    if( h>=p->sz ) h = 0;
+    if( (int)h>=p->sz ) h = 0;
   }
   if( p->a[h]<=0 ){
     if( p->a[h]==0 ) p->used++;
     p->a[h] = e;
     p->cnt++;
@@ -154,11 +154,11 @@
     return 0;
   }
   h = bag_hash(e)%p->sz;
   while( p->a[h] && p->a[h]!=e ){
     h++;
-    if( h>=p->sz ) h = 0;
+    if( (int)h>=p->sz ) h = 0;
   }
   return p->a[h]==e;
 }
 
 /*
@@ -170,11 +170,11 @@
   assert( e>0 );
   if( p->sz==0 ) return;
   h = bag_hash(e)%p->sz;
   while( p->a[h] && p->a[h]!=e ){
     h++;
-    if( h>=p->sz ) h = 0;
+    if( (int)h>=p->sz ) h = 0;
   }
   if( p->a[h] ){
     int nx = h+1;
     if( nx>=p->sz ) nx = 0;
     if( p->a[nx]==0 ){
@@ -217,21 +217,21 @@
   assert( p->sz>0 );
   assert( e>0 );
   h = bag_hash(e)%p->sz;
   while( p->a[h] && p->a[h]!=e ){
     h++;
-    if( h>=p->sz ) h = 0;
+    if( (int)h>=p->sz ) h = 0;
   }
   assert( p->a[h] );
   h++;
-  while( h<p->sz && p->a[h]<=0 ){
+  while( (int)h<p->sz && p->a[h]<=0 ){
     h++;
   }
-  return h<p->sz ? p->a[h] : 0;
+  return (int)h<p->sz ? p->a[h] : 0;
 }
 
 /*
 ** Return the number of elements in the bag.
 */
 int bag_count(Bag *p){
   return p->cnt;
 }

Index: src/blob.c
==================================================================
--- src/blob.c
+++ src/blob.c
@@ -678,11 +678,11 @@
 
 /*
 ** Truncate a blob back to zero length
 */
 void blob_truncate(Blob *p, int sz){
-  if( sz>=0 && sz<p->nUsed ) p->nUsed = sz;
+  if( sz>=0 && sz<(int)(p->nUsed) ) p->nUsed = sz;
 }
 
 /*
 ** Seek the cursor in a blob to the indicated offset.
 */
@@ -1163,11 +1163,11 @@
       return 0;
     }
     blob_is_init(pBlob);
     nWrote = fwrite(blob_buffer(pBlob), 1, blob_size(pBlob), out);
     fclose(out);
-    if( nWrote!=blob_size(pBlob) ){
+    if( nWrote!=(int)blob_size(pBlob) ){
       fossil_fatal_recursive("short write: %d of %d bytes to %s", nWrote,
          blob_size(pBlob), zFilename);
     }
   }
   return nWrote;
@@ -1361,11 +1361,11 @@
   int i, n;
   for(i=n=0; i<j; i++){
     if( z[i]=='\n' ) n++;
   }
   j += n;
-  if( j>=p->nAlloc ){
+  if( j>=(int)(p->nAlloc) ){
     blob_resize(p, j);
     z = p->aData;
   }
   p->nUsed = j;
   z[j] = 0;
@@ -1416,11 +1416,11 @@
       }
       n++;
     }
   }
   j += n;
-  if( j>=p->nAlloc ){
+  if( j>=(int)(p->nAlloc) ){
     blob_resize(p, j);
     z = (unsigned char *)p->aData;
   }
   p->nUsed = j;
   z[j] = 0;

Index: src/browse.c
==================================================================
--- src/browse.c
+++ src/browse.c
@@ -894,19 +894,19 @@
     relinkTree(&sTree, p);
   }
   for(p=sTree.pFirst, nDir=0; p; p=p->pNext){
     const char *zLastClass = p->pSibling==0 ? " last" : "";
     if( p->pChild ){
-      const char *zSubdirClass = p->nFullName==nD-1 ? " subdir" : "";
+      const char *zSubdirClass = (int)(p->nFullName)==nD-1 ? " subdir" : "";
       @ <li class="dir%s(zSubdirClass)%s(zLastClass)"><div class="filetreeline">
       @ %z(href("%s",url_render(&sURI,"name",p->zFullName,0,0)))%h(p->zName)</a>
       if( p->mtime>0.0 ){
         char *zAge = human_readable_age(rNow - p->mtime);
         @ <div class="filetreeage">%s(zAge)</div>
       }
       @ </div>
-      if( startExpanded || p->nFullName<=nD ){
+      if( startExpanded || (int)(p->nFullName)<=nD ){
         @ <ul id="dir%d(nDir)">
       }else{
         @ <ul id="dir%d(nDir)" class="collapsed">
       }
       nDir++;

Index: src/capabilities.c
==================================================================
--- src/capabilities.c
+++ src/capabilities.c
@@ -323,11 +323,11 @@
   if( done ) return;
   db_prepare(&q, "SELECT fullcap(cap) FROM user");
   while( db_step(&q)==SQLITE_ROW ){
     const char *zCap = db_column_text(&q, 0);
     if( zCap==0 || zCap[0]==0 ) continue;
-    for(i=0; i<sizeof(aCap)/sizeof(aCap[0]); i++){
+    for(i=0; i<(int)(sizeof(aCap)/sizeof(aCap[0])); i++){
       if( strchr(zCap, aCap[i].cCap) ) aCap[i].nUser++;
     }
   }
   db_finalize(&q);
   done = 1;
@@ -341,11 +341,11 @@
 void capabilities_table(unsigned mClass){
   int i;
   if( g.perm.Admin ) capabilities_count();
   @ <table>
   @ <tbody>
-  for(i=0; i<sizeof(aCap)/sizeof(aCap[0]); i++){
+  for(i=0; i<(int)(sizeof(aCap)/sizeof(aCap[0])); i++){
     int n;
     if( (aCap[i].eClass & mClass)==0 ) continue;
     @ <tr><th valign="top">%c(aCap[i].cCap)</th>
     @  <td>%h(aCap[i].zAbbrev)</td><td>%h(aCap[i].zOneLiner)</td>\
     n = aCap[i].nUser;

Index: src/cgi.c
==================================================================
--- src/cgi.c
+++ src/cgi.c
@@ -2400,11 +2400,11 @@
   while( iPort<=mxPort ){
     memset(&inaddr, 0, sizeof(inaddr));
     inaddr.sin_family = AF_INET;
     if( zIpAddr ){
       inaddr.sin_addr.s_addr = inet_addr(zIpAddr);
-      if( inaddr.sin_addr.s_addr == (-1) ){
+      if( inaddr.sin_addr.s_addr == INADDR_NONE ){
         fossil_fatal("not a valid IP address: %s", zIpAddr);
       }
     }else if( flags & HTTP_SERVER_LOCALHOST ){
       inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
     }else{

Index: src/comformat.c
==================================================================
--- src/comformat.c
+++ src/comformat.c
@@ -213,21 +213,21 @@
   if( lineChars<=0 ) return;
 #if 0
   assert( indent<sizeof(zBuf)-5 );       /* See following comments to explain */
   assert( origIndent<sizeof(zBuf)-5 );   /* these limits. */
 #endif
-  if( indent>sizeof(zBuf)-6 ){
+  if( indent>(int)sizeof(zBuf)-6 ){
     /* Limit initial indent to fit output buffer. */
     indent = sizeof(zBuf)-6;
   }
   comment_calc_indent(zLine, indent, trimCrLf, trimSpace, &index);
   if( indent>0 ){
     for(i=0; i<indent; i++){
       zBuf[iBuf++] = ' ';
     }
   }
-  if( origIndent>sizeof(zBuf)-6 ){
+  if( origIndent>(int)sizeof(zBuf)-6 ){
     /* Limit line indent to fit output buffer. */
     origIndent = sizeof(zBuf)-6;
   }
   maxChars = lineChars;
   for(;;){
@@ -234,11 +234,11 @@
     int useChars = 1;
     char c = zLine[index];
     /* Flush the output buffer if there's no space left for at least one more
     ** (potentially 4-byte) UTF-8 sequence, one level of indentation spaces,
     ** a new line, and a terminating NULL. */
-    if( iBuf>sizeof(zBuf)-origIndent-6 ){
+    if( iBuf>(int)sizeof(zBuf)-origIndent-6 ){
       zBuf[iBuf]=0;
       iBuf=0;
       fossil_print("%s", zBuf);
     }
     if( c==0 ){
@@ -348,11 +348,11 @@
   if( zText==0 ) zText = "(NULL)";
   if( maxChars<=0 ){
     maxChars = strlen(zText);
   }
   /* Ensure the buffer can hold the longest-possible UTF-8 sequences. */
-  if( maxChars >= (sizeof(zBuffer)/4-1) ){
+  if( maxChars >= ((int)sizeof(zBuffer)/4-1) ){
     zBuf = fossil_malloc(maxChars*4+1);
   }else{
     zBuf = zBuffer;
   }
   for(;;){

Index: src/content.c
==================================================================
--- src/content.c
+++ src/content.c
@@ -1029,11 +1029,11 @@
     if( size<0 ){
       fossil_print("skip phantom %d %s\n", rid, zUuid);
       continue;  /* Ignore phantoms */
     }
     content_get(rid, &content);
-    if( blob_size(&content)!=size ){
+    if( (int)blob_size(&content)!=size ){
       fossil_print("size mismatch on artifact %d: wanted %d but got %d\n",
                      rid, size, blob_size(&content));
       nErr++;
     }
     if( !hname_verify_hash(&content, zUuid, nUuid) ){
@@ -1048,11 +1048,11 @@
       char zFirstLine[400];
       blob_zero(&err);
 
       z = blob_buffer(&content);
       n = blob_size(&content);
-      for(i=0; i<n && z[i] && z[i]!='\n' && i<sizeof(zFirstLine)-1; i++){}
+      for(i=0; i<n && z[i] && z[i]!='\n' && i<(int)sizeof(zFirstLine)-1; i++){}
       memcpy(zFirstLine, z, i);
       zFirstLine[i] = 0;
       p = manifest_parse(&content, 0, &err);
       if( p==0 ){
         fossil_print("manifest_parse failed for %s:\n%s\n",

Index: src/db.c
==================================================================
--- src/db.c
+++ src/db.c
@@ -4746,11 +4746,11 @@
     if( globalFlag && fossil_strcmp(pSetting->name, "manifest")==0 ){
       fossil_fatal("cannot set 'manifest' globally");
     }
     if( unsetFlag || g.argc==4 ){
       int isManifest = fossil_strcmp(pSetting->name, "manifest")==0;
-      if( n!=strlen(pSetting[0].name) && pSetting[1].name &&
+      if( n!=(int)strlen(pSetting[0].name) && pSetting[1].name &&
           fossil_strncmp(pSetting[1].name, zName, n)==0 ){
         Blob x;
         int i;
         blob_init(&x,0,0);
         for(i=0; pSetting[i].name; i++){

Index: src/delta.c
==================================================================
--- src/delta.c
+++ src/delta.c
@@ -204,11 +204,12 @@
 
 /*
 ** Return the number digits in the base-64 representation of a positive integer
 */
 static int digit_count(int v){
-  unsigned int i, x;
+  unsigned int i;
+  int x;
   for(i=1, x=64; v>=x; i++, x <<= 6){}
   return i;
 }
 
 #ifdef __GNUC__
@@ -379,21 +380,21 @@
   */
   nHash = lenSrc/NHASH;
   collide = fossil_malloc( nHash*2*sizeof(int) );
   memset(collide, -1, nHash*2*sizeof(int));
   landmark = &collide[nHash];
-  for(i=0; i<lenSrc-NHASH; i+=NHASH){
+  for(i=0; i<(int)lenSrc-NHASH; i+=NHASH){
     int hv = hash_once(&zSrc[i]) % nHash;
     collide[i/NHASH] = landmark[hv];
     landmark[hv] = i/NHASH;
   }
 
   /* Begin scanning the target file and generating copy commands and
   ** literal sections of the delta.
   */
   base = 0;    /* We have already generated everything before zOut[base] */
-  while( base+NHASH<lenOut ){
+  while( base+NHASH<(int)lenOut ){
     int iSrc, iBlock;
     unsigned int bestCnt, bestOfst=0, bestLitsz=0;
     hash_init(&h, &zOut[base]);
     i = 0;     /* Trying to match a landmark against zOut[base+i] */
     bestCnt = 0;
@@ -449,11 +450,11 @@
         DEBUG2( printf("MATCH %d bytes at %d: [%s] litsz=%d\n",
                         cnt, ofst, print16(&zSrc[ofst]), litsz); )
         /* sz will hold the number of bytes needed to encode the "insert"
         ** command and the copy command, not counting the "insert" text */
         sz = digit_count(i-k)+digit_count(cnt)+digit_count(ofst)+3;
-        if( cnt>=sz && cnt>bestCnt ){
+        if( cnt>=sz && cnt>(int)bestCnt ){
           /* Remember this match only if it is the best so far and it
           ** does not increase the file size */
           bestCnt = cnt;
           bestOfst = iSrc-k;
           bestLitsz = litsz;
@@ -481,20 +482,20 @@
         putInt(bestCnt, &zDelta);
         *(zDelta++) = '@';
         putInt(bestOfst, &zDelta);
         DEBUG2( printf("copy %d bytes from %d\n", bestCnt, bestOfst); )
         *(zDelta++) = ',';
-        if( bestOfst + bestCnt -1 > lastRead ){
+        if( (int)(bestOfst + bestCnt -1) > lastRead ){
           lastRead = bestOfst + bestCnt - 1;
           DEBUG2( printf("lastRead becomes %d\n", lastRead); )
         }
         bestCnt = 0;
         break;
       }
 
       /* If we reach this point, it means no match is found so far */
-      if( base+i+NHASH>=lenOut ){
+      if( base+i+NHASH>=(int)lenOut ){
         /* We have reached the end of the file and have not found any
         ** matches.  Do an "insert" for everything that does not match */
         putInt(lenOut-base, &zDelta);
         *(zDelta++) = ':';
         memcpy(zDelta, &zOut[base], lenOut-base);
@@ -509,11 +510,11 @@
     }
   }
   /* Output a final "insert" record to get all the text at the end of
   ** the file that does not match anything in the source file.
   */
-  if( base<lenOut ){
+  if( base<(int)lenOut ){
     putInt(lenOut-base, &zDelta);
     *(zDelta++) = ':';
     memcpy(zDelta, &zOut[base], lenOut-base);
     zDelta += lenOut-base;
   }
@@ -599,11 +600,11 @@
         total += cnt;
         if( total>limit ){
           /* ERROR: copy exceeds output file size */
           return -1;
         }
-        if( ofst+cnt > lenSrc ){
+        if( (int)(ofst+cnt) > lenSrc ){
           /* ERROR: copy extends past end of input */
           return -1;
         }
         memcpy(zOut, &zSrc[ofst], cnt);
         zOut += cnt;
@@ -615,11 +616,11 @@
         if( total>limit ){
           /* ERROR:  insert command gives an output larger than predicted */
           return -1;
         }
         DEBUG1( printf("INSERT %d\n", cnt); )
-        if( cnt>lenDelta ){
+        if( (int)cnt>lenDelta ){
           /* ERROR: insert count exceeds size of delta */
           return -1;
         }
         memcpy(zOut, zDelta, cnt);
         zOut += cnt;
@@ -688,11 +689,11 @@
         break;
       }
       case ':': {
         zDelta++; lenDelta--;
         nInsert += cnt;
-        if( cnt>lenDelta ){
+        if( (int)cnt>lenDelta ){
           /* ERROR: insert count exceeds size of delta */
           return -1;
         }
         zDelta += cnt;
         lenDelta -= cnt;

Index: src/deltacmd.c
==================================================================
--- src/deltacmd.c
+++ src/deltacmd.c
@@ -60,11 +60,11 @@
   }
   if( blob_read_from_file(&target, g.argv[3], ExtFILE)<0 ){
     fossil_fatal("cannot read %s", g.argv[3]);
   }
   blob_delta_create(&orig, &target, &delta);
-  if( blob_write_to_file(&delta, g.argv[4])<blob_size(&delta) ){
+  if( blob_write_to_file(&delta, g.argv[4])<(int)blob_size(&delta) ){
     fossil_fatal("cannot write %s", g.argv[4]);
   }
   blob_reset(&orig);
   blob_reset(&target);
   blob_reset(&delta);
@@ -160,11 +160,11 @@
   if( blob_read_from_file(&delta, g.argv[3], ExtFILE)<0 ){
     fossil_fatal("cannot read %s", g.argv[3]);
   }
   blob_init(&target, 0, 0);
   blob_delta_apply(&orig, &delta, &target);
-  if( blob_write_to_file(&target, g.argv[4])<blob_size(&target) ){
+  if( blob_write_to_file(&target, g.argv[4])<(int)blob_size(&target) ){
     fossil_fatal("cannot write %s", g.argv[4]);
   }
   blob_reset(&orig);
   blob_reset(&target);
   blob_reset(&delta);

Index: src/diff.c
==================================================================
--- src/diff.c
+++ src/diff.c
@@ -2221,11 +2221,11 @@
   mxr = p->nEdit;
   while( mxr>2 && R[mxr-1]==0 && R[mxr-2]==0 ){ mxr -= 3; }
 
   for(r=0; r<mxr; r += 3*nr){
     /* Figure out how many triples to show in a single block */
-    for(nr=1; R[r+nr*3]>0 && R[r+nr*3]<nContext*2; nr++){}
+    for(nr=1; R[r+nr*3]>0 && R[r+nr*3]<(int)nContext*2; nr++){}
 
     /* If there is a regex, skip this block (generate no diff output)
     ** if the regex matches or does not match both insert and delete.
     ** Only display the block if one side matches but the other side does
     ** not.
@@ -2251,11 +2251,11 @@
     }
 
     /* Figure out how many lines of A and B are to be displayed
     ** for this change block.
     */
-    if( R[r]>nContext ){
+    if( R[r]>(int)nContext ){
       skip = R[r] - nContext;
     }else{
       skip = 0;
     }
     /* Show the initial common area */
@@ -2262,14 +2262,14 @@
     a += skip;
     b += skip;
     m = R[r] - skip;
     if( r ) skip -= nContext;
     if( skip>0 ){
-      if( skip<nContext ){
+      if( skip<(int)nContext ){
         /* If the amount to skip is less that the context band, then
         ** go ahead and show the skip band as it is not worth eliding */
-        for(j=0; j<skip; j++){
+        for(j=0; (int)j<skip; j++){
           pBuilder->xCommon(pBuilder, &A[a+j-skip]);
         }
       }else{
         pBuilder->xSkip(pBuilder, skip, 0);
       }
@@ -2299,11 +2299,11 @@
 
       /* Try to find an alignment for the lines within this one block */
       alignment = diffBlockAlignment(&A[a], ma, &B[b], mb, pCfg, &nAlign);
 
       for(j=0; ma+mb>0; j++){
-        assert( j<nAlign );
+        assert( (int)j<nAlign );
         switch( alignment[j] ){
           case 1: {
             /* Delete one line from the left */
             pBuilder->xDelete(pBuilder, &A[a]);
             ma--;
@@ -2341,11 +2341,11 @@
             b++;
             break;
           }
         }
       }
-      assert( nAlign==j );
+      assert( nAlign==(int)j );
       fossil_free(alignment);
       if( i<nr-1 ){
         m = R[r+i*3+3];
         for(j=0; j<m; j++){
           pBuilder->xCommon(pBuilder, &A[a+j]);
@@ -2361,11 +2361,11 @@
     if( m>nContext ) m = nContext;
     for(j=0; j<m && j<nContext; j++){
       pBuilder->xCommon(pBuilder, &A[a+j]);
     }
   }
-  if( R[r]>nContext ){
+  if( R[r]>(int)nContext ){
     pBuilder->xSkip(pBuilder, R[r] - nContext, 1);
   }
   pBuilder->xEnd(pBuilder);
 }
 

Index: src/doc.c
==================================================================
--- src/doc.c
+++ src/doc.c
@@ -459,11 +459,11 @@
   z = zName;
   for(i=0; zName[i]; i++){
     if( zName[i]=='.' ) z = &zName[i+1];
   }
   len = strlen(z);
-  if( len<sizeof(zSuffix)-1 ){
+  if( len<(int)sizeof(zSuffix)-1 ){
     sqlite3_snprintf(sizeof(zSuffix), zSuffix, "%s", z);
     for(i=0; zSuffix[i]; i++) zSuffix[i] = fossil_tolower(zSuffix[i]);
     z = mimetype_from_name_custom(zSuffix);
     if(z!=0){
       return z;

Index: src/encode.c
==================================================================
--- src/encode.c
+++ src/encode.c
@@ -708,11 +708,11 @@
 */
 int validate16(const char *zIn, int nIn){
   int i;
   if( nIn<0 ) nIn = (int)strlen(zIn);
   if( zIn[nIn]==0 ){
-    return strspn(zIn,"0123456789abcdefABCDEF")==nIn;
+    return (int)strspn(zIn,"0123456789abcdefABCDEF")==nIn;
   }
   for(i=0; i<nIn; i++, zIn++){
     if( zDecode[zIn[0]&0xff]>63 ){
       return zIn[0]==0;
     }

Index: src/extcgi.c
==================================================================
--- src/extcgi.c
+++ src/extcgi.c
@@ -115,11 +115,11 @@
     "index.html", "index.wiki", "index.md"
   };
   int i;
   if( file_isdir(*pzPath, ExtFILE)!=1 ) return 0;
   if( sqlite3_strglob("*/", *pzPath)!=0 ) return 0;
-  for(i=0; i<sizeof(azIndexNames)/sizeof(azIndexNames[0]); i++){
+  for(i=0; i<(int)(sizeof(azIndexNames)/sizeof(azIndexNames[0])); i++){
     char *zNew = mprintf("%s%s", *pzPath, azIndexNames[i]);
     if( file_isfile(zNew, ExtFILE) ){
       fossil_free(*pzPath);
       *pzPath = zNew;
       return 1;
@@ -272,15 +272,15 @@
       zSrvSw = mprintf("%z, %s", z, zSrvSw);
     }
   }
   cgi_replace_parameter("SERVER_SOFTWARE", zSrvSw);
   cgi_replace_parameter("GATEWAY_INTERFACE","CGI/1.0");
-  for(i=0; i<sizeof(azCgiEnv)/sizeof(azCgiEnv[0]); i++){
+  for(i=0; i<(int)(sizeof(azCgiEnv)/sizeof(azCgiEnv[0])); i++){
     (void)P(azCgiEnv[i]);
   }
   fossil_clearenv();
-  for(i=0; i<sizeof(azCgiEnv)/sizeof(azCgiEnv[0]); i++){
+  for(i=0; i<(int)(sizeof(azCgiEnv)/sizeof(azCgiEnv[0])); i++){
     const char *zVal = P(azCgiEnv[i]);
     if( zVal ) fossil_setenv(azCgiEnv[i], zVal);
   }
   fossil_setenv("HTTP_ACCEPT_ENCODING","");
   rc = popen2(zScript, &fdFromChild, &toChild, &pidChild, 1);

Index: src/file.c
==================================================================
--- src/file.c
+++ src/file.c
@@ -203,11 +203,11 @@
 ** Return the mode bits for a file.  Return -1 if the file does not
 ** exist.  If zFilename is NULL return the size of the most recently
 ** stat-ed file.
 */
 int file_mode(const char *zFilename, int eFType){
-  return getStat(zFilename, eFType) ? -1 : fx.fileStat.st_mode;
+  return getStat(zFilename, eFType) ? -1 : (int)(fx.fileStat.st_mode);
 }
 
 /*
 ** Return TRUE if either of the following are true:
 **
@@ -242,11 +242,11 @@
   if( db_allow_symlinks() ){
     int i, nName;
     char *zName, zBuf[1000];
 
     nName = strlen(zLinkFile);
-    if( nName>=sizeof(zBuf) ){
+    if( nName>=(int)sizeof(zBuf) ){
       zName = mprintf("%s", zLinkFile);
     }else{
       zName = zBuf;
       memcpy(zName, zLinkFile, nName+1);
     }

Index: src/fileedit.c
==================================================================
--- src/fileedit.c
+++ src/fileedit.c
@@ -617,11 +617,11 @@
           assert(CIMINI_CONVERT_EOL_WINDOWS & pCI->flags);
           if(!(LOOK_CRLF & lookNew)){
             blob_add_cr(&pCI->fileContent);
           }
         }
-        if(blob_size(&pCI->fileContent)!=oldSize){
+        if((int)blob_size(&pCI->fileContent)!=oldSize){
           rehash = 1;
         }
       }
       if(rehash!=0){
         hname_hash(&pCI->fileContent, 0, &pCI->fileHash);

Index: src/forum.c
==================================================================
--- src/forum.c
+++ src/forum.c
@@ -704,11 +704,11 @@
     zQuery[i++] = 'h';
     zQuery[i++] = 'i';
     zQuery[i++] = 's';
     zQuery[i++] = 't';
   }
-  assert( i<sizeof(zQuery) );
+  assert( i<(int)sizeof(zQuery) );
   zQuery[i] = 0;
   assert( zQuery[0]==0 || zQuery[0]=='?' );
 
   /* Identify which post to display first.  If history is shown, start with the
   ** original, unedited post.  Otherwise advance to the post's latest edit.  */

Index: src/http_ssl.c
==================================================================
--- src/http_ssl.c
+++ src/http_ssl.c
@@ -541,11 +541,11 @@
     x = X509_digest(cert, EVP_sha256(), md, &mdLength);
 #else
     x = X509_digest(cert, EVP_sha1(), md, &mdLength);
 #endif
     if( x ){
-      int j;
+      unsigned j;
       for(j=0; j<mdLength && j*2+1<sizeof(zHash); ++j){
         zHash[j*2] = "0123456789abcdef"[md[j]>>4];
         zHash[j*2+1] = "0123456789abcdef"[md[j]&0xf];
       }
       zHash[j*2] = 0;

Index: src/http_transport.c
==================================================================
--- src/http_transport.c
+++ src/http_transport.c
@@ -82,11 +82,11 @@
 ** like "/bin/rm".
 */
 static int is_safe_fossil_command(const char *zFossil){
   static const char *const azSafe[] = { "*/fossil", "*/fossil.exe", "*/echo" };
   int i;
-  for(i=0; i<sizeof(azSafe)/sizeof(azSafe[0]); i++){
+  for(i=0; i<(int)(sizeof(azSafe)/sizeof(azSafe[0])); i++){
     if( sqlite3_strglob(azSafe[i], zFossil)==0 ) return 1;
     if( strcmp(azSafe[i]+2, zFossil)==0 ) return 1;
   }
   return 0;
 }

Index: src/import.c
==================================================================
--- src/import.c
+++ src/import.c
@@ -597,11 +597,11 @@
       ** last commit that holds that tag.
       **
       ** None of the above is explained in the git-fast-export
       ** documentation.  We had to figure it out via trial and error.
       */
-      for(i=5; i<strlen(zRefName) && zRefName[i]!='/'; i++){}
+      for(i=5; i<(int)strlen(zRefName) && zRefName[i]!='/'; i++){}
       gg.tagCommit = strncmp(&zRefName[5], "tags", 4)==0; /* pattern B */
       if( zRefName[i+1]!=0 ) zRefName += i+1;
       if( fossil_strcmp(zRefName, "master")==0 ) zRefName = ggit.zMasterName;
       gg.zBranch = fossil_strdup(zRefName);
       gg.fromLoaded = 0;
@@ -767,11 +767,11 @@
       nFrom = strlen(zFrom);
       while( (pFile = import_find_file(zFrom, &i, mx))!=0 ){
         if( pFile->isFrom==0 ) continue;
         pNew = import_add_file();
         pFile = &gg.aFile[i-1];
-        if( strlen(pFile->zName)>nFrom ){
+        if( (int)strlen(pFile->zName)>nFrom ){
           pNew->zName = mprintf("%s%s", zTo, pFile->zName+nFrom);
         }else{
           pNew->zName = fossil_strdup(zTo);
         }
         pNew->isExe = pFile->isExe;
@@ -790,11 +790,11 @@
       nFrom = strlen(zFrom);
       while( (pFile = import_find_file(zFrom, &i, gg.nFile))!=0 ){
         if( pFile->isFrom==0 ) continue;
         pNew = import_add_file();
         pFile = &gg.aFile[i-1];
-        if( strlen(pFile->zName)>nFrom ){
+        if( (int)strlen(pFile->zName)>nFrom ){
           pNew->zName = mprintf("%s%s", zTo, pFile->zName+nFrom);
         }else{
           pNew->zName = fossil_strdup(zTo);
         }
         pNew->zPrior = pFile->zName;
@@ -1013,11 +1013,11 @@
   zLen = svn_find_header(*rec, "Text-content-length");
   if( zLen ){
     rec->contentFlag = 1;
     nLen = atoi(zLen);
     blob_read_from_channel(&rec->content, pIn, nLen);
-    if( blob_size(&rec->content)!=nLen ){
+    if( (int)blob_size(&rec->content)!=nLen ){
       fossil_fatal("short read: got %d of %d bytes",
         blob_size(&rec->content), nLen
       );
     }
   }else{
@@ -1278,11 +1278,11 @@
   if( gsvn.azIgnTree ){
     const char **pzIgnTree;
     unsigned nPath = strlen(zPath);
     for( pzIgnTree = gsvn.azIgnTree; *pzIgnTree; ++pzIgnTree ){
       const char *zIgn = *pzIgnTree;
-      int nIgn = strlen(zIgn);
+      unsigned nIgn = strlen(zIgn);
       if( strncmp(zPath, zIgn, nIgn) == 0
        && ( nPath == nIgn || (nPath > nIgn && zPath[nIgn] == '/')) ){
         return 0;
       }
     }

Index: src/lookslike.c
==================================================================
--- src/lookslike.c
+++ src/lookslike.c
@@ -343,11 +343,11 @@
   const char *z = blob_buffer(pContent);
   int bomSize = 0;
   const unsigned char *bom = get_utf8_bom(&bomSize);
 
   if( pnByte ) *pnByte = bomSize;
-  if( blob_size(pContent)<bomSize ) return 0;
+  if( (int)blob_size(pContent)<bomSize ) return 0;
   return memcmp(z, bom, bomSize)==0;
 }
 
 /*
 ** This function returns non-zero if the blob starts with a UTF-16

Index: src/main.c
==================================================================
--- src/main.c
+++ src/main.c
@@ -427,16 +427,16 @@
 
   g.argc = argc;
   g.argv = argv;
   sqlite3_initialize();
 #if defined(_WIN32) && defined(BROKEN_MINGW_CMDLINE)
-  for(i=0; i<g.argc; i++) g.argv[i] = fossil_mbcs_to_utf8(g.argv[i]);
+  for(i=0; (int)i<g.argc; i++) g.argv[i] = fossil_mbcs_to_utf8(g.argv[i]);
 #else
-  for(i=0; i<g.argc; i++) g.argv[i] = fossil_path_to_utf8(g.argv[i]);
+  for(i=0; (int)i<g.argc; i++) g.argv[i] = fossil_path_to_utf8(g.argv[i]);
 #endif
   g.nameOfExe = file_fullexename(g.argv[0]);
-  for(i=1; i<g.argc-1; i++){
+  for(i=1; (int)i<g.argc-1; i++){
     z = g.argv[i];
     if( z[0]!='-' ) continue;
     z++;
     if( z[0]=='-' ) z++;
     /* Maintenance reminder: we do not stop at a "--" flag here,
@@ -444,11 +444,11 @@
     ** introduces some weird corner cases, as covered in forum thread
     ** 4382bbc66757c39f. e.g. (fossil -U -- --args ...) is handled
     ** differently when we stop at "--" here. */
     if( fossil_strcmp(z, "args")==0 ) break;
   }
-  if( i>=g.argc-1 ) return;
+  if( (int)i>=g.argc-1 ) return;
 
   zFileName = g.argv[i+1];
   if( strcmp(zFileName,"-")==0 ){
     inFile = stdin;
   }else if( !file_isfile(zFileName, ExtFILE) ){
@@ -506,11 +506,11 @@
         if( z[k] ) newArgv[j++] = &z[k];
       }
     }
   }
   i += 2;
-  while( i<g.argc ) newArgv[j++] = g.argv[i++];
+  while( (int)i<g.argc ) newArgv[j++] = g.argv[i++];
   newArgv[j] = 0;
   g.argc = j;
   g.argv = newArgv;
 }
 
@@ -1761,11 +1761,11 @@
         if( c=='_' ) continue;
         if( c=='-' && zRepo[j-1]!='/' ) continue;
         if( c=='.' && fossil_isalnum(zRepo[j-1]) && fossil_isalnum(zRepo[j+1])){
           continue;
         }
-        if( c=='.' && g.fAllowACME && j==nBase+1
+        if( c=='.' && g.fAllowACME && j==(int)nBase+1
          && strncmp(&zRepo[j-1],"/.well-known/",12)==0
         ){
           /* We allow .well-known as the top-level directory for ACME */
           continue;
         }

Index: src/markdown.c
==================================================================
--- src/markdown.c
+++ src/markdown.c
@@ -396,11 +396,11 @@
 /* release the given working buffer back to the cache */
 static void release_work_buffer(struct render *rndr, struct Blob *buf){
   if( !buf ) return;
   rndr->iDepth--;
   blob_reset(buf);
-  if( rndr->nBlobCache < sizeof(rndr->aBlobCache)/sizeof(rndr->aBlobCache[0]) ){
+  if( rndr->nBlobCache < (int)(sizeof(rndr->aBlobCache)/sizeof(rndr->aBlobCache[0])) ){
     rndr->aBlobCache[rndr->nBlobCache++] = buf;
   }else{
     fossil_free(buf);
   }
 }
@@ -1570,13 +1570,13 @@
 ** block. */
 static size_t prefix_fencedcode(char *data, size_t size){
   char c = data[0];
   int nb;
   if( c!='`' && c!='~' ) return 0;
-  for(nb=1; nb<size-3 && data[nb]==c; nb++){}
+  for(nb=1; nb<(int)size-3 && data[nb]==c; nb++){}
   if( nb<3 ) return 0;
-  if( nb>=size-nb ) return 0;
+  if( nb>=(int)size-nb ) return 0;
   return nb;
 }
 
 /* prefix_oli -- returns ordered list item prefix */
 static size_t prefix_oli(char *data, size_t size){
@@ -1687,11 +1687,11 @@
   char *work_data = data;
   size_t work_size = 0;
 
   while( i<size ){
     char *zEnd = memchr(data+i, '\n', size-i-1);
-    end = zEnd==0 ? size : (int)(zEnd - (data-1));
+    end = zEnd==0 ? size : (size_t)(zEnd - (data-1));
     /* The above is the same as:
     **    for(end=i+1; end<size && data[end-1]!='\n'; end++);
     ** "end" is left with a value such that data[end] is one byte
     ** past the first '\n' or one byte past the end of the string */
     if( is_empty(data+i, size-i)
@@ -1760,11 +1760,11 @@
   struct Blob *work = new_work_buffer(rndr);
 
   beg = 0;
   while( beg<size ){
     char *zEnd = memchr(data+beg, '\n', size-beg-1);
-    end = zEnd==0 ? size : (int)(zEnd - (data-1));
+    end = zEnd==0 ? size : (size_t)(zEnd - (data-1));
     /* The above is the same as:
     **   for(end=beg+1; end<size && data[end-1]!='\n'; end++);
     ** "end" is left with a value such that data[end] is one byte
     ** past the first \n or past then end of the string. */
     pre = prefix_code(data+beg, end-beg);
@@ -1970,13 +1970,13 @@
   int level = 0;
   size_t i, end, skip, span_beg, span_size;
 
   if( !size || data[0]!='#' ) return 0;
 
-  while( level<size && level<6 && data[level]=='#' ){ level++; }
+  while( level<(int)size && level<6 && data[level]=='#' ){ level++; }
   for(i=level; i<size && (data[i]==' ' || data[i]=='\t'); i++);
-  if ( i == level ) return parse_paragraph(ob, rndr, data, size);
+  if ( (int)i == level ) return parse_paragraph(ob, rndr, data, size);
   span_beg = i;
 
   for(end=i; end<size && data[end]!='\n'; end++);
   skip = end;
   if( end<=i ) return parse_paragraph(ob, rndr, data, size);
@@ -2005,11 +2005,11 @@
   size_t i, w;
 
   /* assuming data[0]=='<' && data[1]=='/' already tested */
 
   /* checking tag is a match */
-  if( (tag->size+3)>size
+  if( (tag->size+3)>(int)size
     || fossil_strnicmp(data+2, tag->text, tag->size)
     || data[tag->size+2]!='>'
   ){
     return 0;
   }
@@ -2635,11 +2635,12 @@
   const struct Blob *ib,             /* input blob in markdown */
   const struct mkd_renderer *rndrer  /* renderer descriptor (callbacks) */
 ){
   struct link_ref *lr;
   struct footnote *fn;
-  size_t i, beg, end = 0;
+  int i;
+  size_t beg, end = 0;
   struct render rndr;
   size_t size;
   Blob text = BLOB_INITIALIZER;        /* input after the first pass  */
   Blob * const allNotes = &rndr.notes.all;
 
@@ -2719,11 +2720,12 @@
     qsort(fn, rndr.notes.nLbled, sizeof(struct footnote), cmp_footnote_id);
 
     /* concatenate footnotes with equal labels */
     for(i=0; i<rndr.notes.nLbled ;){
       struct footnote *x = fn + i;
-      size_t j = i+1, k = blob_size(&x->text) + 64 + blob_size(&x->upc);
+      int j = i+1;
+      size_t k = blob_size(&x->text) + 64 + blob_size(&x->upc);
       while(j<rndr.notes.nLbled && !blob_compare(&x->id, &fn[j].id)){
         k += blob_size(&fn[j].text) + 10 + blob_size(&fn[j].upc);
         j++;
         nDups++;
       }
@@ -2730,11 +2732,11 @@
       if( i+1<j ){
         Blob list = empty_blob;
         blob_reserve(&list, k);
         /* must match _joined_footnote_indicator in html_footnote_item() */
         blob_append_literal(&list, "<ul class='fn-joined'>\n");
-        for(k=i; k<j; k++){
+        for(k=i; (int)k<j; k++){
           struct footnote *y = fn + k;
           blob_append_literal(&list, "<li>");
           if( blob_size(&y->upc) ){
             blob_appendb(&list, &y->upc);
             blob_reset(&y->upc);
@@ -2742,11 +2744,11 @@
           blob_appendb(&list, &y->text);
           blob_append_literal(&list, "</li>\n");
 
           /* free memory buffer */
           blob_reset(&y->text);
-          if( k!=i ) blob_reset(&y->id);
+          if( (int)k!=i ) blob_reset(&y->id);
         }
         blob_append_literal(&list, "</ul>\n");
         x->text = list;
         g.ftntsIssues[2]++;
       }
@@ -2762,11 +2764,11 @@
         }
       }
       blob_reset( allNotes );
       rndr.notes.all = filtered;
       rndr.notes.nLbled = n;
-      assert( COUNT_FOOTNOTES(allNotes) == rndr.notes.nLbled );
+      assert( (int)(COUNT_FOOTNOTES(allNotes)) == rndr.notes.nLbled );
     }
   }
   fn = CAST_AS_FOOTNOTES( allNotes );
   for(i=0; i<rndr.notes.nLbled; i++){
     fn[i].index = i;
@@ -2830,11 +2832,11 @@
       ** If it doesn't then a compiler has done something very weird.
       */
       assert( &(rndr.notes.misref.id)  == &(rndr.notes.misref.text) - 1 );
       assert( &(rndr.notes.misref.upc) == &(rndr.notes.misref.text) + 1 );
 
-      for(i=0; i<COUNT_FOOTNOTES(notes); i++){
+      for(i=0; i<(int)(COUNT_FOOTNOTES(notes)); i++){
         const struct footnote* x = CAST_AS_FOOTNOTES(notes) + i;
         const int xUsed = x->bRndred ? x->nUsed : 0;
         if( !x->iMark ) break;
         assert( x->nUsed );
         rndr.make.footnote_item(all_items, &x->text, x->iMark,
@@ -2845,11 +2847,11 @@
       if( rndr.notes.misref.nUsed ){
         rndr.make.footnote_item(all_items, 0, -1,
                     rndr.notes.misref.nUsed, rndr.make.opaque);
         g.ftntsIssues[0] += rndr.notes.misref.nUsed;
       }
-      while( ++j < COUNT_FOOTNOTES(notes) ){
+      while( ++j < (int)(COUNT_FOOTNOTES(notes)) ){
         const struct footnote* x = CAST_AS_FOOTNOTES(notes) + j;
         assert( !x->iMark );
         assert( !x->nUsed );
         assert( !x->bRndred );
         rndr.make.footnote_item(all_items,&x->text,0,0,rndr.make.opaque);
@@ -2865,23 +2867,23 @@
   /* clean-up */
   assert( rndr.iDepth==0 );
   blob_reset(&text);
   lr = (struct link_ref *)blob_buffer(&rndr.refs);
   end = blob_size(&rndr.refs)/sizeof(struct link_ref);
-  for(i=0; i<end; i++){
+  for(i=0; i<(int)end; i++){
     blob_reset(&lr[i].id);
     blob_reset(&lr[i].link);
     blob_reset(&lr[i].title);
   }
   blob_reset(&rndr.refs);
   fn = CAST_AS_FOOTNOTES( allNotes );
   end = COUNT_FOOTNOTES( allNotes );
-  for(i=0; i<end; i++){
+  for(i=0; i<(int)end; i++){
     if(blob_size(&fn[i].id)) blob_reset(&fn[i].id);
     if(blob_size(&fn[i].upc)) blob_reset(&fn[i].upc);
     blob_reset(&fn[i].text);
   }
   blob_reset(&rndr.notes.all);
   for(i=0; i<rndr.nBlobCache; i++){
     fossil_free(rndr.aBlobCache[i]);
   }
 }

Index: src/merge3.c
==================================================================
--- src/merge3.c
+++ src/merge3.c
@@ -456,11 +456,11 @@
   }
   if( blob_read_from_file(&v2, g.argv[4], ExtFILE)<0 ){
     fossil_fatal("cannot read %s", g.argv[4]);
   }
   nConflict = blob_merge(&pivot, &v1, &v2, &merged);
-  if( blob_write_to_file(&merged, g.argv[5])<blob_size(&merged) ){
+  if( blob_write_to_file(&merged, g.argv[5])<(int)blob_size(&merged) ){
     fossil_fatal("cannot write %s", g.argv[4]);
   }
   blob_reset(&pivot);
   blob_reset(&v1);
   blob_reset(&v2);

Index: src/printf.c
==================================================================
--- src/printf.c
+++ src/printf.c
@@ -864,11 +864,11 @@
     if( !flag_leftjustify ){
       register int nspace;
       nspace = width-length;
       if( nspace>0 ){
         count += nspace;
-        while( nspace>=etSPACESIZE ){
+        while( nspace>=(int)etSPACESIZE ){
           blob_append(pBlob,spaces,etSPACESIZE);
           nspace -= etSPACESIZE;
         }
         if( nspace>0 ) blob_append(pBlob,spaces,nspace);
       }
@@ -880,11 +880,11 @@
     if( flag_leftjustify ){
       register int nspace;
       nspace = width-length;
       if( nspace>0 ){
         count += nspace;
-        while( nspace>=etSPACESIZE ){
+        while( nspace>=(int)etSPACESIZE ){
           blob_append(pBlob,spaces,etSPACESIZE);
           nspace -= etSPACESIZE;
         }
         if( nspace>0 ) blob_append(pBlob,spaces,nspace);
       }

Index: src/rebuild.c
==================================================================
--- src/rebuild.c
+++ src/rebuild.c
@@ -256,11 +256,11 @@
   int nChild, i, cid;
 
   while( rid>0 ){
 
     /* Fix up the "blob.size" field if needed. */
-    if( size!=blob_size(pBase) ){
+    if( size!=(int)blob_size(pBase) ){
       db_multi_exec(
          "UPDATE blob SET size=%d WHERE rid=%d", blob_size(pBase), rid
       );
     }
 

Index: src/tar.c
==================================================================
--- src/tar.c
+++ src/tar.c
@@ -246,11 +246,11 @@
     blen++;
   }
   /* build the string */
   blob_appendf(&tball.pax, "%d %s=%*.*s\n", blen, zField, nValue, nValue, zValue);
   /* this _must_ be right */
-  if(blob_size(&tball.pax) != blen){
+  if((int)blob_size(&tball.pax) != blen){
     fossil_panic("internal error: PAX tar header has bad length");
   }
 }
 
 

Index: src/th.c
==================================================================
--- src/th.c
+++ src/th.c
@@ -853,11 +853,11 @@
       thBufferAddChar(interp, &strbuf, 0);
       thBufferWrite(interp, &lenbuf, &nWord, sizeof(int));
       nCount++;
     }
   }
-  assert((lenbuf.nBuf/sizeof(int))==nCount);
+  assert((int)(lenbuf.nBuf/sizeof(int))==nCount);
 
   assert((pazElem && panElem) || (!pazElem && !panElem));
   if( pazElem && rc==TH_OK ){
     int i;
     char *zElem;

Index: src/th_main.c
==================================================================
--- src/th_main.c
+++ src/th_main.c
@@ -1849,11 +1849,11 @@
   if( argc==2 ){
     if( Th_ToInt(interp, argv[1], argl[1], &n) ){
       return TH_ERROR;
     }
     if( n<1 ) n = 1;
-    if( n>sizeof(aRand) ) n = sizeof(aRand);
+    if( n>(int)sizeof(aRand) ) n = sizeof(aRand);
   }else{
     n = 10;
   }
   sqlite3_randomness(n, aRand);
   encode16(aRand, zOut, n);

Index: src/timeline.c
==================================================================
--- src/timeline.c
+++ src/timeline.c
@@ -547,11 +547,11 @@
             if( z[jj]=='\n' ) break;
           }
         }
         z[ii] = 0;
         cgi_printf("%W",z);
-      }else if( mxWikiLen>0 && blob_size(&comment)>mxWikiLen ){
+      }else if( mxWikiLen>0 && (int)blob_size(&comment)>mxWikiLen ){
         Blob truncated;
         blob_zero(&truncated);
         blob_append(&truncated, blob_buffer(&comment), mxWikiLen);
         blob_append(&truncated, "...", 3);
         @ %W(blob_str(&truncated))
@@ -3432,11 +3432,11 @@
   zStartOfProject = db_text(0,
       "SELECT datetime(min(mtime),toLocal(),'startofday') FROM event;"
   );
   timeline_temp_table();
   db_prepare(&q, "SELECT * FROM timeline ORDER BY sortby DESC /*scan*/");
-  for(i=0; i<sizeof(aYearsAgo)/sizeof(aYearsAgo[0]); i++){
+  for(i=0; i<(int)(sizeof(aYearsAgo)/sizeof(aYearsAgo[0])); i++){
     int iAgo = aYearsAgo[i];
     char *zThis = db_text(0, "SELECT date(%Q,'-%d years')", zToday, iAgo);
     Blob sql;
     char *zId;
     if( strcmp(zThis, zStartOfProject)<0 ) break;

Index: src/tkt.c
==================================================================
--- src/tkt.c
+++ src/tkt.c
@@ -926,11 +926,11 @@
     zValue = Th_Fetch(aField[i].zName, &nValue);
     if( zValue ){
       while( nValue>0 && fossil_isspace(zValue[nValue-1]) ){ nValue--; }
       if( ((aField[i].mUsed & USEDBY_TICKETCHNG)!=0 && nValue>0)
        || memcmp(zValue, aField[i].zValue, nValue)!=0
-       || strlen(aField[i].zValue)!=nValue
+       ||(int)strlen(aField[i].zValue)!=nValue
       ){
         if( memcmp(aField[i].zName, "private_", 8)==0 ){
           zValue = db_conceal(zValue, nValue);
           blob_appendf(&tktchng, "J %s %s\n", aField[i].zName, zValue);
           aUsed[i] = JCARD_PRIVATE;

Index: src/user.c
==================================================================
--- src/user.c
+++ src/user.c
@@ -157,11 +157,11 @@
   int nB = 0;
   int i;
   memcpy(zOrig, "abcdefghijklmnopqrstuvwyz", nA+1);
   memcpy(zA, zOrig, nA+1);
   assert( nA==(int)strlen((char*)zA) );
-  for(i=0; i<sizeof(aSubst); i++) aSubst[i] = i;
+  for(i=0; i<(int)sizeof(aSubst); i++) aSubst[i] = i;
   printFive(zA);
   while( nA>0 ){
     int x = randint(nA);
     zB[nB++] = zA[x];
     zA[x] = zA[--nA];

Index: src/util.c
==================================================================
--- src/util.c
+++ src/util.c
@@ -680,18 +680,18 @@
   }else{
     zDir = fossil_getenv("LOCALAPPDATA");
     if( zDir==0 ) zDir = ".";
   }
 #else
-  for(i=0; i<sizeof(azTmp)/sizeof(azTmp[0]); i++){
+  for(i=0; i<(int)(sizeof(azTmp)/sizeof(azTmp[0])); i++){
     struct stat buf;
     zDir = azTmp[i];
     if( stat(zDir,&buf)==0 && S_ISDIR(buf.st_mode) && access(zDir,03)==0 ){
       break;
     }
   }
-  if( i>=sizeof(azTmp)/sizeof(azTmp[0]) ) zDir = ".";
+  if( i>=(int)(sizeof(azTmp)/sizeof(azTmp[0])) ) zDir = ".";
   cDirSep = '/';
 #endif
   nDir = strlen(zDir);
   zSep[1] = 0;
   zSep[0] = (nDir && zDir[nDir-1]==cDirSep) ? 0 : cDirSep;

Index: src/wikiformat.c
==================================================================
--- src/wikiformat.c
+++ src/wikiformat.c
@@ -790,11 +790,11 @@
     p->endTag = 0;
     i = 1;
   }
   j = 0;
   while( fossil_isalnum(z[i]) ){
-    if( j<sizeof(zTag)-1 ) zTag[j++] = fossil_tolower(z[i]);
+    if( j<(int)sizeof(zTag)-1 ) zTag[j++] = fossil_tolower(z[i]);
     i++;
   }
   zTag[j] = 0;
   p->iCode = findTag(zTag);
   p->iType = aMarkup[p->iCode].iType;
@@ -813,11 +813,11 @@
   while( fossil_isspace(z[i]) ){ i++; }
   while( c!='>' && p->nAttr<8 && fossil_isalpha(z[i]) ){
     int attrOk;    /* True to preserve attribute.  False to ignore it */
     j = 0;
     while( fossil_isalnum(z[i]) ){
-      if( j<sizeof(zTag)-1 ) zTag[j++] = fossil_tolower(z[i]);
+      if( j<(int)sizeof(zTag)-1 ) zTag[j++] = fossil_tolower(z[i]);
       i++;
     }
     zTag[j] = 0;
     p->aAttr[p->nAttr].iACode = iACode = findAttr(zTag);
     attrOk = iACode!=0 && (seen & aAttribute[iACode].iMask)==0;
@@ -1105,11 +1105,11 @@
   db_static_prepare(&q,
      "SELECT 1 FROM blob WHERE uuid>=:u AND uuid<:u2"
   );
   db_bind_text(&q, ":u", zUuid);
   n = (int)strlen(zUuid);
-  if( n>=sizeof(zU2) ) n = sizeof(zU2)-1;
+  if( n>=(int)sizeof(zU2) ) n = sizeof(zU2)-1;
   memcpy(zU2, zUuid, n);
   zU2[n-1]++;
   zU2[n] = 0;
   db_bind_text(&q, ":u2", zU2);
   rc = db_step(&q);
@@ -1358,11 +1358,11 @@
   }else{
     blob_appendf(pOut, "<span class=\"brokenlink\">[%h]", zTarget);
     zTerm = "</span>";
   }
   if( zExtra ) fossil_free(zExtra);
-  assert( strlen(zTerm)<nClose );
+  assert( (int)strlen(zTerm)<nClose );
   sqlite3_snprintf(nClose, zClose, "%s", zTerm);
 }
 
 /*
 ** Check to see if the given parsed markup is the correct

Index: src/xfer.c
==================================================================
--- src/xfer.c
+++ src/xfer.c
@@ -450,11 +450,11 @@
    && content_get(srcId, &src)
   ){
     char *zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", srcId);
     blob_delta_create(&src, pContent, &delta);
     size = blob_size(&delta);
-    if( size>=blob_size(pContent)-50 ){
+    if( size>=(int)blob_size(pContent)-50 ){
       size = 0;
     }else if( uuid_is_shunned(zUuid) ){
       size = 0;
     }else{
        if( isPrivate ) blob_append(pXfer->pOut, "private\n", -1);
@@ -577,11 +577,11 @@
   if( uuid_is_shunned(blob_str(pUuid)) ){
     blob_reset(&uuid);
     return;
   }
   if( (pXfer->maxTime != -1 && time(NULL) >= pXfer->maxTime) ||
-       pXfer->mxSend<=blob_size(pXfer->pOut) ){
+       pXfer->mxSend<=(int)blob_size(pXfer->pOut) ){
     const char *zFormat = isPriv ? "igot %b 1\n" : "igot %b\n";
     blob_appendf(pXfer->pOut, zFormat /*works-like:"%b"*/, pUuid);
     pXfer->nIGotSent++;
     blob_reset(&uuid);
     return;
@@ -701,11 +701,11 @@
   const char *zName,      /* Name of unversioned file to be sent */
   int noContent           /* True to omit the content */
 ){
   Stmt q1;
 
-  if( blob_size(pXfer->pOut)>=pXfer->mxSend ) noContent = 1;
+  if( (int)blob_size(pXfer->pOut)>=pXfer->mxSend ) noContent = 1;
   if( noContent ){
     db_prepare(&q1,
       "SELECT mtime, hash, encoding, sz FROM unversioned WHERE name=%Q",
       zName
     );
@@ -722,11 +722,11 @@
     if( pXfer->remoteVersion<20000 && db_column_bytes(&q1,1)>HNAME_LEN_SHA1 ){
       xfer_cannot_send_sha3_error(pXfer);
       db_reset(&q1);
       return;
     }
-    if( blob_size(pXfer->pOut)>=pXfer->mxSend ){
+    if( (int)blob_size(pXfer->pOut)>=pXfer->mxSend ){
       /* If we have already reached the send size limit, send a (short)
       ** uvigot card rather than a uvfile card.  This only happens on the
       ** server side.  The uvigot card will provoke the client to resend
       ** another uvgimme on the next cycle. */
       blob_appendf(pXfer->pOut, "uvigot %s %lld %s %d\n",
@@ -1029,11 +1029,11 @@
     );
   }
   while( db_step(&q)==SQLITE_ROW ){
     blob_appendf(pXfer->pOut, "igot %s\n", db_column_text(&q, 0));
     cnt++;
-    if( pXfer->resync && pXfer->mxSend<blob_size(pXfer->pOut) ){
+    if( pXfer->resync && pXfer->mxSend<(int)blob_size(pXfer->pOut) ){
       pXfer->resync = db_column_int(&q, 1)-1;
     }
   }
   db_finalize(&q);
   if( cnt==0 ) pXfer->resync = 0;
@@ -1457,11 +1457,11 @@
         if( iVers>=3 ){
           cgi_set_content_type("application/x-fossil-uncompressed");
         }
         blob_is_int(&xfer.aToken[2], &seqno);
         max = db_int(0, "SELECT max(rid) FROM blob");
-        while( xfer.mxSend>blob_size(xfer.pOut) && seqno<=max){
+        while( xfer.mxSend>(int)blob_size(xfer.pOut) && seqno<=max){
           if( time(NULL) >= xfer.maxTime ) break;
           if( iVers>=3 ){
             send_compressed_file(&xfer, seqno);
           }else{
             send_file(&xfer, seqno, 0, 1);
@@ -2228,11 +2228,11 @@
           nArtifactSent++;
           db_multi_exec("DELETE FROM uv_tosend WHERE name=%Q", zName);
           if( syncFlags & SYNC_VERBOSE ){
             fossil_print("\rUnversioned-file sent: %s\n", zName);
           }
-          if( blob_size(xfer.pOut)>xfer.mxSend ) break;
+          if( (int)blob_size(xfer.pOut)>xfer.mxSend ) break;
         }
         db_finalize(&uvq);
         if( rc==SQLITE_DONE ) uvDoPush = 0;
       }
     }

Index: src/zip.c
==================================================================
--- src/zip.c
+++ src/zip.c
@@ -66,11 +66,11 @@
 
 /*
 ** Ensure that blob pBlob is at least nMin bytes in size.
 */
 static void zip_blob_minsize(Blob *pBlob, int nMin){
-  if( blob_size(pBlob)<nMin ){
+  if( (int)blob_size(pBlob)<nMin ){
     blob_resize(pBlob, nMin);
   }
 }
 
 /*************************************************************************
@@ -441,19 +441,19 @@
       sqlite3_bind_int(p->pInsert, 4, -1);
       sqlite3_bind_text(p->pInsert, 5, 
           blob_buffer(pFile), blob_size(pFile), SQLITE_STATIC
       );
     }else{
-      int nIn = blob_size(pFile);
+      unsigned int nIn = blob_size(pFile);
       unsigned long int nOut = nIn;
       sqlite3_bind_int(p->pInsert, 2, mPerm==PERM_EXE ? 0100755 : 0100644);
       sqlite3_bind_int(p->pInsert, 4, nIn);
       zip_blob_minsize(&p->tmp, nIn);
       compress( (unsigned char*)
           blob_buffer(&p->tmp), &nOut, (unsigned char*)blob_buffer(pFile), nIn
       );
-      if( nOut>=nIn ){
+      if( nOut>=(unsigned long)nIn ){
         sqlite3_bind_blob(p->pInsert, 5, 
             blob_buffer(pFile), blob_size(pFile), SQLITE_STATIC
         );
       }else{
         sqlite3_bind_blob(p->pInsert, 5,