diff --git a/pigz.c b/pigz.c
index 7430e1e..6ec3a82 100644
--- a/pigz.c
+++ b/pigz.c
@@ -333,7 +333,7 @@
 // Portability defines.
 #define _FILE_OFFSET_BITS 64            // Use large file functions
 #define _LARGE_FILES                    // Same thing for AIX
-#define _POSIX_C_SOURCE 200809L         // For MinGW
+#define _XOPEN_SOURCE 700               // For POSIX 2008
 
 // Included headers and what is expected from each.
 #include <stdio.h>      // fflush(), fprintf(), fputs(), getchar(), putc(),
@@ -874,10 +874,10 @@
         ;
     log_free();
     if (mem_track.num || mem_track.size)
-        complain("memory leak: %lu allocs of %lu bytes total",
+        complain("memory leak: %zu allocs of %zu bytes total",
                  mem_track.num, mem_track.size);
     if (mem_track.max)
-        fprintf(stderr, "%lu bytes of memory used in %lu allocs\n",
+        fprintf(stderr, "%zu bytes of memory used in %zu allocs\n",
                 mem_track.max, mem_track.tot);
 }
 
@@ -993,7 +993,7 @@
     size_t left = len;
 
     while (left) {
-        size_t const max = SIZE_MAX >> 1;       // max ssize_t
+        size_t const max = SSIZE_MAX;
         ssize_t ret = write(desc, next, left > max ? max : left);
         if (ret < 1)
             throw(errno, "write error on %s (%s)", g.outf, strerror(errno));
@@ -1669,25 +1669,31 @@
 #if ZLIB_VERNUM >= 0x1260
     int bits;                       // deflate pending bits
 #endif
-#ifndef NOZOPFLI
-    struct space *temp = NULL;      // temporary space for zopfli input
-#endif
     int ret;                        // zlib return code
-    z_stream strm;                  // deflate stream
     ball_t err;                     // error information from throw()
 
     (void)dummy;
 
     try {
-        // initialize the deflate stream for this thread
-        strm.zfree = ZFREE;
-        strm.zalloc = ZALLOC;
-        strm.opaque = OPAQUE;
-        ret = deflateInit2(&strm, 6, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
-        if (ret == Z_MEM_ERROR)
-            throw(ENOMEM, "not enough memory");
-        if (ret != Z_OK)
-            throw(EINVAL, "internal error");
+        z_stream strm;                  // deflate stream
+#ifndef NOZOPFLI
+        struct space *temp = NULL;
+        // get temporary space for zopfli input
+        if (g.level > 9)
+            temp = get_space(&out_pool);
+        else
+#endif
+        {
+            // initialize the deflate stream for this thread
+            strm.zfree = ZFREE;
+            strm.zalloc = ZALLOC;
+            strm.opaque = OPAQUE;
+            ret = deflateInit2(&strm, 6, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
+            if (ret == Z_MEM_ERROR)
+                throw(ENOMEM, "not enough memory");
+            if (ret != Z_OK)
+                throw(EINVAL, "internal error");
+        }
 
         // keep looking for work
         for (;;) {
@@ -1714,11 +1720,8 @@
                 (void)deflateParams(&strm, g.level, Z_DEFAULT_STRATEGY);
 #ifndef NOZOPFLI
             }
-            else {
-                if (temp == NULL)
-                    temp = get_space(&out_pool);
+            else
                 temp->len = 0;
-            }
 #endif
 
             // set dictionary if provided, release that input or dictionary
@@ -1912,11 +1915,15 @@
         }
 
         // found job with seq == -1 -- return to join
-#ifndef NOZOPFLI
-        drop_space(temp);
-#endif
         release(compress_have);
-        (void)deflateEnd(&strm);
+#ifndef NOZOPFLI
+        if (g.level > 9)
+            drop_space(temp);
+        else
+#endif
+        {
+            (void)deflateEnd(&strm);
+        }
     }
     catch (err) {
         THREADABORT(err);
@@ -3078,7 +3085,7 @@
         strncpy(tag, "<...>", max + 1);
     else if (g.hname == NULL) {
         n = strlen(g.inf) - compressed_suffix(g.inf);
-        strncpy(tag, g.inf, n > max + 1 ? max + 1 : n);
+        memcpy(tag, g.inf, n > max + 1 ? max + 1 : n);
         if (strcmp(g.inf + n, ".tgz") == 0 && n < max + 1)
             strncpy(tag + n, ".tar", max + 1 - n);
     }
@@ -3802,37 +3809,33 @@
     return p == NULL ? path : p + 1;
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-result"
-
 // Copy file attributes, from -> to, as best we can. This is best effort, so no
 // errors are reported. The mode bits, including suid, sgid, and the sticky bit
 // are copied (if allowed), the owner's user id and group id are copied (again
 // if allowed), and the access and modify times are copied.
-local void copymeta(char *from, char *to) {
+local int copymeta(char *from, char *to) {
     struct stat st;
     struct timeval times[2];
 
     // get all of from's Unix meta data, return if not a regular file
     if (stat(from, &st) != 0 || (st.st_mode & S_IFMT) != S_IFREG)
-        return;
+        return -4;
 
     // set to's mode bits, ignore errors
-    (void)chmod(to, st.st_mode & 07777);
+    int ret = chmod(to, st.st_mode & 07777);
 
     // copy owner's user and group, ignore errors
-    (void)chown(to, st.st_uid, st.st_gid);
+    ret += chown(to, st.st_uid, st.st_gid);
 
     // copy access and modify times, ignore errors
     times[0].tv_sec = st.st_atime;
     times[0].tv_usec = 0;
     times[1].tv_sec = st.st_mtime;
     times[1].tv_usec = 0;
-    (void)utimes(to, times);
+    ret += utimes(to, times);
+    return ret;
 }
 
-#pragma GCC diagnostic pop
-
 // Set the access and modify times of fd to t.
 local void touch(char *path, time_t t) {
     struct timeval times[2];
@@ -4430,6 +4433,7 @@
                 puts("Subject to the terms of the zlib license.");
                 puts("No warranty is provided or implied.");
                 exit(0);
+                break;          // avoid warning
             case 'M':  g.headis |= 0xa;  break;
             case 'N':  g.headis = 0xf;  break;
 #ifndef NOZOPFLI
@@ -4443,13 +4447,16 @@
                 if (g.verbosity > 1)
                     printf("zlib %s\n", zlibVersion());
                 exit(0);
+                break;          // avoid warning
             case 'Y':  g.sync = 1;  break;
             case 'Z':
                 throw(EINVAL, "invalid option: LZW output not supported: %s",
                       bad);
+                break;          // avoid warning
             case 'a':
                 throw(EINVAL, "invalid option: no ascii conversion: %s",
                       bad);
+                break;          // avoid warning
             case 'b':  get = 1;  break;
             case 'c':  g.pipeout = 1;  break;
             case 'd':  if (!g.decode) g.headis >>= 2;  g.decode = 1;  break;
diff --git a/try.h b/try.h
index 03289dd..3009f7d 100644
--- a/try.h
+++ b/try.h
@@ -304,8 +304,8 @@
 #   define try_stack_ ((try_t_ *)pthread_getspecific(try_key_))
 #   define try_stack_set_(next) \
         do { \
-            int try_ret_ = pthread_setspecific(try_key_, next); \
-            assert(try_ret_ == 0 && "try: pthread_setspecific() failed"); \
+            assert(pthread_setspecific(try_key_, next) == 0 && \
+                   "try: pthread_setspecific() failed"); \
         } while (0)
 #else /* !PTHREAD_ONCE_INIT */
     extern try_t_ *try_stack_;
@@ -320,7 +320,7 @@
 #define TRY_TRY_ \
     do { \
         try_t_ try_this_; \
-        int try_pushed_ = 1; \
+        volatile int try_pushed_ = 1; \
         try_this_.ball.code = 0; \
         try_this_.ball.free = 0; \
         try_this_.ball.why = NULL; \
diff --git a/zopfli/src/zopfli/cache.c b/zopfli/src/zopfli/cache.c
index f5559c3..e5934df 100644
--- a/zopfli/src/zopfli/cache.c
+++ b/zopfli/src/zopfli/cache.c
@@ -33,7 +33,7 @@
   lmc->sublen = (unsigned char*)malloc(ZOPFLI_CACHE_LENGTH * 3 * blocksize);
   if(lmc->sublen == NULL) {
     fprintf(stderr,
-        "Error: Out of memory. Tried allocating %lu bytes of memory.\n",
+        "Error: Out of memory. Tried allocating %zu bytes of memory.\n",
         ZOPFLI_CACHE_LENGTH * 3 * blocksize);
     exit (EXIT_FAILURE);
   }
diff --git a/zopfli/src/zopfli/deflate.c b/zopfli/src/zopfli/deflate.c
index abe7360..f7b62e4 100644
--- a/zopfli/src/zopfli/deflate.c
+++ b/zopfli/src/zopfli/deflate.c
@@ -431,22 +431,23 @@
 compression, especially its rle-part, will be more likely to compress this data
 more efficiently. length contains the size of the histogram.
 */
-void OptimizeHuffmanForRle(int length, size_t* counts) {
-  int i, k, stride;
+void OptimizeHuffmanForRle(unsigned length, size_t* counts) {
+  unsigned i;
+  int k, stride;
   size_t symbol, sum, limit;
   int* good_for_rle;
 
   /* 1) We don't want to touch the trailing zeros. We may break the
   rules of the format by adding more data in the distance codes. */
-  for (; length >= 0; --length) {
-    if (length == 0) {
-      return;
-    }
+  for (; length > 0; --length) {
     if (counts[length - 1] != 0) {
       /* Now counts[0..length - 1] does not have trailing zeros. */
       break;
     }
   }
+  if (length == 0) {
+    return;
+  }
   /* 2) Let's mark all population counts that already can be encoded
   with an rle code.*/
   good_for_rle = (int*)malloc(length * sizeof(int));