Fix missing embedded zlib, remove unneeded zlib files

30 files changed, 0 insertions, 13495 deletions

diff --git a/deps/adler32.c b/deps/adler32.c
deleted file mode 100644
index cccb3a2..0000000
--- a/deps/adler32.c
+++ /dev/null
@@ -1,75 +0,0 @@
-/* adler32.c -- compute the Adler-32 checksum of a data stream
- * Copyright (C) 1995-2003 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#define ZLIB_INTERNAL
-#include <stdint.h>
-#include <stddef.h>
-#include "zutil.h"
-
-#define BASE 65521UL    /* largest prime smaller than 65536 */
-#define NMAX 5552
-/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
-
-#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
-#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
-#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
-#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
-#define DO16(buf)   DO8(buf,0); DO8(buf,8);
-
-#ifdef NO_DIVIDE
-#  define MOD(a) \
-   do { \
-      if (a >= (BASE << 16)) a -= (BASE << 16); \
-      if (a >= (BASE << 15)) a -= (BASE << 15); \
-      if (a >= (BASE << 14)) a -= (BASE << 14); \
-      if (a >= (BASE << 13)) a -= (BASE << 13); \
-      if (a >= (BASE << 12)) a -= (BASE << 12); \
-      if (a >= (BASE << 11)) a -= (BASE << 11); \
-      if (a >= (BASE << 10)) a -= (BASE << 10); \
-      if (a >= (BASE << 9)) a -= (BASE << 9); \
-      if (a >= (BASE << 8)) a -= (BASE << 8); \
-      if (a >= (BASE << 7)) a -= (BASE << 7); \
-      if (a >= (BASE << 6)) a -= (BASE << 6); \
-      if (a >= (BASE << 5)) a -= (BASE << 5); \
-      if (a >= (BASE << 4)) a -= (BASE << 4); \
-      if (a >= (BASE << 3)) a -= (BASE << 3); \
-      if (a >= (BASE << 2)) a -= (BASE << 2); \
-      if (a >= (BASE << 1)) a -= (BASE << 1); \
-      if (a >= BASE) a -= BASE; \
-   } while (0)
-#else
-#  define MOD(a) a %= BASE
-#endif
-
-/* ========================================================================= */
-uLong adler32(uLong adler, const Bytef *buf, uInt len)
-{
-   uint32_t s1 = adler & 0xffff;
-   uint32_t s2 = (adler >> 16) & 0xffff;
-   int k;
-
-   if (buf == NULL)
-      return 1L;
-
-   while (len > 0) {
-      k = len < NMAX ? (int)len : NMAX;
-      len -= k;
-      while (k >= 16) {
-         DO16(buf);
-         buf += 16;
-         k -= 16;
-      }
-      if (k != 0) do {
-         s1 += *buf++;
-         s2 += s1;
-      } while (--k);
-      MOD(s1);
-      MOD(s2);
-   }
-   return (s2 << 16) | s1;
-}
-
diff --git a/deps/compress.c b/deps/compress.c
deleted file mode 100644
index 48465bd..0000000
--- a/deps/compress.c
+++ /dev/null
@@ -1,70 +0,0 @@
-/* compress.c -- compress a memory buffer
- * Copyright (C) 1995-2005 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#define ZLIB_INTERNAL
-#include "zlib.h"
-
-/* ===========================================================================
-   Compresses the source buffer into the destination buffer. The level
-   parameter has the same meaning as in deflateInit.  sourceLen is the byte
-   length of the source buffer. Upon entry, destLen is the total size of the
-   destination buffer, which must be at least 0.1% larger than sourceLen plus
-   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
-
-   compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
-   Z_STREAM_ERROR if the level parameter is invalid.
-   */
-int ZEXPORT compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)
-{
-   z_stream stream;
-   int err;
-
-   stream.next_in = (Bytef *)source;
-   stream.avail_in = (uInt)sourceLen;
-#ifdef MAXSEG_64K
-   /* Check for source > 64K on 16-bit machine: */
-   if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-#endif
-   stream.next_out = dest;
-   stream.avail_out = (uInt)*destLen;
-   if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
-
-   stream.zalloc = Z_NULL;
-   stream.zfree = Z_NULL;
-   stream.opaque = (voidpf)0;
-
-   err = deflateInit(&stream, level);
-   if (err != Z_OK) return err;
-
-   err = deflate(&stream, Z_FINISH);
-   if (err != Z_STREAM_END) {
-      deflateEnd(&stream);
-      return err == Z_OK ? Z_BUF_ERROR : err;
-   }
-   *destLen = stream.total_out;
-
-   err = deflateEnd(&stream);
-   return err;
-}
-
-/* ===========================================================================
-*/
-int ZEXPORT compress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
-{
-   return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
-}
-
-/* ===========================================================================
-   If the default memLevel or windowBits for deflateInit() is changed, then
-   this function needs to be updated.
-   */
-uLong ZEXPORT compressBound (uLong sourceLen)
-{
-   return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
-      (sourceLen >> 25) + 13;
-}
diff --git a/deps/crc32.c b/deps/crc32.c
deleted file mode 100644
index 73369a2..0000000
--- a/deps/crc32.c
+++ /dev/null
@@ -1,88 +0,0 @@
-#ifndef _S_CRC32_H
-#define _S_CRC32_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-   static const unsigned long crc_table[256] = {
-      0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
-      0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
-      0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
-      0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
-      0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
-      0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
-      0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
-      0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
-      0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
-      0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
-      0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
-      0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
-      0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
-      0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
-      0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
-      0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
-      0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
-      0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
-      0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
-      0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
-      0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
-      0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
-      0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
-      0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
-      0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
-      0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
-      0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
-      0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
-      0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
-      0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
-      0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
-      0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
-      0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
-      0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
-      0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
-      0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
-      0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
-      0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
-      0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
-      0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
-      0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
-      0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
-      0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
-      0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
-      0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
-      0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
-      0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
-      0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
-      0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
-      0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
-      0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
-      0x2d02ef8dL
-   };
-
-#define DO1_CRC32(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
-#define DO2_CRC32(buf) DO1_CRC32(buf); DO1_CRC32(buf);
-#define DO4_CRC32(buf) DO2_CRC32(buf); DO2_CRC32(buf);
-#define DO8_CRC32(buf) DO4_CRC32(buf); DO4_CRC32(buf);
-
-   unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned int len)
-   {
-      if (buf == 0) return 0L;
-      crc = crc ^ 0xffffffffL;
-      while (len >= 8)
-      {
-         DO8_CRC32(buf);
-         len -= 8;
-      }
-      if (len) do {
-         DO1_CRC32(buf);
-      } while (--len);
-      return crc ^ 0xffffffffL;
-   }
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
diff --git a/deps/deflate.c b/deps/deflate.c
deleted file mode 100644
index f8fbc48..0000000
--- a/deps/deflate.c
+++ /dev/null
@@ -1,1913 +0,0 @@
-/* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
- *  ALGORITHM
- *
- *      The "deflation" process depends on being able to identify portions
- *      of the input text which are identical to earlier input (within a
- *      sliding window trailing behind the input currently being processed).
- *
- *      The most straightforward technique turns out to be the fastest for
- *      most input files: try all possible matches and select the longest.
- *      The key feature of this algorithm is that insertions into the string
- *      dictionary are very simple and thus fast, and deletions are avoided
- *      completely. Insertions are performed at each input character, whereas
- *      string matches are performed only when the previous match ends. So it
- *      is preferable to spend more time in matches to allow very fast string
- *      insertions and avoid deletions. The matching algorithm for small
- *      strings is inspired from that of Rabin & Karp. A brute force approach
- *      is used to find longer strings when a small match has been found.
- *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
- *      (by Leonid Broukhis).
- *         A previous version of this file used a more sophisticated algorithm
- *      (by Fiala and Greene) which is guaranteed to run in linear amortized
- *      time, but has a larger average cost, uses more memory and is patented.
- *      However the F&G algorithm may be faster for some highly redundant
- *      files if the parameter max_chain_length (described below) is too large.
- *
- *  ACKNOWLEDGEMENTS
- *
- *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
- *      I found it in 'freeze' written by Leonid Broukhis.
- *      Thanks to many people for bug reports and testing.
- *
- *  REFERENCES
- *
- *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
- *      Available in http://tools.ietf.org/html/rfc1951
- *
- *      A description of the Rabin and Karp algorithm is given in the book
- *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
- *
- *      Fiala,E.R., and Greene,D.H.
- *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
- *
- */
-
-/* @(#) $Id$ */
-
-#include "deflate.h"
-
-const char deflate_copyright[] =
-" deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ";
-/*
-   If you use the zlib library in a product, an acknowledgment is welcome
-   in the documentation of your product. If for some reason you cannot
-   include such an acknowledgment, I would appreciate that you keep this
-   copyright string in the executable of your product.
-   */
-
-/* ===========================================================================
- *  Function prototypes.
- */
-typedef enum {
-   need_more,      /* block not completed, need more input or more output */
-   block_done,     /* block flush performed */
-   finish_started, /* finish started, need only more output at next deflate */
-   finish_done     /* finish done, accept no more input or output */
-} block_state;
-
-typedef block_state (*compress_func) OF((deflate_state *s, int flush));
-/* Compression function. Returns the block state after the call. */
-
-local void fill_window    OF((deflate_state *s));
-local block_state deflate_stored OF((deflate_state *s, int flush));
-local block_state deflate_fast   OF((deflate_state *s, int flush));
-#ifndef FASTEST
-local block_state deflate_slow   OF((deflate_state *s, int flush));
-#endif
-local block_state deflate_rle    OF((deflate_state *s, int flush));
-local block_state deflate_huff   OF((deflate_state *s, int flush));
-local void lm_init        OF((deflate_state *s));
-local void putShortMSB    OF((deflate_state *s, uInt b));
-local void flush_pending  OF((z_streamp strm));
-local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
-#ifdef ASMV
-void match_init OF((void)); /* asm code initialization */
-uInt longest_match  OF((deflate_state *s, IPos cur_match));
-#else
-local uInt longest_match  OF((deflate_state *s, IPos cur_match));
-#endif
-
-#ifdef DEBUG
-local  void check_match OF((deflate_state *s, IPos start, IPos match,
-         int length));
-#endif
-
-/* ===========================================================================
- * Local data
- */
-
-#define NIL 0
-/* Tail of hash chains */
-
-#ifndef TOO_FAR
-#  define TOO_FAR 4096
-#endif
-/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
-
-/* Values for max_lazy_match, good_match and max_chain_length, depending on
- * the desired pack level (0..9). The values given below have been tuned to
- * exclude worst case performance for pathological files. Better values may be
- * found for specific files.
- */
-typedef struct config_s {
-   ush good_length; /* reduce lazy search above this match length */
-   ush max_lazy;    /* do not perform lazy search above this match length */
-   ush nice_length; /* quit search above this match length */
-   ush max_chain;
-   compress_func func;
-} config;
-
-#ifdef FASTEST
-local const config configuration_table[2] = {
-   /*      good lazy nice chain */
-   /* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
-   /* 1 */ {4,    4,  8,    4, deflate_fast}}; /* max speed, no lazy matches */
-#else
-local const config configuration_table[10] = {
-   /*      good lazy nice chain */
-   /* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
-   /* 1 */ {4,    4,  8,    4, deflate_fast}, /* max speed, no lazy matches */
-   /* 2 */ {4,    5, 16,    8, deflate_fast},
-   /* 3 */ {4,    6, 32,   32, deflate_fast},
-
-   /* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
-   /* 5 */ {8,   16, 32,   32, deflate_slow},
-   /* 6 */ {8,   16, 128, 128, deflate_slow},
-   /* 7 */ {8,   32, 128, 256, deflate_slow},
-   /* 8 */ {32, 128, 258, 1024, deflate_slow},
-   /* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
-#endif
-
-/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
- * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
- * meaning.
- */
-
-#define EQUAL 0
-/* result of memcmp for equal strings */
-
-/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
-#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0))
-
-/* ===========================================================================
- * Update a hash value with the given input byte
- * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
- *    input characters, so that a running hash key can be computed from the
- *    previous key instead of complete recalculation each time.
- */
-#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
-
-
-/* ===========================================================================
- * Insert string str in the dictionary and set match_head to the previous head
- * of the hash chain (the most recent string with same hash key). Return
- * the previous length of the hash chain.
- * If this file is compiled with -DFASTEST, the compression level is forced
- * to 1, and no hash chains are maintained.
- * IN  assertion: all calls to to INSERT_STRING are made with consecutive
- *    input characters and the first MIN_MATCH bytes of str are valid
- *    (except for the last MIN_MATCH-1 bytes of the input file).
- */
-#ifdef FASTEST
-#define INSERT_STRING(s, str, match_head) \
-   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
-    match_head = s->head[s->ins_h], \
-    s->head[s->ins_h] = (Pos)(str))
-#else
-#define INSERT_STRING(s, str, match_head) \
-   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
-    match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
-    s->head[s->ins_h] = (Pos)(str))
-#endif
-
-/* ===========================================================================
- * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
- * prev[] will be initialized on the fly.
- */
-#define CLEAR_HASH(s) \
-   s->head[s->hash_size-1] = NIL; \
-zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
-
-int ZEXPORT deflateResetKeep (z_streamp strm);
-
-int ZEXPORT deflatePending (z_streamp strm, unsigned *pending, int *bits);
-
-/* ========================================================================= */
-int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version, int stream_size)
-{
-   return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
-         Z_DEFAULT_STRATEGY, version, stream_size);
-   /* To do: ignore strm->next_in if we use it as window */
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy,
-      const char *version, int stream_size)
-{
-   deflate_state *s;
-   int wrap = 1;
-   static const char my_version[] = ZLIB_VERSION;
-
-   ushf *overlay;
-   /* We overlay pending_buf and d_buf+l_buf. This works since the average
-    * output size for (length,distance) codes is <= 24 bits.
-    */
-
-   if (version == Z_NULL || version[0] != my_version[0] ||
-         stream_size != sizeof(z_stream)) {
-      return Z_VERSION_ERROR;
-   }
-   if (strm == Z_NULL) return Z_STREAM_ERROR;
-
-   strm->msg = Z_NULL;
-   if (strm->zalloc == (alloc_func)0) {
-#ifdef Z_SOLO
-      return Z_STREAM_ERROR;
-#else
-      strm->zalloc = zcalloc;
-      strm->opaque = (voidpf)0;
-#endif
-   }
-   if (strm->zfree == NULL)
-#ifdef Z_SOLO
-      return Z_STREAM_ERROR;
-#else
-   strm->zfree = zcfree;
-#endif
-
-#ifdef FASTEST
-   if (level != 0) level = 1;
-#else
-   if (level == Z_DEFAULT_COMPRESSION) level = 6;
-#endif
-
-   if (windowBits < 0) { /* suppress zlib wrapper */
-      wrap = 0;
-      windowBits = -windowBits;
-   }
-#ifdef GZIP
-   else if (windowBits > 15) {
-      wrap = 2;       /* write gzip wrapper instead */
-      windowBits -= 16;
-   }
-#endif
-   if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
-         windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
-         strategy < 0 || strategy > Z_FIXED) {
-      return Z_STREAM_ERROR;
-   }
-   if (windowBits == 8) windowBits = 9;  /* until 256-byte window bug fixed */
-   s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
-   if (s == Z_NULL) return Z_MEM_ERROR;
-   strm->state = (struct internal_state*)s;
-   s->strm = strm;
-
-   s->wrap = wrap;
-   s->gzhead = Z_NULL;
-   s->w_bits = windowBits;
-   s->w_size = 1 << s->w_bits;
-   s->w_mask = s->w_size - 1;
-
-   s->hash_bits = memLevel + 7;
-   s->hash_size = 1 << s->hash_bits;
-   s->hash_mask = s->hash_size - 1;
-   s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
-
-   s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
-   s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
-   s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
-
-   s->high_water = 0;      /* nothing written to s->window yet */
-
-   s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
-
-   overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
-   s->pending_buf = (uchf *) overlay;
-   s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
-
-   if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
-         s->pending_buf == Z_NULL) {
-      s->status = FINISH_STATE;
-      strm->msg = ERR_MSG(Z_MEM_ERROR);
-      deflateEnd (strm);
-      return Z_MEM_ERROR;
-   }
-   s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
-   s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
-
-   s->level = level;
-   s->strategy = strategy;
-   s->method = (Byte)method;
-
-   return deflateReset(strm);
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength)
-{
-   deflate_state *s;
-   uInt str, n;
-   int wrap;
-   unsigned avail;
-   unsigned char *next;
-
-   if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
-      return Z_STREAM_ERROR;
-   s = (deflate_state*)strm->state;
-   wrap = s->wrap;
-   if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
-      return Z_STREAM_ERROR;
-
-   /* when using zlib wrappers, compute Adler-32 for provided dictionary */
-   if (wrap == 1)
-      strm->adler = adler32(strm->adler, dictionary, dictLength);
-   s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */
-
-   /* if dictionary would fill window, just replace the history */
-   if (dictLength >= s->w_size) {
-      if (wrap == 0) {            /* already empty otherwise */
-         CLEAR_HASH(s);
-         s->strstart = 0;
-         s->block_start = 0L;
-         s->insert = 0;
-      }
-      dictionary += dictLength - s->w_size;  /* use the tail */
-      dictLength = s->w_size;
-   }
-
-   /* insert dictionary into window and hash */
-   avail = strm->avail_in;
-   next = strm->next_in;
-   strm->avail_in = dictLength;
-   strm->next_in = (Bytef *)dictionary;
-   fill_window(s);
-   while (s->lookahead >= MIN_MATCH) {
-      str = s->strstart;
-      n = s->lookahead - (MIN_MATCH-1);
-      do {
-         UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
-#ifndef FASTEST
-         s->prev[str & s->w_mask] = s->head[s->ins_h];
-#endif
-         s->head[s->ins_h] = (Pos)str;
-         str++;
-      } while (--n);
-      s->strstart = str;
-      s->lookahead = MIN_MATCH-1;
-      fill_window(s);
-   }
-   s->strstart += s->lookahead;
-   s->block_start = (long)s->strstart;
-   s->insert = s->lookahead;
-   s->lookahead = 0;
-   s->match_length = s->prev_length = MIN_MATCH-1;
-   s->match_available = 0;
-   strm->next_in = next;
-   strm->avail_in = avail;
-   s->wrap = wrap;
-   return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateResetKeep (z_streamp strm)
-{
-   deflate_state *s;
-
-   if (strm == Z_NULL || strm->state == Z_NULL ||
-         strm->zalloc == Z_NULL || strm->zfree == Z_NULL) {
-      return Z_STREAM_ERROR;
-   }
-
-   strm->total_in = strm->total_out = 0;
-   strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
-   strm->data_type = Z_UNKNOWN;
-
-   s = (deflate_state *)strm->state;
-   s->pending = 0;
-   s->pending_out = s->pending_buf;
-
-   if (s->wrap < 0) {
-      s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
-   }
-   s->status = s->wrap ? INIT_STATE : BUSY_STATE;
-   strm->adler =
-#ifdef GZIP
-      s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
-#endif
-      adler32(0L, Z_NULL, 0);
-   s->last_flush = Z_NO_FLUSH;
-
-   _tr_init(s);
-
-   return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateReset (z_streamp strm)
-{
-   int ret;
-
-   ret = deflateResetKeep(strm);
-   if (ret == Z_OK)
-      lm_init((deflate_state*)strm->state);
-   return ret;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateSetHeader (z_streamp strm, gz_headerp head)
-{
-   struct internal_state_deflate *state = (struct internal_state_deflate*)strm->state;
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   if (state->wrap != 2)
-      return Z_STREAM_ERROR;
-   state->gzhead = head;
-   return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflatePending (z_streamp strm, unsigned *pending, int *bits)
-{
-   struct internal_state_deflate *state = (struct internal_state_deflate*)strm->state;
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   if (pending != Z_NULL)
-      *pending = state->pending;
-   if (bits != Z_NULL)
-      *bits = state->bi_valid;
-   return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflatePrime (z_streamp strm, int bits, int value)
-{
-   deflate_state *s;
-   int put;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   s = (deflate_state*)strm->state;
-   if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
-      return Z_BUF_ERROR;
-   do {
-      put = Buf_size - s->bi_valid;
-      if (put > bits)
-         put = bits;
-      s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
-      s->bi_valid += put;
-      _tr_flush_bits(s);
-      value >>= put;
-      bits -= put;
-   } while (bits);
-   return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
-{
-   deflate_state *s;
-   compress_func func;
-   int err = Z_OK;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   s = (deflate_state*)strm->state;
-
-#ifdef FASTEST
-   if (level != 0) level = 1;
-#else
-   if (level == Z_DEFAULT_COMPRESSION) level = 6;
-#endif
-   if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
-      return Z_STREAM_ERROR;
-   }
-   func = configuration_table[s->level].func;
-
-   if ((strategy != s->strategy || func != configuration_table[level].func) &&
-         strm->total_in != 0) {
-      /* Flush the last buffer: */
-      err = deflate(strm, Z_BLOCK);
-      if (err == Z_BUF_ERROR && s->pending == 0)
-         err = Z_OK;
-   }
-   if (s->level != level) {
-      s->level = level;
-      s->max_lazy_match   = configuration_table[level].max_lazy;
-      s->good_match       = configuration_table[level].good_length;
-      s->nice_match       = configuration_table[level].nice_length;
-      s->max_chain_length = configuration_table[level].max_chain;
-   }
-   s->strategy = strategy;
-   return err;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain)
-{
-   deflate_state *s;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   s = (deflate_state*)strm->state;
-   s->good_match = good_length;
-   s->max_lazy_match = max_lazy;
-   s->nice_match = nice_length;
-   s->max_chain_length = max_chain;
-   return Z_OK;
-}
-
-/* =========================================================================
- * For the default windowBits of 15 and memLevel of 8, this function returns
- * a close to exact, as well as small, upper bound on the compressed size.
- * They are coded as constants here for a reason--if the #define's are
- * changed, then this function needs to be changed as well.  The return
- * value for 15 and 8 only works for those exact settings.
- *
- * For any setting other than those defaults for windowBits and memLevel,
- * the value returned is a conservative worst case for the maximum expansion
- * resulting from using fixed blocks instead of stored blocks, which deflate
- * can emit on compressed data for some combinations of the parameters.
- *
- * This function could be more sophisticated to provide closer upper bounds for
- * every combination of windowBits and memLevel.  But even the conservative
- * upper bound of about 14% expansion does not seem onerous for output buffer
- * allocation.
- */
-uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen)
-{
-   deflate_state *s;
-   uLong complen, wraplen;
-   Bytef *str;
-
-   /* conservative upper bound for compressed data */
-   complen = sourceLen +
-      ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
-
-   /* if can't get parameters, return conservative bound plus zlib wrapper */
-   if (strm == Z_NULL || strm->state == Z_NULL)
-      return complen + 6;
-
-   /* compute wrapper length */
-   s = (deflate_state*)strm->state;
-   switch (s->wrap) {
-      case 0:                                 /* raw deflate */
-         wraplen = 0;
-         break;
-      case 1:                                 /* zlib wrapper */
-         wraplen = 6 + (s->strstart ? 4 : 0);
-         break;
-      case 2:                                 /* gzip wrapper */
-         wraplen = 18;
-         if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
-            if (s->gzhead->extra != Z_NULL)
-               wraplen += 2 + s->gzhead->extra_len;
-            str = s->gzhead->name;
-            if (str != Z_NULL)
-               do {
-                  wraplen++;
-               } while (*str++);
-            str = s->gzhead->comment;
-            if (str != Z_NULL)
-               do {
-                  wraplen++;
-               } while (*str++);
-            if (s->gzhead->hcrc)
-               wraplen += 2;
-         }
-         break;
-      default:                                /* for compiler happiness */
-         wraplen = 6;
-   }
-
-   /* if not default parameters, return conservative bound */
-   if (s->w_bits != 15 || s->hash_bits != 8 + 7)
-      return complen + wraplen;
-
-   /* default settings: return tight bound for that case */
-   return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
-      (sourceLen >> 25) + 13 - 6 + wraplen;
-}
-
-/* =========================================================================
- * Put a short in the pending buffer. The 16-bit value is put in MSB order.
- * IN assertion: the stream state is correct and there is enough room in
- * pending_buf.
- */
-local void putShortMSB (deflate_state *s, uInt b)
-{
-   put_byte(s, (Byte)(b >> 8));
-   put_byte(s, (Byte)(b & 0xff));
-}
-
-/* =========================================================================
- * Flush as much pending output as possible. All deflate() output goes
- * through this function so some applications may wish to modify it
- * to avoid allocating a large strm->next_out buffer and copying into it.
- * (See also read_buf()).
- */
-local void flush_pending(z_streamp strm)
-{
-   unsigned len;
-   deflate_state *s = (deflate_state*)strm->state;
-
-   _tr_flush_bits(s);
-   len = s->pending;
-   if (len > strm->avail_out) len = strm->avail_out;
-   if (len == 0) return;
-
-   zmemcpy(strm->next_out, s->pending_out, len);
-   strm->next_out  += len;
-   s->pending_out  += len;
-   strm->total_out += len;
-   strm->avail_out  -= len;
-   s->pending -= len;
-   if (s->pending == 0) {
-      s->pending_out = s->pending_buf;
-   }
-}
-
-/* ========================================================================= */
-int ZEXPORT deflate (z_streamp strm, int flush)
-{
-   int old_flush; /* value of flush param for previous deflate call */
-   deflate_state *s;
-
-   if (strm == Z_NULL || strm->state == Z_NULL ||
-         flush > Z_BLOCK || flush < 0) {
-      return Z_STREAM_ERROR;
-   }
-   s = (deflate_state*)strm->state;
-
-   if (strm->next_out == Z_NULL ||
-         (strm->next_in == Z_NULL && strm->avail_in != 0) ||
-         (s->status == FINISH_STATE && flush != Z_FINISH)) {
-      ERR_RETURN(strm, Z_STREAM_ERROR);
-   }
-   if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
-
-   s->strm = strm; /* just in case */
-   old_flush = s->last_flush;
-   s->last_flush = flush;
-
-   /* Write the header */
-   if (s->status == INIT_STATE) {
-#ifdef GZIP
-      if (s->wrap == 2) {
-         strm->adler = crc32(0L, Z_NULL, 0);
-         put_byte(s, 31);
-         put_byte(s, 139);
-         put_byte(s, 8);
-         if (s->gzhead == Z_NULL) {
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, s->level == 9 ? 2 :
-                  (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
-                   4 : 0));
-            put_byte(s, OS_CODE);
-            s->status = BUSY_STATE;
-         }
-         else {
-            put_byte(s, (s->gzhead->text ? 1 : 0) +
-                  (s->gzhead->hcrc ? 2 : 0) +
-                  (s->gzhead->extra == Z_NULL ? 0 : 4) +
-                  (s->gzhead->name == Z_NULL ? 0 : 8) +
-                  (s->gzhead->comment == Z_NULL ? 0 : 16)
-                  );
-            put_byte(s, (Byte)(s->gzhead->time & 0xff));
-            put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
-            put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
-            put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
-            put_byte(s, s->level == 9 ? 2 :
-                  (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
-                   4 : 0));
-            put_byte(s, s->gzhead->os & 0xff);
-            if (s->gzhead->extra != Z_NULL) {
-               put_byte(s, s->gzhead->extra_len & 0xff);
-               put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
-            }
-            if (s->gzhead->hcrc)
-               strm->adler = crc32(strm->adler, s->pending_buf,
-                     s->pending);
-            s->gzindex = 0;
-            s->status = EXTRA_STATE;
-         }
-      }
-      else
-#endif
-      {
-         uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
-         uInt level_flags;
-
-         if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
-            level_flags = 0;
-         else if (s->level < 6)
-            level_flags = 1;
-         else if (s->level == 6)
-            level_flags = 2;
-         else
-            level_flags = 3;
-         header |= (level_flags << 6);
-         if (s->strstart != 0) header |= PRESET_DICT;
-         header += 31 - (header % 31);
-
-         s->status = BUSY_STATE;
-         putShortMSB(s, header);
-
-         /* Save the adler32 of the preset dictionary: */
-         if (s->strstart != 0) {
-            putShortMSB(s, (uInt)(strm->adler >> 16));
-            putShortMSB(s, (uInt)(strm->adler & 0xffff));
-         }
-         strm->adler = adler32(0L, Z_NULL, 0);
-      }
-   }
-#ifdef GZIP
-   if (s->status == EXTRA_STATE) {
-      if (s->gzhead->extra != Z_NULL) {
-         uInt beg = s->pending;  /* start of bytes to update crc */
-
-         while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
-            if (s->pending == s->pending_buf_size) {
-               if (s->gzhead->hcrc && s->pending > beg)
-                  strm->adler = crc32(strm->adler, s->pending_buf + beg,
-                        s->pending - beg);
-               flush_pending(strm);
-               beg = s->pending;
-               if (s->pending == s->pending_buf_size)
-                  break;
-            }
-            put_byte(s, s->gzhead->extra[s->gzindex]);
-            s->gzindex++;
-         }
-         if (s->gzhead->hcrc && s->pending > beg)
-            strm->adler = crc32(strm->adler, s->pending_buf + beg,
-                  s->pending - beg);
-         if (s->gzindex == s->gzhead->extra_len) {
-            s->gzindex = 0;
-            s->status = NAME_STATE;
-         }
-      }
-      else
-         s->status = NAME_STATE;
-   }
-   if (s->status == NAME_STATE) {
-      if (s->gzhead->name != Z_NULL) {
-         uInt beg = s->pending;  /* start of bytes to update crc */
-         int val;
-
-         do {
-            if (s->pending == s->pending_buf_size) {
-               if (s->gzhead->hcrc && s->pending > beg)
-                  strm->adler = crc32(strm->adler, s->pending_buf + beg,
-                        s->pending - beg);
-               flush_pending(strm);
-               beg = s->pending;
-               if (s->pending == s->pending_buf_size) {
-                  val = 1;
-                  break;
-               }
-            }
-            val = s->gzhead->name[s->gzindex++];
-            put_byte(s, val);
-         } while (val != 0);
-         if (s->gzhead->hcrc && s->pending > beg)
-            strm->adler = crc32(strm->adler, s->pending_buf + beg,
-                  s->pending - beg);
-         if (val == 0) {
-            s->gzindex = 0;
-            s->status = COMMENT_STATE;
-         }
-      }
-      else
-         s->status = COMMENT_STATE;
-   }
-   if (s->status == COMMENT_STATE) {
-      if (s->gzhead->comment != Z_NULL) {
-         uInt beg = s->pending;  /* start of bytes to update crc */
-         int val;
-
-         do {
-            if (s->pending == s->pending_buf_size) {
-               if (s->gzhead->hcrc && s->pending > beg)
-                  strm->adler = crc32(strm->adler, s->pending_buf + beg,
-                        s->pending - beg);
-               flush_pending(strm);
-               beg = s->pending;
-               if (s->pending == s->pending_buf_size) {
-                  val = 1;
-                  break;
-               }
-            }
-            val = s->gzhead->comment[s->gzindex++];
-            put_byte(s, val);
-         } while (val != 0);
-         if (s->gzhead->hcrc && s->pending > beg)
-            strm->adler = crc32(strm->adler, s->pending_buf + beg,
-                  s->pending - beg);
-         if (val == 0)
-            s->status = HCRC_STATE;
-      }
-      else
-         s->status = HCRC_STATE;
-   }
-   if (s->status == HCRC_STATE) {
-      if (s->gzhead->hcrc) {
-         if (s->pending + 2 > s->pending_buf_size)
-            flush_pending(strm);
-         if (s->pending + 2 <= s->pending_buf_size) {
-            put_byte(s, (Byte)(strm->adler & 0xff));
-            put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
-            strm->adler = crc32(0L, Z_NULL, 0);
-            s->status = BUSY_STATE;
-         }
-      }
-      else
-         s->status = BUSY_STATE;
-   }
-#endif
-
-   /* Flush as much pending output as possible */
-   if (s->pending != 0) {
-      flush_pending(strm);
-      if (strm->avail_out == 0) {
-         /* Since avail_out is 0, deflate will be called again with
-          * more output space, but possibly with both pending and
-          * avail_in equal to zero. There won't be anything to do,
-          * but this is not an error situation so make sure we
-          * return OK instead of BUF_ERROR at next call of deflate:
-          */
-         s->last_flush = -1;
-         return Z_OK;
-      }
-
-      /* Make sure there is something to do and avoid duplicate consecutive
-       * flushes. For repeated and useless calls with Z_FINISH, we keep
-       * returning Z_STREAM_END instead of Z_BUF_ERROR.
-       */
-   } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
-         flush != Z_FINISH) {
-      ERR_RETURN(strm, Z_BUF_ERROR);
-   }
-
-   /* User must not provide more input after the first FINISH: */
-   if (s->status == FINISH_STATE && strm->avail_in != 0) {
-      ERR_RETURN(strm, Z_BUF_ERROR);
-   }
-
-   /* Start a new block or continue the current one.
-   */
-   if (strm->avail_in != 0 || s->lookahead != 0 ||
-         (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
-      block_state bstate;
-
-      bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
-         (s->strategy == Z_RLE ? deflate_rle(s, flush) :
-          (*(configuration_table[s->level].func))(s, flush));
-
-      if (bstate == finish_started || bstate == finish_done) {
-         s->status = FINISH_STATE;
-      }
-      if (bstate == need_more || bstate == finish_started) {
-         if (strm->avail_out == 0) {
-            s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
-         }
-         return Z_OK;
-         /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
-          * of deflate should use the same flush parameter to make sure
-          * that the flush is complete. So we don't have to output an
-          * empty block here, this will be done at next call. This also
-          * ensures that for a very small output buffer, we emit at most
-          * one empty block.
-          */
-      }
-      if (bstate == block_done) {
-         if (flush == Z_PARTIAL_FLUSH) {
-            _tr_align(s);
-         } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
-            _tr_stored_block(s, (char*)0, 0L, 0);
-            /* For a full flush, this empty block will be recognized
-             * as a special marker by inflate_sync().
-             */
-            if (flush == Z_FULL_FLUSH) {
-               CLEAR_HASH(s);             /* forget history */
-               if (s->lookahead == 0) {
-                  s->strstart = 0;
-                  s->block_start = 0L;
-                  s->insert = 0;
-               }
-            }
-         }
-         flush_pending(strm);
-         if (strm->avail_out == 0) {
-            s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
-            return Z_OK;
-         }
-      }
-   }
-   Assert(strm->avail_out > 0, "bug2");
-
-   if (flush != Z_FINISH) return Z_OK;
-   if (s->wrap <= 0) return Z_STREAM_END;
-
-   /* Write the trailer */
-#ifdef GZIP
-   if (s->wrap == 2) {
-      put_byte(s, (Byte)(strm->adler & 0xff));
-      put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
-      put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
-      put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
-      put_byte(s, (Byte)(strm->total_in & 0xff));
-      put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
-      put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
-      put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
-   }
-   else
-#endif
-   {
-      putShortMSB(s, (uInt)(strm->adler >> 16));
-      putShortMSB(s, (uInt)(strm->adler & 0xffff));
-   }
-   flush_pending(strm);
-   /* If avail_out is zero, the application will call deflate again
-    * to flush the rest.
-    */
-   if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
-   return s->pending != 0 ? Z_OK : Z_STREAM_END;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateEnd (z_streamp strm)
-{
-   struct internal_state_deflate *state;
-   int status;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct internal_state_deflate*)strm->state;
-
-   status = state->status;
-   if (status != INIT_STATE &&
-         status != EXTRA_STATE &&
-         status != NAME_STATE &&
-         status != COMMENT_STATE &&
-         status != HCRC_STATE &&
-         status != BUSY_STATE &&
-         status != FINISH_STATE) {
-      return Z_STREAM_ERROR;
-   }
-
-   /* Deallocate in reverse order of allocations: */
-   TRY_FREE(strm, state->pending_buf);
-   TRY_FREE(strm, state->head);
-   TRY_FREE(strm, state->prev);
-   TRY_FREE(strm, state->window);
-
-   ZFREE(strm, state);
-   state = Z_NULL;
-
-   return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
-}
-
-/* =========================================================================
- * Copy the source state to the destination state.
- * To simplify the source, this is not supported for 16-bit MSDOS (which
- * doesn't have enough memory anyway to duplicate compression states).
- */
-int ZEXPORT deflateCopy (z_streamp dest, z_streamp source)
-{
-#ifdef MAXSEG_64K
-   return Z_STREAM_ERROR;
-#else
-   deflate_state *ds;
-   deflate_state *ss;
-   ushf *overlay;
-
-
-   if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
-      return Z_STREAM_ERROR;
-   }
-
-   ss = (deflate_state*)source->state;
-
-   zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
-
-   ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
-   if (ds == Z_NULL) return Z_MEM_ERROR;
-   dest->state = (struct internal_state FAR *) ds;
-   zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
-   ds->strm = dest;
-
-   ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
-   ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
-   ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
-   overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
-   ds->pending_buf = (uchf *) overlay;
-
-   if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
-         ds->pending_buf == Z_NULL) {
-      deflateEnd (dest);
-      return Z_MEM_ERROR;
-   }
-   /* following zmemcpy do not work for 16-bit MSDOS */
-   zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
-   zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
-   zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
-   zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
-
-   ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
-   ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
-   ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
-
-   ds->l_desc.dyn_tree = ds->dyn_ltree;
-   ds->d_desc.dyn_tree = ds->dyn_dtree;
-   ds->bl_desc.dyn_tree = ds->bl_tree;
-
-   return Z_OK;
-#endif /* MAXSEG_64K */
-}
-
-/* ===========================================================================
- * Read a new buffer from the current input stream, update the adler32
- * and total number of bytes read.  All deflate() input goes through
- * this function so some applications may wish to modify it to avoid
- * allocating a large strm->next_in buffer and copying from it.
- * (See also flush_pending()).
- */
-local int read_buf(z_streamp strm, Bytef *buf, unsigned size)
-{
-   struct internal_state_deflate *state = (struct internal_state_deflate*)strm->state;
-   unsigned len = strm->avail_in;
-
-   if (len > size) len = size;
-   if (len == 0) return 0;
-
-   strm->avail_in  -= len;
-
-   zmemcpy(buf, strm->next_in, len);
-   if (state->wrap == 1) {
-      strm->adler = adler32(strm->adler, buf, len);
-   }
-#ifdef GZIP
-   else if (state->wrap == 2) {
-      strm->adler = crc32(strm->adler, buf, len);
-   }
-#endif
-   strm->next_in  += len;
-   strm->total_in += len;
-
-   return (int)len;
-}
-
-/* ===========================================================================
- * Initialize the "longest match" routines for a new zlib stream
- */
-local void lm_init (deflate_state *s)
-{
-   s->window_size = (ulg)2L*s->w_size;
-
-   CLEAR_HASH(s);
-
-   /* Set the default configuration parameters:
-   */
-   s->max_lazy_match   = configuration_table[s->level].max_lazy;
-   s->good_match       = configuration_table[s->level].good_length;
-   s->nice_match       = configuration_table[s->level].nice_length;
-   s->max_chain_length = configuration_table[s->level].max_chain;
-
-   s->strstart = 0;
-   s->block_start = 0L;
-   s->lookahead = 0;
-   s->insert = 0;
-   s->match_length = s->prev_length = MIN_MATCH-1;
-   s->match_available = 0;
-   s->ins_h = 0;
-#ifndef FASTEST
-#ifdef ASMV
-   match_init(); /* initialize the asm code */
-#endif
-#endif
-}
-
-#ifndef FASTEST
-/* ===========================================================================
- * Set match_start to the longest match starting at the given string and
- * return its length. Matches shorter or equal to prev_length are discarded,
- * in which case the result is equal to prev_length and match_start is
- * garbage.
- * IN assertions: cur_match is the head of the hash chain for the current
- *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
- * OUT assertion: the match length is not greater than s->lookahead.
- */
-#ifndef ASMV
-/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
- * match.S. The code will be functionally equivalent.
- */
-local uInt longest_match(deflate_state *s, IPos cur_match)
-{
-   unsigned chain_length = s->max_chain_length;/* max hash chain length */
-   register Bytef *scan = s->window + s->strstart; /* current string */
-   register Bytef *match;                       /* matched string */
-   register int len;                           /* length of current match */
-   int best_len = s->prev_length;              /* best match length so far */
-   int nice_match = s->nice_match;             /* stop if match long enough */
-   IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
-      s->strstart - (IPos)MAX_DIST(s) : NIL;
-   /* Stop when cur_match becomes <= limit. To simplify the code,
-    * we prevent matches with the string of window index 0.
-    */
-   Posf *prev = s->prev;
-   uInt wmask = s->w_mask;
-
-#ifdef UNALIGNED_OK
-   /* Compare two bytes at a time. Note: this is not always beneficial.
-    * Try with and without -DUNALIGNED_OK to check.
-    */
-   register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
-   register ush scan_start = *(ushf*)scan;
-   register ush scan_end   = *(ushf*)(scan+best_len-1);
-#else
-   register Bytef *strend = s->window + s->strstart + MAX_MATCH;
-   register Byte scan_end1  = scan[best_len-1];
-   register Byte scan_end   = scan[best_len];
-#endif
-
-   /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
-    * It is easy to get rid of this optimization if necessary.
-    */
-   Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
-
-   /* Do not waste too much time if we already have a good match: */
-   if (s->prev_length >= s->good_match) {
-      chain_length >>= 2;
-   }
-   /* Do not look for matches beyond the end of the input. This is necessary
-    * to make deflate deterministic.
-    */
-   if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
-
-   Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
-
-   do {
-      Assert(cur_match < s->strstart, "no future");
-      match = s->window + cur_match;
-
-      /* Skip to next match if the match length cannot increase
-       * or if the match length is less than 2.  Note that the checks below
-       * for insufficient lookahead only occur occasionally for performance
-       * reasons.  Therefore uninitialized memory will be accessed, and
-       * conditional jumps will be made that depend on those values.
-       * However the length of the match is limited to the lookahead, so
-       * the output of deflate is not affected by the uninitialized values.
-       */
-#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
-      /* This code assumes sizeof(unsigned short) == 2. Do not use
-       * UNALIGNED_OK if your compiler uses a different size.
-       */
-      if (*(ushf*)(match+best_len-1) != scan_end ||
-            *(ushf*)match != scan_start) continue;
-
-      /* It is not necessary to compare scan[2] and match[2] since they are
-       * always equal when the other bytes match, given that the hash keys
-       * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
-       * strstart+3, +5, ... up to strstart+257. We check for insufficient
-       * lookahead only every 4th comparison; the 128th check will be made
-       * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
-       * necessary to put more guard bytes at the end of the window, or
-       * to check more often for insufficient lookahead.
-       */
-      Assert(scan[2] == match[2], "scan[2]?");
-      scan++, match++;
-      do {
-      } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-            *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-            *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-            *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-            scan < strend);
-      /* The funny "do {}" generates better code on most compilers */
-
-      /* Here, scan <= window+strstart+257 */
-      Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-      if (*scan == *match) scan++;
-
-      len = (MAX_MATCH - 1) - (int)(strend-scan);
-      scan = strend - (MAX_MATCH-1);
-
-#else /* UNALIGNED_OK */
-
-      if (match[best_len]   != scan_end  ||
-            match[best_len-1] != scan_end1 ||
-            *match            != *scan     ||
-            *++match          != scan[1])      continue;
-
-      /* The check at best_len-1 can be removed because it will be made
-       * again later. (This heuristic is not always a win.)
-       * It is not necessary to compare scan[2] and match[2] since they
-       * are always equal when the other bytes match, given that
-       * the hash keys are equal and that HASH_BITS >= 8.
-       */
-      scan += 2, match++;
-      Assert(*scan == *match, "match[2]?");
-
-      /* We check for insufficient lookahead only every 8th comparison;
-       * the 256th check will be made at strstart+258.
-       */
-      do {
-      } while (*++scan == *++match && *++scan == *++match &&
-            *++scan == *++match && *++scan == *++match &&
-            *++scan == *++match && *++scan == *++match &&
-            *++scan == *++match && *++scan == *++match &&
-            scan < strend);
-
-      Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-
-      len = MAX_MATCH - (int)(strend - scan);
-      scan = strend - MAX_MATCH;
-
-#endif /* UNALIGNED_OK */
-
-      if (len > best_len) {
-         s->match_start = cur_match;
-         best_len = len;
-         if (len >= nice_match) break;
-#ifdef UNALIGNED_OK
-         scan_end = *(ushf*)(scan+best_len-1);
-#else
-         scan_end1  = scan[best_len-1];
-         scan_end   = scan[best_len];
-#endif
-      }
-   } while ((cur_match = prev[cur_match & wmask]) > limit
-         && --chain_length != 0);
-
-   if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
-   return s->lookahead;
-}
-#endif /* ASMV */
-
-#else /* FASTEST */
-
-/* ---------------------------------------------------------------------------
- * Optimized version for FASTEST only
- */
-local uInt longest_match(s, cur_match)
-   deflate_state *s;
-   IPos cur_match;                             /* current match */
-{
-   register Bytef *scan = s->window + s->strstart; /* current string */
-   register Bytef *match;                       /* matched string */
-   register int len;                           /* length of current match */
-   register Bytef *strend = s->window + s->strstart + MAX_MATCH;
-
-   /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
-    * It is easy to get rid of this optimization if necessary.
-    */
-   Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
-
-   Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
-
-   Assert(cur_match < s->strstart, "no future");
-
-   match = s->window + cur_match;
-
-   /* Return failure if the match length is less than 2:
-   */
-   if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
-
-   /* The check at best_len-1 can be removed because it will be made
-    * again later. (This heuristic is not always a win.)
-    * It is not necessary to compare scan[2] and match[2] since they
-    * are always equal when the other bytes match, given that
-    * the hash keys are equal and that HASH_BITS >= 8.
-    */
-   scan += 2, match += 2;
-   Assert(*scan == *match, "match[2]?");
-
-   /* We check for insufficient lookahead only every 8th comparison;
-    * the 256th check will be made at strstart+258.
-    */
-   do {
-   } while (*++scan == *++match && *++scan == *++match &&
-         *++scan == *++match && *++scan == *++match &&
-         *++scan == *++match && *++scan == *++match &&
-         *++scan == *++match && *++scan == *++match &&
-         scan < strend);
-
-   Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-
-   len = MAX_MATCH - (int)(strend - scan);
-
-   if (len < MIN_MATCH) return MIN_MATCH - 1;
-
-   s->match_start = cur_match;
-   return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
-}
-
-#endif /* FASTEST */
-
-#ifdef DEBUG
-/* ===========================================================================
- * Check that the match at match_start is indeed a match.
- */
-local void check_match(s, start, match, length)
-   deflate_state *s;
-   IPos start, match;
-   int length;
-{
-   /* check that the match is indeed a match */
-   if (zmemcmp(s->window + match,
-            s->window + start, length) != EQUAL) {
-      fprintf(stderr, " start %u, match %u, length %d\n",
-            start, match, length);
-      do {
-         fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
-      } while (--length != 0);
-      z_error("invalid match");
-   }
-   if (z_verbose > 1) {
-      fprintf(stderr,"\\[%d,%d]", start-match, length);
-      do { putc(s->window[start++], stderr); } while (--length != 0);
-   }
-}
-#else
-#  define check_match(s, start, match, length)
-#endif /* DEBUG */
-
-/* ===========================================================================
- * Fill the window when the lookahead becomes insufficient.
- * Updates strstart and lookahead.
- *
- * IN assertion: lookahead < MIN_LOOKAHEAD
- * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
- *    At least one byte has been read, or avail_in == 0; reads are
- *    performed for at least two bytes (required for the zip translate_eol
- *    option -- not supported here).
- */
-local void fill_window(deflate_state *s)
-{
-   register unsigned n, m;
-   register Posf *p;
-   unsigned more;    /* Amount of free space at the end of the window. */
-   uInt wsize = s->w_size;
-
-   Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
-
-   do {
-      more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
-
-      /* Deal with !@#$% 64K limit: */
-      if (sizeof(int) <= 2) {
-         if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
-            more = wsize;
-
-         } else if (more == (unsigned)(-1)) {
-            /* Very unlikely, but possible on 16 bit machine if
-             * strstart == 0 && lookahead == 1 (input done a byte at time)
-             */
-            more--;
-         }
-      }
-
-      /* If the window is almost full and there is insufficient lookahead,
-       * move the upper half to the lower one to make room in the upper half.
-       */
-      if (s->strstart >= wsize+MAX_DIST(s)) {
-
-         zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
-         s->match_start -= wsize;
-         s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
-         s->block_start -= (long) wsize;
-
-         /* Slide the hash table (could be avoided with 32 bit values
-            at the expense of memory usage). We slide even when level == 0
-            to keep the hash table consistent if we switch back to level > 0
-            later. (Using level 0 permanently is not an optimal usage of
-            zlib, so we don't care about this pathological case.)
-            */
-         n = s->hash_size;
-         p = &s->head[n];
-         do {
-            m = *--p;
-            *p = (Pos)(m >= wsize ? m-wsize : NIL);
-         } while (--n);
-
-         n = wsize;
-#ifndef FASTEST
-         p = &s->prev[n];
-         do {
-            m = *--p;
-            *p = (Pos)(m >= wsize ? m-wsize : NIL);
-            /* If n is not on any hash chain, prev[n] is garbage but
-             * its value will never be used.
-             */
-         } while (--n);
-#endif
-         more += wsize;
-      }
-      if (s->strm->avail_in == 0) break;
-
-      /* If there was no sliding:
-       *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
-       *    more == window_size - lookahead - strstart
-       * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
-       * => more >= window_size - 2*WSIZE + 2
-       * In the BIG_MEM or MMAP case (not yet supported),
-       *   window_size == input_size + MIN_LOOKAHEAD  &&
-       *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
-       * Otherwise, window_size == 2*WSIZE so more >= 2.
-       * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
-       */
-      Assert(more >= 2, "more < 2");
-
-      n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
-      s->lookahead += n;
-
-      /* Initialize the hash value now that we have some input: */
-      if (s->lookahead + s->insert >= MIN_MATCH) {
-         uInt str = s->strstart - s->insert;
-         s->ins_h = s->window[str];
-         UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
-#if MIN_MATCH != 3
-         Call UPDATE_HASH() MIN_MATCH-3 more times
-#endif
-            while (s->insert) {
-               UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
-#ifndef FASTEST
-               s->prev[str & s->w_mask] = s->head[s->ins_h];
-#endif
-               s->head[s->ins_h] = (Pos)str;
-               str++;
-               s->insert--;
-               if (s->lookahead + s->insert < MIN_MATCH)
-                  break;
-            }
-      }
-      /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
-       * but this is not important since only literal bytes will be emitted.
-       */
-
-   } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
-
-   /* If the WIN_INIT bytes after the end of the current data have never been
-    * written, then zero those bytes in order to avoid memory check reports of
-    * the use of uninitialized (or uninitialised as Julian writes) bytes by
-    * the longest match routines.  Update the high water mark for the next
-    * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
-    * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
-    */
-   if (s->high_water < s->window_size) {
-      ulg curr = s->strstart + (ulg)(s->lookahead);
-      ulg init;
-
-      if (s->high_water < curr) {
-         /* Previous high water mark below current data -- zero WIN_INIT
-          * bytes or up to end of window, whichever is less.
-          */
-         init = s->window_size - curr;
-         if (init > WIN_INIT)
-            init = WIN_INIT;
-         zmemzero(s->window + curr, (unsigned)init);
-         s->high_water = curr + init;
-      }
-      else if (s->high_water < (ulg)curr + WIN_INIT) {
-         /* High water mark at or above current data, but below current data
-          * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
-          * to end of window, whichever is less.
-          */
-         init = (ulg)curr + WIN_INIT - s->high_water;
-         if (init > s->window_size - s->high_water)
-            init = s->window_size - s->high_water;
-         zmemzero(s->window + s->high_water, (unsigned)init);
-         s->high_water += init;
-      }
-   }
-
-   Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
-         "not enough room for search");
-}
-
-/* ===========================================================================
- * Flush the current block, with given end-of-file flag.
- * IN assertion: strstart is set to the end of the current match.
- */
-#define FLUSH_BLOCK_ONLY(s, last) { \
-   _tr_flush_block(s, (s->block_start >= 0L ? \
-            (charf *)&s->window[(unsigned)s->block_start] : \
-            (charf *)Z_NULL), \
-         (ulg)((long)s->strstart - s->block_start), \
-         (last)); \
-   s->block_start = s->strstart; \
-   flush_pending(s->strm); \
-   Tracev((stderr,"[FLUSH]")); \
-}
-
-/* Same but force premature exit if necessary. */
-#define FLUSH_BLOCK(s, last) { \
-   FLUSH_BLOCK_ONLY(s, last); \
-   if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
-}
-
-/* ===========================================================================
- * Copy without compression as much as possible from the input stream, return
- * the current block state.
- * This function does not insert new strings in the dictionary since
- * uncompressible data is probably not useful. This function is used
- * only for the level=0 compression option.
- * NOTE: this function should be optimized to avoid extra copying from
- * window to pending_buf.
- */
-local block_state deflate_stored(deflate_state *s, int flush)
-{
-   /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
-    * to pending_buf_size, and each stored block has a 5 byte header:
-    */
-   ulg max_block_size = 0xffff;
-   ulg max_start;
-
-   if (max_block_size > s->pending_buf_size - 5) {
-      max_block_size = s->pending_buf_size - 5;
-   }
-
-   /* Copy as much as possible from input to output: */
-   for (;;) {
-      /* Fill the window as much as possible: */
-      if (s->lookahead <= 1) {
-
-         Assert(s->strstart < s->w_size+MAX_DIST(s) ||
-               s->block_start >= (long)s->w_size, "slide too late");
-
-         fill_window(s);
-         if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
-
-         if (s->lookahead == 0) break; /* flush the current block */
-      }
-      Assert(s->block_start >= 0L, "block gone");
-
-      s->strstart += s->lookahead;
-      s->lookahead = 0;
-
-      /* Emit a stored block if pending_buf will be full: */
-      max_start = s->block_start + max_block_size;
-      if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
-         /* strstart == 0 is possible when wraparound on 16-bit machine */
-         s->lookahead = (uInt)(s->strstart - max_start);
-         s->strstart = (uInt)max_start;
-         FLUSH_BLOCK(s, 0);
-      }
-      /* Flush if we may have to slide, otherwise block_start may become
-       * negative and the data will be gone:
-       */
-      if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
-         FLUSH_BLOCK(s, 0);
-      }
-   }
-   s->insert = 0;
-   if (flush == Z_FINISH) {
-      FLUSH_BLOCK(s, 1);
-      return finish_done;
-   }
-   if ((long)s->strstart > s->block_start)
-      FLUSH_BLOCK(s, 0);
-   return block_done;
-}
-
-/* ===========================================================================
- * Compress as much as possible from the input stream, return the current
- * block state.
- * This function does not perform lazy evaluation of matches and inserts
- * new strings in the dictionary only for unmatched strings or for short
- * matches. It is used only for the fast compression options.
- */
-local block_state deflate_fast(deflate_state *s, int flush)
-{
-   IPos hash_head;       /* head of the hash chain */
-   int bflush;           /* set if current block must be flushed */
-
-   for (;;) {
-      /* Make sure that we always have enough lookahead, except
-       * at the end of the input file. We need MAX_MATCH bytes
-       * for the next match, plus MIN_MATCH bytes to insert the
-       * string following the next match.
-       */
-      if (s->lookahead < MIN_LOOKAHEAD) {
-         fill_window(s);
-         if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
-            return need_more;
-         }
-         if (s->lookahead == 0) break; /* flush the current block */
-      }
-
-      /* Insert the string window[strstart .. strstart+2] in the
-       * dictionary, and set hash_head to the head of the hash chain:
-       */
-      hash_head = NIL;
-      if (s->lookahead >= MIN_MATCH) {
-         INSERT_STRING(s, s->strstart, hash_head);
-      }
-
-      /* Find the longest match, discarding those <= prev_length.
-       * At this point we have always match_length < MIN_MATCH
-       */
-      if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
-         /* To simplify the code, we prevent matches with the string
-          * of window index 0 (in particular we have to avoid a match
-          * of the string with itself at the start of the input file).
-          */
-         s->match_length = longest_match (s, hash_head);
-         /* longest_match() sets match_start */
-      }
-      if (s->match_length >= MIN_MATCH) {
-         check_match(s, s->strstart, s->match_start, s->match_length);
-
-         _tr_tally_dist(s, s->strstart - s->match_start,
-               s->match_length - MIN_MATCH, bflush);
-
-         s->lookahead -= s->match_length;
-
-         /* Insert new strings in the hash table only if the match length
-          * is not too large. This saves time but degrades compression.
-          */
-#ifndef FASTEST
-         if (s->match_length <= s->max_insert_length &&
-               s->lookahead >= MIN_MATCH) {
-            s->match_length--; /* string at strstart already in table */
-            do {
-               s->strstart++;
-               INSERT_STRING(s, s->strstart, hash_head);
-               /* strstart never exceeds WSIZE-MAX_MATCH, so there are
-                * always MIN_MATCH bytes ahead.
-                */
-            } while (--s->match_length != 0);
-            s->strstart++;
-         } else
-#endif
-         {
-            s->strstart += s->match_length;
-            s->match_length = 0;
-            s->ins_h = s->window[s->strstart];
-            UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
-#if MIN_MATCH != 3
-            Call UPDATE_HASH() MIN_MATCH-3 more times
-#endif
-               /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
-                * matter since it will be recomputed at next deflate call.
-                */
-         }
-      } else {
-         /* No match, output a literal byte */
-         Tracevv((stderr,"%c", s->window[s->strstart]));
-         _tr_tally_lit (s, s->window[s->strstart], bflush);
-         s->lookahead--;
-         s->strstart++;
-      }
-      if (bflush) FLUSH_BLOCK(s, 0);
-   }
-   s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-   if (flush == Z_FINISH) {
-      FLUSH_BLOCK(s, 1);
-      return finish_done;
-   }
-   if (s->last_lit)
-      FLUSH_BLOCK(s, 0);
-   return block_done;
-}
-
-#ifndef FASTEST
-/* ===========================================================================
- * Same as above, but achieves better compression. We use a lazy
- * evaluation for matches: a match is finally adopted only if there is
- * no better match at the next window position.
- */
-local block_state deflate_slow(deflate_state *s, int flush)
-{
-   IPos hash_head;          /* head of hash chain */
-   int bflush;              /* set if current block must be flushed */
-
-   /* Process the input block. */
-   for (;;) {
-      /* Make sure that we always have enough lookahead, except
-       * at the end of the input file. We need MAX_MATCH bytes
-       * for the next match, plus MIN_MATCH bytes to insert the
-       * string following the next match.
-       */
-      if (s->lookahead < MIN_LOOKAHEAD) {
-         fill_window(s);
-         if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
-            return need_more;
-         }
-         if (s->lookahead == 0) break; /* flush the current block */
-      }
-
-      /* Insert the string window[strstart .. strstart+2] in the
-       * dictionary, and set hash_head to the head of the hash chain:
-       */
-      hash_head = NIL;
-      if (s->lookahead >= MIN_MATCH) {
-         INSERT_STRING(s, s->strstart, hash_head);
-      }
-
-      /* Find the longest match, discarding those <= prev_length.
-      */
-      s->prev_length = s->match_length, s->prev_match = s->match_start;
-      s->match_length = MIN_MATCH-1;
-
-      if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
-            s->strstart - hash_head <= MAX_DIST(s)) {
-         /* To simplify the code, we prevent matches with the string
-          * of window index 0 (in particular we have to avoid a match
-          * of the string with itself at the start of the input file).
-          */
-         s->match_length = longest_match (s, hash_head);
-         /* longest_match() sets match_start */
-
-         if (s->match_length <= 5 && (s->strategy == Z_FILTERED
-#if TOO_FAR <= 32767
-                  || (s->match_length == MIN_MATCH &&
-                     s->strstart - s->match_start > TOO_FAR)
-#endif
-                  )) {
-
-            /* If prev_match is also MIN_MATCH, match_start is garbage
-             * but we will ignore the current match anyway.
-             */
-            s->match_length = MIN_MATCH-1;
-         }
-      }
-      /* If there was a match at the previous step and the current
-       * match is not better, output the previous match:
-       */
-      if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
-         uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
-         /* Do not insert strings in hash table beyond this. */
-
-         check_match(s, s->strstart-1, s->prev_match, s->prev_length);
-
-         _tr_tally_dist(s, s->strstart -1 - s->prev_match,
-               s->prev_length - MIN_MATCH, bflush);
-
-         /* Insert in hash table all strings up to the end of the match.
-          * strstart-1 and strstart are already inserted. If there is not
-          * enough lookahead, the last two strings are not inserted in
-          * the hash table.
-          */
-         s->lookahead -= s->prev_length-1;
-         s->prev_length -= 2;
-         do {
-            if (++s->strstart <= max_insert) {
-               INSERT_STRING(s, s->strstart, hash_head);
-            }
-         } while (--s->prev_length != 0);
-         s->match_available = 0;
-         s->match_length = MIN_MATCH-1;
-         s->strstart++;
-
-         if (bflush) FLUSH_BLOCK(s, 0);
-
-      } else if (s->match_available) {
-         /* If there was no match at the previous position, output a
-          * single literal. If there was a match but the current match
-          * is longer, truncate the previous match to a single literal.
-          */
-         Tracevv((stderr,"%c", s->window[s->strstart-1]));
-         _tr_tally_lit(s, s->window[s->strstart-1], bflush);
-         if (bflush) {
-            FLUSH_BLOCK_ONLY(s, 0);
-         }
-         s->strstart++;
-         s->lookahead--;
-         if (s->strm->avail_out == 0) return need_more;
-      } else {
-         /* There is no previous match to compare with, wait for
-          * the next step to decide.
-          */
-         s->match_available = 1;
-         s->strstart++;
-         s->lookahead--;
-      }
-   }
-   Assert (flush != Z_NO_FLUSH, "no flush?");
-   if (s->match_available) {
-      Tracevv((stderr,"%c", s->window[s->strstart-1]));
-      _tr_tally_lit(s, s->window[s->strstart-1], bflush);
-      s->match_available = 0;
-   }
-   s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-   if (flush == Z_FINISH) {
-      FLUSH_BLOCK(s, 1);
-      return finish_done;
-   }
-   if (s->last_lit)
-      FLUSH_BLOCK(s, 0);
-   return block_done;
-}
-#endif /* FASTEST */
-
-/* ===========================================================================
- * For Z_RLE, simply look for runs of bytes, generate matches only of distance
- * one.  Do not maintain a hash table.  (It will be regenerated if this run of
- * deflate switches away from Z_RLE.)
- */
-local block_state deflate_rle(deflate_state *s, int flush)
-{
-   int bflush;             /* set if current block must be flushed */
-   uInt prev;              /* byte at distance one to match */
-   Bytef *scan, *strend;   /* scan goes up to strend for length of run */
-
-   for (;;) {
-      /* Make sure that we always have enough lookahead, except
-       * at the end of the input file. We need MAX_MATCH bytes
-       * for the longest run, plus one for the unrolled loop.
-       */
-      if (s->lookahead <= MAX_MATCH) {
-         fill_window(s);
-         if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
-            return need_more;
-         }
-         if (s->lookahead == 0) break; /* flush the current block */
-      }
-
-      /* See how many times the previous byte repeats */
-      s->match_length = 0;
-      if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
-         scan = s->window + s->strstart - 1;
-         prev = *scan;
-         if (prev == *++scan && prev == *++scan && prev == *++scan) {
-            strend = s->window + s->strstart + MAX_MATCH;
-            do {
-            } while (prev == *++scan && prev == *++scan &&
-                  prev == *++scan && prev == *++scan &&
-                  prev == *++scan && prev == *++scan &&
-                  prev == *++scan && prev == *++scan &&
-                  scan < strend);
-            s->match_length = MAX_MATCH - (int)(strend - scan);
-            if (s->match_length > s->lookahead)
-               s->match_length = s->lookahead;
-         }
-         Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
-      }
-
-      /* Emit match if have run of MIN_MATCH or longer, else emit literal */
-      if (s->match_length >= MIN_MATCH) {
-         check_match(s, s->strstart, s->strstart - 1, s->match_length);
-
-         _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
-
-         s->lookahead -= s->match_length;
-         s->strstart += s->match_length;
-         s->match_length = 0;
-      } else {
-         /* No match, output a literal byte */
-         Tracevv((stderr,"%c", s->window[s->strstart]));
-         _tr_tally_lit (s, s->window[s->strstart], bflush);
-         s->lookahead--;
-         s->strstart++;
-      }
-      if (bflush) FLUSH_BLOCK(s, 0);
-   }
-   s->insert = 0;
-   if (flush == Z_FINISH) {
-      FLUSH_BLOCK(s, 1);
-      return finish_done;
-   }
-   if (s->last_lit)
-      FLUSH_BLOCK(s, 0);
-   return block_done;
-}
-
-/* ===========================================================================
- * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
- * (It will be regenerated if this run of deflate switches away from Huffman.)
- */
-local block_state deflate_huff(deflate_state *s, int flush)
-{
-   int bflush;             /* set if current block must be flushed */
-
-   for (;;) {
-      /* Make sure that we have a literal to write. */
-      if (s->lookahead == 0) {
-         fill_window(s);
-         if (s->lookahead == 0) {
-            if (flush == Z_NO_FLUSH)
-               return need_more;
-            break;      /* flush the current block */
-         }
-      }
-
-      /* Output a literal byte */
-      s->match_length = 0;
-      Tracevv((stderr,"%c", s->window[s->strstart]));
-      _tr_tally_lit (s, s->window[s->strstart], bflush);
-      s->lookahead--;
-      s->strstart++;
-      if (bflush) FLUSH_BLOCK(s, 0);
-   }
-   s->insert = 0;
-   if (flush == Z_FINISH) {
-      FLUSH_BLOCK(s, 1);
-      return finish_done;
-   }
-   if (s->last_lit)
-      FLUSH_BLOCK(s, 0);
-   return block_done;
-}
diff --git a/deps/deflate.h b/deps/deflate.h
deleted file mode 100644
index 82fe93e..0000000
--- a/deps/deflate.h
+++ /dev/null
@@ -1,346 +0,0 @@
-/* deflate.h -- internal compression state
- * Copyright (C) 1995-2012 Jean-loup Gailly
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* @(#) $Id$ */
-
-#ifndef DEFLATE_H
-#define DEFLATE_H
-
-#include "zutil.h"
-
-/* define NO_GZIP when compiling if you want to disable gzip header and
-   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
-   the crc code when it is not needed.  For shared libraries, gzip encoding
-   should be left enabled. */
-#ifndef NO_GZIP
-#  define GZIP
-#endif
-
-/* ===========================================================================
- * Internal compression state.
- */
-
-#define LENGTH_CODES 29
-/* number of length codes, not counting the special END_BLOCK code */
-
-#define LITERALS  256
-/* number of literal bytes 0..255 */
-
-#define L_CODES (LITERALS+1+LENGTH_CODES)
-/* number of Literal or Length codes, including the END_BLOCK code */
-
-#define D_CODES   30
-/* number of distance codes */
-
-#define BL_CODES  19
-/* number of codes used to transfer the bit lengths */
-
-#define HEAP_SIZE (2*L_CODES+1)
-/* maximum heap size */
-
-#define MAX_BITS 15
-/* All codes must not exceed MAX_BITS bits */
-
-#define Buf_size 16
-/* size of bit buffer in bi_buf */
-
-#define INIT_STATE    42
-#define EXTRA_STATE   69
-#define NAME_STATE    73
-#define COMMENT_STATE 91
-#define HCRC_STATE   103
-#define BUSY_STATE   113
-#define FINISH_STATE 666
-/* Stream status */
-
-
-/* Data structure describing a single value and its code string. */
-typedef struct ct_data_s {
-    union {
-        ush  freq;       /* frequency count */
-        ush  code;       /* bit string */
-    } fc;
-    union {
-        ush  dad;        /* father node in Huffman tree */
-        ush  len;        /* length of bit string */
-    } dl;
-} FAR ct_data;
-
-#define Freq fc.freq
-#define Code fc.code
-#define Dad  dl.dad
-#define Len  dl.len
-
-typedef struct static_tree_desc_s  static_tree_desc;
-
-typedef struct tree_desc_s {
-    ct_data *dyn_tree;           /* the dynamic tree */
-    int     max_code;            /* largest code with non zero frequency */
-    static_tree_desc *stat_desc; /* the corresponding static tree */
-} FAR tree_desc;
-
-typedef ush Pos;
-typedef Pos FAR Posf;
-typedef unsigned IPos;
-
-/* A Pos is an index in the character window. We use short instead of int to
- * save space in the various tables. IPos is used only for parameter passing.
- */
-
-typedef struct internal_state_deflate {
-    z_streamp strm;      /* pointer back to this zlib stream */
-    int   status;        /* as the name implies */
-    Bytef *pending_buf;  /* output still pending */
-    ulg   pending_buf_size; /* size of pending_buf */
-    Bytef *pending_out;  /* next pending byte to output to the stream */
-    uInt   pending;      /* nb of bytes in the pending buffer */
-    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
-    gz_headerp  gzhead;  /* gzip header information to write */
-    uInt   gzindex;      /* where in extra, name, or comment */
-    Byte  method;        /* can only be DEFLATED */
-    int   last_flush;    /* value of flush param for previous deflate call */
-
-                /* used by deflate.c: */
-
-    uInt  w_size;        /* LZ77 window size (32K by default) */
-    uInt  w_bits;        /* log2(w_size)  (8..16) */
-    uInt  w_mask;        /* w_size - 1 */
-
-    Bytef *window;
-    /* Sliding window. Input bytes are read into the second half of the window,
-     * and move to the first half later to keep a dictionary of at least wSize
-     * bytes. With this organization, matches are limited to a distance of
-     * wSize-MAX_MATCH bytes, but this ensures that IO is always
-     * performed with a length multiple of the block size. Also, it limits
-     * the window size to 64K, which is quite useful on MSDOS.
-     * To do: use the user input buffer as sliding window.
-     */
-
-    ulg window_size;
-    /* Actual size of window: 2*wSize, except when the user input buffer
-     * is directly used as sliding window.
-     */
-
-    Posf *prev;
-    /* Link to older string with same hash index. To limit the size of this
-     * array to 64K, this link is maintained only for the last 32K strings.
-     * An index in this array is thus a window index modulo 32K.
-     */
-
-    Posf *head; /* Heads of the hash chains or NIL. */
-
-    uInt  ins_h;          /* hash index of string to be inserted */
-    uInt  hash_size;      /* number of elements in hash table */
-    uInt  hash_bits;      /* log2(hash_size) */
-    uInt  hash_mask;      /* hash_size-1 */
-
-    uInt  hash_shift;
-    /* Number of bits by which ins_h must be shifted at each input
-     * step. It must be such that after MIN_MATCH steps, the oldest
-     * byte no longer takes part in the hash key, that is:
-     *   hash_shift * MIN_MATCH >= hash_bits
-     */
-
-    long block_start;
-    /* Window position at the beginning of the current output block. Gets
-     * negative when the window is moved backwards.
-     */
-
-    uInt match_length;           /* length of best match */
-    IPos prev_match;             /* previous match */
-    int match_available;         /* set if previous match exists */
-    uInt strstart;               /* start of string to insert */
-    uInt match_start;            /* start of matching string */
-    uInt lookahead;              /* number of valid bytes ahead in window */
-
-    uInt prev_length;
-    /* Length of the best match at previous step. Matches not greater than this
-     * are discarded. This is used in the lazy match evaluation.
-     */
-
-    uInt max_chain_length;
-    /* To speed up deflation, hash chains are never searched beyond this
-     * length.  A higher limit improves compression ratio but degrades the
-     * speed.
-     */
-
-    uInt max_lazy_match;
-    /* Attempt to find a better match only when the current match is strictly
-     * smaller than this value. This mechanism is used only for compression
-     * levels >= 4.
-     */
-#   define max_insert_length  max_lazy_match
-    /* Insert new strings in the hash table only if the match length is not
-     * greater than this length. This saves time but degrades compression.
-     * max_insert_length is used only for compression levels <= 3.
-     */
-
-    int level;    /* compression level (1..9) */
-    int strategy; /* favor or force Huffman coding*/
-
-    uInt good_match;
-    /* Use a faster search when the previous match is longer than this */
-
-    int nice_match; /* Stop searching when current match exceeds this */
-
-                /* used by trees.c: */
-    /* Didn't use ct_data typedef below to suppress compiler warning */
-    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
-    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
-    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
-
-    struct tree_desc_s l_desc;               /* desc. for literal tree */
-    struct tree_desc_s d_desc;               /* desc. for distance tree */
-    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
-
-    ush bl_count[MAX_BITS+1];
-    /* number of codes at each bit length for an optimal tree */
-
-    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
-    int heap_len;               /* number of elements in the heap */
-    int heap_max;               /* element of largest frequency */
-    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
-     * The same heap array is used to build all trees.
-     */
-
-    uch depth[2*L_CODES+1];
-    /* Depth of each subtree used as tie breaker for trees of equal frequency
-     */
-
-    uchf *l_buf;          /* buffer for literals or lengths */
-
-    uInt  lit_bufsize;
-    /* Size of match buffer for literals/lengths.  There are 4 reasons for
-     * limiting lit_bufsize to 64K:
-     *   - frequencies can be kept in 16 bit counters
-     *   - if compression is not successful for the first block, all input
-     *     data is still in the window so we can still emit a stored block even
-     *     when input comes from standard input.  (This can also be done for
-     *     all blocks if lit_bufsize is not greater than 32K.)
-     *   - if compression is not successful for a file smaller than 64K, we can
-     *     even emit a stored file instead of a stored block (saving 5 bytes).
-     *     This is applicable only for zip (not gzip or zlib).
-     *   - creating new Huffman trees less frequently may not provide fast
-     *     adaptation to changes in the input data statistics. (Take for
-     *     example a binary file with poorly compressible code followed by
-     *     a highly compressible string table.) Smaller buffer sizes give
-     *     fast adaptation but have of course the overhead of transmitting
-     *     trees more frequently.
-     *   - I can't count above 4
-     */
-
-    uInt last_lit;      /* running index in l_buf */
-
-    ushf *d_buf;
-    /* Buffer for distances. To simplify the code, d_buf and l_buf have
-     * the same number of elements. To use different lengths, an extra flag
-     * array would be necessary.
-     */
-
-    ulg opt_len;        /* bit length of current block with optimal trees */
-    ulg static_len;     /* bit length of current block with static trees */
-    uInt matches;       /* number of string matches in current block */
-    uInt insert;        /* bytes at end of window left to insert */
-
-#ifdef DEBUG
-    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
-    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
-#endif
-
-    ush bi_buf;
-    /* Output buffer. bits are inserted starting at the bottom (least
-     * significant bits).
-     */
-    int bi_valid;
-    /* Number of valid bits in bi_buf.  All bits above the last valid bit
-     * are always zero.
-     */
-
-    ulg high_water;
-    /* High water mark offset in window for initialized bytes -- bytes above
-     * this are set to zero in order to avoid memory check warnings when
-     * longest match routines access bytes past the input.  This is then
-     * updated to the new high water mark.
-     */
-
-} deflate_state;
-
-/* Output a byte on the stream.
- * IN assertion: there is enough room in pending_buf.
- */
-#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
-
-
-#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
-/* Minimum amount of lookahead, except at the end of the input file.
- * See deflate.c for comments about the MIN_MATCH+1.
- */
-
-#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
-/* In order to simplify the code, particularly on 16 bit machines, match
- * distances are limited to MAX_DIST instead of WSIZE.
- */
-
-#define WIN_INIT MAX_MATCH
-/* Number of bytes after end of data in window to initialize in order to avoid
-   memory checker errors from longest match routines */
-
-        /* in trees.c */
-void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
-int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
-void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
-                        ulg stored_len, int last));
-void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
-                        ulg stored_len, int last));
-
-#define d_code(dist) \
-   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
-/* Mapping from a distance to a distance code. dist is the distance - 1 and
- * must not have side effects. _dist_code[256] and _dist_code[257] are never
- * used.
- */
-
-#ifndef DEBUG
-/* Inline versions of _tr_tally for speed: */
-
-#if defined(GEN_TREES_H) || !defined(STDC)
-  extern uch ZLIB_INTERNAL _length_code[];
-  extern uch ZLIB_INTERNAL _dist_code[];
-#else
-  extern const uch ZLIB_INTERNAL _length_code[];
-  extern const uch ZLIB_INTERNAL _dist_code[];
-#endif
-
-# define _tr_tally_lit(s, c, flush) \
-  { uch cc = (c); \
-    s->d_buf[s->last_lit] = 0; \
-    s->l_buf[s->last_lit++] = cc; \
-    s->dyn_ltree[cc].Freq++; \
-    flush = (s->last_lit == s->lit_bufsize-1); \
-   }
-# define _tr_tally_dist(s, distance, length, flush) \
-  { uch len = (length); \
-    ush dist = (distance); \
-    s->d_buf[s->last_lit] = dist; \
-    s->l_buf[s->last_lit++] = len; \
-    dist--; \
-    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
-    s->dyn_dtree[d_code(dist)].Freq++; \
-    flush = (s->last_lit == s->lit_bufsize-1); \
-  }
-#else
-# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
-# define _tr_tally_dist(s, distance, length, flush) \
-              flush = _tr_tally(s, distance, length)
-#endif
-
-#endif /* DEFLATE_H */
diff --git a/deps/gzclose.c b/deps/gzclose.c
deleted file mode 100644
index edeee03..0000000
--- a/deps/gzclose.c
+++ /dev/null
@@ -1,27 +0,0 @@
-/* gzclose.c -- zlib gzclose() function
- * Copyright (C) 2004, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "gzguts.h"
-
-extern int gzclose_w(gzFile file);
-extern int gzclose_r(gzFile file);
-
-/* gzclose() is in a separate file so that it is linked in only if it is used.
-   That way the other gzclose functions can be used instead to avoid linking in
-   unneeded compression or decompression routines. */
-int gzclose(gzFile file)
-{
-#ifndef NO_GZCOMPRESS
-   gz_statep state;
-
-   if (file == NULL)
-      return Z_STREAM_ERROR;
-   state = (gz_statep)file;
-
-   return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
-#else
-   return gzclose_r(file);
-#endif
-}
diff --git a/deps/gzfile.h b/deps/gzfile.h
deleted file mode 100644
index 2df4842..0000000
--- a/deps/gzfile.h
+++ /dev/null
@@ -1,12 +0,0 @@
-
-#ifndef _GZFILE_H
-#define _GZFILE_H
-
-struct gzFile_s
-{
-   unsigned have;
-   unsigned char *next;
-   z_off64_t pos;
-};
-
-#endif
diff --git a/deps/gzguts.h b/deps/gzguts.h
deleted file mode 100644
index 6068d41..0000000
--- a/deps/gzguts.h
+++ /dev/null
@@ -1,222 +0,0 @@
-/* gzguts.h -- zlib internal header definitions for gz* operations
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#ifndef _GZGUTS_H
-#define _GZGUTS_H
-
-#ifdef _LARGEFILE64_SOURCE
-#  ifndef _LARGEFILE_SOURCE
-#    define _LARGEFILE_SOURCE 1
-#  endif
-#  ifdef _FILE_OFFSET_BITS
-#    undef _FILE_OFFSET_BITS
-#  endif
-#endif
-
-#ifdef HAVE_HIDDEN
-#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-#else
-#  define ZLIB_INTERNAL
-#endif
-
-#include <stdio.h>
-#include "zlib.h"
-#ifdef STDC
-#  include <string.h>
-#  include <stdlib.h>
-#  include <limits.h>
-#endif
-#include <fcntl.h>
-
-#ifdef _WIN32
-#  include <stddef.h>
-#else
-#  include <unistd.h>
-#endif
-
-#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
-#  include <io.h>
-#endif
-
-#ifdef WINAPI_FAMILY
-#  define open _open
-#  define read _read
-#  define write _write
-#  define close _close
-#endif
-
-#ifdef NO_DEFLATE       /* for compatibility with old definition */
-#  define NO_GZCOMPRESS
-#endif
-
-#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
-#  ifndef HAVE_VSNPRINTF
-#    define HAVE_VSNPRINTF
-#  endif
-#endif
-
-#if defined(__CYGWIN__)
-#  ifndef HAVE_VSNPRINTF
-#    define HAVE_VSNPRINTF
-#  endif
-#endif
-
-#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
-#  ifndef HAVE_VSNPRINTF
-#    define HAVE_VSNPRINTF
-#  endif
-#endif
-
-#ifndef HAVE_VSNPRINTF
-#  ifdef MSDOS
-/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
-   but for now we just assume it doesn't. */
-#    define NO_vsnprintf
-#  endif
-#  ifdef __TURBOC__
-#    define NO_vsnprintf
-#  endif
-#  ifdef WIN32
-/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
-#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
-#      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
-#         define vsnprintf _vsnprintf
-#      endif
-#    endif
-#  endif
-#  ifdef __SASC
-#    define NO_vsnprintf
-#  endif
-#  ifdef VMS
-#    define NO_vsnprintf
-#  endif
-#  ifdef __OS400__
-#    define NO_vsnprintf
-#  endif
-#  ifdef __MVS__
-#    define NO_vsnprintf
-#  endif
-#endif
-
-/* unlike snprintf (which is required in C99, yet still not supported by
-   Microsoft more than a decade later!), _snprintf does not guarantee null
-   termination of the result -- however this is only used in gzlib.c where
-   the result is assured to fit in the space provided */
-#ifdef _MSC_VER
-#  define snprintf _snprintf
-#endif
-
-#ifndef local
-#  define local static
-#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-/* gz* functions always use library allocation functions */
-#ifndef STDC
-  extern voidp  malloc OF((uInt size));
-  extern void   free   OF((voidpf ptr));
-#endif
-
-/* get errno and strerror definition */
-#if defined UNDER_CE
-#  include <windows.h>
-#  define zstrerror() gz_strwinerror((DWORD)GetLastError())
-#else
-#  ifndef NO_STRERROR
-#    include <errno.h>
-#    define zstrerror() strerror(errno)
-#  else
-#    define zstrerror() "stdio error (consult errno)"
-#  endif
-#endif
-
-/* provide prototypes for these when building zlib without LFS */
-#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
-#ifndef z_off64_t
-#define z_off64_t z_off_t
-#endif
-
-    gzFile gzopen64 OF((const char *, const char *));
-    z_off64_t gzseek64 OF((gzFile, z_off64_t, int));
-    z_off64_t gztell64 OF((gzFile));
-    z_off64_t gzoffset64 OF((gzFile));
-#endif
-
-/* default memLevel */
-#if MAX_MEM_LEVEL >= 8
-#  define DEF_MEM_LEVEL 8
-#else
-#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#endif
-
-/* default i/o buffer size -- double this for output when reading (this and
-   twice this must be able to fit in an unsigned type) */
-#define GZBUFSIZE 8192
-
-/* gzip modes, also provide a little integrity check on the passed structure */
-#define GZ_NONE 0
-#define GZ_READ 7247
-#define GZ_WRITE 31153
-#define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
-
-/* values for gz_state how */
-#define LOOK 0      /* look for a gzip header */
-#define MODE_COPY 1      /* copy input directly */
-#define MODE_GZIP 2      /* decompress a gzip stream */
-
-#include "gzfile.h"
-
-/* internal gzip file state data structure */
-typedef struct {
-        /* exposed contents for gzgetc() macro */
-    struct gzFile_s x;      /* "x" for exposed */
-                            /* x.have: number of bytes available at x.next */
-                            /* x.next: next output data to deliver or write */
-                            /* x.pos: current position in uncompressed data */
-        /* used for both reading and writing */
-    int mode;               /* see gzip modes above */
-    int fd;                 /* file descriptor */
-    char *path;             /* path or fd for error messages */
-    unsigned size;          /* buffer size, zero if not allocated yet */
-    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
-    unsigned char *in;      /* input buffer */
-    unsigned char *out;     /* output buffer (double-sized when reading) */
-    int direct;             /* 0 if processing gzip, 1 if transparent */
-        /* just for reading */
-    int how;                /* 0: get header, 1: copy, 2: decompress */
-    z_off64_t start;        /* where the gzip data started, for rewinding */
-    int eof;                /* true if end of input file reached */
-    int past;               /* true if read requested past end */
-        /* just for writing */
-    int level;              /* compression level */
-    int strategy;           /* compression strategy */
-        /* seek request */
-    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
-    int seek;               /* true if seek request pending */
-        /* error information */
-    int err;                /* error code */
-    char *msg;              /* error message */
-        /* zlib inflate or deflate stream */
-    z_stream strm;          /* stream structure in-place (not a pointer) */
-} gz_state;
-typedef gz_state FAR *gz_statep;
-
-/* shared functions */
-void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
-#if defined UNDER_CE
-char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
-#endif
-
-/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
-   value -- needed when comparing unsigned to z_off64_t, which is signed
-   (possible z_off64_t types off_t, off64_t, and long are all signed) */
-#ifdef INT_MAX
-#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
-#else
-unsigned ZLIB_INTERNAL gz_intmax OF((void));
-#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
-#endif
-
-#endif
diff --git a/deps/gzlib.c b/deps/gzlib.c
deleted file mode 100644
index 7443a75..0000000
--- a/deps/gzlib.c
+++ /dev/null
@@ -1,604 +0,0 @@
-/* gzlib.c -- zlib functions common to reading and writing gzip files
- * Copyright (C) 2004, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "gzguts.h"
-
-#if defined(_WIN32) && !defined(__BORLANDC__)
-#  define LSEEK _lseeki64
-#else
-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
-#  define LSEEK lseek64
-#else
-#  define LSEEK lseek
-#endif
-#endif
-
-/* Forward declarations */
-z_off_t ZEXPORT gzoffset(gzFile file);
-int ZEXPORT gzbuffer(gzFile file, unsigned size);
-
-/* Local functions */
-local void gz_reset OF((gz_statep));
-local gzFile gz_open OF((const void *, int, const char *));
-
-#if defined UNDER_CE
-
-/* Map the Windows error number in ERROR to a locale-dependent error message
-   string and return a pointer to it.  Typically, the values for ERROR come
-   from GetLastError.
-
-   The string pointed to shall not be modified by the application, but may be
-   overwritten by a subsequent call to gz_strwinerror
-
-   The gz_strwinerror function does not change the current setting of
-   GetLastError. */
-char ZLIB_INTERNAL *gz_strwinerror (error)
-   DWORD error;
-{
-   static char buf[1024];
-
-   wchar_t *msgbuf;
-   DWORD lasterr = GetLastError();
-   DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
-         | FORMAT_MESSAGE_ALLOCATE_BUFFER,
-         NULL,
-         error,
-         0, /* Default language */
-         (LPVOID)&msgbuf,
-         0,
-         NULL);
-   if (chars != 0) {
-      /* If there is an \r\n appended, zap it.  */
-      if (chars >= 2
-            && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
-         chars -= 2;
-         msgbuf[chars] = 0;
-      }
-
-      if (chars > sizeof (buf) - 1) {
-         chars = sizeof (buf) - 1;
-         msgbuf[chars] = 0;
-      }
-
-      wcstombs(buf, msgbuf, chars + 1);
-      LocalFree(msgbuf);
-   }
-   else {
-      sprintf(buf, "unknown win32 error (%ld)", error);
-   }
-
-   SetLastError(lasterr);
-   return buf;
-}
-
-#endif /* UNDER_CE */
-
-/* Reset gzip file state */
-local void gz_reset(gz_statep state)
-{
-   state->x.have = 0;              /* no output data available */
-   if (state->mode == GZ_READ) {   /* for reading ... */
-      state->eof = 0;             /* not at end of file */
-      state->past = 0;            /* have not read past end yet */
-      state->how = LOOK;          /* look for gzip header */
-   }
-   state->seek = 0;                /* no seek request pending */
-   gz_error(state, Z_OK, NULL);    /* clear error */
-   state->x.pos = 0;               /* no uncompressed data yet */
-   state->strm.avail_in = 0;       /* no input data yet */
-}
-
-/* Open a gzip file either by name or file descriptor. */
-local gzFile gz_open(const void *path, int fd, const char *mode)
-{
-   gz_statep state;
-   size_t len;
-   int oflag;
-#ifdef O_CLOEXEC
-   int cloexec = 0;
-#endif
-#ifdef O_EXCL
-   int exclusive = 0;
-#endif
-
-   /* check input */
-   if (path == NULL)
-      return NULL;
-
-   /* allocate gzFile structure to return */
-   state = (gz_statep)malloc(sizeof(gz_state));
-   if (state == NULL)
-      return NULL;
-   state->size = 0;            /* no buffers allocated yet */
-   state->want = GZBUFSIZE;    /* requested buffer size */
-   state->msg = NULL;          /* no error message yet */
-
-   /* interpret mode */
-   state->mode = GZ_NONE;
-   state->level = Z_DEFAULT_COMPRESSION;
-   state->strategy = Z_DEFAULT_STRATEGY;
-   state->direct = 0;
-   while (*mode) {
-      if (*mode >= '0' && *mode <= '9')
-         state->level = *mode - '0';
-      else
-         switch (*mode) {
-            case 'r':
-               state->mode = GZ_READ;
-               break;
-#ifndef NO_GZCOMPRESS
-            case 'w':
-               state->mode = GZ_WRITE;
-               break;
-            case 'a':
-               state->mode = GZ_APPEND;
-               break;
-#endif
-            case '+':       /* can't read and write at the same time */
-               free(state);
-               return NULL;
-            case 'b':       /* ignore -- will request binary anyway */
-               break;
-#ifdef O_CLOEXEC
-            case 'e':
-               cloexec = 1;
-               break;
-#endif
-#ifdef O_EXCL
-            case 'x':
-               exclusive = 1;
-               break;
-#endif
-            case 'f':
-               state->strategy = Z_FILTERED;
-               break;
-            case 'h':
-               state->strategy = Z_HUFFMAN_ONLY;
-               break;
-            case 'R':
-               state->strategy = Z_RLE;
-               break;
-            case 'F':
-               state->strategy = Z_FIXED;
-               break;
-            case 'T':
-               state->direct = 1;
-               break;
-            default:        /* could consider as an error, but just ignore */
-               ;
-         }
-      mode++;
-   }
-
-   /* must provide an "r", "w", or "a" */
-   if (state->mode == GZ_NONE) {
-      free(state);
-      return NULL;
-   }
-
-   /* can't force transparent read */
-   if (state->mode == GZ_READ) {
-      if (state->direct) {
-         free(state);
-         return NULL;
-      }
-      state->direct = 1;      /* for empty file */
-   }
-
-   /* save the path name for error messages */
-#ifdef _WIN32
-   if (fd == -2) {
-      len = wcstombs(NULL, (const wchar_t*)path, 0);
-      if (len == (size_t)-1)
-         len = 0;
-   }
-   else
-#endif
-      len = strlen((const char *)path);
-   state->path = (char *)malloc(len + 1);
-   if (state->path == NULL) {
-      free(state);
-      return NULL;
-   }
-#ifdef _WIN32
-   if (fd == -2)
-      if (len)
-         wcstombs(state->path, (const wchar_t*)path, len + 1);
-      else
-         *(state->path) = 0;
-   else
-#endif
-#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
-      snprintf(state->path, len + 1, "%s", (const char *)path);
-#else
-   strlcpy(state->path, path, sizeof(state->path));
-#endif
-
-   /* compute the flags for open() */
-   oflag =
-#ifdef O_LARGEFILE
-      O_LARGEFILE |
-#endif
-#ifdef O_BINARY
-      O_BINARY |
-#endif
-#ifdef O_CLOEXEC
-      (cloexec ? O_CLOEXEC : 0) |
-#endif
-      (state->mode == GZ_READ ?
-       O_RDONLY :
-       (O_WRONLY | O_CREAT |
-#ifdef O_EXCL
-        (exclusive ? O_EXCL : 0) |
-#endif
-        (state->mode == GZ_WRITE ?
-         O_TRUNC :
-         O_APPEND)));
-
-   /* open the file with the appropriate flags (or just use fd) */
-   state->fd = fd > -1 ? fd : (
-#ifdef _WIN32
-         fd == -2 ? _wopen((const wchar_t*)path, oflag, 0666) :
-#endif
-         open((const char *)path, oflag, 0666));
-   if (state->fd == -1) {
-      free(state->path);
-      free(state);
-      return NULL;
-   }
-   if (state->mode == GZ_APPEND)
-      state->mode = GZ_WRITE;         /* simplify later checks */
-
-   /* save the current position for rewinding (only if reading) */
-   if (state->mode == GZ_READ) {
-      state->start = LSEEK(state->fd, 0, SEEK_CUR);
-      if (state->start == -1) state->start = 0;
-   }
-
-   /* initialize stream */
-   gz_reset(state);
-
-   /* return stream */
-   return (gzFile)state;
-}
-
-/* -- see zlib.h -- */
-gzFile ZEXPORT gzopen(const char *path, const char *mode)
-{
-   return gz_open(path, -1, mode);
-}
-
-/* -- see zlib.h -- */
-gzFile ZEXPORT gzopen64(const char *path, const char *mode)
-{
-   return gz_open(path, -1, mode);
-}
-
-/* -- see zlib.h -- */
-gzFile ZEXPORT gzdopen(int fd, const char *mode)
-{
-   char *path;         /* identifier for error messages */
-   gzFile gz;
-
-   if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
-      return NULL;
-#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
-   snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */
-#else
-   sprintf(path, "<fd:%d>", fd);   /* for debugging */
-#endif
-   gz = gz_open(path, fd, mode);
-   free(path);
-   return gz;
-}
-
-/* -- see zlib.h -- */
-#ifdef _WIN32
-gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode)
-{
-   return gz_open(path, -2, mode);
-}
-#endif
-
-/* -- see zlib.h -- */
-int ZEXPORT gzbuffer(gzFile file, unsigned size)
-{
-   gz_statep state;
-
-   /* get internal structure and check integrity */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-   if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-      return -1;
-
-   /* make sure we haven't already allocated memory */
-   if (state->size != 0)
-      return -1;
-
-   /* check and set requested size */
-   if (size < 2)
-      size = 2;               /* need two bytes to check magic header */
-   state->want = size;
-   return 0;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzrewind(gzFile file)
-{
-   gz_statep state;
-
-   /* get internal structure */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-
-   /* check that we're reading and that there's no error */
-   if (state->mode != GZ_READ ||
-         (state->err != Z_OK && state->err != Z_BUF_ERROR))
-      return -1;
-
-   /* back up and start over */
-   if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
-      return -1;
-   gz_reset(state);
-   return 0;
-}
-
-/* -- see zlib.h -- */
-z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence)
-{
-   unsigned n;
-   z_off64_t ret;
-   gz_statep state;
-
-   /* get internal structure and check integrity */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-   if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-      return -1;
-
-   /* check that there's no error */
-   if (state->err != Z_OK && state->err != Z_BUF_ERROR)
-      return -1;
-
-   /* can only seek from start or relative to current position */
-   if (whence != SEEK_SET && whence != SEEK_CUR)
-      return -1;
-
-   /* normalize offset to a SEEK_CUR specification */
-   if (whence == SEEK_SET)
-      offset -= state->x.pos;
-   else if (state->seek)
-      offset += state->skip;
-   state->seek = 0;
-
-   /* if within raw area while reading, just go there */
-   if (state->mode == GZ_READ && state->how == MODE_COPY &&
-         state->x.pos + offset >= 0) {
-      ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);
-      if (ret == -1)
-         return -1;
-      state->x.have = 0;
-      state->eof = 0;
-      state->past = 0;
-      state->seek = 0;
-      gz_error(state, Z_OK, NULL);
-      state->strm.avail_in = 0;
-      state->x.pos += offset;
-      return state->x.pos;
-   }
-
-   /* calculate skip amount, rewinding if needed for back seek when reading */
-   if (offset < 0) {
-      if (state->mode != GZ_READ)         /* writing -- can't go backwards */
-         return -1;
-      offset += state->x.pos;
-      if (offset < 0)                     /* before start of file! */
-         return -1;
-      if (gzrewind(file) == -1)           /* rewind, then skip to offset */
-         return -1;
-   }
-
-   /* if reading, skip what's in output buffer (one less gzgetc() check) */
-   if (state->mode == GZ_READ) {
-      n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
-         (unsigned)offset : state->x.have;
-      state->x.have -= n;
-      state->x.next += n;
-      state->x.pos += n;
-      offset -= n;
-   }
-
-   /* request skip (if not zero) */
-   if (offset) {
-      state->seek = 1;
-      state->skip = offset;
-   }
-   return state->x.pos + offset;
-}
-
-/* -- see zlib.h -- */
-z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence)
-{
-   z_off64_t ret;
-
-   ret = gzseek64(file, (z_off64_t)offset, whence);
-   return ret == (z_off_t)ret ? (z_off_t)ret : -1;
-}
-
-/* -- see zlib.h -- */
-z_off64_t ZEXPORT gztell64(gzFile file)
-{
-   gz_statep state;
-
-   /* get internal structure and check integrity */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-   if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-      return -1;
-
-   /* return position */
-   return state->x.pos + (state->seek ? state->skip : 0);
-}
-
-/* -- see zlib.h -- */
-z_off_t ZEXPORT gztell(gzFile file)
-{
-   z_off64_t ret;
-
-   ret = gztell64(file);
-   return ret == (z_off_t)ret ? (z_off_t)ret : -1;
-}
-
-/* -- see zlib.h -- */
-z_off64_t ZEXPORT gzoffset64(gzFile file)
-{
-   z_off64_t offset;
-   gz_statep state;
-
-   /* get internal structure and check integrity */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-   if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-      return -1;
-
-   /* compute and return effective offset in file */
-   offset = LSEEK(state->fd, 0, SEEK_CUR);
-   if (offset == -1)
-      return -1;
-   if (state->mode == GZ_READ)             /* reading */
-      offset -= state->strm.avail_in;     /* don't count buffered input */
-   return offset;
-}
-
-/* -- see zlib.h -- */
-z_off_t ZEXPORT gzoffset(gzFile file)
-{
-   z_off64_t ret = gzoffset64(file);
-   return ret == (z_off_t)ret ? (z_off_t)ret : -1;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzeof(gzFile file)
-{
-   gz_statep state;
-
-   /* get internal structure and check integrity */
-   if (file == NULL)
-      return 0;
-   state = (gz_statep)file;
-   if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-      return 0;
-
-   /* return end-of-file state */
-   return state->mode == GZ_READ ? state->past : 0;
-}
-
-/* -- see zlib.h -- */
-const char * ZEXPORT gzerror(gzFile file, int *errnum)
-{
-   gz_statep state;
-
-   /* get internal structure and check integrity */
-   if (file == NULL)
-      return NULL;
-   state = (gz_statep)file;
-   if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-      return NULL;
-
-   /* return error information */
-   if (errnum != NULL)
-      *errnum = state->err;
-   return state->err == Z_MEM_ERROR ? "out of memory" :
-      (state->msg == NULL ? "" : state->msg);
-}
-
-/* -- see zlib.h -- */
-void ZEXPORT gzclearerr(gzFile file)
-{
-   gz_statep state;
-
-   /* get internal structure and check integrity */
-   if (file == NULL)
-      return;
-   state = (gz_statep)file;
-   if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-      return;
-
-   /* clear error and end-of-file */
-   if (state->mode == GZ_READ) {
-      state->eof = 0;
-      state->past = 0;
-   }
-   gz_error(state, Z_OK, NULL);
-}
-
-/* Create an error message in allocated memory and set state->err and
-   state->msg accordingly.  Free any previous error message already there.  Do
-   not try to free or allocate space if the error is Z_MEM_ERROR (out of
-   memory).  Simply save the error message as a static string.  If there is an
-   allocation failure constructing the error message, then convert the error to
-   out of memory. */
-void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
-{
-   /* free previously allocated message and clear */
-   if (state->msg != NULL) {
-      if (state->err != Z_MEM_ERROR)
-         free(state->msg);
-      state->msg = NULL;
-   }
-
-   /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
-   if (err != Z_OK && err != Z_BUF_ERROR)
-      state->x.have = 0;
-
-   /* set error code, and if no message, then done */
-   state->err = err;
-   if (msg == NULL)
-      return;
-
-   /* for an out of memory error, return literal string when requested */
-   if (err == Z_MEM_ERROR)
-      return;
-
-   /* construct error message with path */
-   if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
-         NULL) {
-      state->err = Z_MEM_ERROR;
-      return;
-   }
-#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
-   snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
-         "%s%s%s", state->path, ": ", msg);
-#else
-   strlcpy(state->msg, state->path, sizeof(state->msg));
-   strlcat(state->msg, ": ", sizeof(state->msg));
-   strlcat(state->msg, msg, sizeof(state->msg));
-#endif
-   return;
-}
-
-#ifndef INT_MAX
-/* portably return maximum value for an int (when limits.h presumed not
-   available) -- we need to do this to cover cases where 2's complement not
-   used, since C standard permits 1's complement and sign-bit representations,
-   otherwise we could just use ((unsigned)-1) >> 1 */
-unsigned ZLIB_INTERNAL gz_intmax()
-{
-   unsigned p, q;
-
-   p = 1;
-   do {
-      q = p;
-      p <<= 1;
-      p++;
-   } while (p > q);
-   return q >> 1;
-}
-#endif
diff --git a/deps/gzread.c b/deps/gzread.c
deleted file mode 100644
index 7f6ec7e..0000000
--- a/deps/gzread.c
+++ /dev/null
@@ -1,575 +0,0 @@
-/* gzread.c -- zlib functions for reading gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "gzguts.h"
-
-/* Local functions */
-local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
-local int gz_avail OF((gz_statep));
-local int gz_look OF((gz_statep));
-local int gz_decomp OF((gz_statep));
-local int gz_fetch OF((gz_statep));
-local int gz_skip OF((gz_statep, z_off64_t));
-
-int ZEXPORT gzgetc_(gzFile file);
-
-/* Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from
-   state->fd, and update state->eof, state->err, and state->msg as appropriate.
-   This function needs to loop on read(), since read() is not guaranteed to
-   read the number of bytes requested, depending on the type of descriptor. */
-local int gz_load(gz_statep state, unsigned char *buf, unsigned len, unsigned *have)
-{
-   int ret;
-
-   *have = 0;
-   do {
-      ret = read(state->fd, buf + *have, len - *have);
-      if (ret <= 0)
-         break;
-      *have += ret;
-   } while (*have < len);
-   if (ret < 0) {
-      gz_error(state, Z_ERRNO, zstrerror());
-      return -1;
-   }
-   if (ret == 0)
-      state->eof = 1;
-   return 0;
-}
-
-/* Load up input buffer and set eof flag if last data loaded -- return -1 on
-   error, 0 otherwise.  Note that the eof flag is set when the end of the input
-   file is reached, even though there may be unused data in the buffer.  Once
-   that data has been used, no more attempts will be made to read the file.
-   If strm->avail_in != 0, then the current data is moved to the beginning of
-   the input buffer, and then the remainder of the buffer is loaded with the
-   available data from the input file. */
-local int gz_avail(gz_statep state)
-{
-   unsigned got;
-   z_streamp strm = &(state->strm);
-
-   if (state->err != Z_OK && state->err != Z_BUF_ERROR)
-      return -1;
-   if (state->eof == 0) {
-      if (strm->avail_in) {       /* copy what's there to the start */
-         unsigned char *p = state->in;
-         unsigned const char *q = strm->next_in;
-         unsigned n = strm->avail_in;
-         do {
-            *p++ = *q++;
-         } while (--n);
-      }
-      if (gz_load(state, state->in + strm->avail_in,
-               state->size - strm->avail_in, &got) == -1)
-         return -1;
-      strm->avail_in += got;
-      strm->next_in = state->in;
-   }
-   return 0;
-}
-
-/* Look for gzip header, set up for inflate or copy.  state->x.have must be 0.
-   If this is the first time in, allocate required memory.  state->how will be
-   left unchanged if there is no more input data available, will be set to COPY
-   if there is no gzip header and direct copying will be performed, or it will
-   be set to GZIP for decompression.  If direct copying, then leftover input
-   data from the input buffer will be copied to the output buffer.  In that
-   case, all further file reads will be directly to either the output buffer or
-   a user buffer.  If decompressing, the inflate state will be initialized.
-   gz_look() will return 0 on success or -1 on failure. */
-local int gz_look(gz_statep state)
-{
-   z_streamp strm = &(state->strm);
-
-   /* allocate read buffers and inflate memory */
-   if (state->size == 0) {
-      /* allocate buffers */
-      state->in = (unsigned char *)malloc(state->want);
-      state->out = (unsigned char *)malloc(state->want << 1);
-      if (state->in == NULL || state->out == NULL) {
-         if (state->out != NULL)
-            free(state->out);
-         if (state->in != NULL)
-            free(state->in);
-         gz_error(state, Z_MEM_ERROR, "out of memory");
-         return -1;
-      }
-      state->size = state->want;
-
-      /* allocate inflate memory */
-      state->strm.zalloc = Z_NULL;
-      state->strm.zfree = Z_NULL;
-      state->strm.opaque = Z_NULL;
-      state->strm.avail_in = 0;
-      state->strm.next_in = Z_NULL;
-      if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */
-         free(state->out);
-         free(state->in);
-         state->size = 0;
-         gz_error(state, Z_MEM_ERROR, "out of memory");
-         return -1;
-      }
-   }
-
-   /* get at least the magic bytes in the input buffer */
-   if (strm->avail_in < 2) {
-      if (gz_avail(state) == -1)
-         return -1;
-      if (strm->avail_in == 0)
-         return 0;
-   }
-
-   /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
-      a logical dilemma here when considering the case of a partially written
-      gzip file, to wit, if a single 31 byte is written, then we cannot tell
-      whether this is a single-byte file, or just a partially written gzip
-      file -- for here we assume that if a gzip file is being written, then
-      the header will be written in a single operation, so that reading a
-      single byte is sufficient indication that it is not a gzip file) */
-   if (strm->avail_in > 1 &&
-         strm->next_in[0] == 31 && strm->next_in[1] == 139) {
-      inflateReset(strm);
-      state->how = MODE_GZIP;
-      state->direct = 0;
-      return 0;
-   }
-
-   /* no gzip header -- if we were decoding gzip before, then this is trailing
-      garbage.  Ignore the trailing garbage and finish. */
-   if (state->direct == 0) {
-      strm->avail_in = 0;
-      state->eof = 1;
-      state->x.have = 0;
-      return 0;
-   }
-
-   /* doing raw i/o, copy any leftover input to output -- this assumes that
-      the output buffer is larger than the input buffer, which also assures
-      space for gzungetc() */
-   state->x.next = state->out;
-   if (strm->avail_in) {
-      memcpy(state->x.next, strm->next_in, strm->avail_in);
-      state->x.have = strm->avail_in;
-      strm->avail_in = 0;
-   }
-   state->how = MODE_COPY;
-   state->direct = 1;
-   return 0;
-}
-
-/* Decompress from input to the provided next_out and avail_out in the state.
-   On return, state->x.have and state->x.next point to the just decompressed
-   data.  If the gzip stream completes, state->how is reset to LOOK to look for
-   the next gzip stream or raw data, once state->x.have is depleted.  Returns 0
-   on success, -1 on failure. */
-local int gz_decomp(gz_statep state)
-{
-   int ret = Z_OK;
-   unsigned had;
-   z_streamp strm = &(state->strm);
-
-   /* fill output buffer up to end of deflate stream */
-   had = strm->avail_out;
-   do {
-      /* get more input for inflate() */
-      if (strm->avail_in == 0 && gz_avail(state) == -1)
-         return -1;
-      if (strm->avail_in == 0) {
-         gz_error(state, Z_BUF_ERROR, "unexpected end of file");
-         break;
-      }
-
-      /* decompress and handle errors */
-      ret = inflate(strm, Z_NO_FLUSH);
-      if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
-         gz_error(state, Z_STREAM_ERROR,
-               "internal error: inflate stream corrupt");
-         return -1;
-      }
-      if (ret == Z_MEM_ERROR) {
-         gz_error(state, Z_MEM_ERROR, "out of memory");
-         return -1;
-      }
-      if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
-         gz_error(state, Z_DATA_ERROR,
-               strm->msg == NULL ? "compressed data error" : strm->msg);
-         return -1;
-      }
-   } while (strm->avail_out && ret != Z_STREAM_END);
-
-   /* update available output */
-   state->x.have = had - strm->avail_out;
-   state->x.next = strm->next_out - state->x.have;
-
-   /* if the gzip stream completed successfully, look for another */
-   if (ret == Z_STREAM_END)
-      state->how = LOOK;
-
-   /* good decompression */
-   return 0;
-}
-
-/* Fetch data and put it in the output buffer.  Assumes state->x.have is 0.
-   Data is either copied from the input file or decompressed from the input
-   file depending on state->how.  If state->how is LOOK, then a gzip header is
-   looked for to determine whether to copy or decompress.  Returns -1 on error,
-   otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
-   end of the input file has been reached and all data has been processed.  */
-local int gz_fetch(gz_statep state)
-{
-   z_streamp strm = &(state->strm);
-
-   do {
-      switch(state->how) {
-         case LOOK:      /* -> LOOK, MODE_COPY (only if never GZIP), or MODE_GZIP */
-            if (gz_look(state) == -1)
-               return -1;
-            if (state->how == LOOK)
-               return 0;
-            break;
-         case MODE_COPY:      /* -> MODE_COPY */
-            if (gz_load(state, state->out, state->size << 1, &(state->x.have))
-                  == -1)
-               return -1;
-            state->x.next = state->out;
-            return 0;
-         case MODE_GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
-            strm->avail_out = state->size << 1;
-            strm->next_out = state->out;
-            if (gz_decomp(state) == -1)
-               return -1;
-      }
-   } while (state->x.have == 0 && (!state->eof || strm->avail_in));
-   return 0;
-}
-
-/* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */
-local int gz_skip(gz_statep state, z_off64_t len)
-{
-   unsigned n;
-
-   /* skip over len bytes or reach end-of-file, whichever comes first */
-   while (len)
-      /* skip over whatever is in output buffer */
-      if (state->x.have) {
-         n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
-            (unsigned)len : state->x.have;
-         state->x.have -= n;
-         state->x.next += n;
-         state->x.pos += n;
-         len -= n;
-      }
-
-   /* output buffer empty -- return if we're at the end of the input */
-      else if (state->eof && state->strm.avail_in == 0)
-         break;
-
-   /* need more data to skip -- load up output buffer */
-      else {
-         /* get more output, looking for header if required */
-         if (gz_fetch(state) == -1)
-            return -1;
-      }
-   return 0;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzread(gzFile file, voidp buf, unsigned len)
-{
-   unsigned got, n;
-   gz_statep state;
-   z_streamp strm;
-
-   /* get internal structure */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-   strm = &(state->strm);
-
-   /* check that we're reading and that there's no (serious) error */
-   if (state->mode != GZ_READ ||
-         (state->err != Z_OK && state->err != Z_BUF_ERROR))
-      return -1;
-
-   /* since an int is returned, make sure len fits in one, otherwise return
-      with an error (this avoids the flaw in the interface) */
-   if ((int)len < 0) {
-      gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
-      return -1;
-   }
-
-   /* if len is zero, avoid unnecessary operations */
-   if (len == 0)
-      return 0;
-
-   /* process a skip request */
-   if (state->seek) {
-      state->seek = 0;
-      if (gz_skip(state, state->skip) == -1)
-         return -1;
-   }
-
-   /* get len bytes to buf, or less than len if at the end */
-   got = 0;
-   n = 0;
-   do {
-      /* first just try copying data from the output buffer */
-      if (state->x.have) {
-         n = state->x.have > len ? len : state->x.have;
-         memcpy(buf, state->x.next, n);
-         state->x.next += n;
-         state->x.have -= n;
-      }
-
-      /* output buffer empty -- return if we're at the end of the input */
-      else if (state->eof && strm->avail_in == 0) {
-         state->past = 1;        /* tried to read past end */
-         break;
-      }
-
-      /* need output data -- for small len or new stream load up our output
-         buffer */
-      else if (state->how == LOOK || len < (state->size << 1)) {
-         /* get more output, looking for header if required */
-         if (gz_fetch(state) == -1)
-            return -1;
-         continue;       /* no progress yet -- go back to copy above */
-         /* the copy above assures that we will leave with space in the
-            output buffer, allowing at least one gzungetc() to succeed */
-      }
-
-      /* large len -- read directly into user buffer */
-      else if (state->how == MODE_COPY) {      /* read directly */
-         if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
-            return -1;
-      }
-
-      /* large len -- decompress directly into user buffer */
-      else {  /* state->how == GZIP */
-         strm->avail_out = len;
-         strm->next_out = (unsigned char *)buf;
-         if (gz_decomp(state) == -1)
-            return -1;
-         n = state->x.have;
-         state->x.have = 0;
-      }
-
-      /* update progress */
-      len -= n;
-      buf = (char *)buf + n;
-      got += n;
-      state->x.pos += n;
-   } while (len);
-
-   /* return number of bytes read into user buffer (will fit in int) */
-   return (int)got;
-}
-
-/* -- see zlib.h -- */
-#ifdef Z_PREFIX_SET
-#  undef z_gzgetc
-#else
-#  undef gzgetc
-#endif
-int ZEXPORT gzgetc(gzFile file)
-{
-   int ret;
-   unsigned char buf[1];
-   gz_statep state;
-
-   /* get internal structure */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-
-   /* check that we're reading and that there's no (serious) error */
-   if (state->mode != GZ_READ ||
-         (state->err != Z_OK && state->err != Z_BUF_ERROR))
-      return -1;
-
-   /* try output buffer (no need to check for skip request) */
-   if (state->x.have) {
-      state->x.have--;
-      state->x.pos++;
-      return *(state->x.next)++;
-   }
-
-   /* nothing there -- try gzread() */
-   ret = gzread(file, buf, 1);
-   return ret < 1 ? -1 : buf[0];
-}
-
-int ZEXPORT gzgetc_(gzFile file)
-{
-   return gzgetc(file);
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzungetc(int c, gzFile file)
-{
-   gz_statep state;
-
-   /* get internal structure */
-   if (file == NULL)
-      return -1;
-   state = (gz_statep)file;
-
-   /* check that we're reading and that there's no (serious) error */
-   if (state->mode != GZ_READ ||
-         (state->err != Z_OK && state->err != Z_BUF_ERROR))
-      return -1;
-
-   /* process a skip request */
-   if (state->seek) {
-      state->seek = 0;
-      if (gz_skip(state, state->skip) == -1)
-         return -1;
-   }
-
-   /* can't push EOF */
-   if (c < 0)
-      return -1;
-
-   /* if output buffer empty, put byte at end (allows more pushing) */
-   if (state->x.have == 0) {
-      state->x.have = 1;
-      state->x.next = state->out + (state->size << 1) - 1;
-      state->x.next[0] = c;
-      state->x.pos--;
-      state->past = 0;
-      return c;
-   }
-
-   /* if no room, give up (must have already done a gzungetc()) */
-   if (state->x.have == (state->size << 1)) {
-      gz_error(state, Z_DATA_ERROR, "out of room to push characters");
-      return -1;
-   }
-
-   /* slide output data if needed and insert byte before existing data */
-   if (state->x.next == state->out) {
-      unsigned char *src = state->out + state->x.have;
-      unsigned char *dest = state->out + (state->size << 1);
-      while (src > state->out)
-         *--dest = *--src;
-      state->x.next = dest;
-   }
-   state->x.have++;
-   state->x.next--;
-   state->x.next[0] = c;
-   state->x.pos--;
-   state->past = 0;
-   return c;
-}
-
-/* -- see zlib.h -- */
-char * ZEXPORT gzgets(gzFile file, char *buf, int len)
-{
-   unsigned left, n;
-   char *str;
-   unsigned char *eol;
-   gz_statep state;
-
-   /* check parameters and get internal structure */
-   if (file == NULL || buf == NULL || len < 1)
-      return NULL;
-   state = (gz_statep)file;
-
-   /* check that we're reading and that there's no (serious) error */
-   if (state->mode != GZ_READ ||
-         (state->err != Z_OK && state->err != Z_BUF_ERROR))
-      return NULL;
-
-   /* process a skip request */
-   if (state->seek) {
-      state->seek = 0;
-      if (gz_skip(state, state->skip) == -1)
-         return NULL;
-   }
-
-   /* copy output bytes up to new line or len - 1, whichever comes first --
-      append a terminating zero to the string (we don't check for a zero in
-      the contents, let the user worry about that) */
-   str = buf;
-   left = (unsigned)len - 1;
-   if (left) do {
-      /* assure that something is in the output buffer */
-      if (state->x.have == 0 && gz_fetch(state) == -1)
-         return NULL;                /* error */
-      if (state->x.have == 0) {       /* end of file */
-         state->past = 1;            /* read past end */
-         break;                      /* return what we have */
-      }
-
-      /* look for end-of-line in current output buffer */
-      n = state->x.have > left ? left : state->x.have;
-      eol = (unsigned char *)memchr(state->x.next, '\n', n);
-      if (eol != NULL)
-         n = (unsigned)(eol - state->x.next) + 1;
-
-      /* copy through end-of-line, or remainder if not found */
-      memcpy(buf, state->x.next, n);
-      state->x.have -= n;
-      state->x.next += n;
-      state->x.pos += n;
-      left -= n;
-      buf += n;
-   } while (left && eol == NULL);
-
-   /* return terminated string, or if nothing, end of file */
-   if (buf == str)
-      return NULL;
-   buf[0] = 0;
-   return str;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzdirect(gzFile file)
-{
-   gz_statep state;
-
-   /* get internal structure */
-   if (file == NULL)
-      return 0;
-   state = (gz_statep)file;
-
-   /* if the state is not known, but we can find out, then do so (this is
-      mainly for right after a gzopen() or gzdopen()) */
-   if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
-      (void)gz_look(state);
-
-   /* return 1 if transparent, 0 if processing a gzip stream */
-   return state->direct;
-}
-
-/* -- see zlib.h -- */
-int gzclose_r(gzFile file)
-{
-   int ret, err;
-   gz_statep state;
-
-   /* get internal structure */
-   if (file == NULL)
-      return Z_STREAM_ERROR;
-   state = (gz_statep)file;
-
-   /* check that we're reading */
-   if (state->mode != GZ_READ)
-      return Z_STREAM_ERROR;
-
-   /* free memory and close file */
-   if (state->size) {
-      inflateEnd(&(state->strm));
-      free(state->out);
-      free(state->in);
-   }
-   err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
-   gz_error(state, Z_OK, NULL);
-   free(state->path);
-   ret = close(state->fd);
-   free(state);
-   return ret ? Z_ERRNO : err;
-}
diff --git a/deps/gzwrite.c b/deps/gzwrite.c
deleted file mode 100644
index 61b217e..0000000
--- a/deps/gzwrite.c
+++ /dev/null
@@ -1,557 +0,0 @@
-/* gzwrite.c -- zlib functions for writing gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "gzguts.h"
-
-/* Local functions */
-local int gz_init OF((gz_statep));
-local int gz_comp OF((gz_statep, int));
-local int gz_zero OF((gz_statep, z_off64_t));
-
-int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va);
-
-/* Initialize state for writing a gzip file.  Mark initialization by setting
-   state->size to non-zero.  Return -1 on failure or 0 on success. */
-local int gz_init(gz_statep state)
-{
-    int ret;
-    z_streamp strm = &(state->strm);
-
-    /* allocate input buffer */
-    state->in = (unsigned char *)malloc(state->want);
-    if (state->in == NULL) {
-        gz_error(state, Z_MEM_ERROR, "out of memory");
-        return -1;
-    }
-
-    /* only need output buffer and deflate state if compressing */
-    if (!state->direct) {
-        /* allocate output buffer */
-        state->out = (unsigned char *)malloc(state->want);
-        if (state->out == NULL) {
-            free(state->in);
-            gz_error(state, Z_MEM_ERROR, "out of memory");
-            return -1;
-        }
-
-        /* allocate deflate memory, set up for gzip compression */
-        strm->zalloc = Z_NULL;
-        strm->zfree = Z_NULL;
-        strm->opaque = Z_NULL;
-        ret = deflateInit2(strm, state->level, Z_DEFLATED,
-                           MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
-        if (ret != Z_OK) {
-            free(state->out);
-            free(state->in);
-            gz_error(state, Z_MEM_ERROR, "out of memory");
-            return -1;
-        }
-    }
-
-    /* mark state as initialized */
-    state->size = state->want;
-
-    /* initialize write buffer if compressing */
-    if (!state->direct) {
-        strm->avail_out = state->size;
-        strm->next_out = state->out;
-        state->x.next = strm->next_out;
-    }
-    return 0;
-}
-
-/* Compress whatever is at avail_in and next_in and write to the output file.
-   Return -1 if there is an error writing to the output file, otherwise 0.
-   flush is assumed to be a valid deflate() flush value.  If flush is Z_FINISH,
-   then the deflate() state is reset to start a new gzip stream.  If gz->direct
-   is true, then simply write to the output file without compressing, and
-   ignore flush. */
-local int gz_comp(gz_statep state, int flush)
-{
-    int ret, got;
-    unsigned have;
-    z_streamp strm = &(state->strm);
-
-    /* allocate memory if this is the first time through */
-    if (state->size == 0 && gz_init(state) == -1)
-        return -1;
-
-    /* write directly if requested */
-    if (state->direct) {
-        got = write(state->fd, strm->next_in, strm->avail_in);
-        if (got < 0 || (unsigned)got != strm->avail_in) {
-            gz_error(state, Z_ERRNO, zstrerror());
-            return -1;
-        }
-        strm->avail_in = 0;
-        return 0;
-    }
-
-    /* run deflate() on provided input until it produces no more output */
-    ret = Z_OK;
-    do {
-        /* write out current buffer contents if full, or if flushing, but if
-           doing Z_FINISH then don't write until we get to Z_STREAM_END */
-        if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
-            (flush != Z_FINISH || ret == Z_STREAM_END))) {
-            have = (unsigned)(strm->next_out - state->x.next);
-            if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||
-                         (unsigned)got != have)) {
-                gz_error(state, Z_ERRNO, zstrerror());
-                return -1;
-            }
-            if (strm->avail_out == 0) {
-                strm->avail_out = state->size;
-                strm->next_out = state->out;
-            }
-            state->x.next = strm->next_out;
-        }
-
-        /* compress */
-        have = strm->avail_out;
-        ret = deflate(strm, flush);
-        if (ret == Z_STREAM_ERROR) {
-            gz_error(state, Z_STREAM_ERROR,
-                      "internal error: deflate stream corrupt");
-            return -1;
-        }
-        have -= strm->avail_out;
-    } while (have);
-
-    /* if that completed a deflate stream, allow another to start */
-    if (flush == Z_FINISH)
-        deflateReset(strm);
-
-    /* all done, no errors */
-    return 0;
-}
-
-/* Compress len zeros to output.  Return -1 on error, 0 on success. */
-local int gz_zero(gz_statep state, z_off64_t len)
-{
-    int first;
-    unsigned n;
-    z_streamp strm = &(state->strm);
-
-    /* consume whatever's left in the input buffer */
-    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
-        return -1;
-
-    /* compress len zeros (len guaranteed > 0) */
-    first = 1;
-    while (len) {
-        n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
-            (unsigned)len : state->size;
-        if (first) {
-            memset(state->in, 0, n);
-            first = 0;
-        }
-        strm->avail_in = n;
-        strm->next_in = state->in;
-        state->x.pos += n;
-        if (gz_comp(state, Z_NO_FLUSH) == -1)
-            return -1;
-        len -= n;
-    }
-    return 0;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len)
-{
-    unsigned put = len;
-    gz_statep state;
-    z_streamp strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return 0;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return 0;
-
-    /* since an int is returned, make sure len fits in one, otherwise return
-       with an error (this avoids the flaw in the interface) */
-    if ((int)len < 0) {
-        gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
-        return 0;
-    }
-
-    /* if len is zero, avoid unnecessary operations */
-    if (len == 0)
-        return 0;
-
-    /* allocate memory if this is the first time through */
-    if (state->size == 0 && gz_init(state) == -1)
-        return 0;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return 0;
-    }
-
-    /* for small len, copy to input buffer, otherwise compress directly */
-    if (len < state->size) {
-        /* copy to input buffer, compress when full */
-        do {
-            unsigned have, copy;
-
-            if (strm->avail_in == 0)
-                strm->next_in = state->in;
-            have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
-            copy = state->size - have;
-            if (copy > len)
-                copy = len;
-            memcpy(state->in + have, buf, copy);
-            strm->avail_in += copy;
-            state->x.pos += copy;
-            buf = (const char *)buf + copy;
-            len -= copy;
-            if (len && gz_comp(state, Z_NO_FLUSH) == -1)
-                return 0;
-        } while (len);
-    }
-    else {
-        /* consume whatever's left in the input buffer */
-        if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
-            return 0;
-
-        /* directly compress user buffer to file */
-        strm->avail_in = len;
-        strm->next_in = (Bytef *)buf;
-        state->x.pos += len;
-        if (gz_comp(state, Z_NO_FLUSH) == -1)
-            return 0;
-    }
-
-    /* input was all buffered or compressed (put will fit in int) */
-    return (int)put;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzputc(gzFile file, int c)
-{
-    unsigned have;
-    unsigned char buf[1];
-    gz_statep state;
-    z_streamp strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return -1;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* try writing to input buffer for speed (state->size == 0 if buffer not
-       initialized) */
-    if (state->size) {
-        if (strm->avail_in == 0)
-            strm->next_in = state->in;
-        have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
-        if (have < state->size) {
-            state->in[have] = c;
-            strm->avail_in++;
-            state->x.pos++;
-            return c & 0xff;
-        }
-    }
-
-    /* no room in buffer or not initialized, use gz_write() */
-    buf[0] = c;
-    if (gzwrite(file, buf, 1) != 1)
-        return -1;
-    return c & 0xff;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzputs(gzFile file, const char *str)
-{
-    int ret;
-    unsigned len;
-
-    /* write string */
-    len = (unsigned)strlen(str);
-    ret = gzwrite(file, str, len);
-    return ret == 0 && len != 0 ? -1 : ret;
-}
-
-#if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#include <stdarg.h>
-
-/* -- see zlib.h -- */
-int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
-{
-    int size, len;
-    gz_statep state;
-    z_streamp strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return 0;
-
-    /* make sure we have some buffer space */
-    if (state->size == 0 && gz_init(state) == -1)
-        return 0;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return 0;
-    }
-
-    /* consume whatever's left in the input buffer */
-    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
-        return 0;
-
-    /* do the printf() into the input buffer, put length in len */
-    size = (int)(state->size);
-    state->in[size - 1] = 0;
-#ifdef NO_vsnprintf
-#  ifdef HAS_vsprintf_void
-    (void)vsprintf((char *)(state->in), format, va);
-    for (len = 0; len < size; len++)
-        if (state->in[len] == 0) break;
-#  else
-    len = vsprintf((char *)(state->in), format, va);
-#  endif
-#else
-#  ifdef HAS_vsnprintf_void
-    (void)vsnprintf((char *)(state->in), size, format, va);
-    len = strlen((char *)(state->in));
-#  else
-    len = vsnprintf((char *)(state->in), size, format, va);
-#  endif
-#endif
-
-    /* check that printf() results fit in buffer */
-    if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
-        return 0;
-
-    /* update buffer and position, defer compression until needed */
-    strm->avail_in = (unsigned)len;
-    strm->next_in = state->in;
-    state->x.pos += len;
-    return len;
-}
-
-int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
-{
-    va_list va;
-    int ret;
-
-    va_start(va, format);
-    ret = gzvprintf(file, format, va);
-    va_end(va);
-    return ret;
-}
-
-#else /* !STDC && !Z_HAVE_STDARG_H */
-
-/* -- see zlib.h -- */
-int ZEXPORTVA gzprintf (gzFile file, const char *format, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10,
-                       int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
-{
-    int size, len;
-    gz_statep state;
-    z_streamp strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that can really pass pointer in ints */
-    if (sizeof(int) != sizeof(void *))
-        return 0;
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return 0;
-
-    /* make sure we have some buffer space */
-    if (state->size == 0 && gz_init(state) == -1)
-        return 0;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return 0;
-    }
-
-    /* consume whatever's left in the input buffer */
-    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
-        return 0;
-
-    /* do the printf() into the input buffer, put length in len */
-    size = (int)(state->size);
-    state->in[size - 1] = 0;
-#ifdef NO_snprintf
-#  ifdef HAS_sprintf_void
-    sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
-            a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
-    for (len = 0; len < size; len++)
-        if (state->in[len] == 0) break;
-#  else
-    len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
-                  a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
-#  endif
-#else
-#  ifdef HAS_snprintf_void
-    snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8,
-             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
-    len = strlen((char *)(state->in));
-#  else
-    len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6,
-                   a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
-                   a19, a20);
-#  endif
-#endif
-
-    /* check that printf() results fit in buffer */
-    if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
-        return 0;
-
-    /* update buffer and position, defer compression until needed */
-    strm->avail_in = (unsigned)len;
-    strm->next_in = state->in;
-    state->x.pos += len;
-    return len;
-}
-
-#endif
-
-/* -- see zlib.h -- */
-int ZEXPORT gzflush(gzFile file, int flush)
-{
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return Z_STREAM_ERROR;
-
-    /* check flush parameter */
-    if (flush < 0 || flush > Z_FINISH)
-        return Z_STREAM_ERROR;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* compress remaining data with requested flush */
-    gz_comp(state, flush);
-    return state->err;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzsetparams(gzFile file, int level, int strategy)
-{
-    gz_statep state;
-    z_streamp strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return Z_STREAM_ERROR;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return Z_STREAM_ERROR;
-
-    /* if no change is requested, then do nothing */
-    if (level == state->level && strategy == state->strategy)
-        return Z_OK;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* change compression parameters for subsequent input */
-    if (state->size) {
-        /* flush previous input with previous parameters before changing */
-        if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
-            return state->err;
-        deflateParams(strm, level, strategy);
-    }
-    state->level = level;
-    state->strategy = strategy;
-    return Z_OK;
-}
-
-/* -- see zlib.h -- */
-int gzclose_w(gzFile file)
-{
-    int ret = Z_OK;
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return Z_STREAM_ERROR;
-    state = (gz_statep)file;
-
-    /* check that we're writing */
-    if (state->mode != GZ_WRITE)
-        return Z_STREAM_ERROR;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            ret = state->err;
-    }
-
-    /* flush, free memory, and close file */
-    if (gz_comp(state, Z_FINISH) == -1)
-        ret = state->err;
-    if (state->size) {
-        if (!state->direct) {
-            (void)deflateEnd(&(state->strm));
-            free(state->out);
-        }
-        free(state->in);
-    }
-    gz_error(state, Z_OK, NULL);
-    free(state->path);
-    if (close(state->fd) == -1)
-        ret = Z_ERRNO;
-    free(state);
-    return ret;
-}
diff --git a/deps/infback.c b/deps/infback.c
deleted file mode 100644
index 7206cde..0000000
--- a/deps/infback.c
+++ /dev/null
@@ -1,628 +0,0 @@
-/* infback.c -- inflate using a call-back interface
- * Copyright (C) 1995-2011 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
-   This code is largely copied from inflate.c.  Normally either infback.o or
-   inflate.o would be linked into an application--not both.  The interface
-   with inffast.c is retained so that optimized assembler-coded versions of
-   inflate_fast() can be used with either inflate.c or infback.c.
-   */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-/* function prototypes */
-local void fixedtables OF((struct inflate_state FAR *state));
-
-/*
-   strm provides memory allocation functions in zalloc and zfree, or
-   Z_NULL to use the library memory allocation functions.
-
-   windowBits is in the range 8..15, and window is a user-supplied
-   window and output buffer that is 2**windowBits bytes.
-   */
-int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size)
-{
-   struct inflate_state FAR *state;
-
-   if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
-         stream_size != (int)(sizeof(z_stream)))
-      return Z_VERSION_ERROR;
-   if (strm == Z_NULL || window == Z_NULL ||
-         windowBits < 8 || windowBits > 15)
-      return Z_STREAM_ERROR;
-   strm->msg = Z_NULL;                 /* in case we return an error */
-   if (strm->zalloc == (alloc_func)0) {
-#ifdef Z_SOLO
-      return Z_STREAM_ERROR;
-#else
-      strm->zalloc = zcalloc;
-      strm->opaque = (voidpf)0;
-#endif
-   }
-   if (strm->zfree == Z_NULL)
-#ifdef Z_SOLO
-      return Z_STREAM_ERROR;
-#else
-   strm->zfree = zcfree;
-#endif
-   state = (struct inflate_state FAR *)ZALLOC(strm, 1,
-         sizeof(struct inflate_state));
-   if (state == Z_NULL) return Z_MEM_ERROR;
-   Tracev((stderr, "inflate: allocated\n"));
-   strm->state = (struct internal_state FAR *)state;
-   state->dmax = 32768U;
-   state->wbits = windowBits;
-   state->wsize = 1U << windowBits;
-   state->window = window;
-   state->wnext = 0;
-   state->whave = 0;
-   return Z_OK;
-}
-
-/*
-   Return state with length and distance decoding tables and index sizes set to
-   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
-   If BUILDFIXED is defined, then instead this routine builds the tables the
-   first time it's called, and returns those tables the first time and
-   thereafter.  This reduces the size of the code by about 2K bytes, in
-   exchange for a little execution time.  However, BUILDFIXED should not be
-   used for threaded applications, since the rewriting of the tables and virgin
-   may not be thread-safe.
-   */
-local void fixedtables(struct inflate_state FAR *state)
-{
-#ifdef BUILDFIXED
-   static int virgin = 1;
-   static code *lenfix, *distfix;
-   static code fixed[544];
-
-   /* build fixed huffman tables if first call (may not be thread safe) */
-   if (virgin) {
-      unsigned sym, bits;
-      static code *next;
-
-      /* literal/length table */
-      sym = 0;
-      while (sym < 144) state->lens[sym++] = 8;
-      while (sym < 256) state->lens[sym++] = 9;
-      while (sym < 280) state->lens[sym++] = 7;
-      while (sym < 288) state->lens[sym++] = 8;
-      next = fixed;
-      lenfix = next;
-      bits = 9;
-      inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
-
-      /* distance table */
-      sym = 0;
-      while (sym < 32) state->lens[sym++] = 5;
-      distfix = next;
-      bits = 5;
-      inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
-
-      /* do this just once */
-      virgin = 0;
-   }
-#else /* !BUILDFIXED */
-#   include "inffixed.h"
-#endif /* BUILDFIXED */
-   state->lencode = lenfix;
-   state->lenbits = 9;
-   state->distcode = distfix;
-   state->distbits = 5;
-}
-
-/* Macros for inflateBack(): */
-
-/* Load returned state from inflate_fast() */
-#define LOAD() \
-   do { \
-      put = strm->next_out; \
-      left = strm->avail_out; \
-      next = strm->next_in; \
-      have = strm->avail_in; \
-      hold = state->hold; \
-      bits = state->bits; \
-   } while (0)
-
-/* Set state from registers for inflate_fast() */
-#define RESTORE() \
-   do { \
-      strm->next_out = put; \
-      strm->avail_out = left; \
-      strm->next_in = next; \
-      strm->avail_in = have; \
-      state->hold = hold; \
-      state->bits = bits; \
-   } while (0)
-
-/* Clear the input bit accumulator */
-#define INITBITS() \
-   do { \
-      hold = 0; \
-      bits = 0; \
-   } while (0)
-
-/* Assure that some input is available.  If input is requested, but denied,
-   then return a Z_BUF_ERROR from inflateBack(). */
-#define PULL() \
-   do { \
-      if (have == 0) { \
-         have = in(in_desc, &next); \
-         if (have == 0) { \
-            next = Z_NULL; \
-            ret = Z_BUF_ERROR; \
-            goto inf_leave; \
-         } \
-      } \
-   } while (0)
-
-/* Get a byte of input into the bit accumulator, or return from inflateBack()
-   with an error if there is no input available. */
-#define PULLBYTE() \
-   do { \
-      PULL(); \
-      have--; \
-      hold += (unsigned long)(*next++) << bits; \
-      bits += 8; \
-   } while (0)
-
-/* Assure that there are at least n bits in the bit accumulator.  If there is
-   not enough available input to do that, then return from inflateBack() with
-   an error. */
-#define NEEDBITS(n) \
-   do { \
-      while (bits < (unsigned)(n)) \
-      PULLBYTE(); \
-   } while (0)
-
-/* Return the low n bits of the bit accumulator (n < 16) */
-#define BITS(n) \
-   ((unsigned)hold & ((1U << (n)) - 1))
-
-/* Remove n bits from the bit accumulator */
-#define DROPBITS(n) \
-   do { \
-      hold >>= (n); \
-      bits -= (unsigned)(n); \
-   } while (0)
-
-/* Remove zero to seven bits as needed to go to a byte boundary */
-#define BYTEBITS() \
-   do { \
-      hold >>= bits & 7; \
-      bits -= bits & 7; \
-   } while (0)
-
-/* Assure that some output space is available, by writing out the window
-   if it's full.  If the write fails, return from inflateBack() with a
-   Z_BUF_ERROR. */
-#define ROOM() \
-   do { \
-      if (left == 0) { \
-         put = state->window; \
-         left = state->wsize; \
-         state->whave = left; \
-         if (out(out_desc, put, left)) { \
-            ret = Z_BUF_ERROR; \
-            goto inf_leave; \
-         } \
-      } \
-   } while (0)
-
-/*
-   strm provides the memory allocation functions and window buffer on input,
-   and provides information on the unused input on return.  For Z_DATA_ERROR
-   returns, strm will also provide an error message.
-
-   in() and out() are the call-back input and output functions.  When
-   inflateBack() needs more input, it calls in().  When inflateBack() has
-   filled the window with output, or when it completes with data in the
-   window, it calls out() to write out the data.  The application must not
-   change the provided input until in() is called again or inflateBack()
-   returns.  The application must not change the window/output buffer until
-   inflateBack() returns.
-
-   in() and out() are called with a descriptor parameter provided in the
-   inflateBack() call.  This parameter can be a structure that provides the
-   information required to do the read or write, as well as accumulated
-   information on the input and output such as totals and check values.
-
-   in() should return zero on failure.  out() should return non-zero on
-   failure.  If either in() or out() fails, than inflateBack() returns a
-   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
-   was in() or out() that caused in the error.  Otherwise,  inflateBack()
-   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
-   error, or Z_MEM_ERROR if it could not allocate memory for the state.
-   inflateBack() can also return Z_STREAM_ERROR if the input parameters
-   are not correct, i.e. strm is Z_NULL or the state was not initialized.
-   */
-int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc)
-{
-   struct inflate_state FAR *state;
-   z_const unsigned char FAR *next;    /* next input */
-   unsigned char FAR *put;     /* next output */
-   unsigned have, left;        /* available input and output */
-   unsigned long hold;         /* bit buffer */
-   unsigned bits;              /* bits in bit buffer */
-   unsigned copy;              /* number of stored or match bytes to copy */
-   unsigned char FAR *from;    /* where to copy match bytes from */
-   code here;                  /* current decoding table entry */
-   code last;                  /* parent table entry */
-   unsigned len;               /* length to copy for repeats, bits to drop */
-   int ret;                    /* return code */
-   static const unsigned short order[19] = /* permutation of code lengths */
-   {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-
-   /* Check that the strm exists and that the state was initialized */
-   if (strm == Z_NULL || strm->state == Z_NULL)
-      return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-
-   /* Reset the state */
-   strm->msg = Z_NULL;
-   state->mode = TYPE;
-   state->last = 0;
-   state->whave = 0;
-   next = strm->next_in;
-   have = next != Z_NULL ? strm->avail_in : 0;
-   hold = 0;
-   bits = 0;
-   put = state->window;
-   left = state->wsize;
-
-   /* Inflate until end of block marked as last */
-   for (;;)
-      switch (state->mode) {
-         case TYPE:
-            /* determine and dispatch block type */
-            if (state->last) {
-               BYTEBITS();
-               state->mode = DONE;
-               break;
-            }
-            NEEDBITS(3);
-            state->last = BITS(1);
-            DROPBITS(1);
-            switch (BITS(2)) {
-               case 0:                             /* stored block */
-                  Tracev((stderr, "inflate:     stored block%s\n",
-                           state->last ? " (last)" : ""));
-                  state->mode = STORED;
-                  break;
-               case 1:                             /* fixed block */
-                  fixedtables(state);
-                  Tracev((stderr, "inflate:     fixed codes block%s\n",
-                           state->last ? " (last)" : ""));
-                  state->mode = LEN;              /* decode codes */
-                  break;
-               case 2:                             /* dynamic block */
-                  Tracev((stderr, "inflate:     dynamic codes block%s\n",
-                           state->last ? " (last)" : ""));
-                  state->mode = TABLE;
-                  break;
-               case 3:
-                  strm->msg = (char *)"invalid block type";
-                  state->mode = BAD;
-            }
-            DROPBITS(2);
-            break;
-
-         case STORED:
-            /* get and verify stored block length */
-            BYTEBITS();                         /* go to byte boundary */
-            NEEDBITS(32);
-            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-               strm->msg = (char *)"invalid stored block lengths";
-               state->mode = BAD;
-               break;
-            }
-            state->length = (unsigned)hold & 0xffff;
-            Tracev((stderr, "inflate:       stored length %u\n",
-                     state->length));
-            INITBITS();
-
-            /* copy stored block from input to output */
-            while (state->length != 0) {
-               copy = state->length;
-               PULL();
-               ROOM();
-               if (copy > have) copy = have;
-               if (copy > left) copy = left;
-               zmemcpy(put, next, copy);
-               have -= copy;
-               next += copy;
-               left -= copy;
-               put += copy;
-               state->length -= copy;
-            }
-            Tracev((stderr, "inflate:       stored end\n"));
-            state->mode = TYPE;
-            break;
-
-         case TABLE:
-            /* get dynamic table entries descriptor */
-            NEEDBITS(14);
-            state->nlen = BITS(5) + 257;
-            DROPBITS(5);
-            state->ndist = BITS(5) + 1;
-            DROPBITS(5);
-            state->ncode = BITS(4) + 4;
-            DROPBITS(4);
-#ifndef PKZIP_BUG_WORKAROUND
-            if (state->nlen > 286 || state->ndist > 30) {
-               strm->msg = (char *)"too many length or distance symbols";
-               state->mode = BAD;
-               break;
-            }
-#endif
-            Tracev((stderr, "inflate:       table sizes ok\n"));
-
-            /* get code length code lengths (not a typo) */
-            state->have = 0;
-            while (state->have < state->ncode) {
-               NEEDBITS(3);
-               state->lens[order[state->have++]] = (unsigned short)BITS(3);
-               DROPBITS(3);
-            }
-            while (state->have < 19)
-               state->lens[order[state->have++]] = 0;
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 7;
-            ret = inflate_table(CODES, state->lens, 19, &(state->next),
-                  &(state->lenbits), state->work);
-            if (ret) {
-               strm->msg = (char *)"invalid code lengths set";
-               state->mode = BAD;
-               break;
-            }
-            Tracev((stderr, "inflate:       code lengths ok\n"));
-
-            /* get length and distance code code lengths */
-            state->have = 0;
-            while (state->have < state->nlen + state->ndist) {
-               for (;;) {
-                  here = state->lencode[BITS(state->lenbits)];
-                  if ((unsigned)(here.bits) <= bits) break;
-                  PULLBYTE();
-               }
-               if (here.val < 16) {
-                  DROPBITS(here.bits);
-                  state->lens[state->have++] = here.val;
-               }
-               else {
-                  if (here.val == 16) {
-                     NEEDBITS(here.bits + 2);
-                     DROPBITS(here.bits);
-                     if (state->have == 0) {
-                        strm->msg = (char *)"invalid bit length repeat";
-                        state->mode = BAD;
-                        break;
-                     }
-                     len = (unsigned)(state->lens[state->have - 1]);
-                     copy = 3 + BITS(2);
-                     DROPBITS(2);
-                  }
-                  else if (here.val == 17) {
-                     NEEDBITS(here.bits + 3);
-                     DROPBITS(here.bits);
-                     len = 0;
-                     copy = 3 + BITS(3);
-                     DROPBITS(3);
-                  }
-                  else {
-                     NEEDBITS(here.bits + 7);
-                     DROPBITS(here.bits);
-                     len = 0;
-                     copy = 11 + BITS(7);
-                     DROPBITS(7);
-                  }
-                  if (state->have + copy > state->nlen + state->ndist) {
-                     strm->msg = (char *)"invalid bit length repeat";
-                     state->mode = BAD;
-                     break;
-                  }
-                  while (copy--)
-                     state->lens[state->have++] = (unsigned short)len;
-               }
-            }
-
-            /* handle error breaks in while */
-            if (state->mode == BAD) break;
-
-            /* check for end-of-block code (better have one) */
-            if (state->lens[256] == 0) {
-               strm->msg = (char *)"invalid code -- missing end-of-block";
-               state->mode = BAD;
-               break;
-            }
-
-            /* build code tables -- note: do not change the lenbits or distbits
-               values here (9 and 6) without reading the comments in inftrees.h
-               concerning the ENOUGH constants, which depend on those values */
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 9;
-            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
-                  &(state->lenbits), state->work);
-            if (ret) {
-               strm->msg = (char *)"invalid literal/lengths set";
-               state->mode = BAD;
-               break;
-            }
-            state->distcode = (code const FAR *)(state->next);
-            state->distbits = 6;
-            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
-                  &(state->next), &(state->distbits), state->work);
-            if (ret) {
-               strm->msg = (char *)"invalid distances set";
-               state->mode = BAD;
-               break;
-            }
-            Tracev((stderr, "inflate:       codes ok\n"));
-            state->mode = LEN;
-
-         case LEN:
-            /* use inflate_fast() if we have enough input and output */
-            if (have >= 6 && left >= 258) {
-               RESTORE();
-               if (state->whave < state->wsize)
-                  state->whave = state->wsize - left;
-               inflate_fast(strm, state->wsize);
-               LOAD();
-               break;
-            }
-
-            /* get a literal, length, or end-of-block code */
-            for (;;) {
-               here = state->lencode[BITS(state->lenbits)];
-               if ((unsigned)(here.bits) <= bits) break;
-               PULLBYTE();
-            }
-            if (here.op && (here.op & 0xf0) == 0) {
-               last = here;
-               for (;;) {
-                  here = state->lencode[last.val +
-                     (BITS(last.bits + last.op) >> last.bits)];
-                  if ((unsigned)(last.bits + here.bits) <= bits) break;
-                  PULLBYTE();
-               }
-               DROPBITS(last.bits);
-            }
-            DROPBITS(here.bits);
-            state->length = (unsigned)here.val;
-
-            /* process literal */
-            if (here.op == 0) {
-               Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                        "inflate:         literal '%c'\n" :
-                        "inflate:         literal 0x%02x\n", here.val));
-               ROOM();
-               *put++ = (unsigned char)(state->length);
-               left--;
-               state->mode = LEN;
-               break;
-            }
-
-            /* process end of block */
-            if (here.op & 32) {
-               Tracevv((stderr, "inflate:         end of block\n"));
-               state->mode = TYPE;
-               break;
-            }
-
-            /* invalid code */
-            if (here.op & 64) {
-               strm->msg = (char *)"invalid literal/length code";
-               state->mode = BAD;
-               break;
-            }
-
-            /* length code -- get extra bits, if any */
-            state->extra = (unsigned)(here.op) & 15;
-            if (state->extra != 0) {
-               NEEDBITS(state->extra);
-               state->length += BITS(state->extra);
-               DROPBITS(state->extra);
-            }
-            Tracevv((stderr, "inflate:         length %u\n", state->length));
-
-            /* get distance code */
-            for (;;) {
-               here = state->distcode[BITS(state->distbits)];
-               if ((unsigned)(here.bits) <= bits) break;
-               PULLBYTE();
-            }
-            if ((here.op & 0xf0) == 0) {
-               last = here;
-               for (;;) {
-                  here = state->distcode[last.val +
-                     (BITS(last.bits + last.op) >> last.bits)];
-                  if ((unsigned)(last.bits + here.bits) <= bits) break;
-                  PULLBYTE();
-               }
-               DROPBITS(last.bits);
-            }
-            DROPBITS(here.bits);
-            if (here.op & 64) {
-               strm->msg = (char *)"invalid distance code";
-               state->mode = BAD;
-               break;
-            }
-            state->offset = (unsigned)here.val;
-
-            /* get distance extra bits, if any */
-            state->extra = (unsigned)(here.op) & 15;
-            if (state->extra != 0) {
-               NEEDBITS(state->extra);
-               state->offset += BITS(state->extra);
-               DROPBITS(state->extra);
-            }
-            if (state->offset > state->wsize - (state->whave < state->wsize ?
-                     left : 0)) {
-               strm->msg = (char *)"invalid distance too far back";
-               state->mode = BAD;
-               break;
-            }
-            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-
-            /* copy match from window to output */
-            do {
-               ROOM();
-               copy = state->wsize - state->offset;
-               if (copy < left) {
-                  from = put + copy;
-                  copy = left - copy;
-               }
-               else {
-                  from = put - state->offset;
-                  copy = left;
-               }
-               if (copy > state->length) copy = state->length;
-               state->length -= copy;
-               left -= copy;
-               do {
-                  *put++ = *from++;
-               } while (--copy);
-            } while (state->length != 0);
-            break;
-
-         case DONE:
-            /* inflate stream terminated properly -- write leftover output */
-            ret = Z_STREAM_END;
-            if (left < state->wsize) {
-               if (out(out_desc, state->window, state->wsize - left))
-                  ret = Z_BUF_ERROR;
-            }
-            goto inf_leave;
-
-         case BAD:
-            ret = Z_DATA_ERROR;
-            goto inf_leave;
-
-         default:                /* can't happen, but makes compilers happy */
-            ret = Z_STREAM_ERROR;
-            goto inf_leave;
-      }
-
-   /* Return unused input */
-inf_leave:
-   strm->next_in = next;
-   strm->avail_in = have;
-   return ret;
-}
-
-int ZEXPORT inflateBackEnd(z_streamp strm)
-{
-   if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == Z_NULL)
-      return Z_STREAM_ERROR;
-   ZFREE(strm, strm->state);
-   strm->state = Z_NULL;
-   Tracev((stderr, "inflate: end\n"));
-   return Z_OK;
-}
diff --git a/deps/inffast.c b/deps/inffast.c
deleted file mode 100644
index a88859f..0000000
--- a/deps/inffast.c
+++ /dev/null
@@ -1,338 +0,0 @@
-/* inffast.c -- fast decoding
- * Copyright (C) 1995-2008, 2010, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-#ifndef ASMINF
-
-/* Allow machine dependent optimization for post-increment or pre-increment.
-   Based on testing to date,
-   Pre-increment preferred for:
-   - PowerPC G3 (Adler)
-   - MIPS R5000 (Randers-Pehrson)
-   Post-increment preferred for:
-   - none
-   No measurable difference:
-   - Pentium III (Anderson)
-   - M68060 (Nikl)
-   */
-#ifdef POSTINC
-#  define OFF 0
-#  define PUP(a) *(a)++
-#else
-#  define OFF 1
-#  define PUP(a) *++(a)
-#endif
-
-/*
-   Decode literal, length, and distance codes and write out the resulting
-   literal and match bytes until either not enough input or output is
-   available, an end-of-block is encountered, or a data error is encountered.
-   When large enough input and output buffers are supplied to inflate(), for
-   example, a 16K input buffer and a 64K output buffer, more than 95% of the
-   inflate execution time is spent in this routine.
-
-   Entry assumptions:
-
-   state->mode == LEN
-   strm->avail_in >= 6
-   strm->avail_out >= 258
-   start >= strm->avail_out
-   state->bits < 8
-
-   On return, state->mode is one of:
-
-   LEN -- ran out of enough output space or enough available input
-   TYPE -- reached end of block code, inflate() to interpret next block
-   BAD -- error in block data
-
-Notes:
-
-- The maximum input bits used by a length/distance pair is 15 bits for the
-length code, 5 bits for the length extra, 15 bits for the distance code,
-and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
-Therefore if strm->avail_in >= 6, then there is enough input to avoid
-checking for available input while decoding.
-
-- The maximum bytes that a single length/distance pair can output is 258
-bytes, which is the maximum length that can be coded.  inflate_fast()
-requires strm->avail_out >= 258 for each loop to avoid checking for
-output space.
-*/
-void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start)
-{
-   struct inflate_state FAR *state;
-   unsigned char FAR *in;      /* local strm->next_in */
-   unsigned char FAR *last;    /* have enough input while in < last */
-   unsigned char FAR *out;     /* local strm->next_out */
-   unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
-   unsigned char FAR *end;     /* while out < end, enough space available */
-#ifdef INFLATE_STRICT
-   unsigned dmax;              /* maximum distance from zlib header */
-#endif
-   unsigned wsize;             /* window size or zero if not using window */
-   unsigned whave;             /* valid bytes in the window */
-   unsigned wnext;             /* window write index */
-   unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
-   unsigned long hold;         /* local strm->hold */
-   unsigned bits;              /* local strm->bits */
-   code const FAR *lcode;      /* local strm->lencode */
-   code const FAR *dcode;      /* local strm->distcode */
-   unsigned lmask;             /* mask for first level of length codes */
-   unsigned dmask;             /* mask for first level of distance codes */
-   code here;                  /* retrieved table entry */
-   unsigned op;                /* code bits, operation, extra bits, or */
-   /*  window position, window bytes to copy */
-   unsigned len;               /* match length, unused bytes */
-   unsigned dist;              /* match distance */
-   unsigned char FAR *from;    /* where to copy match from */
-
-   /* copy state to local variables */
-   state = (struct inflate_state FAR *)strm->state;
-   in = strm->next_in - OFF;
-   last = in + (strm->avail_in - 5);
-   out = strm->next_out - OFF;
-   beg = out - (start - strm->avail_out);
-   end = out + (strm->avail_out - 257);
-#ifdef INFLATE_STRICT
-   dmax = state->dmax;
-#endif
-   wsize = state->wsize;
-   whave = state->whave;
-   wnext = state->wnext;
-   window = state->window;
-   hold = state->hold;
-   bits = state->bits;
-   lcode = state->lencode;
-   dcode = state->distcode;
-   lmask = (1U << state->lenbits) - 1;
-   dmask = (1U << state->distbits) - 1;
-
-   /* decode literals and length/distances until end-of-block or not enough
-      input data or output space */
-   do {
-      if (bits < 15) {
-         hold += (unsigned long)(PUP(in)) << bits;
-         bits += 8;
-         hold += (unsigned long)(PUP(in)) << bits;
-         bits += 8;
-      }
-      here = lcode[hold & lmask];
-dolen:
-      op = (unsigned)(here.bits);
-      hold >>= op;
-      bits -= op;
-      op = (unsigned)(here.op);
-      if (op == 0) {                          /* literal */
-         Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                  "inflate:         literal '%c'\n" :
-                  "inflate:         literal 0x%02x\n", here.val));
-         PUP(out) = (unsigned char)(here.val);
-      }
-      else if (op & 16) {                     /* length base */
-         len = (unsigned)(here.val);
-         op &= 15;                           /* number of extra bits */
-         if (op) {
-            if (bits < op) {
-               hold += (unsigned long)(PUP(in)) << bits;
-               bits += 8;
-            }
-            len += (unsigned)hold & ((1U << op) - 1);
-            hold >>= op;
-            bits -= op;
-         }
-         Tracevv((stderr, "inflate:         length %u\n", len));
-         if (bits < 15) {
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-         }
-         here = dcode[hold & dmask];
-dodist:
-         op = (unsigned)(here.bits);
-         hold >>= op;
-         bits -= op;
-         op = (unsigned)(here.op);
-         if (op & 16) {                      /* distance base */
-            dist = (unsigned)(here.val);
-            op &= 15;                       /* number of extra bits */
-            if (bits < op) {
-               hold += (unsigned long)(PUP(in)) << bits;
-               bits += 8;
-               if (bits < op) {
-                  hold += (unsigned long)(PUP(in)) << bits;
-                  bits += 8;
-               }
-            }
-            dist += (unsigned)hold & ((1U << op) - 1);
-#ifdef INFLATE_STRICT
-            if (dist > dmax) {
-               strm->msg = (char *)"invalid distance too far back";
-               state->mode = BAD;
-               break;
-            }
-#endif
-            hold >>= op;
-            bits -= op;
-            Tracevv((stderr, "inflate:         distance %u\n", dist));
-            op = (unsigned)(out - beg);     /* max distance in output */
-            if (dist > op) {                /* see if copy from window */
-               op = dist - op;             /* distance back in window */
-               if (op > whave) {
-                  if (state->sane) {
-                     strm->msg =
-                        (char *)"invalid distance too far back";
-                     state->mode = BAD;
-                     break;
-                  }
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-                  if (len <= op - whave) {
-                     do {
-                        PUP(out) = 0;
-                     } while (--len);
-                     continue;
-                  }
-                  len -= op - whave;
-                  do {
-                     PUP(out) = 0;
-                  } while (--op > whave);
-                  if (op == 0) {
-                     from = out - dist;
-                     do {
-                        PUP(out) = PUP(from);
-                     } while (--len);
-                     continue;
-                  }
-#endif
-               }
-               from = window - OFF;
-               if (wnext == 0) {           /* very common case */
-                  from += wsize - op;
-                  if (op < len) {         /* some from window */
-                     len -= op;
-                     do {
-                        PUP(out) = PUP(from);
-                     } while (--op);
-                     from = out - dist;  /* rest from output */
-                  }
-               }
-               else if (wnext < op) {      /* wrap around window */
-                  from += wsize + wnext - op;
-                  op -= wnext;
-                  if (op < len) {         /* some from end of window */
-                     len -= op;
-                     do {
-                        PUP(out) = PUP(from);
-                     } while (--op);
-                     from = window - OFF;
-                     if (wnext < len) {  /* some from start of window */
-                        op = wnext;
-                        len -= op;
-                        do {
-                           PUP(out) = PUP(from);
-                        } while (--op);
-                        from = out - dist;      /* rest from output */
-                     }
-                  }
-               }
-               else {                      /* contiguous in window */
-                  from += wnext - op;
-                  if (op < len) {         /* some from window */
-                     len -= op;
-                     do {
-                        PUP(out) = PUP(from);
-                     } while (--op);
-                     from = out - dist;  /* rest from output */
-                  }
-               }
-               while (len > 2) {
-                  PUP(out) = PUP(from);
-                  PUP(out) = PUP(from);
-                  PUP(out) = PUP(from);
-                  len -= 3;
-               }
-               if (len) {
-                  PUP(out) = PUP(from);
-                  if (len > 1)
-                     PUP(out) = PUP(from);
-               }
-            }
-            else {
-               from = out - dist;          /* copy direct from output */
-               do {                        /* minimum length is three */
-                  PUP(out) = PUP(from);
-                  PUP(out) = PUP(from);
-                  PUP(out) = PUP(from);
-                  len -= 3;
-               } while (len > 2);
-               if (len) {
-                  PUP(out) = PUP(from);
-                  if (len > 1)
-                     PUP(out) = PUP(from);
-               }
-            }
-         }
-         else if ((op & 64) == 0) {          /* 2nd level distance code */
-            here = dcode[here.val + (hold & ((1U << op) - 1))];
-            goto dodist;
-         }
-         else {
-            strm->msg = (char *)"invalid distance code";
-            state->mode = BAD;
-            break;
-         }
-      }
-      else if ((op & 64) == 0) {              /* 2nd level length code */
-         here = lcode[here.val + (hold & ((1U << op) - 1))];
-         goto dolen;
-      }
-      else if (op & 32) {                     /* end-of-block */
-         Tracevv((stderr, "inflate:         end of block\n"));
-         state->mode = TYPE;
-         break;
-      }
-      else {
-         strm->msg = (char *)"invalid literal/length code";
-         state->mode = BAD;
-         break;
-      }
-   } while (in < last && out < end);
-
-   /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
-   len = bits >> 3;
-   in -= len;
-   bits -= len << 3;
-   hold &= (1U << bits) - 1;
-
-   /* update state and return */
-   strm->next_in = in + OFF;
-   strm->next_out = out + OFF;
-   strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
-   strm->avail_out = (unsigned)(out < end ?
-         257 + (end - out) : 257 - (out - end));
-   state->hold = hold;
-   state->bits = bits;
-   return;
-}
-
-/*
-   inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
-   - Using bit fields for code structure
-   - Different op definition to avoid & for extra bits (do & for table bits)
-   - Three separate decoding do-loops for direct, window, and wnext == 0
-   - Special case for distance > 1 copies to do overlapped load and store copy
-   - Explicit branch predictions (based on measured branch probabilities)
-   - Deferring match copy and interspersed it with decoding subsequent codes
-   - Swapping literal/length else
-   - Swapping window/direct else
-   - Larger unrolled copy loops (three is about right)
-   - Moving len -= 3 statement into middle of loop
-   */
-
-#endif /* !ASMINF */
diff --git a/deps/inffast.h b/deps/inffast.h
deleted file mode 100644
index 169a85a..0000000
--- a/deps/inffast.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/* inffast.h -- header to use inffast.c
- * Copyright (C) 1995-2003, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-#ifndef _INFFAST_H
-#define _INFFAST_H
-
-void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
-
-#endif
diff --git a/deps/inffixed.h b/deps/inffixed.h
deleted file mode 100644
index 238a55f..0000000
--- a/deps/inffixed.h
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef _INFFIXED_H
-#define _INFFIXED_H
-
-/* inffixed.h -- table for decoding fixed codes
-     * Generated automatically by makefixed().
-     */
-
-    /* WARNING: this file should *not* be used by applications.
-       It is part of the implementation of this library and is
-       subject to change. Applications should only use zlib.h.
-     */
-
-    static const code lenfix[512] = {
-        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
-        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
-        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
-        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
-        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
-        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
-        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
-        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
-        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
-        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
-        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
-        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
-        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
-        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
-        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
-        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
-        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
-        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
-        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
-        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
-        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
-        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
-        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
-        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
-        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
-        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
-        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
-        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
-        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
-        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
-        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
-        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
-        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
-        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
-        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
-        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
-        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
-        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
-        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
-        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
-        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
-        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
-        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
-        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
-        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
-        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
-        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
-        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
-        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
-        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
-        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
-        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
-        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
-        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
-        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
-        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
-        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
-        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
-        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
-        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
-        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
-        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
-        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
-        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
-        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
-        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
-        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
-        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
-        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
-        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
-        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
-        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
-        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
-        {0,9,255}
-    };
-
-    static const code distfix[32] = {
-        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
-        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
-        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
-        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
-        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
-        {22,5,193},{64,5,0}
-    };
-
-#endif
diff --git a/deps/inflate.c b/deps/inflate.c
deleted file mode 100644
index 0b4f0b7..0000000
--- a/deps/inflate.c
+++ /dev/null
@@ -1,1489 +0,0 @@
-/* inflate.c -- zlib decompression
- * Copyright (C) 1995-2012 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
- * Change history:
- *
- * 1.2.beta0    24 Nov 2002
- * - First version -- complete rewrite of inflate to simplify code, avoid
- *   creation of window when not needed, minimize use of window when it is
- *   needed, make inffast.c even faster, implement gzip decoding, and to
- *   improve code readability and style over the previous zlib inflate code
- *
- * 1.2.beta1    25 Nov 2002
- * - Use pointers for available input and output checking in inffast.c
- * - Remove input and output counters in inffast.c
- * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
- * - Remove unnecessary second byte pull from length extra in inffast.c
- * - Unroll direct copy to three copies per loop in inffast.c
- *
- * 1.2.beta2    4 Dec 2002
- * - Change external routine names to reduce potential conflicts
- * - Correct filename to inffixed.h for fixed tables in inflate.c
- * - Make hbuf[] unsigned char to match parameter type in inflate.c
- * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
- *   to avoid negation problem on Alphas (64 bit) in inflate.c
- *
- * 1.2.beta3    22 Dec 2002
- * - Add comments on state->bits assertion in inffast.c
- * - Add comments on op field in inftrees.h
- * - Fix bug in reuse of allocated window after inflateReset()
- * - Remove bit fields--back to byte structure for speed
- * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
- * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
- * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
- * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
- * - Use local copies of stream next and avail values, as well as local bit
- *   buffer and bit count in inflate()--for speed when inflate_fast() not used
- *
- * 1.2.beta4    1 Jan 2003
- * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
- * - Move a comment on output buffer sizes from inffast.c to inflate.c
- * - Add comments in inffast.c to introduce the inflate_fast() routine
- * - Rearrange window copies in inflate_fast() for speed and simplification
- * - Unroll last copy for window match in inflate_fast()
- * - Use local copies of window variables in inflate_fast() for speed
- * - Pull out common wnext == 0 case for speed in inflate_fast()
- * - Make op and len in inflate_fast() unsigned for consistency
- * - Add FAR to lcode and dcode declarations in inflate_fast()
- * - Simplified bad distance check in inflate_fast()
- * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
- *   source file infback.c to provide a call-back interface to inflate for
- *   programs like gzip and unzip -- uses window as output buffer to avoid
- *   window copying
- *
- * 1.2.beta5    1 Jan 2003
- * - Improved inflateBack() interface to allow the caller to provide initial
- *   input in strm.
- * - Fixed stored blocks bug in inflateBack()
- *
- * 1.2.beta6    4 Jan 2003
- * - Added comments in inffast.c on effectiveness of POSTINC
- * - Typecasting all around to reduce compiler warnings
- * - Changed loops from while (1) or do {} while (1) to for (;;), again to
- *   make compilers happy
- * - Changed type of window in inflateBackInit() to unsigned char *
- *
- * 1.2.beta7    27 Jan 2003
- * - Changed many types to unsigned or unsigned short to avoid warnings
- * - Added inflateCopy() function
- *
- * 1.2.0        9 Mar 2003
- * - Changed inflateBack() interface to provide separate opaque descriptors
- *   for the in() and out() functions
- * - Changed inflateBack() argument and in_func typedef to swap the length
-   *   and buffer address return values for the input function
-* - Check next_in and next_out for Z_NULL on entry to inflate()
-   *
-   * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
-   */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-#ifdef MAKEFIXED
-#  ifndef BUILDFIXED
-#    define BUILDFIXED
-#  endif
-#endif
-
-#ifndef Z_TREES
-#define Z_TREES 6
-#endif
-
-   /* function prototypes */
-int ZEXPORT inflateReset2(z_streamp strm, int windowBits);
-   local void fixedtables OF((struct inflate_state FAR *state));
-   local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
-            unsigned copy));
-#ifdef BUILDFIXED
-void makefixed OF((void));
-#endif
-local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
-         unsigned len));
-
-long ZEXPORT inflateMark(z_streamp strm);
-
-int ZEXPORT inflateResetKeep(z_streamp strm);
-
-int ZEXPORT inflateUndermine(z_streamp strm, int subvert);
-
-int ZEXPORT inflateGetDictionary(z_streamp strm, Bytef *dictionary, uInt *dictLength);
-
-int ZEXPORT inflateResetKeep(z_streamp strm)
-{
-   struct inflate_state FAR *state;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   strm->total_in = strm->total_out = state->total = 0;
-   strm->msg = Z_NULL;
-   if (state->wrap)        /* to support ill-conceived Java test suite */
-      strm->adler = state->wrap & 1;
-   state->mode = HEAD;
-   state->last = 0;
-   state->havedict = 0;
-   state->dmax = 32768U;
-   state->head = Z_NULL;
-   state->hold = 0;
-   state->bits = 0;
-   state->lencode = state->distcode = state->next = state->codes;
-   state->sane = 1;
-   state->back = -1;
-   Tracev((stderr, "inflate: reset\n"));
-   return Z_OK;
-}
-
-int ZEXPORT inflateReset(z_streamp strm)
-{
-   struct inflate_state FAR *state;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   state->wsize = 0;
-   state->whave = 0;
-   state->wnext = 0;
-   return inflateResetKeep(strm);
-}
-
-int ZEXPORT inflateReset2(z_streamp strm, int windowBits)
-{
-   int wrap;
-   struct inflate_state FAR *state = NULL;
-
-   /* get the state */
-   if (strm == Z_NULL || strm->state == Z_NULL)
-	   return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-
-   /* extract wrap request from windowBits parameter */
-   if (windowBits < 0) {
-      wrap = 0;
-      windowBits = -windowBits;
-   }
-   else {
-      wrap = (windowBits >> 4) + 1;
-#ifdef GUNZIP
-      if (windowBits < 48)
-         windowBits &= 15;
-#endif
-   }
-
-   /* set number of window bits, free window if different */
-   if (windowBits && (windowBits < 8 || windowBits > 15))
-      return Z_STREAM_ERROR;
-   if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
-      ZFREE(strm, state->window);
-      state->window = Z_NULL;
-   }
-
-   /* update state and reset the rest of it */
-   state->wrap = wrap;
-   state->wbits = (unsigned)windowBits;
-   return inflateReset(strm);
-}
-
-int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, const char *version, int stream_size)
-{
-   int ret;
-   struct inflate_state FAR *state;
-
-   if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
-         stream_size != (int)(sizeof(z_stream)))
-      return Z_VERSION_ERROR;
-   if (strm == Z_NULL) return Z_STREAM_ERROR;
-   strm->msg = Z_NULL;                 /* in case we return an error */
-   if (strm->zalloc == (alloc_func)0) {
-#ifdef Z_SOLO
-      return Z_STREAM_ERROR;
-#else
-      strm->zalloc = zcalloc;
-      strm->opaque = (voidpf)0;
-#endif
-   }
-   if (strm->zfree == Z_NULL)
-#ifdef Z_SOLO
-      return Z_STREAM_ERROR;
-#else
-   strm->zfree = zcfree;
-#endif
-   state = (struct inflate_state FAR *)
-      ZALLOC(strm, 1, sizeof(struct inflate_state));
-   if (state == Z_NULL) return Z_MEM_ERROR;
-   Tracev((stderr, "inflate: allocated\n"));
-   strm->state = (struct internal_state FAR *)state;
-   state->window = Z_NULL;
-   ret = inflateReset2(strm, windowBits);
-   if (ret != Z_OK) {
-      ZFREE(strm, state);
-      strm->state = Z_NULL;
-   }
-   return ret;
-}
-
-int ZEXPORT inflateInit_(z_streamp strm, const char *version, int stream_size)
-{
-   return inflateInit2_(strm, DEF_WBITS, version, stream_size);
-}
-
-int ZEXPORT inflatePrime(z_streamp strm, int bits, int value)
-{
-   struct inflate_state FAR *state;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   if (bits < 0) {
-      state->hold = 0;
-      state->bits = 0;
-      return Z_OK;
-   }
-   if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
-   value &= (1L << bits) - 1;
-   state->hold += value << state->bits;
-   state->bits += bits;
-   return Z_OK;
-}
-
-/*
-   Return state with length and distance decoding tables and index sizes set to
-   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
-   If BUILDFIXED is defined, then instead this routine builds the tables the
-   first time it's called, and returns those tables the first time and
-   thereafter.  This reduces the size of the code by about 2K bytes, in
-   exchange for a little execution time.  However, BUILDFIXED should not be
-   used for threaded applications, since the rewriting of the tables and virgin
-   may not be thread-safe.
-   */
-local void fixedtables(struct inflate_state FAR *state)
-{
-#ifdef BUILDFIXED
-   static int virgin = 1;
-   static code *lenfix, *distfix;
-   static code fixed[544];
-
-   /* build fixed huffman tables if first call (may not be thread safe) */
-   if (virgin) {
-      unsigned sym, bits;
-      static code *next;
-
-      /* literal/length table */
-      sym = 0;
-      while (sym < 144) state->lens[sym++] = 8;
-      while (sym < 256) state->lens[sym++] = 9;
-      while (sym < 280) state->lens[sym++] = 7;
-      while (sym < 288) state->lens[sym++] = 8;
-      next = fixed;
-      lenfix = next;
-      bits = 9;
-      inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
-
-      /* distance table */
-      sym = 0;
-      while (sym < 32) state->lens[sym++] = 5;
-      distfix = next;
-      bits = 5;
-      inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
-
-      /* do this just once */
-      virgin = 0;
-   }
-#else /* !BUILDFIXED */
-#   include "inffixed.h"
-#endif /* BUILDFIXED */
-   state->lencode = lenfix;
-   state->lenbits = 9;
-   state->distcode = distfix;
-   state->distbits = 5;
-}
-
-#ifdef MAKEFIXED
-#include <stdio.h>
-
-/*
-   Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
-   defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
-   those tables to stdout, which would be piped to inffixed.h.  A small program
-   can simply call makefixed to do this:
-
-   void makefixed(void);
-
-   int main(void)
-   {
-   makefixed();
-   return 0;
-   }
-
-   Then that can be linked with zlib built with MAKEFIXED defined and run:
-
-   a.out > inffixed.h
-   */
-void makefixed(void)
-{
-   unsigned low, size;
-   struct inflate_state state;
-
-   fixedtables(&state);
-   puts("    /* inffixed.h -- table for decoding fixed codes");
-   puts("     * Generated automatically by makefixed().");
-   puts("     */");
-   puts("");
-   puts("    /* WARNING: this file should *not* be used by applications.");
-   puts("       It is part of the implementation of this library and is");
-   puts("       subject to change. Applications should only use zlib.h.");
-   puts("     */");
-   puts("");
-   size = 1U << 9;
-   printf("    static const code lenfix[%u] = {", size);
-   low = 0;
-   for (;;) {
-      if ((low % 7) == 0) printf("\n        ");
-      printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
-            state.lencode[low].bits, state.lencode[low].val);
-      if (++low == size) break;
-      putchar(',');
-   }
-   puts("\n    };");
-   size = 1U << 5;
-   printf("\n    static const code distfix[%u] = {", size);
-   low = 0;
-   for (;;) {
-      if ((low % 6) == 0) printf("\n        ");
-      printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
-            state.distcode[low].val);
-      if (++low == size) break;
-      putchar(',');
-   }
-   puts("\n    };");
-}
-#endif /* MAKEFIXED */
-
-/*
-   Update the window with the last wsize (normally 32K) bytes written before
-   returning.  If window does not exist yet, create it.  This is only called
-   when a window is already in use, or when output has been written during this
-   inflate call, but the end of the deflate stream has not been reached yet.
-   It is also called to create a window for dictionary data when a dictionary
-   is loaded.
-
-   Providing output buffers larger than 32K to inflate() should provide a speed
-   advantage, since only the last 32K of output is copied to the sliding window
-   upon return from inflate(), and since all distances after the first 32K of
-   output will fall in the output data, making match copies simpler and faster.
-   The advantage may be dependent on the size of the processor's data caches.
-   */
-local int updatewindow(z_streamp strm, const Bytef *end, unsigned copy)
-{
-   struct inflate_state FAR *state;
-   unsigned dist;
-
-   state = (struct inflate_state FAR *)strm->state;
-
-   /* if it hasn't been done already, allocate space for the window */
-   if (state->window == Z_NULL) {
-      state->window = (unsigned char FAR *)
-         ZALLOC(strm, 1U << state->wbits,
-               sizeof(unsigned char));
-      if (state->window == Z_NULL) return 1;
-   }
-
-   /* if window not in use yet, initialize */
-   if (state->wsize == 0) {
-      state->wsize = 1U << state->wbits;
-      state->wnext = 0;
-      state->whave = 0;
-   }
-
-   /* copy state->wsize or less output bytes into the circular window */
-   if (copy >= state->wsize) {
-      zmemcpy(state->window, end - state->wsize, state->wsize);
-      state->wnext = 0;
-      state->whave = state->wsize;
-   }
-   else {
-      dist = state->wsize - state->wnext;
-      if (dist > copy) dist = copy;
-      zmemcpy(state->window + state->wnext, end - copy, dist);
-      copy -= dist;
-      if (copy) {
-         zmemcpy(state->window, end - copy, copy);
-         state->wnext = copy;
-         state->whave = state->wsize;
-      }
-      else {
-         state->wnext += dist;
-         if (state->wnext == state->wsize) state->wnext = 0;
-         if (state->whave < state->wsize) state->whave += dist;
-      }
-   }
-   return 0;
-}
-
-/* Macros for inflate(): */
-
-/* check function to use adler32() for zlib or crc32() for gzip */
-#ifdef GUNZIP
-#  define UPDATE(check, buf, len) \
-   (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
-#else
-#  define UPDATE(check, buf, len) adler32(check, buf, len)
-#endif
-
-/* check macros for header crc */
-#ifdef GUNZIP
-#  define CRC2(check, word) \
-   do { \
-      hbuf[0] = (unsigned char)(word); \
-      hbuf[1] = (unsigned char)((word) >> 8); \
-      check = crc32(check, hbuf, 2); \
-   } while (0)
-
-#  define CRC4(check, word) \
-   do { \
-      hbuf[0] = (unsigned char)(word); \
-      hbuf[1] = (unsigned char)((word) >> 8); \
-      hbuf[2] = (unsigned char)((word) >> 16); \
-      hbuf[3] = (unsigned char)((word) >> 24); \
-      check = crc32(check, hbuf, 4); \
-   } while (0)
-#endif
-
-/* Load registers with state in inflate() for speed */
-#define LOAD() \
-   do { \
-      put = strm->next_out; \
-      left = strm->avail_out; \
-      next = strm->next_in; \
-      have = strm->avail_in; \
-      hold = state->hold; \
-      bits = state->bits; \
-   } while (0)
-
-/* Restore state from registers in inflate() */
-#define RESTORE() \
-   do { \
-      strm->next_out = put; \
-      strm->avail_out = left; \
-      strm->next_in = next; \
-      strm->avail_in = have; \
-      state->hold = hold; \
-      state->bits = bits; \
-   } while (0)
-
-/* Clear the input bit accumulator */
-#define INITBITS() \
-   do { \
-      hold = 0; \
-      bits = 0; \
-   } while (0)
-
-/* Get a byte of input into the bit accumulator, or return from inflate()
-   if there is no input available. */
-#define PULLBYTE() \
-   do { \
-      if (have == 0) goto inf_leave; \
-      have--; \
-      hold += (unsigned long)(*next++) << bits; \
-      bits += 8; \
-   } while (0)
-
-/* Assure that there are at least n bits in the bit accumulator.  If there is
-   not enough available input to do that, then return from inflate(). */
-#define NEEDBITS(n) \
-   do { \
-      while (bits < (unsigned)(n)) \
-      PULLBYTE(); \
-   } while (0)
-
-/* Return the low n bits of the bit accumulator (n < 16) */
-#define BITS(n) \
-   ((unsigned)hold & ((1U << (n)) - 1))
-
-/* Remove n bits from the bit accumulator */
-#define DROPBITS(n) \
-   do { \
-      hold >>= (n); \
-      bits -= (unsigned)(n); \
-   } while (0)
-
-/* Remove zero to seven bits as needed to go to a byte boundary */
-#define BYTEBITS() \
-   do { \
-      hold >>= bits & 7; \
-      bits -= bits & 7; \
-   } while (0)
-
-/*
-   inflate() uses a state machine to process as much input data and generate as
-   much output data as possible before returning.  The state machine is
-   structured roughly as follows:
-
-   for (;;) switch (state) {
-   ...
-   case STATEn:
-   if (not enough input data or output space to make progress)
-   return;
-   ... make progress ...
-   state = STATEm;
-   break;
-   ...
-   }
-
-   so when inflate() is called again, the same case is attempted again, and
-   if the appropriate resources are provided, the machine proceeds to the
-   next state.  The NEEDBITS() macro is usually the way the state evaluates
-   whether it can proceed or should return.  NEEDBITS() does the return if
-   the requested bits are not available.  The typical use of the BITS macros
-is:
-
-NEEDBITS(n);
-... do something with BITS(n) ...
-DROPBITS(n);
-
-where NEEDBITS(n) either returns from inflate() if there isn't enough
-input left to load n bits into the accumulator, or it continues.  BITS(n)
-gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
-the low n bits off the accumulator.  INITBITS() clears the accumulator
-and sets the number of available bits to zero.  BYTEBITS() discards just
-enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
-and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
-
-NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
-if there is no input available.  The decoding of variable length codes uses
-PULLBYTE() directly in order to pull just enough bytes to decode the next
-code, and no more.
-
-Some states loop until they get enough input, making sure that enough
-state information is maintained to continue the loop where it left off
-if NEEDBITS() returns in the loop.  For example, want, need, and keep
-would all have to actually be part of the saved state in case NEEDBITS()
-returns:
-
-case STATEw:
-while (want < need) {
-NEEDBITS(n);
-keep[want++] = BITS(n);
-DROPBITS(n);
-}
-state = STATEx;
-case STATEx:
-
-As shown above, if the next state is also the next case, then the break
-is omitted.
-
-A state may also return if there is not enough output space available to
-complete that state.  Those states are copying stored data, writing a
-literal byte, and copying a matching string.
-
-When returning, a "goto inf_leave" is used to update the total counters,
-update the check value, and determine whether any progress has been made
-during that inflate() call in order to return the proper return code.
-Progress is defined as a change in either strm->avail_in or strm->avail_out.
-When there is a window, goto inf_leave will update the window with the last
-output written.  If a goto inf_leave occurs in the middle of decompression
-and there is no window currently, goto inf_leave will create one and copy
-output to the window for the next call of inflate().
-
-In this implementation, the flush parameter of inflate() only affects the
-return code (per zlib.h).  inflate() always writes as much as possible to
-strm->next_out, given the space available and the provided input--the effect
-documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
-the allocation of and copying into a sliding window until necessary, which
-provides the effect documented in zlib.h for Z_FINISH when the entire input
-stream available.  So the only thing the flush parameter actually does is:
-when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
-will return Z_BUF_ERROR if it has not reached the end of the stream.
-*/
-
-int ZEXPORT inflate(z_streamp strm, int flush)
-{
-   struct inflate_state FAR *state;
-   unsigned char FAR *next;    /* next input */
-   unsigned char FAR *put;     /* next output */
-   unsigned have, left;        /* available input and output */
-   unsigned long hold;         /* bit buffer */
-   unsigned bits;              /* bits in bit buffer */
-   unsigned in, out;           /* save starting available input and output */
-   unsigned copy;              /* number of stored or match bytes to copy */
-   unsigned char FAR *from;    /* where to copy match bytes from */
-   code here;                  /* current decoding table entry */
-   code last;                  /* parent table entry */
-   unsigned len;               /* length to copy for repeats, bits to drop */
-   int ret;                    /* return code */
-#ifdef GUNZIP
-   unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
-#endif
-   static const unsigned short order[19] = /* permutation of code lengths */
-   {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-
-   if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
-         (strm->next_in == Z_NULL && strm->avail_in != 0))
-      return Z_STREAM_ERROR;
-
-   state = (struct inflate_state FAR *)strm->state;
-   if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
-   LOAD();
-   in = have;
-   out = left;
-   ret = Z_OK;
-   for (;;)
-      switch (state->mode) {
-         case HEAD:
-            if (state->wrap == 0) {
-               state->mode = TYPEDO;
-               break;
-            }
-            NEEDBITS(16);
-#ifdef GUNZIP
-            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
-               state->check = crc32(0L, Z_NULL, 0);
-               CRC2(state->check, hold);
-               INITBITS();
-               state->mode = FLAGS;
-               break;
-            }
-            state->flags = 0;           /* expect zlib header */
-            if (state->head != Z_NULL)
-               state->head->done = -1;
-            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
-#else
-                  if (
-#endif
-                     ((BITS(8) << 8) + (hold >> 8)) % 31) {
-                  strm->msg = (char *)"incorrect header check";
-                  state->mode = BAD;
-                  break;
-                  }
-                  if (BITS(4) != Z_DEFLATED) {
-                  strm->msg = (char *)"unknown compression method";
-                  state->mode = BAD;
-                  break;
-                  }
-                  DROPBITS(4);
-                  len = BITS(4) + 8;
-                  if (state->wbits == 0)
-                  state->wbits = len;
-                  else if (len > state->wbits) {
-                  strm->msg = (char *)"invalid window size";
-                  state->mode = BAD;
-                  break;
-                  }
-                  state->dmax = 1U << len;
-                  Tracev((stderr, "inflate:   zlib header ok\n"));
-                  strm->adler = state->check = adler32(0L, Z_NULL, 0);
-                  state->mode = hold & 0x200 ? DICTID : TYPE;
-                  INITBITS();
-                  break;
-#ifdef GUNZIP
-         case FLAGS:
-                  NEEDBITS(16);
-                  state->flags = (int)(hold);
-                  if ((state->flags & 0xff) != Z_DEFLATED) {
-                     strm->msg = (char *)"unknown compression method";
-                     state->mode = BAD;
-                     break;
-                  }
-                  if (state->flags & 0xe000) {
-                     strm->msg = (char *)"unknown header flags set";
-                     state->mode = BAD;
-                     break;
-                  }
-                  if (state->head != Z_NULL)
-                     state->head->text = (int)((hold >> 8) & 1);
-                  if (state->flags & 0x0200) CRC2(state->check, hold);
-                  INITBITS();
-                  state->mode = TIME;
-         case TIME:
-                  NEEDBITS(32);
-                  if (state->head != Z_NULL)
-                     state->head->time = hold;
-                  if (state->flags & 0x0200) CRC4(state->check, hold);
-                  INITBITS();
-                  state->mode = OS;
-         case OS:
-                  NEEDBITS(16);
-                  if (state->head != Z_NULL) {
-                     state->head->xflags = (int)(hold & 0xff);
-                     state->head->os = (int)(hold >> 8);
-                  }
-                  if (state->flags & 0x0200) CRC2(state->check, hold);
-                  INITBITS();
-                  state->mode = EXLEN;
-         case EXLEN:
-                  if (state->flags & 0x0400) {
-                     NEEDBITS(16);
-                     state->length = (unsigned)(hold);
-                     if (state->head != Z_NULL)
-                        state->head->extra_len = (unsigned)hold;
-                     if (state->flags & 0x0200) CRC2(state->check, hold);
-                     INITBITS();
-                  }
-                  else if (state->head != Z_NULL)
-                     state->head->extra = Z_NULL;
-                  state->mode = EXTRA;
-         case EXTRA:
-                  if (state->flags & 0x0400) {
-                     copy = state->length;
-                     if (copy > have) copy = have;
-                     if (copy) {
-                        if (state->head != Z_NULL &&
-                              state->head->extra != Z_NULL) {
-                           len = state->head->extra_len - state->length;
-                           zmemcpy(state->head->extra + len, next,
-                                 len + copy > state->head->extra_max ?
-                                 state->head->extra_max - len : copy);
-                        }
-                        if (state->flags & 0x0200)
-                           state->check = crc32(state->check, next, copy);
-                        have -= copy;
-                        next += copy;
-                        state->length -= copy;
-                     }
-                     if (state->length) goto inf_leave;
-                  }
-                  state->length = 0;
-                  state->mode = NAME;
-         case NAME:
-                  if (state->flags & 0x0800) {
-                     if (have == 0) goto inf_leave;
-                     copy = 0;
-                     do {
-                        len = (unsigned)(next[copy++]);
-                        if (state->head != Z_NULL &&
-                              state->head->name != Z_NULL &&
-                              state->length < state->head->name_max)
-                           state->head->name[state->length++] = len;
-                     } while (len && copy < have);
-                     if (state->flags & 0x0200)
-                        state->check = crc32(state->check, next, copy);
-                     have -= copy;
-                     next += copy;
-                     if (len) goto inf_leave;
-                  }
-                  else if (state->head != Z_NULL)
-                     state->head->name = Z_NULL;
-                  state->length = 0;
-                  state->mode = COMMENT;
-         case COMMENT:
-                  if (state->flags & 0x1000) {
-                     if (have == 0) goto inf_leave;
-                     copy = 0;
-                     do {
-                        len = (unsigned)(next[copy++]);
-                        if (state->head != Z_NULL &&
-                              state->head->comment != Z_NULL &&
-                              state->length < state->head->comm_max)
-                           state->head->comment[state->length++] = len;
-                     } while (len && copy < have);
-                     if (state->flags & 0x0200)
-                        state->check = crc32(state->check, next, copy);
-                     have -= copy;
-                     next += copy;
-                     if (len) goto inf_leave;
-                  }
-                  else if (state->head != Z_NULL)
-                     state->head->comment = Z_NULL;
-                  state->mode = HCRC;
-         case HCRC:
-                  if (state->flags & 0x0200) {
-                     NEEDBITS(16);
-                     if (hold != (state->check & 0xffff)) {
-                        strm->msg = (char *)"header crc mismatch";
-                        state->mode = BAD;
-                        break;
-                     }
-                     INITBITS();
-                  }
-                  if (state->head != Z_NULL) {
-                     state->head->hcrc = (int)((state->flags >> 9) & 1);
-                     state->head->done = 1;
-                  }
-                  strm->adler = state->check = crc32(0L, Z_NULL, 0);
-                  state->mode = TYPE;
-                  break;
-#endif
-         case DICTID:
-                  NEEDBITS(32);
-                  strm->adler = state->check = ZSWAP32(hold);
-                  INITBITS();
-                  state->mode = DICT;
-         case DICT:
-                  if (state->havedict == 0) {
-                     RESTORE();
-                     return Z_NEED_DICT;
-                  }
-                  strm->adler = state->check = adler32(0L, Z_NULL, 0);
-                  state->mode = TYPE;
-         case TYPE:
-                  if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
-         case TYPEDO:
-                  if (state->last) {
-                     BYTEBITS();
-                     state->mode = CHECK;
-                     break;
-                  }
-                  NEEDBITS(3);
-                  state->last = BITS(1);
-                  DROPBITS(1);
-                  switch (BITS(2)) {
-                     case 0:                             /* stored block */
-                        Tracev((stderr, "inflate:     stored block%s\n",
-                                 state->last ? " (last)" : ""));
-                        state->mode = STORED;
-                        break;
-                     case 1:                             /* fixed block */
-                        fixedtables(state);
-                        Tracev((stderr, "inflate:     fixed codes block%s\n",
-                                 state->last ? " (last)" : ""));
-                        state->mode = LEN_;             /* decode codes */
-                        if (flush == Z_TREES) {
-                           DROPBITS(2);
-                           goto inf_leave;
-                        }
-                        break;
-                     case 2:                             /* dynamic block */
-                        Tracev((stderr, "inflate:     dynamic codes block%s\n",
-                                 state->last ? " (last)" : ""));
-                        state->mode = TABLE;
-                        break;
-                     case 3:
-                        strm->msg = (char *)"invalid block type";
-                        state->mode = BAD;
-                  }
-                  DROPBITS(2);
-                  break;
-         case STORED:
-                  BYTEBITS();                         /* go to byte boundary */
-                  NEEDBITS(32);
-                  if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                     strm->msg = (char *)"invalid stored block lengths";
-                     state->mode = BAD;
-                     break;
-                  }
-                  state->length = (unsigned)hold & 0xffff;
-                  Tracev((stderr, "inflate:       stored length %u\n",
-                           state->length));
-                  INITBITS();
-                  state->mode = COPY_;
-                  if (flush == Z_TREES) goto inf_leave;
-         case COPY_:
-                  state->mode = COPY;
-         case COPY:
-                  copy = state->length;
-                  if (copy) {
-                     if (copy > have) copy = have;
-                     if (copy > left) copy = left;
-                     if (copy == 0) goto inf_leave;
-                     zmemcpy(put, next, copy);
-                     have -= copy;
-                     next += copy;
-                     left -= copy;
-                     put += copy;
-                     state->length -= copy;
-                     break;
-                  }
-                  Tracev((stderr, "inflate:       stored end\n"));
-                  state->mode = TYPE;
-                  break;
-         case TABLE:
-                  NEEDBITS(14);
-                  state->nlen = BITS(5) + 257;
-                  DROPBITS(5);
-                  state->ndist = BITS(5) + 1;
-                  DROPBITS(5);
-                  state->ncode = BITS(4) + 4;
-                  DROPBITS(4);
-#ifndef PKZIP_BUG_WORKAROUND
-                  if (state->nlen > 286 || state->ndist > 30) {
-                     strm->msg = (char *)"too many length or distance symbols";
-                     state->mode = BAD;
-                     break;
-                  }
-#endif
-                  Tracev((stderr, "inflate:       table sizes ok\n"));
-                  state->have = 0;
-                  state->mode = LENLENS;
-         case LENLENS:
-                  while (state->have < state->ncode) {
-                     NEEDBITS(3);
-                     state->lens[order[state->have++]] = (unsigned short)BITS(3);
-                     DROPBITS(3);
-                  }
-                  while (state->have < 19)
-                     state->lens[order[state->have++]] = 0;
-                  state->next = state->codes;
-                  state->lencode = (const code FAR *)(state->next);
-                  state->lenbits = 7;
-                  ret = inflate_table(CODES, state->lens, 19, &(state->next),
-                        &(state->lenbits), state->work);
-                  if (ret) {
-                     strm->msg = (char *)"invalid code lengths set";
-                     state->mode = BAD;
-                     break;
-                  }
-                  Tracev((stderr, "inflate:       code lengths ok\n"));
-                  state->have = 0;
-                  state->mode = CODELENS;
-         case CODELENS:
-                  while (state->have < state->nlen + state->ndist) {
-                     for (;;) {
-                        here = state->lencode[BITS(state->lenbits)];
-                        if ((unsigned)(here.bits) <= bits) break;
-                        PULLBYTE();
-                     }
-                     if (here.val < 16) {
-                        DROPBITS(here.bits);
-                        state->lens[state->have++] = here.val;
-                     }
-                     else {
-                        if (here.val == 16) {
-                           NEEDBITS(here.bits + 2);
-                           DROPBITS(here.bits);
-                           if (state->have == 0) {
-                              strm->msg = (char *)"invalid bit length repeat";
-                              state->mode = BAD;
-                              break;
-                           }
-                           len = state->lens[state->have - 1];
-                           copy = 3 + BITS(2);
-                           DROPBITS(2);
-                        }
-                        else if (here.val == 17) {
-                           NEEDBITS(here.bits + 3);
-                           DROPBITS(here.bits);
-                           len = 0;
-                           copy = 3 + BITS(3);
-                           DROPBITS(3);
-                        }
-                        else {
-                           NEEDBITS(here.bits + 7);
-                           DROPBITS(here.bits);
-                           len = 0;
-                           copy = 11 + BITS(7);
-                           DROPBITS(7);
-                        }
-                        if (state->have + copy > state->nlen + state->ndist) {
-                           strm->msg = (char *)"invalid bit length repeat";
-                           state->mode = BAD;
-                           break;
-                        }
-                        while (copy--)
-                           state->lens[state->have++] = (unsigned short)len;
-                     }
-                  }
-
-                  /* handle error breaks in while */
-                  if (state->mode == BAD) break;
-
-                  /* check for end-of-block code (better have one) */
-                  if (state->lens[256] == 0) {
-                     strm->msg = (char *)"invalid code -- missing end-of-block";
-                     state->mode = BAD;
-                     break;
-                  }
-
-                  /* build code tables -- note: do not change the lenbits or distbits
-                     values here (9 and 6) without reading the comments in inftrees.h
-                     concerning the ENOUGH constants, which depend on those values */
-                  state->next = state->codes;
-                  state->lencode = (const code FAR *)(state->next);
-                  state->lenbits = 9;
-                  ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
-                        &(state->lenbits), state->work);
-                  if (ret) {
-                     strm->msg = (char *)"invalid literal/lengths set";
-                     state->mode = BAD;
-                     break;
-                  }
-                  state->distcode = (const code FAR *)(state->next);
-                  state->distbits = 6;
-                  ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
-                        &(state->next), &(state->distbits), state->work);
-                  if (ret) {
-                     strm->msg = (char *)"invalid distances set";
-                     state->mode = BAD;
-                     break;
-                  }
-                  Tracev((stderr, "inflate:       codes ok\n"));
-                  state->mode = LEN_;
-                  if (flush == Z_TREES) goto inf_leave;
-         case LEN_:
-                  state->mode = LEN;
-         case LEN:
-                  if (have >= 6 && left >= 258) {
-                     RESTORE();
-                     inflate_fast(strm, out);
-                     LOAD();
-                     if (state->mode == TYPE)
-                        state->back = -1;
-                     break;
-                  }
-                  state->back = 0;
-                  for (;;) {
-                     here = state->lencode[BITS(state->lenbits)];
-                     if ((unsigned)(here.bits) <= bits) break;
-                     PULLBYTE();
-                  }
-                  if (here.op && (here.op & 0xf0) == 0) {
-                     last = here;
-                     for (;;) {
-                        here = state->lencode[last.val +
-                           (BITS(last.bits + last.op) >> last.bits)];
-                        if ((unsigned)(last.bits + here.bits) <= bits) break;
-                        PULLBYTE();
-                     }
-                     DROPBITS(last.bits);
-                     state->back += last.bits;
-                  }
-                  DROPBITS(here.bits);
-                  state->back += here.bits;
-                  state->length = (unsigned)here.val;
-                  if ((int)(here.op) == 0) {
-                     Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                              "inflate:         literal '%c'\n" :
-                              "inflate:         literal 0x%02x\n", here.val));
-                     state->mode = LIT;
-                     break;
-                  }
-                  if (here.op & 32) {
-                     Tracevv((stderr, "inflate:         end of block\n"));
-                     state->back = -1;
-                     state->mode = TYPE;
-                     break;
-                  }
-                  if (here.op & 64) {
-                     strm->msg = (char *)"invalid literal/length code";
-                     state->mode = BAD;
-                     break;
-                  }
-                  state->extra = (unsigned)(here.op) & 15;
-                  state->mode = LENEXT;
-         case LENEXT:
-                  if (state->extra) {
-                     NEEDBITS(state->extra);
-                     state->length += BITS(state->extra);
-                     DROPBITS(state->extra);
-                     state->back += state->extra;
-                  }
-                  Tracevv((stderr, "inflate:         length %u\n", state->length));
-                  state->was = state->length;
-                  state->mode = DIST;
-         case DIST:
-                  for (;;) {
-                     here = state->distcode[BITS(state->distbits)];
-                     if ((unsigned)(here.bits) <= bits) break;
-                     PULLBYTE();
-                  }
-                  if ((here.op & 0xf0) == 0) {
-                     last = here;
-                     for (;;) {
-                        here = state->distcode[last.val +
-                           (BITS(last.bits + last.op) >> last.bits)];
-                        if ((unsigned)(last.bits + here.bits) <= bits) break;
-                        PULLBYTE();
-                     }
-                     DROPBITS(last.bits);
-                     state->back += last.bits;
-                  }
-                  DROPBITS(here.bits);
-                  state->back += here.bits;
-                  if (here.op & 64) {
-                     strm->msg = (char *)"invalid distance code";
-                     state->mode = BAD;
-                     break;
-                  }
-                  state->offset = (unsigned)here.val;
-                  state->extra = (unsigned)(here.op) & 15;
-                  state->mode = DISTEXT;
-         case DISTEXT:
-                  if (state->extra) {
-                     NEEDBITS(state->extra);
-                     state->offset += BITS(state->extra);
-                     DROPBITS(state->extra);
-                     state->back += state->extra;
-                  }
-#ifdef INFLATE_STRICT
-                  if (state->offset > state->dmax) {
-                     strm->msg = (char *)"invalid distance too far back";
-                     state->mode = BAD;
-                     break;
-                  }
-#endif
-                  Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-                  state->mode = MATCH;
-         case MATCH:
-                  if (left == 0) goto inf_leave;
-                  copy = out - left;
-                  if (state->offset > copy) {         /* copy from window */
-                     copy = state->offset - copy;
-                     if (copy > state->whave) {
-                        if (state->sane) {
-                           strm->msg = (char *)"invalid distance too far back";
-                           state->mode = BAD;
-                           break;
-                        }
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-                        Trace((stderr, "inflate.c too far\n"));
-                        copy -= state->whave;
-                        if (copy > state->length) copy = state->length;
-                        if (copy > left) copy = left;
-                        left -= copy;
-                        state->length -= copy;
-                        do {
-                           *put++ = 0;
-                        } while (--copy);
-                        if (state->length == 0) state->mode = LEN;
-                        break;
-#endif
-                     }
-                     if (copy > state->wnext) {
-                        copy -= state->wnext;
-                        from = state->window + (state->wsize - copy);
-                     }
-                     else
-                        from = state->window + (state->wnext - copy);
-                     if (copy > state->length) copy = state->length;
-                  }
-                  else {                              /* copy from output */
-                     from = put - state->offset;
-                     copy = state->length;
-                  }
-                  if (copy > left) copy = left;
-                  left -= copy;
-                  state->length -= copy;
-                  do {
-                     *put++ = *from++;
-                  } while (--copy);
-                  if (state->length == 0) state->mode = LEN;
-                  break;
-         case LIT:
-                  if (left == 0) goto inf_leave;
-                  *put++ = (unsigned char)(state->length);
-                  left--;
-                  state->mode = LEN;
-                  break;
-         case CHECK:
-                  if (state->wrap) {
-                     NEEDBITS(32);
-                     out -= left;
-                     strm->total_out += out;
-                     state->total += out;
-                     if (out)
-                        strm->adler = state->check =
-                           UPDATE(state->check, put - out, out);
-                     out = left;
-                     if ((
-#ifdef GUNZIP
-                              state->flags ? hold :
-#endif
-                              ZSWAP32(hold)) != state->check) {
-                        strm->msg = (char *)"incorrect data check";
-                        state->mode = BAD;
-                        break;
-                     }
-                     INITBITS();
-                     Tracev((stderr, "inflate:   check matches trailer\n"));
-                  }
-#ifdef GUNZIP
-                  state->mode = LENGTH;
-         case LENGTH:
-                  if (state->wrap && state->flags) {
-                     NEEDBITS(32);
-                     if (hold != (state->total & 0xffffffffUL)) {
-                        strm->msg = (char *)"incorrect length check";
-                        state->mode = BAD;
-                        break;
-                     }
-                     INITBITS();
-                     Tracev((stderr, "inflate:   length matches trailer\n"));
-                  }
-#endif
-                  state->mode = DONE;
-         case DONE:
-                  ret = Z_STREAM_END;
-                  goto inf_leave;
-         case BAD:
-                  ret = Z_DATA_ERROR;
-                  goto inf_leave;
-         case MEM:
-                  return Z_MEM_ERROR;
-         case SYNC:
-         default:
-                  return Z_STREAM_ERROR;
-      }
-
-   /*
-      Return from inflate(), updating the total counts and the check value.
-      If there was no progress during the inflate() call, return a buffer
-      error.  Call updatewindow() to create and/or update the window state.
-Note: a memory error from inflate() is non-recoverable.
-*/
-inf_leave:
-   RESTORE();
-   if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
-            (state->mode < CHECK || flush != Z_FINISH)))
-      if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
-         state->mode = MEM;
-         return Z_MEM_ERROR;
-      }
-   in -= strm->avail_in;
-   out -= strm->avail_out;
-   strm->total_in += in;
-   strm->total_out += out;
-   state->total += out;
-   if (state->wrap && out)
-      strm->adler = state->check =
-         UPDATE(state->check, strm->next_out - out, out);
-   strm->data_type = state->bits + (state->last ? 64 : 0) +
-      (state->mode == TYPE ? 128 : 0) +
-      (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
-   if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
-      ret = Z_BUF_ERROR;
-   return ret;
-}
-
-int ZEXPORT inflateEnd(z_streamp strm)
-{
-   struct inflate_state FAR *state;
-   if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == Z_NULL)
-      return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   if (state->window != Z_NULL) ZFREE(strm, state->window);
-   ZFREE(strm, strm->state);
-   strm->state = Z_NULL;
-   Tracev((stderr, "inflate: end\n"));
-   return Z_OK;
-}
-
-int ZEXPORT inflateGetDictionary(z_streamp strm, Bytef *dictionary, uInt *dictLength)
-{
-   struct inflate_state FAR *state;
-
-   /* check state */
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-
-   /* copy dictionary */
-   if (state->whave && dictionary != Z_NULL) {
-      zmemcpy(dictionary, state->window + state->wnext,
-            state->whave - state->wnext);
-      zmemcpy(dictionary + state->whave - state->wnext,
-            state->window, state->wnext);
-   }
-   if (dictLength != Z_NULL)
-      *dictLength = state->whave;
-   return Z_OK;
-}
-
-int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
-{
-   struct inflate_state FAR *state;
-   unsigned long dictid;
-   int ret;
-
-   /* check state */
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   if (state->wrap != 0 && state->mode != DICT)
-      return Z_STREAM_ERROR;
-
-   /* check for correct dictionary identifier */
-   if (state->mode == DICT) {
-      dictid = adler32(0L, Z_NULL, 0);
-      dictid = adler32(dictid, dictionary, dictLength);
-      if (dictid != state->check)
-         return Z_DATA_ERROR;
-   }
-
-   /* copy dictionary to window using updatewindow(), which will amend the
-      existing dictionary if appropriate */
-   ret = updatewindow(strm, dictionary + dictLength, dictLength);
-   if (ret) {
-      state->mode = MEM;
-      return Z_MEM_ERROR;
-   }
-   state->havedict = 1;
-   Tracev((stderr, "inflate:   dictionary set\n"));
-   return Z_OK;
-}
-
-int ZEXPORT inflateGetHeader(z_streamp strm, gz_headerp head)
-{
-   struct inflate_state FAR *state;
-
-   /* check state */
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
-
-   /* save header structure */
-   state->head = head;
-   head->done = 0;
-   return Z_OK;
-}
-
-/*
-   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
-   or when out of input.  When called, *have is the number of pattern bytes
-   found in order so far, in 0..3.  On return *have is updated to the new
-   state.  If on return *have equals four, then the pattern was found and the
-   return value is how many bytes were read including the last byte of the
-   pattern.  If *have is less than four, then the pattern has not been found
-   yet and the return value is len.  In the latter case, syncsearch() can be
-   called again with more data and the *have state.  *have is initialized to
-   zero for the first call.
-   */
-local unsigned syncsearch(unsigned FAR *have, const unsigned char FAR *buf, unsigned len)
-{
-   unsigned got;
-   unsigned next;
-
-   got = *have;
-   next = 0;
-   while (next < len && got < 4) {
-      if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
-         got++;
-      else if (buf[next])
-         got = 0;
-      else
-         got = 4 - got;
-      next++;
-   }
-   *have = got;
-   return next;
-}
-
-int ZEXPORT inflateSync(z_streamp strm)
-{
-   unsigned len;               /* number of bytes to look at or looked at */
-   unsigned long in, out;      /* temporary to save total_in and total_out */
-   unsigned char buf[4];       /* to restore bit buffer to byte string */
-   struct inflate_state FAR *state;
-
-   /* check parameters */
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
-
-   /* if first time, start search in bit buffer */
-   if (state->mode != SYNC) {
-      state->mode = SYNC;
-      state->hold <<= state->bits & 7;
-      state->bits -= state->bits & 7;
-      len = 0;
-      while (state->bits >= 8) {
-         buf[len++] = (unsigned char)(state->hold);
-         state->hold >>= 8;
-         state->bits -= 8;
-      }
-      state->have = 0;
-      syncsearch(&(state->have), buf, len);
-   }
-
-   /* search available input */
-   len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
-   strm->avail_in -= len;
-   strm->next_in += len;
-   strm->total_in += len;
-
-   /* return no joy or set up to restart inflate() on a new block */
-   if (state->have != 4) return Z_DATA_ERROR;
-   in = strm->total_in;  out = strm->total_out;
-   inflateReset(strm);
-   strm->total_in = in;  strm->total_out = out;
-   state->mode = TYPE;
-   return Z_OK;
-}
-
-/*
-   Returns true if inflate is currently at the end of a block generated by
-   Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
-   implementation to provide an additional safety check. PPP uses
-   Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
-   block. When decompressing, PPP checks that at the end of input packet,
-   inflate is waiting for these length bytes.
-   */
-int ZEXPORT inflateSyncPoint(z_streamp strm)
-{
-   struct inflate_state FAR *state;
-
-   if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   return state->mode == STORED && state->bits == 0;
-}
-
-int ZEXPORT inflateCopy(z_streamp dest, z_streamp source)
-{
-   struct inflate_state FAR *state;
-   struct inflate_state FAR *copy;
-   unsigned char FAR *window;
-   unsigned wsize;
-
-   /* check input */
-   if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
-         source->zalloc == Z_NULL || source->zfree == Z_NULL)
-      return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)source->state;
-
-   /* allocate space */
-   copy = (struct inflate_state FAR *)
-      ZALLOC(source, 1, sizeof(struct inflate_state));
-   if (copy == Z_NULL) return Z_MEM_ERROR;
-   window = Z_NULL;
-   if (state->window != Z_NULL) {
-      window = (unsigned char FAR *)
-         ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
-      if (window == Z_NULL) {
-         ZFREE(source, copy);
-         return Z_MEM_ERROR;
-      }
-   }
-
-   /* copy state */
-   zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
-   zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
-   if (state->lencode >= state->codes &&
-         state->lencode <= state->codes + ENOUGH - 1) {
-      copy->lencode = copy->codes + (state->lencode - state->codes);
-      copy->distcode = copy->codes + (state->distcode - state->codes);
-   }
-   copy->next = copy->codes + (state->next - state->codes);
-   if (window != Z_NULL) {
-      wsize = 1U << state->wbits;
-      zmemcpy(window, state->window, wsize);
-   }
-   copy->window = window;
-   dest->state = (struct internal_state FAR *)copy;
-   return Z_OK;
-}
-
-int ZEXPORT inflateUndermine(z_streamp strm, int subvert)
-{
-   struct inflate_state FAR *state = NULL;
-
-   if (strm == Z_NULL || strm->state == Z_NULL)
-	   return Z_STREAM_ERROR;
-   state = (struct inflate_state FAR *)strm->state;
-   state->sane = !subvert;
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-   return Z_OK;
-#else
-   state->sane = 1;
-   return Z_DATA_ERROR;
-#endif
-}
-
-long ZEXPORT inflateMark(z_streamp strm)
-{
-   struct inflate_state FAR *state = NULL;
-
-   if (strm == Z_NULL || strm->state == Z_NULL)
-	   return -1L << 16;
-   state = (struct inflate_state FAR *)strm->state;
-   return ((long)(state->back) << 16) +
-      (state->mode == COPY ? state->length :
-       (state->mode == MATCH ? state->was - state->length : 0));
-}
diff --git a/deps/inflate.h b/deps/inflate.h
deleted file mode 100644
index dbc173a..0000000
--- a/deps/inflate.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/* inflate.h -- internal inflate state definition
- * Copyright (C) 1995-2009 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* define NO_GZIP when compiling if you want to disable gzip header and
-   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
-   the crc code when it is not needed.  For shared libraries, gzip decoding
-   should be left enabled. */
-#ifndef _INFLATE_H
-#define _INFLATE_H
-
-#ifndef NO_GZIP
-#  define GUNZIP
-#endif
-
-/* Possible inflate modes between inflate() calls */
-typedef enum {
-    HEAD,       /* i: waiting for magic header */
-    FLAGS,      /* i: waiting for method and flags (gzip) */
-    TIME,       /* i: waiting for modification time (gzip) */
-    OS,         /* i: waiting for extra flags and operating system (gzip) */
-    EXLEN,      /* i: waiting for extra length (gzip) */
-    EXTRA,      /* i: waiting for extra bytes (gzip) */
-    NAME,       /* i: waiting for end of file name (gzip) */
-    COMMENT,    /* i: waiting for end of comment (gzip) */
-    HCRC,       /* i: waiting for header crc (gzip) */
-    DICTID,     /* i: waiting for dictionary check value */
-    DICT,       /* waiting for inflateSetDictionary() call */
-        TYPE,       /* i: waiting for type bits, including last-flag bit */
-        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
-        STORED,     /* i: waiting for stored size (length and complement) */
-        COPY_,      /* i/o: same as COPY below, but only first time in */
-        COPY,       /* i/o: waiting for input or output to copy stored block */
-        TABLE,      /* i: waiting for dynamic block table lengths */
-        LENLENS,    /* i: waiting for code length code lengths */
-        CODELENS,   /* i: waiting for length/lit and distance code lengths */
-            LEN_,       /* i: same as LEN below, but only first time in */
-            LEN,        /* i: waiting for length/lit/eob code */
-            LENEXT,     /* i: waiting for length extra bits */
-            DIST,       /* i: waiting for distance code */
-            DISTEXT,    /* i: waiting for distance extra bits */
-            MATCH,      /* o: waiting for output space to copy string */
-            LIT,        /* o: waiting for output space to write literal */
-    CHECK,      /* i: waiting for 32-bit check value */
-    LENGTH,     /* i: waiting for 32-bit length (gzip) */
-    DONE,       /* finished check, done -- remain here until reset */
-    BAD,        /* got a data error -- remain here until reset */
-    MEM,        /* got an inflate() memory error -- remain here until reset */
-    SYNC        /* looking for synchronization bytes to restart inflate() */
-} inflate_mode;
-
-/*
-    State transitions between above modes -
-
-    (most modes can go to BAD or MEM on error -- not shown for clarity)
-
-    Process header:
-        HEAD -> (gzip) or (zlib) or (raw)
-        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
-                  HCRC -> TYPE
-        (zlib) -> DICTID or TYPE
-        DICTID -> DICT -> TYPE
-        (raw) -> TYPEDO
-    Read deflate blocks:
-            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
-            STORED -> COPY_ -> COPY -> TYPE
-            TABLE -> LENLENS -> CODELENS -> LEN_
-            LEN_ -> LEN
-    Read deflate codes in fixed or dynamic block:
-                LEN -> LENEXT or LIT or TYPE
-                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
-                LIT -> LEN
-    Process trailer:
-        CHECK -> LENGTH -> DONE
- */
-
-/* state maintained between inflate() calls.  Approximately 10K bytes. */
-struct inflate_state {
-    inflate_mode mode;          /* current inflate mode */
-    int last;                   /* true if processing last block */
-    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip */
-    int havedict;               /* true if dictionary provided */
-    int flags;                  /* gzip header method and flags (0 if zlib) */
-    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
-    unsigned long check;        /* protected copy of check value */
-    unsigned long total;        /* protected copy of output count */
-    gz_headerp head;            /* where to save gzip header information */
-        /* sliding window */
-    unsigned wbits;             /* log base 2 of requested window size */
-    unsigned wsize;             /* window size or zero if not using window */
-    unsigned whave;             /* valid bytes in the window */
-    unsigned wnext;             /* window write index */
-    unsigned char FAR *window;  /* allocated sliding window, if needed */
-        /* bit accumulator */
-    unsigned long hold;         /* input bit accumulator */
-    unsigned bits;              /* number of bits in "in" */
-        /* for string and stored block copying */
-    unsigned length;            /* literal or length of data to copy */
-    unsigned offset;            /* distance back to copy string from */
-        /* for table and code decoding */
-    unsigned extra;             /* extra bits needed */
-        /* fixed and dynamic code tables */
-    code const FAR *lencode;    /* starting table for length/literal codes */
-    code const FAR *distcode;   /* starting table for distance codes */
-    unsigned lenbits;           /* index bits for lencode */
-    unsigned distbits;          /* index bits for distcode */
-        /* dynamic table building */
-    unsigned ncode;             /* number of code length code lengths */
-    unsigned nlen;              /* number of length code lengths */
-    unsigned ndist;             /* number of distance code lengths */
-    unsigned have;              /* number of code lengths in lens[] */
-    code FAR *next;             /* next available space in codes[] */
-    unsigned short lens[320];   /* temporary storage for code lengths */
-    unsigned short work[288];   /* work area for code table building */
-    code codes[ENOUGH];         /* space for code tables */
-    int sane;                   /* if false, allow invalid distance too far */
-    int back;                   /* bits back of last unprocessed length/lit */
-    unsigned was;               /* initial length of match */
-};
-
-#endif
diff --git a/deps/inftrees.c b/deps/inftrees.c
deleted file mode 100644
index 8b8a964..0000000
--- a/deps/inftrees.c
+++ /dev/null
@@ -1,300 +0,0 @@
-/* inftrees.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-
-#define MAXBITS 15
-
-const char inflate_copyright[] =
-" inflate 1.2.8 Copyright 1995-2013 Mark Adler ";
-/*
-   If you use the zlib library in a product, an acknowledgment is welcome
-   in the documentation of your product. If for some reason you cannot
-   include such an acknowledgment, I would appreciate that you keep this
-   copyright string in the executable of your product.
-   */
-
-/*
-   Build a set of tables to decode the provided canonical Huffman code.
-   The code lengths are lens[0..codes-1].  The result starts at *table,
-   whose indices are 0..2^bits-1.  work is a writable array of at least
-   lens shorts, which is used as a work area.  type is the type of code
-   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
-   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
-   on return points to the next available entry's address.  bits is the
-   requested root table index bits, and on return it is the actual root
-   table index bits.  It will differ if the request is greater than the
-   longest code or if it is less than the shortest code.
-   */
-int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, unsigned codes, code FAR * FAR *table, unsigned FAR *bits, unsigned short FAR *work)
-{
-   unsigned len;               /* a code's length in bits */
-   unsigned sym;               /* index of code symbols */
-   unsigned min, max;          /* minimum and maximum code lengths */
-   unsigned root;              /* number of index bits for root table */
-   unsigned curr;              /* number of index bits for current table */
-   unsigned drop;              /* code bits to drop for sub-table */
-   int left;                   /* number of prefix codes available */
-   unsigned used;              /* code entries in table used */
-   unsigned huff;              /* Huffman code */
-   unsigned incr;              /* for incrementing code, index */
-   unsigned fill;              /* index for replicating entries */
-   unsigned low;               /* low bits for current root entry */
-   unsigned mask;              /* mask for low root bits */
-   code here;                  /* table entry for duplication */
-   code FAR *next;             /* next available space in table */
-   const unsigned short FAR *base;     /* base value table to use */
-   const unsigned short FAR *extra;    /* extra bits table to use */
-   int end;                    /* use base and extra for symbol > end */
-   unsigned short count[MAXBITS+1];    /* number of codes of each length */
-   unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
-   static const unsigned short lbase[31] = { /* Length codes 257..285 base */
-      3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
-      35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
-   static const unsigned short lext[31] = { /* Length codes 257..285 extra */
-      16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-      19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
-   static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
-      1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
-      257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
-      8193, 12289, 16385, 24577, 0, 0};
-   static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
-      16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
-      23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
-      28, 28, 29, 29, 64, 64};
-
-   /*
-      Process a set of code lengths to create a canonical Huffman code.  The
-      code lengths are lens[0..codes-1].  Each length corresponds to the
-      symbols 0..codes-1.  The Huffman code is generated by first sorting the
-      symbols by length from short to long, and retaining the symbol order
-      for codes with equal lengths.  Then the code starts with all zero bits
-      for the first code of the shortest length, and the codes are integer
-      increments for the same length, and zeros are appended as the length
-      increases.  For the deflate format, these bits are stored backwards
-      from their more natural integer increment ordering, and so when the
-      decoding tables are built in the large loop below, the integer codes
-      are incremented backwards.
-
-      This routine assumes, but does not check, that all of the entries in
-      lens[] are in the range 0..MAXBITS.  The caller must assure this.
-      1..MAXBITS is interpreted as that code length.  zero means that that
-      symbol does not occur in this code.
-
-      The codes are sorted by computing a count of codes for each length,
-      creating from that a table of starting indices for each length in the
-      sorted table, and then entering the symbols in order in the sorted
-      table.  The sorted table is work[], with that space being provided by
-      the caller.
-
-      The length counts are used for other purposes as well, i.e. finding
-      the minimum and maximum length codes, determining if there are any
-      codes at all, checking for a valid set of lengths, and looking ahead
-      at length counts to determine sub-table sizes when building the
-      decoding tables.
-      */
-
-   /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
-   for (len = 0; len <= MAXBITS; len++)
-      count[len] = 0;
-   for (sym = 0; sym < codes; sym++)
-      count[lens[sym]]++;
-
-   /* bound code lengths, force root to be within code lengths */
-   root = *bits;
-   for (max = MAXBITS; max >= 1; max--)
-      if (count[max] != 0) break;
-   if (root > max) root = max;
-   if (max == 0) {                     /* no symbols to code at all */
-      here.op = (unsigned char)64;    /* invalid code marker */
-      here.bits = (unsigned char)1;
-      here.val = (unsigned short)0;
-      *(*table)++ = here;             /* make a table to force an error */
-      *(*table)++ = here;
-      *bits = 1;
-      return 0;     /* no symbols, but wait for decoding to report error */
-   }
-   for (min = 1; min < max; min++)
-      if (count[min] != 0) break;
-   if (root < min) root = min;
-
-   /* check for an over-subscribed or incomplete set of lengths */
-   left = 1;
-   for (len = 1; len <= MAXBITS; len++) {
-      left <<= 1;
-      left -= count[len];
-      if (left < 0) return -1;        /* over-subscribed */
-   }
-   if (left > 0 && (type == CODES || max != 1))
-      return -1;                      /* incomplete set */
-
-   /* generate offsets into symbol table for each length for sorting */
-   offs[1] = 0;
-   for (len = 1; len < MAXBITS; len++)
-      offs[len + 1] = offs[len] + count[len];
-
-   /* sort symbols by length, by symbol order within each length */
-   for (sym = 0; sym < codes; sym++)
-      if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
-
-   /*
-      Create and fill in decoding tables.  In this loop, the table being
-      filled is at next and has curr index bits.  The code being used is huff
-      with length len.  That code is converted to an index by dropping drop
-      bits off of the bottom.  For codes where len is less than drop + curr,
-      those top drop + curr - len bits are incremented through all values to
-      fill the table with replicated entries.
-
-      root is the number of index bits for the root table.  When len exceeds
-      root, sub-tables are created pointed to by the root entry with an index
-      of the low root bits of huff.  This is saved in low to check for when a
-      new sub-table should be started.  drop is zero when the root table is
-      being filled, and drop is root when sub-tables are being filled.
-
-      When a new sub-table is needed, it is necessary to look ahead in the
-      code lengths to determine what size sub-table is needed.  The length
-      counts are used for this, and so count[] is decremented as codes are
-      entered in the tables.
-
-      used keeps track of how many table entries have been allocated from the
-      provided *table space.  It is checked for LENS and DIST tables against
-      the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
-      the initial root table size constants.  See the comments in inftrees.h
-      for more information.
-
-      sym increments through all symbols, and the loop terminates when
-      all codes of length max, i.e. all codes, have been processed.  This
-      routine permits incomplete codes, so another loop after this one fills
-      in the rest of the decoding tables with invalid code markers.
-      */
-
-   /* set up for code type */
-   switch (type) {
-      case CODES:
-         base = extra = work;    /* dummy value--not used */
-         end = 19;
-         break;
-      case LENS:
-         base = lbase;
-         base -= 257;
-         extra = lext;
-         extra -= 257;
-         end = 256;
-         break;
-      default:            /* DISTS */
-         base = dbase;
-         extra = dext;
-         end = -1;
-   }
-
-   /* initialize state for loop */
-   huff = 0;                   /* starting code */
-   sym = 0;                    /* starting code symbol */
-   len = min;                  /* starting code length */
-   next = *table;              /* current table to fill in */
-   curr = root;                /* current table index bits */
-   drop = 0;                   /* current bits to drop from code for index */
-   low = (unsigned)(-1);       /* trigger new sub-table when len > root */
-   used = 1U << root;          /* use root table entries */
-   mask = used - 1;            /* mask for comparing low */
-
-   /* check available table space */
-   if ((type == LENS && used > ENOUGH_LENS) ||
-         (type == DISTS && used > ENOUGH_DISTS))
-      return 1;
-
-   /* process all codes and make table entries */
-   for (;;) {
-      /* create table entry */
-      here.bits = (unsigned char)(len - drop);
-      if ((int)(work[sym]) < end) {
-         here.op = (unsigned char)0;
-         here.val = work[sym];
-      }
-      else if ((int)(work[sym]) > end) {
-         here.op = (unsigned char)(extra[work[sym]]);
-         here.val = base[work[sym]];
-      }
-      else {
-         here.op = (unsigned char)(32 + 64);         /* end of block */
-         here.val = 0;
-      }
-
-      /* replicate for those indices with low len bits equal to huff */
-      incr = 1U << (len - drop);
-      fill = 1U << curr;
-      min = fill;                 /* save offset to next table */
-      do {
-         fill -= incr;
-         next[(huff >> drop) + fill] = here;
-      } while (fill != 0);
-
-      /* backwards increment the len-bit code huff */
-      incr = 1U << (len - 1);
-      while (huff & incr)
-         incr >>= 1;
-      if (incr != 0) {
-         huff &= incr - 1;
-         huff += incr;
-      }
-      else
-         huff = 0;
-
-      /* go to next symbol, update count, len */
-      sym++;
-      if (--(count[len]) == 0) {
-         if (len == max) break;
-         len = lens[work[sym]];
-      }
-
-      /* create new sub-table if needed */
-      if (len > root && (huff & mask) != low) {
-         /* if first time, transition to sub-tables */
-         if (drop == 0)
-            drop = root;
-
-         /* increment past last table */
-         next += min;            /* here min is 1 << curr */
-
-         /* determine length of next table */
-         curr = len - drop;
-         left = (int)(1 << curr);
-         while (curr + drop < max) {
-            left -= count[curr + drop];
-            if (left <= 0) break;
-            curr++;
-            left <<= 1;
-         }
-
-         /* check for enough space */
-         used += 1U << curr;
-         if ((type == LENS && used > ENOUGH_LENS) ||
-               (type == DISTS && used > ENOUGH_DISTS))
-            return 1;
-
-         /* point entry in root table to sub-table */
-         low = huff & mask;
-         (*table)[low].op = (unsigned char)curr;
-         (*table)[low].bits = (unsigned char)root;
-         (*table)[low].val = (unsigned short)(next - *table);
-      }
-   }
-
-   /* fill in remaining table entry if code is incomplete (guaranteed to have
-      at most one remaining entry, since if the code is incomplete, the
-      maximum code length that was allowed to get this far is one bit) */
-   if (huff != 0) {
-      here.op = (unsigned char)64;            /* invalid code marker */
-      here.bits = (unsigned char)(len - drop);
-      here.val = (unsigned short)0;
-      next[huff] = here;
-   }
-
-   /* set return parameters */
-   *table += used;
-   *bits = root;
-   return 0;
-}
diff --git a/deps/inftrees.h b/deps/inftrees.h
deleted file mode 100644
index cd9e67c..0000000
--- a/deps/inftrees.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/* inftrees.h -- header to use inftrees.c
- * Copyright (C) 1995-2005, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-#ifndef _INFTREES_H
-#define _INFTREES_H
-
-/* Structure for decoding tables.  Each entry provides either the
-   information needed to do the operation requested by the code that
-   indexed that table entry, or it provides a pointer to another
-   table that indexes more bits of the code.  op indicates whether
-   the entry is a pointer to another table, a literal, a length or
-   distance, an end-of-block, or an invalid code.  For a table
-   pointer, the low four bits of op is the number of index bits of
-   that table.  For a length or distance, the low four bits of op
-   is the number of extra bits to get after the code.  bits is
-   the number of bits in this code or part of the code to drop off
-   of the bit buffer.  val is the actual byte to output in the case
-   of a literal, the base length or distance, or the offset from
-   the current table to the next table.  Each entry is four bytes. */
-typedef struct {
-    unsigned char op;           /* operation, extra bits, table bits */
-    unsigned char bits;         /* bits in this part of the code */
-    unsigned short val;         /* offset in table or code value */
-} code;
-
-/* op values as set by inflate_table():
-    00000000 - literal
-    0000tttt - table link, tttt != 0 is the number of table index bits
-    0001eeee - length or distance, eeee is the number of extra bits
-    01100000 - end of block
-    01000000 - invalid code
- */
-
-/* Maximum size of the dynamic table.  The maximum number of code structures is
-   1444, which is the sum of 852 for literal/length codes and 592 for distance
-   codes.  These values were found by exhaustive searches using the program
-   examples/enough.c found in the zlib distribtution.  The arguments to that
-   program are the number of symbols, the initial root table size, and the
-   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
-   returns returns 852, and "enough 30 6 15" for distance codes returns 592.
-   The initial root table size (9 or 6) is found in the fifth argument of the
-   inflate_table() calls in inflate.c and infback.c.  If the root table size is
-   changed, then these maximum sizes would be need to be recalculated and
-   updated. */
-#define ENOUGH_LENS 852
-#define ENOUGH_DISTS 592
-#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
-
-/* Type of code to build for inflate_table() */
-typedef enum {
-    CODES,
-    LENS,
-    DISTS
-} codetype;
-
-int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
-                             unsigned codes, code FAR * FAR *table,
-                             unsigned FAR *bits, unsigned short FAR *work));
-
-#endif
diff --git a/deps/ioapi.c b/deps/ioapi.c
deleted file mode 100644
index 767ac2f..0000000
--- a/deps/ioapi.c
+++ /dev/null
@@ -1,236 +0,0 @@
-/* ioapi.h -- IO base function header for compress/uncompress .zip
-   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
-
-   Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
-
-   Modifications for Zip64 support
-   Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
-
-   For more info read MiniZip_info.txt
-
-*/
-
-#ifdef _WIN32
-#ifndef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-#endif
-
-#include "ioapi.h"
-
-voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
-{
-   if (pfilefunc->zfile_func64.zopen64_file != NULL)
-      return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
-   else
-   {
-      return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
-   }
-}
-
-long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
-{
-   if (pfilefunc->zfile_func64.zseek64_file != NULL)
-      return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
-   else
-   {
-      uLong offsetTruncated = (uLong)offset;
-      if (offsetTruncated != offset)
-         return -1;
-      else
-         return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
-   }
-}
-
-ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
-{
-   if (pfilefunc->zfile_func64.zseek64_file != NULL)
-      return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
-   else
-   {
-      uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
-      if ((tell_uLong) == ((uLong)-1))
-         return (ZPOS64_T)-1;
-      else
-         return tell_uLong;
-   }
-}
-
-void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
-{
-   p_filefunc64_32->zfile_func64.zopen64_file = NULL;
-   p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
-   p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
-   p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
-   p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
-   p_filefunc64_32->zfile_func64.ztell64_file = NULL;
-   p_filefunc64_32->zfile_func64.zseek64_file = NULL;
-   p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
-   p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
-   p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
-   p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
-   p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
-}
-
-
-
-static voidpf  ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
-static uLong   ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
-static uLong   ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
-static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
-static long    ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
-static int     ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
-static int     ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
-
-static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
-{
-   FILE* file = NULL;
-   const char* mode_fopen = NULL;
-   if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
-      mode_fopen = "rb";
-   else
-      if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
-         mode_fopen = "r+b";
-      else
-         if (mode & ZLIB_FILEFUNC_MODE_CREATE)
-            mode_fopen = "wb";
-
-   if ((filename!=NULL) && (mode_fopen != NULL))
-      file = fopen(filename, mode_fopen);
-   return file;
-}
-
-static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
-{
-   FILE* file = NULL;
-   const char* mode_fopen = NULL;
-   if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
-      mode_fopen = "rb";
-   else
-      if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
-         mode_fopen = "r+b";
-      else
-         if (mode & ZLIB_FILEFUNC_MODE_CREATE)
-            mode_fopen = "wb";
-
-   if ((filename!=NULL) && (mode_fopen != NULL))
-      file = fopen((const char*)filename, mode_fopen);
-   return file;
-}
-
-
-static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
-{
-   uLong ret;
-   ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
-   return ret;
-}
-
-static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
-{
-   uLong ret;
-   ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
-   return ret;
-}
-
-static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
-{
-   long ret;
-   ret = ftell((FILE *)stream);
-   return ret;
-}
-
-
-static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
-{
-   ZPOS64_T ret;
-   ret = ftell((FILE *)stream);
-   return ret;
-}
-
-static long ZCALLBACK fseek_file_func (voidpf  opaque, voidpf stream, uLong offset, int origin)
-{
-   int fseek_origin=0;
-   long ret;
-   switch (origin)
-   {
-      case ZLIB_FILEFUNC_SEEK_CUR :
-         fseek_origin = SEEK_CUR;
-         break;
-      case ZLIB_FILEFUNC_SEEK_END :
-         fseek_origin = SEEK_END;
-         break;
-      case ZLIB_FILEFUNC_SEEK_SET :
-         fseek_origin = SEEK_SET;
-         break;
-      default: return -1;
-   }
-   ret = 0;
-   if (fseek((FILE *)stream, offset, fseek_origin) != 0)
-      ret = -1;
-   return ret;
-}
-
-static long ZCALLBACK fseek64_file_func (voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
-{
-   int fseek_origin=0;
-   long ret;
-   switch (origin)
-   {
-      case ZLIB_FILEFUNC_SEEK_CUR :
-         fseek_origin = SEEK_CUR;
-         break;
-      case ZLIB_FILEFUNC_SEEK_END :
-         fseek_origin = SEEK_END;
-         break;
-      case ZLIB_FILEFUNC_SEEK_SET :
-         fseek_origin = SEEK_SET;
-         break;
-      default: return -1;
-   }
-   ret = 0;
-
-   if(fseek((FILE *)stream, (long)offset, fseek_origin) != 0)
-      ret = -1;
-
-   return ret;
-}
-
-
-static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
-{
-   int ret;
-   ret = fclose((FILE *)stream);
-   return ret;
-}
-
-static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
-{
-   int ret;
-   ret = ferror((FILE *)stream);
-   return ret;
-}
-
-void fill_fopen_filefunc (zlib_filefunc_def *pzlib_filefunc_def)
-{
-   pzlib_filefunc_def->zopen_file = fopen_file_func;
-   pzlib_filefunc_def->zread_file = fread_file_func;
-   pzlib_filefunc_def->zwrite_file = fwrite_file_func;
-   pzlib_filefunc_def->ztell_file = ftell_file_func;
-   pzlib_filefunc_def->zseek_file = fseek_file_func;
-   pzlib_filefunc_def->zclose_file = fclose_file_func;
-   pzlib_filefunc_def->zerror_file = ferror_file_func;
-   pzlib_filefunc_def->opaque = NULL;
-}
-
-void fill_fopen64_filefunc (zlib_filefunc64_def*  pzlib_filefunc_def)
-{
-   pzlib_filefunc_def->zopen64_file = fopen64_file_func;
-   pzlib_filefunc_def->zread_file = fread_file_func;
-   pzlib_filefunc_def->zwrite_file = fwrite_file_func;
-   pzlib_filefunc_def->ztell64_file = ftell64_file_func;
-   pzlib_filefunc_def->zseek64_file = fseek64_file_func;
-   pzlib_filefunc_def->zclose_file = fclose_file_func;
-   pzlib_filefunc_def->zerror_file = ferror_file_func;
-   pzlib_filefunc_def->opaque = NULL;
-}
diff --git a/deps/ioapi.h b/deps/ioapi.h
deleted file mode 100644
index 8309c4c..0000000
--- a/deps/ioapi.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/* ioapi.h -- IO base function header for compress/uncompress .zip
-   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
-
-         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
-
-         Modifications for Zip64 support
-         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
-
-         For more info read MiniZip_info.txt
-
-         Changes
-
-    Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
-    Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
-               More if/def section may be needed to support other platforms
-    Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
-                          (but you should use iowin32.c for windows instead)
-
-*/
-
-#ifndef _ZLIBIOAPI64_H
-#define _ZLIBIOAPI64_H
-
-#if (!defined(_WIN32)) && (!defined(WIN32))
-
-  // Linux needs this to support file operation on files larger then 4+GB
-  // But might need better if/def to select just the platforms that needs them.
-
-        #ifndef __USE_FILE_OFFSET64
-                #define __USE_FILE_OFFSET64
-        #endif
-        #ifndef __USE_LARGEFILE64
-                #define __USE_LARGEFILE64
-        #endif
-        #ifndef _LARGEFILE64_SOURCE
-                #define _LARGEFILE64_SOURCE
-        #endif
-        #ifndef _FILE_OFFSET_BIT
-                #define _FILE_OFFSET_BIT 64
-        #endif
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "zlib.h"
-
-#if defined(USE_FILE32API)
-#define fopen64 fopen
-#define ftello64 ftell
-#define fseeko64 fseek
-#else
-#ifdef _MSC_VER
- #define fopen64 fopen
- #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
-  #define ftello64 _ftelli64
-  #define fseeko64 _fseeki64
- #else // old MSC
-  #define ftello64 ftell
-  #define fseeko64 fseek
- #endif
-#endif
-#endif
-
-/*
-#ifndef ZPOS64_T
-  #ifdef _WIN32
-                #define ZPOS64_T fpos_t
-  #else
-    #include <stdint.h>
-    #define ZPOS64_T uint64_t
-  #endif
-#endif
-*/
-
-#ifdef HAVE_MINIZIP64_CONF_H
-#include "mz64conf.h"
-#endif
-
-/* a type choosen by DEFINE */
-#ifdef HAVE_64BIT_INT_CUSTOM
-typedef  64BIT_INT_CUSTOM_TYPE ZPOS64_T;
-#else
-#ifdef HAS_STDINT_H
-#include "stdint.h"
-typedef uint64_t ZPOS64_T;
-#else
-
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-typedef unsigned __int64 ZPOS64_T;
-#else
-typedef unsigned long long int ZPOS64_T;
-#endif
-#endif
-#endif
-
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#define ZLIB_FILEFUNC_SEEK_CUR (1)
-#define ZLIB_FILEFUNC_SEEK_END (2)
-#define ZLIB_FILEFUNC_SEEK_SET (0)
-
-#define ZLIB_FILEFUNC_MODE_READ      (1)
-#define ZLIB_FILEFUNC_MODE_WRITE     (2)
-#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
-
-#define ZLIB_FILEFUNC_MODE_EXISTING (4)
-#define ZLIB_FILEFUNC_MODE_CREATE   (8)
-
-
-#ifndef ZCALLBACK
- #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
-   #define ZCALLBACK CALLBACK
- #else
-   #define ZCALLBACK
- #endif
-#endif
-
-
-
-
-typedef voidpf   (ZCALLBACK *open_file_func)      OF((voidpf opaque, const char* filename, int mode));
-typedef uLong    (ZCALLBACK *read_file_func)      OF((voidpf opaque, voidpf stream, void* buf, uLong size));
-typedef uLong    (ZCALLBACK *write_file_func)     OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
-typedef int      (ZCALLBACK *close_file_func)     OF((voidpf opaque, voidpf stream));
-typedef int      (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
-
-typedef long     (ZCALLBACK *tell_file_func)      OF((voidpf opaque, voidpf stream));
-typedef long     (ZCALLBACK *seek_file_func)      OF((voidpf opaque, voidpf stream, uLong offset, int origin));
-
-
-/* here is the "old" 32 bits structure structure */
-typedef struct zlib_filefunc_def_s
-{
-    open_file_func      zopen_file;
-    read_file_func      zread_file;
-    write_file_func     zwrite_file;
-    tell_file_func      ztell_file;
-    seek_file_func      zseek_file;
-    close_file_func     zclose_file;
-    testerror_file_func zerror_file;
-    voidpf              opaque;
-} zlib_filefunc_def;
-
-typedef ZPOS64_T (ZCALLBACK *tell64_file_func)    OF((voidpf opaque, voidpf stream));
-typedef long     (ZCALLBACK *seek64_file_func)    OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
-typedef voidpf   (ZCALLBACK *open64_file_func)    OF((voidpf opaque, const void* filename, int mode));
-
-typedef struct zlib_filefunc64_def_s
-{
-    open64_file_func    zopen64_file;
-    read_file_func      zread_file;
-    write_file_func     zwrite_file;
-    tell64_file_func    ztell64_file;
-    seek64_file_func    zseek64_file;
-    close_file_func     zclose_file;
-    testerror_file_func zerror_file;
-    voidpf              opaque;
-} zlib_filefunc64_def;
-
-void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
-void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
-
-/* now internal definition, only for zip.c and unzip.h */
-typedef struct zlib_filefunc64_32_def_s
-{
-    zlib_filefunc64_def zfile_func64;
-    open_file_func      zopen32_file;
-    tell_file_func      ztell32_file;
-    seek_file_func      zseek32_file;
-} zlib_filefunc64_32_def;
-
-
-#define ZREAD64(filefunc,filestream,buf,size)     ((*((filefunc).zfile_func64.zread_file))   ((filefunc).zfile_func64.opaque,filestream,buf,size))
-#define ZWRITE64(filefunc,filestream,buf,size)    ((*((filefunc).zfile_func64.zwrite_file))  ((filefunc).zfile_func64.opaque,filestream,buf,size))
-//#define ZTELL64(filefunc,filestream)            ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
-//#define ZSEEK64(filefunc,filestream,pos,mode)   ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
-#define ZCLOSE64(filefunc,filestream)             ((*((filefunc).zfile_func64.zclose_file))  ((filefunc).zfile_func64.opaque,filestream))
-#define ZERROR64(filefunc,filestream)             ((*((filefunc).zfile_func64.zerror_file))  ((filefunc).zfile_func64.opaque,filestream))
-
-voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
-long    call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
-ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
-
-void    fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
-
-#define ZOPEN64(filefunc,filename,mode)         (call_zopen64((&(filefunc)),(filename),(mode)))
-#define ZTELL64(filefunc,filestream)            (call_ztell64((&(filefunc)),(filestream)))
-#define ZSEEK64(filefunc,filestream,pos,mode)   (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/deps/trees.c b/deps/trees.c
deleted file mode 100644
index fa41a13..0000000
--- a/deps/trees.c
+++ /dev/null
@@ -1,1177 +0,0 @@
-/* trees.c -- output deflated data using Huffman coding
- * Copyright (C) 1995-2012 Jean-loup Gailly
- * detect_data_type() function provided freely by Cosmin Truta, 2006
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
- *  ALGORITHM
- *
- *      The "deflation" process uses several Huffman trees. The more
- *      common source values are represented by shorter bit sequences.
- *
- *      Each code tree is stored in a compressed form which is itself
- * a Huffman encoding of the lengths of all the code strings (in
- * ascending order by source values).  The actual code strings are
- * reconstructed from the lengths in the inflate process, as described
- * in the deflate specification.
- *
- *  REFERENCES
- *
- *      Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
- *      Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
- *
- *      Storer, James A.
- *          Data Compression:  Methods and Theory, pp. 49-50.
- *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
- *
- *      Sedgewick, R.
- *          Algorithms, p290.
- *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
- */
-
-/* @(#) $Id$ */
-
-/* #define GEN_TREES_H */
-
-#include "deflate.h"
-
-#ifdef DEBUG
-#  include <ctype.h>
-#endif
-
-/* ===========================================================================
- * Constants
- */
-
-#define MAX_BL_BITS 7
-/* Bit length codes must not exceed MAX_BL_BITS bits */
-
-#define END_BLOCK 256
-/* end of block literal code */
-
-#define REP_3_6      16
-/* repeat previous bit length 3-6 times (2 bits of repeat count) */
-
-#define REPZ_3_10    17
-/* repeat a zero length 3-10 times  (3 bits of repeat count) */
-
-#define REPZ_11_138  18
-/* repeat a zero length 11-138 times  (7 bits of repeat count) */
-
-local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
-= {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
-
-local const int extra_dbits[D_CODES] /* extra bits for each distance code */
-= {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
-
-local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
-= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
-
-local const uch bl_order[BL_CODES]
-= {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
-/* The lengths of the bit length codes are sent in order of decreasing
- * probability, to avoid transmitting the lengths for unused bit length codes.
- */
-
-/* ===========================================================================
- * Local data. These are initialized only once.
- */
-
-#define DIST_CODE_LEN  512 /* see definition of array dist_code below */
-
-#if defined(GEN_TREES_H) || !defined(STDC)
-/* non ANSI compilers may not accept trees.h */
-
-local ct_data static_ltree[L_CODES+2];
-/* The static literal tree. Since the bit lengths are imposed, there is no
- * need for the L_CODES extra codes used during heap construction. However
- * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
- * below).
- */
-
-local ct_data static_dtree[D_CODES];
-/* The static distance tree. (Actually a trivial tree since all codes use
- * 5 bits.)
- */
-
-uch _dist_code[DIST_CODE_LEN];
-/* Distance codes. The first 256 values correspond to the distances
- * 3 .. 258, the last 256 values correspond to the top 8 bits of
- * the 15 bit distances.
- */
-
-uch _length_code[MAX_MATCH-MIN_MATCH+1];
-/* length code for each normalized match length (0 == MIN_MATCH) */
-
-local int base_length[LENGTH_CODES];
-/* First normalized length for each code (0 = MIN_MATCH) */
-
-local int base_dist[D_CODES];
-/* First normalized distance for each code (0 = distance of 1) */
-
-#else
-#  include "trees.h"
-#endif /* GEN_TREES_H */
-
-struct static_tree_desc_s {
-   const ct_data *static_tree;  /* static tree or NULL */
-   const intf *extra_bits;      /* extra bits for each code or NULL */
-   int     extra_base;          /* base index for extra_bits */
-   int     elems;               /* max number of elements in the tree */
-   int     max_length;          /* max bit length for the codes */
-};
-
-local static_tree_desc  static_l_desc =
-{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
-
-local static_tree_desc  static_d_desc =
-{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};
-
-local static_tree_desc  static_bl_desc =
-{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};
-
-/* ===========================================================================
- * Local (static) routines in this file.
- */
-
-local void tr_static_init OF((void));
-local void init_block     OF((deflate_state *s));
-local void pqdownheap     OF((deflate_state *s, ct_data *tree, int k));
-local void gen_bitlen     OF((deflate_state *s, tree_desc *desc));
-local void gen_codes      OF((ct_data *tree, int max_code, ushf *bl_count));
-local void build_tree     OF((deflate_state *s, tree_desc *desc));
-local void scan_tree      OF((deflate_state *s, ct_data *tree, int max_code));
-local void send_tree      OF((deflate_state *s, ct_data *tree, int max_code));
-local int  build_bl_tree  OF((deflate_state *s));
-local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
-         int blcodes));
-local void compress_block OF((deflate_state *s, const ct_data *ltree,
-         const ct_data *dtree));
-local int  detect_data_type OF((deflate_state *s));
-local unsigned bi_reverse OF((unsigned value, int length));
-local void bi_windup      OF((deflate_state *s));
-local void bi_flush       OF((deflate_state *s));
-local void copy_block     OF((deflate_state *s, charf *buf, unsigned len,
-         int header));
-
-#ifdef GEN_TREES_H
-local void gen_trees_header OF((void));
-#endif
-
-#ifndef DEBUG
-#  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
-/* Send a code of the given tree. c and tree must not have side effects */
-
-#else /* DEBUG */
-#  define send_code(s, c, tree) \
-{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
-   send_bits(s, tree[c].Code, tree[c].Len); }
-#endif
-
-/* ===========================================================================
- * Output a short LSB first on the stream.
- * IN assertion: there is enough room in pendingBuf.
- */
-#define put_short(s, w) { \
-   put_byte(s, (uch)((w) & 0xff)); \
-   put_byte(s, (uch)((ush)(w) >> 8)); \
-}
-
-/* ===========================================================================
- * Send a value on a given number of bits.
- * IN assertion: length <= 16 and value fits in length bits.
- */
-#ifdef DEBUG
-local void send_bits      OF((deflate_state *s, int value, int length));
-
-local void send_bits(deflate_state *s, int value, int length)
-{
-   Tracevv((stderr," l %2d v %4x ", length, value));
-   Assert(length > 0 && length <= 15, "invalid length");
-   s->bits_sent += (ulg)length;
-
-   /* If not enough room in bi_buf, use (valid) bits from bi_buf and
-    * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
-    * unused bits in value.
-    */
-   if (s->bi_valid > (int)Buf_size - length) {
-      s->bi_buf |= (ush)value << s->bi_valid;
-      put_short(s, s->bi_buf);
-      s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
-      s->bi_valid += length - Buf_size;
-   } else {
-      s->bi_buf |= (ush)value << s->bi_valid;
-      s->bi_valid += length;
-   }
-}
-#else /* !DEBUG */
-
-#define send_bits(s, value, length) \
-{ int len = length;\
-   if (s->bi_valid > (int)Buf_size - len) {\
-      int val = value;\
-      s->bi_buf |= (ush)val << s->bi_valid;\
-      put_short(s, s->bi_buf);\
-      s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
-      s->bi_valid += len - Buf_size;\
-   } else {\
-      s->bi_buf |= (ush)(value) << s->bi_valid;\
-      s->bi_valid += len;\
-   }\
-}
-#endif /* DEBUG */
-
-
-/* the arguments must not have side effects */
-
-/* ===========================================================================
- * Initialize the various 'constant' tables.
- */
-local void tr_static_init(void)
-{
-#if defined(GEN_TREES_H) || !defined(STDC)
-   static int static_init_done = 0;
-   int n;        /* iterates over tree elements */
-   int bits;     /* bit counter */
-   int length;   /* length value */
-   int codes;    /* code value */
-   int dist;     /* distance index */
-   ush bl_count[MAX_BITS+1];
-   /* number of codes at each bit length for an optimal tree */
-
-   if (static_init_done) return;
-
-   /* For some embedded targets, global variables are not initialized: */
-#ifdef NO_INIT_GLOBAL_POINTERS
-   static_l_desc.static_tree = static_ltree;
-   static_l_desc.extra_bits = extra_lbits;
-   static_d_desc.static_tree = static_dtree;
-   static_d_desc.extra_bits = extra_dbits;
-   static_bl_desc.extra_bits = extra_blbits;
-#endif
-
-   /* Initialize the mapping length (0..255) -> length code (0..28) */
-   length = 0;
-   for (codes = 0; codes < LENGTH_CODES-1; codes++) {
-      base_length[codes] = length;
-      for (n = 0; n < (1<<extra_lbits[codes]); n++) {
-         _length_code[length++] = (uch)codes;
-      }
-   }
-   Assert (length == 256, "tr_static_init: length != 256");
-   /* Note that the length 255 (match length 258) can be represented
-    * in two different ways: code 284 + 5 bits or code 285, so we
-    * overwrite length_code[255] to use the best encoding:
-    */
-   _length_code[length-1] = (uch)codes;
-
-   /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
-   dist = 0;
-   for (codes = 0 ; codes < 16; codes++) {
-      base_dist[codes] = dist;
-      for (n = 0; n < (1<<extra_dbits[codes]); n++) {
-         _dist_code[dist++] = (uch)codes;
-      }
-   }
-   Assert (dist == 256, "tr_static_init: dist != 256");
-   dist >>= 7; /* from now on, all distances are divided by 128 */
-   for ( ; codes < D_CODES; codes++) {
-      base_dist[codes] = dist << 7;
-      for (n = 0; n < (1<<(extra_dbits[codes]-7)); n++) {
-         _dist_code[256 + dist++] = (uch)codes;
-      }
-   }
-   Assert (dist == 256, "tr_static_init: 256+dist != 512");
-
-   /* Construct the codes of the static literal tree */
-   for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
-   n = 0;
-   while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
-   while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
-   while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
-   while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
-   /* Codes 286 and 287 do not exist, but we must include them in the
-    * tree construction to get a canonical Huffman tree (longest code
-    * all ones)
-    */
-   gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
-
-   /* The static distance tree is trivial: */
-   for (n = 0; n < D_CODES; n++) {
-      static_dtree[n].Len = 5;
-      static_dtree[n].Code = bi_reverse((unsigned)n, 5);
-   }
-   static_init_done = 1;
-
-#  ifdef GEN_TREES_H
-   gen_trees_header();
-#  endif
-#endif /* defined(GEN_TREES_H) || !defined(STDC) */
-}
-
-/* ===========================================================================
- * Genererate the file trees.h describing the static trees.
- */
-#ifdef GEN_TREES_H
-#  ifndef DEBUG
-#    include <stdio.h>
-#  endif
-
-#  define SEPARATOR(i, last, width) \
-   ((i) == (last)? "\n};\n\n" :    \
-    ((i) % (width) == (width)-1 ? ",\n" : ", "))
-
-void gen_trees_header(void)
-{
-   FILE *header = fopen("trees.h", "w");
-   int i;
-
-   Assert (header != NULL, "Can't open trees.h");
-   fprintf(header,
-         "/* header created automatically with -DGEN_TREES_H */\n\n");
-
-   fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
-   for (i = 0; i < L_CODES+2; i++) {
-      fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
-            static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
-   }
-
-   fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
-   for (i = 0; i < D_CODES; i++) {
-      fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
-            static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
-   }
-
-   fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n");
-   for (i = 0; i < DIST_CODE_LEN; i++) {
-      fprintf(header, "%2u%s", _dist_code[i],
-            SEPARATOR(i, DIST_CODE_LEN-1, 20));
-   }
-
-   fprintf(header,
-         "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
-   for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
-      fprintf(header, "%2u%s", _length_code[i],
-            SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
-   }
-
-   fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
-   for (i = 0; i < LENGTH_CODES; i++) {
-      fprintf(header, "%1u%s", base_length[i],
-            SEPARATOR(i, LENGTH_CODES-1, 20));
-   }
-
-   fprintf(header, "local const int base_dist[D_CODES] = {\n");
-   for (i = 0; i < D_CODES; i++) {
-      fprintf(header, "%5u%s", base_dist[i],
-            SEPARATOR(i, D_CODES-1, 10));
-   }
-
-   fclose(header);
-}
-#endif /* GEN_TREES_H */
-
-/* ===========================================================================
- * Initialize the tree data structures for a new zlib stream.
- */
-void ZLIB_INTERNAL _tr_init(deflate_state *s)
-{
-   tr_static_init();
-
-   s->l_desc.dyn_tree = s->dyn_ltree;
-   s->l_desc.stat_desc = &static_l_desc;
-
-   s->d_desc.dyn_tree = s->dyn_dtree;
-   s->d_desc.stat_desc = &static_d_desc;
-
-   s->bl_desc.dyn_tree = s->bl_tree;
-   s->bl_desc.stat_desc = &static_bl_desc;
-
-   s->bi_buf = 0;
-   s->bi_valid = 0;
-#ifdef DEBUG
-   s->compressed_len = 0L;
-   s->bits_sent = 0L;
-#endif
-
-   /* Initialize the first block of the first file: */
-   init_block(s);
-}
-
-/* ===========================================================================
- * Initialize a new block.
- */
-local void init_block(deflate_state *s)
-{
-   int n; /* iterates over tree elements */
-
-   /* Initialize the trees. */
-   for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;
-   for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;
-   for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
-
-   s->dyn_ltree[END_BLOCK].Freq = 1;
-   s->opt_len = s->static_len = 0L;
-   s->last_lit = s->matches = 0;
-}
-
-#define SMALLEST 1
-/* Index within the heap array of least frequent node in the Huffman tree */
-
-
-/* ===========================================================================
- * Remove the smallest element from the heap and recreate the heap with
- * one less element. Updates heap and heap_len.
- */
-#define pqremove(s, tree, top) \
-{\
-   top = s->heap[SMALLEST]; \
-   s->heap[SMALLEST] = s->heap[s->heap_len--]; \
-   pqdownheap(s, tree, SMALLEST); \
-}
-
-/* ===========================================================================
- * Compares to subtrees, using the tree depth as tie breaker when
- * the subtrees have equal frequency. This minimizes the worst case length.
- */
-#define smaller(tree, n, m, depth) \
-   (tree[n].Freq < tree[m].Freq || \
-    (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
-
-/* ===========================================================================
- * Restore the heap property by moving down the tree starting at node k,
- * exchanging a node with the smallest of its two sons if necessary, stopping
- * when the heap property is re-established (each father smaller than its
- * two sons).
- */
-local void pqdownheap(deflate_state *s, ct_data *tree, int k)
-{
-   int v = s->heap[k];
-   int j = k << 1;  /* left son of k */
-   while (j <= s->heap_len) {
-      /* Set j to the smallest of the two sons: */
-      if (j < s->heap_len &&
-            smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
-         j++;
-      }
-      /* Exit if v is smaller than both sons */
-      if (smaller(tree, v, s->heap[j], s->depth)) break;
-
-      /* Exchange v with the smallest son */
-      s->heap[k] = s->heap[j];  k = j;
-
-      /* And continue down the tree, setting j to the left son of k */
-      j <<= 1;
-   }
-   s->heap[k] = v;
-}
-
-/* ===========================================================================
- * Compute the optimal bit lengths for a tree and update the total bit length
- * for the current block.
- * IN assertion: the fields freq and dad are set, heap[heap_max] and
- *    above are the tree nodes sorted by increasing frequency.
- * OUT assertions: the field len is set to the optimal bit length, the
- *     array bl_count contains the frequencies for each bit length.
- *     The length opt_len is updated; static_len is also updated if stree is
- *     not null.
- */
-local void gen_bitlen(deflate_state *s, tree_desc *desc)
-{
-   ct_data *tree        = desc->dyn_tree;
-   int max_code         = desc->max_code;
-   const ct_data *stree = desc->stat_desc->static_tree;
-   const intf *extra    = desc->stat_desc->extra_bits;
-   int base             = desc->stat_desc->extra_base;
-   int max_length       = desc->stat_desc->max_length;
-   int h;              /* heap index */
-   int n, m;           /* iterate over the tree elements */
-   int bits;           /* bit length */
-   int xbits;          /* extra bits */
-   ush f;              /* frequency */
-   int overflow = 0;   /* number of elements with bit length too large */
-
-   for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
-
-   /* In a first pass, compute the optimal bit lengths (which may
-    * overflow in the case of the bit length tree).
-    */
-   tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
-
-   for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
-      n = s->heap[h];
-      bits = tree[tree[n].Dad].Len + 1;
-      if (bits > max_length) bits = max_length, overflow++;
-      tree[n].Len = (ush)bits;
-      /* We overwrite tree[n].Dad which is no longer needed */
-
-      if (n > max_code) continue; /* not a leaf node */
-
-      s->bl_count[bits]++;
-      xbits = 0;
-      if (n >= base) xbits = extra[n-base];
-      f = tree[n].Freq;
-      s->opt_len += (ulg)f * (bits + xbits);
-      if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
-   }
-   if (overflow == 0) return;
-
-   Trace((stderr,"\nbit length overflow\n"));
-   /* This happens for example on obj2 and pic of the Calgary corpus */
-
-   /* Find the first bit length which could increase: */
-   do {
-      bits = max_length-1;
-      while (s->bl_count[bits] == 0) bits--;
-      s->bl_count[bits]--;      /* move one leaf down the tree */
-      s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
-      s->bl_count[max_length]--;
-      /* The brother of the overflow item also moves one step up,
-       * but this does not affect bl_count[max_length]
-       */
-      overflow -= 2;
-   } while (overflow > 0);
-
-   /* Now recompute all bit lengths, scanning in increasing frequency.
-    * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
-    * lengths instead of fixing only the wrong ones. This idea is taken
-    * from 'ar' written by Haruhiko Okumura.)
-    */
-   for (bits = max_length; bits != 0; bits--) {
-      n = s->bl_count[bits];
-      while (n != 0) {
-         m = s->heap[--h];
-         if (m > max_code) continue;
-         if ((unsigned) tree[m].Len != (unsigned) bits) {
-            Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
-            s->opt_len += ((long)bits - (long)tree[m].Len)
-               *(long)tree[m].Freq;
-            tree[m].Len = (ush)bits;
-         }
-         n--;
-      }
-   }
-}
-
-/* ===========================================================================
- * Generate the codes for a given tree and bit counts (which need not be
- * optimal).
- * IN assertion: the array bl_count contains the bit length statistics for
- * the given tree and the field len is set for all tree elements.
- * OUT assertion: the field code is set for all tree elements of non
- *     zero code length.
- */
-local void gen_codes (ct_data *tree, int max_code, ushf *bl_count)
-{
-   ush next_code[MAX_BITS+1]; /* next code value for each bit length */
-   ush codes = 0;              /* running code value */
-   int bits;                  /* bit index */
-   int n;                     /* code index */
-
-   /* The distribution counts are first used to generate the code values
-    * without bit reversal.
-    */
-   for (bits = 1; bits <= MAX_BITS; bits++) {
-      next_code[bits] = codes = (codes + bl_count[bits-1]) << 1;
-   }
-   /* Check that the bit counts in bl_count are consistent. The last code
-    * must be all ones.
-    */
-   Assert (codes + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
-         "inconsistent bit counts");
-   Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
-
-   for (n = 0;  n <= max_code; n++) {
-      int len = tree[n].Len;
-      if (len == 0) continue;
-      /* Now reverse the bits */
-      tree[n].Code = bi_reverse(next_code[len]++, len);
-
-      Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
-               n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
-   }
-}
-
-/* ===========================================================================
- * Construct one Huffman tree and assigns the code bit strings and lengths.
- * Update the total bit length for the current block.
- * IN assertion: the field freq is set for all tree elements.
- * OUT assertions: the fields len and code are set to the optimal bit length
- *     and corresponding code. The length opt_len is updated; static_len is
- *     also updated if stree is not null. The field max_code is set.
- */
-local void build_tree(deflate_state *s, tree_desc *desc)
-{
-   ct_data *tree         = desc->dyn_tree;
-   const ct_data *stree  = desc->stat_desc->static_tree;
-   int elems             = desc->stat_desc->elems;
-   int n, m;          /* iterate over heap elements */
-   int max_code = -1; /* largest code with non zero frequency */
-   int node;          /* new node being created */
-
-   /* Construct the initial heap, with least frequent element in
-    * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
-    * heap[0] is not used.
-    */
-   s->heap_len = 0, s->heap_max = HEAP_SIZE;
-
-   for (n = 0; n < elems; n++) {
-      if (tree[n].Freq != 0) {
-         s->heap[++(s->heap_len)] = max_code = n;
-         s->depth[n] = 0;
-      } else {
-         tree[n].Len = 0;
-      }
-   }
-
-   /* The pkzip format requires that at least one distance code exists,
-    * and that at least one bit should be sent even if there is only one
-    * possible code. So to avoid special checks later on we force at least
-    * two codes of non zero frequency.
-    */
-   while (s->heap_len < 2) {
-      node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
-      tree[node].Freq = 1;
-      s->depth[node] = 0;
-      s->opt_len--; if (stree) s->static_len -= stree[node].Len;
-      /* node is 0 or 1 so it does not have extra bits */
-   }
-   desc->max_code = max_code;
-
-   /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
-    * establish sub-heaps of increasing lengths:
-    */
-   for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
-
-   /* Construct the Huffman tree by repeatedly combining the least two
-    * frequent nodes.
-    */
-   node = elems;              /* next internal node of the tree */
-   do {
-      pqremove(s, tree, n);  /* n = node of least frequency */
-      m = s->heap[SMALLEST]; /* m = node of next least frequency */
-
-      s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
-      s->heap[--(s->heap_max)] = m;
-
-      /* Create a new node father of n and m */
-      tree[node].Freq = tree[n].Freq + tree[m].Freq;
-      s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
-               s->depth[n] : s->depth[m]) + 1);
-      tree[n].Dad = tree[m].Dad = (ush)node;
-#ifdef DUMP_BL_TREE
-      if (tree == s->bl_tree) {
-         fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
-               node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
-      }
-#endif
-      /* and insert the new node in the heap */
-      s->heap[SMALLEST] = node++;
-      pqdownheap(s, tree, SMALLEST);
-
-   } while (s->heap_len >= 2);
-
-   s->heap[--(s->heap_max)] = s->heap[SMALLEST];
-
-   /* At this point, the fields freq and dad are set. We can now
-    * generate the bit lengths.
-    */
-   gen_bitlen(s, (tree_desc *)desc);
-
-   /* The field len is now set, we can generate the bit codes */
-   gen_codes ((ct_data *)tree, max_code, s->bl_count);
-}
-
-/* ===========================================================================
- * Scan a literal or distance tree to determine the frequencies of the codes
- * in the bit length tree.
- */
-local void scan_tree (deflate_state *s, ct_data *tree, int max_code)
-{
-   int n;                     /* iterates over all tree elements */
-   int prevlen = -1;          /* last emitted length */
-   int curlen;                /* length of current code */
-   int nextlen = tree[0].Len; /* length of next code */
-   int count = 0;             /* repeat count of the current code */
-   int max_count = 7;         /* max repeat count */
-   int min_count = 4;         /* min repeat count */
-
-   if (nextlen == 0) max_count = 138, min_count = 3;
-   tree[max_code+1].Len = (ush)0xffff; /* guard */
-
-   for (n = 0; n <= max_code; n++) {
-      curlen = nextlen; nextlen = tree[n+1].Len;
-      if (++count < max_count && curlen == nextlen) {
-         continue;
-      } else if (count < min_count) {
-         s->bl_tree[curlen].Freq += count;
-      } else if (curlen != 0) {
-         if (curlen != prevlen) s->bl_tree[curlen].Freq++;
-         s->bl_tree[REP_3_6].Freq++;
-      } else if (count <= 10) {
-         s->bl_tree[REPZ_3_10].Freq++;
-      } else {
-         s->bl_tree[REPZ_11_138].Freq++;
-      }
-      count = 0; prevlen = curlen;
-      if (nextlen == 0) {
-         max_count = 138, min_count = 3;
-      } else if (curlen == nextlen) {
-         max_count = 6, min_count = 3;
-      } else {
-         max_count = 7, min_count = 4;
-      }
-   }
-}
-
-/* ===========================================================================
- * Send a literal or distance tree in compressed form, using the codes in
- * bl_tree.
- */
-local void send_tree (deflate_state *s, ct_data *tree, int max_code)
-{
-   int n;                     /* iterates over all tree elements */
-   int prevlen = -1;          /* last emitted length */
-   int curlen;                /* length of current code */
-   int nextlen = tree[0].Len; /* length of next code */
-   int count = 0;             /* repeat count of the current code */
-   int max_count = 7;         /* max repeat count */
-   int min_count = 4;         /* min repeat count */
-
-   /* tree[max_code+1].Len = -1; */  /* guard already set */
-   if (nextlen == 0) max_count = 138, min_count = 3;
-
-   for (n = 0; n <= max_code; n++) {
-      curlen = nextlen; nextlen = tree[n+1].Len;
-      if (++count < max_count && curlen == nextlen) {
-         continue;
-      } else if (count < min_count) {
-         do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
-
-      } else if (curlen != 0) {
-         if (curlen != prevlen) {
-            send_code(s, curlen, s->bl_tree); count--;
-         }
-         Assert(count >= 3 && count <= 6, " 3_6?");
-         send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
-
-      } else if (count <= 10) {
-         send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
-
-      } else {
-         send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
-      }
-      count = 0; prevlen = curlen;
-      if (nextlen == 0) {
-         max_count = 138, min_count = 3;
-      } else if (curlen == nextlen) {
-         max_count = 6, min_count = 3;
-      } else {
-         max_count = 7, min_count = 4;
-      }
-   }
-}
-
-/* ===========================================================================
- * Construct the Huffman tree for the bit lengths and return the index in
- * bl_order of the last bit length code to send.
- */
-local int build_bl_tree(deflate_state *s)
-{
-   int max_blindex;  /* index of last bit length code of non zero freq */
-
-   /* Determine the bit length frequencies for literal and distance trees */
-   scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
-   scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
-
-   /* Build the bit length tree: */
-   build_tree(s, (tree_desc *)(&(s->bl_desc)));
-   /* opt_len now includes the length of the tree representations, except
-    * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
-    */
-
-   /* Determine the number of bit length codes to send. The pkzip format
-    * requires that at least 4 bit length codes be sent. (appnote.txt says
-    * 3 but the actual value used is 4.)
-    */
-   for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
-      if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
-   }
-   /* Update opt_len to include the bit length tree and counts */
-   s->opt_len += 3*(max_blindex+1) + 5+5+4;
-   Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
-            s->opt_len, s->static_len));
-
-   return max_blindex;
-}
-
-/* ===========================================================================
- * Send the header for a block using dynamic Huffman trees: the counts, the
- * lengths of the bit length codes, the literal tree and the distance tree.
- * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
- */
-local void send_all_trees(deflate_state *s, int lcodes, int dcodes, int blcodes)
-{
-   int rank;                    /* index in bl_order */
-
-   Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
-   Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
-         "too many codes");
-   Tracev((stderr, "\nbl counts: "));
-   send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
-   send_bits(s, dcodes-1,   5);
-   send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
-   for (rank = 0; rank < blcodes; rank++) {
-      Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
-      send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
-   }
-   Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
-
-   send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
-   Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
-
-   send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
-   Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
-}
-
-/* ===========================================================================
- * Send a stored block
- */
-void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf, ulg stored_len, int last)
-{
-   send_bits(s, (STORED_BLOCK<<1)+last, 3);    /* send block type */
-#ifdef DEBUG
-   s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
-   s->compressed_len += (stored_len + 4) << 3;
-#endif
-   copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
-}
-
-/* ===========================================================================
- * Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
- */
-void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s)
-{
-   bi_flush(s);
-}
-
-/* ===========================================================================
- * Send one empty static block to give enough lookahead for inflate.
- * This takes 10 bits, of which 7 may remain in the bit buffer.
- */
-void ZLIB_INTERNAL _tr_align(deflate_state *s)
-{
-   send_bits(s, STATIC_TREES<<1, 3);
-   send_code(s, END_BLOCK, static_ltree);
-#ifdef DEBUG
-   s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
-#endif
-   bi_flush(s);
-}
-
-/* ===========================================================================
- * Determine the best encoding for the current block: dynamic trees, static
- * trees or store, and output the encoded block to the zip file.
- */
-void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf, ulg stored_len, int last)
-{
-   ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
-   int max_blindex = 0;  /* index of last bit length code of non zero freq */
-
-   /* Build the Huffman trees unless a stored block is forced */
-   if (s->level > 0) {
-
-      /* Check if the file is binary or text */
-      if (s->strm->data_type == Z_UNKNOWN)
-         s->strm->data_type = detect_data_type(s);
-
-      /* Construct the literal and distance trees */
-      build_tree(s, (tree_desc *)(&(s->l_desc)));
-      Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
-               s->static_len));
-
-      build_tree(s, (tree_desc *)(&(s->d_desc)));
-      Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
-               s->static_len));
-      /* At this point, opt_len and static_len are the total bit lengths of
-       * the compressed block data, excluding the tree representations.
-       */
-
-      /* Build the bit length tree for the above two trees, and get the index
-       * in bl_order of the last bit length code to send.
-       */
-      max_blindex = build_bl_tree(s);
-
-      /* Determine the best encoding. Compute the block lengths in bytes. */
-      opt_lenb = (s->opt_len+3+7)>>3;
-      static_lenb = (s->static_len+3+7)>>3;
-
-      Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
-               opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
-               s->last_lit));
-
-      if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
-
-   } else {
-      Assert(buf != (char*)0, "lost buf");
-      opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
-   }
-
-#ifdef FORCE_STORED
-   if (buf != (char*)0) { /* force stored block */
-#else
-      if (stored_len+4 <= opt_lenb && buf != (char*)0) {
-         /* 4: two words for the lengths */
-#endif
-         /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
-          * Otherwise we can't have processed more than WSIZE input bytes since
-          * the last block flush, because compression would have been
-          * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
-          * transform a block into a stored block.
-          */
-         _tr_stored_block(s, buf, stored_len, last);
-
-#ifdef FORCE_STATIC
-      } else if (static_lenb >= 0) { /* force static trees */
-#else
-      } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
-#endif
-         send_bits(s, (STATIC_TREES<<1)+last, 3);
-         compress_block(s, (const ct_data *)static_ltree,
-               (const ct_data *)static_dtree);
-#ifdef DEBUG
-         s->compressed_len += 3 + s->static_len;
-#endif
-      } else {
-         send_bits(s, (DYN_TREES<<1)+last, 3);
-         send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
-               max_blindex+1);
-         compress_block(s, (const ct_data *)s->dyn_ltree,
-               (const ct_data *)s->dyn_dtree);
-#ifdef DEBUG
-         s->compressed_len += 3 + s->opt_len;
-#endif
-      }
-      Assert (s->compressed_len == s->bits_sent, "bad compressed size");
-      /* The above check is made mod 2^32, for files larger than 512 MB
-       * and uLong implemented on 32 bits.
-       */
-      init_block(s);
-
-      if (last) {
-         bi_windup(s);
-#ifdef DEBUG
-         s->compressed_len += 7;  /* align on byte boundary */
-#endif
-      }
-      Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
-               s->compressed_len-7*last));
-   }
-
-   /* ===========================================================================
-    * Save the match info and tally the frequency counts. Return true if
-    * the current block must be flushed.
-    */
-   int ZLIB_INTERNAL _tr_tally (deflate_state *s, unsigned dist, unsigned lc)
-   {
-      s->d_buf[s->last_lit] = (ush)dist;
-      s->l_buf[s->last_lit++] = (uch)lc;
-      if (dist == 0) {
-         /* lc is the unmatched char */
-         s->dyn_ltree[lc].Freq++;
-      } else {
-         s->matches++;
-         /* Here, lc is the match length - MIN_MATCH */
-         dist--;             /* dist = match distance - 1 */
-         Assert((ush)dist < (ush)MAX_DIST(s) &&
-               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
-               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
-
-         s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
-         s->dyn_dtree[d_code(dist)].Freq++;
-      }
-
-#ifdef TRUNCATE_BLOCK
-      /* Try to guess if it is profitable to stop the current block here */
-      if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
-         /* Compute an upper bound for the compressed length */
-         ulg out_length = (ulg)s->last_lit*8L;
-         ulg in_length = (ulg)((long)s->strstart - s->block_start);
-         int dcode;
-         for (dcode = 0; dcode < D_CODES; dcode++) {
-            out_length += (ulg)s->dyn_dtree[dcode].Freq *
-               (5L+extra_dbits[dcode]);
-         }
-         out_length >>= 3;
-         Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
-                  s->last_lit, in_length, out_length,
-                  100L - out_length*100L/in_length));
-         if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
-      }
-#endif
-      return (s->last_lit == s->lit_bufsize-1);
-      /* We avoid equality with lit_bufsize because of wraparound at 64K
-       * on 16 bit machines and because stored blocks are restricted to
-       * 64K-1 bytes.
-       */
-   }
-
-   /* ===========================================================================
-    * Send the block data compressed using the given Huffman trees
-    */
-   local void compress_block(deflate_state *s, const ct_data *ltree, const ct_data *dtree)
-   {
-      unsigned dist;      /* distance of matched string */
-      int lc;             /* match length or unmatched char (if dist == 0) */
-      unsigned lx = 0;    /* running index in l_buf */
-      unsigned codes;      /* the code to send */
-      int extra;          /* number of extra bits to send */
-
-      if (s->last_lit != 0) do {
-         dist = s->d_buf[lx];
-         lc = s->l_buf[lx++];
-         if (dist == 0) {
-            send_code(s, lc, ltree); /* send a literal byte */
-            Tracecv(isgraph(lc), (stderr," '%c' ", lc));
-         } else {
-            /* Here, lc is the match length - MIN_MATCH */
-            codes = _length_code[lc];
-            send_code(s, codes + LITERALS+1, ltree); /* send the length code */
-            extra = extra_lbits[codes];
-            if (extra != 0) {
-               lc -= base_length[codes];
-               send_bits(s, lc, extra);       /* send the extra length bits */
-            }
-            dist--; /* dist is now the match distance - 1 */
-            codes = d_code(dist);
-            Assert (codes < D_CODES, "bad d_code");
-
-            send_code(s, codes, dtree);       /* send the distance code */
-            extra = extra_dbits[codes];
-            if (extra != 0) {
-               dist -= base_dist[codes];
-               send_bits(s, dist, extra);   /* send the extra distance bits */
-            }
-         } /* literal or match pair ? */
-
-         /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
-         Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
-               "pendingBuf overflow");
-
-      } while (lx < s->last_lit);
-
-      send_code(s, END_BLOCK, ltree);
-   }
-
-   /* ===========================================================================
-    * Check if the data type is TEXT or BINARY, using the following algorithm:
-    * - TEXT if the two conditions below are satisfied:
-    *    a) There are no non-portable control characters belonging to the
-    *       "black list" (0..6, 14..25, 28..31).
-    *    b) There is at least one printable character belonging to the
-    *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
-    * - BINARY otherwise.
-    * - The following partially-portable control characters form a
-    *   "gray list" that is ignored in this detection algorithm:
-    *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
-    * IN assertion: the fields Freq of dyn_ltree are set.
-    */
-   local int detect_data_type(deflate_state *s)
-   {
-      /* black_mask is the bit mask of black-listed bytes
-       * set bits 0..6, 14..25, and 28..31
-       * 0xf3ffc07f = binary 11110011111111111100000001111111
-       */
-      unsigned long black_mask = 0xf3ffc07fUL;
-      int n;
-
-      /* Check for non-textual ("black-listed") bytes. */
-      for (n = 0; n <= 31; n++, black_mask >>= 1)
-         if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
-            return Z_BINARY;
-
-      /* Check for textual ("white-listed") bytes. */
-      if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
-            || s->dyn_ltree[13].Freq != 0)
-         return Z_TEXT;
-      for (n = 32; n < LITERALS; n++)
-         if (s->dyn_ltree[n].Freq != 0)
-            return Z_TEXT;
-
-      /* There are no "black-listed" or "white-listed" bytes:
-       * this stream either is empty or has tolerated ("gray-listed") bytes only.
-       */
-      return Z_BINARY;
-   }
-
-   /* ===========================================================================
-    * Reverse the first len bits of a code, using straightforward code (a faster
-    * method would use a table)
-    * IN assertion: 1 <= len <= 15
-    */
-   local unsigned bi_reverse(unsigned codes, int len)
-   {
-      register unsigned res = 0;
-      do {
-         res |= codes & 1;
-         codes >>= 1, res <<= 1;
-      } while (--len > 0);
-      return res >> 1;
-   }
-
-   /* ===========================================================================
-    * Flush the bit buffer, keeping at most 7 bits in it.
-    */
-   local void bi_flush(deflate_state *s)
-   {
-      if (s->bi_valid == 16) {
-         put_short(s, s->bi_buf);
-         s->bi_buf = 0;
-         s->bi_valid = 0;
-      } else if (s->bi_valid >= 8) {
-         put_byte(s, (Byte)s->bi_buf);
-         s->bi_buf >>= 8;
-         s->bi_valid -= 8;
-      }
-   }
-
-   /* ===========================================================================
-    * Flush the bit buffer and align the output on a byte boundary
-    */
-   local void bi_windup(deflate_state *s)
-   {
-      if (s->bi_valid > 8) {
-         put_short(s, s->bi_buf);
-      } else if (s->bi_valid > 0) {
-         put_byte(s, (Byte)s->bi_buf);
-      }
-      s->bi_buf = 0;
-      s->bi_valid = 0;
-#ifdef DEBUG
-      s->bits_sent = (s->bits_sent+7) & ~7;
-#endif
-   }
-
-   /* ===========================================================================
-    * Copy a stored block, storing first the length and its
-    * one's complement if requested.
-    */
-   local void copy_block(deflate_state *s, charf *buf, unsigned len, int header)
-   {
-      bi_windup(s);        /* align on byte boundary */
-
-      if (header) {
-         put_short(s, (ush)len);
-         put_short(s, (ush)~len);
-#ifdef DEBUG
-         s->bits_sent += 2*16;
-#endif
-      }
-#ifdef DEBUG
-      s->bits_sent += (ulg)len<<3;
-#endif
-      while (len--) {
-         put_byte(s, *buf++);
-      }
-   }
diff --git a/deps/trees.h b/deps/trees.h
deleted file mode 100644
index c0261b2..0000000
--- a/deps/trees.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/* header created automatically with -DGEN_TREES_H */
-#ifndef _TREES_H
-#define _TREES_H
-
-local const ct_data static_ltree[L_CODES+2] = {
-{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
-{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
-{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
-{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
-{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
-{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
-{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
-{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
-{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
-{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
-{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
-{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
-{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
-{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
-{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
-{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
-{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
-{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
-{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
-{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
-{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
-{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
-{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
-{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
-{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
-{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
-{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
-{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
-{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
-{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
-{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
-{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
-{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
-{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
-{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
-{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
-{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
-{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
-{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
-{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
-{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
-{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
-{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
-{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
-{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
-{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
-{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
-{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
-{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
-{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
-{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
-{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
-{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
-{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
-{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
-{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
-{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
-{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
-};
-
-local const ct_data static_dtree[D_CODES] = {
-{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
-{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
-{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
-{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
-{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
-{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
-};
-
-const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
- 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
- 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
-10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
-13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
-18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
-};
-
-const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
- 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
-13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
-17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
-19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
-22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
-};
-
-local const int base_length[LENGTH_CODES] = {
-0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
-64, 80, 96, 112, 128, 160, 192, 224, 0
-};
-
-local const int base_dist[D_CODES] = {
-    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
-   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
- 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
-};
-
-
-#endif
diff --git a/deps/uncompr.c b/deps/uncompr.c
deleted file mode 100644
index c7e30b3..0000000
--- a/deps/uncompr.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/* uncompr.c -- decompress a memory buffer
- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#define ZLIB_INTERNAL
-#include "zlib.h"
-
-/* ===========================================================================
-   Decompresses the source buffer into the destination buffer.  sourceLen is
-   the byte length of the source buffer. Upon entry, destLen is the total
-   size of the destination buffer, which must be large enough to hold the
-   entire uncompressed data. (The size of the uncompressed data must have
-   been saved previously by the compressor and transmitted to the decompressor
-   by some mechanism outside the scope of this compression library.)
-   Upon exit, destLen is the actual size of the compressed buffer.
-
-   uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer, or Z_DATA_ERROR if the input data was corrupted.
-   */
-int ZEXPORT uncompress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
-{
-   z_stream stream;
-   int err;
-
-   stream.next_in = (Bytef *)source;
-   stream.avail_in = (uInt)sourceLen;
-   /* Check for source > 64K on 16-bit machine: */
-   if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-
-   stream.next_out = dest;
-   stream.avail_out = (uInt)*destLen;
-   if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
-
-   stream.zalloc = Z_NULL;
-   stream.zfree = Z_NULL;
-
-   err = inflateInit(&stream);
-   if (err != Z_OK) return err;
-
-   err = inflate(&stream, Z_FINISH);
-   if (err != Z_STREAM_END) {
-      inflateEnd(&stream);
-      if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
-         return Z_DATA_ERROR;
-      return err;
-   }
-   *destLen = stream.total_out;
-
-   err = inflateEnd(&stream);
-   return err;
-}
diff --git a/deps/unzip.c b/deps/unzip.c
deleted file mode 100644
index ba6abbf..0000000
--- a/deps/unzip.c
+++ /dev/null
@@ -1,2126 +0,0 @@
-/* unzip.c -- IO for uncompress .zip files using zlib
-   Version 1.1, February 14h, 2010
-   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
-
-   Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
-
-   Modifications of Unzip for Zip64
-   Copyright (C) 2007-2008 Even Rouault
-
-   Modifications for Zip64 support on both zip and unzip
-   Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
-
-   For more info read MiniZip_info.txt
-
-
-   ------------------------------------------------------------------------------------
-   Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
-   compatibility with older software. The following is from the original crypt.c.
-   Code woven in by Terry Thorsen 1/2003.
-
-   Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
-
-   See the accompanying file LICENSE, version 2000-Apr-09 or later
-   (the contents of which are also included in zip.h) for terms of use.
-   If, for some reason, all these files are missing, the Info-ZIP license
-   also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
-
-   crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
-
-   The encryption/decryption parts of this source code (as opposed to the
-   non-echoing password parts) were originally written in Europe.  The
-   whole source package can be freely distributed, including from the USA.
-   (Prior to January 2000, re-export from the US was a violation of US law.)
-
-   This encryption code is a direct transcription of the algorithm from
-   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
-   file (appnote.txt) is distributed with the PKZIP program (even in the
-   version without encryption capabilities).
-
-   ------------------------------------------------------------------------------------
-
-   Changes in unzip.c
-
-   2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos
-   2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*
-   2007-2008 - Even Rouault - Remove old C style function prototypes
-   2007-2008 - Even Rouault - Add unzip support for ZIP64
-
-   Copyright (C) 2007-2008 Even Rouault
-
-
-   Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).
-   Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G
-   should only read the compressed/uncompressed size from the Zip64 format if
-   the size from normal header was 0xFFFFFFFF
-   Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant
-   Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)
-   Patch created by Daniel Borca
-
-   Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
-
-   Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson
-
-*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef NOUNCRYPT
-#define NOUNCRYPT
-#endif
-
-#include "zlib.h"
-#include "unzip.h"
-
-#ifdef STDC
-#  include <stddef.h>
-#  include <string.h>
-#  include <stdlib.h>
-#endif
-#ifdef NO_ERRNO_H
-extern int errno;
-#else
-#   include <errno.h>
-#endif
-
-
-#ifndef local
-#  define local static
-#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-
-#ifndef CASESENSITIVITYDEFAULT_NO
-#  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
-#    define CASESENSITIVITYDEFAULT_NO
-#  endif
-#endif
-
-
-#ifndef UNZ_BUFSIZE
-#define UNZ_BUFSIZE (16384)
-#endif
-
-#ifndef UNZ_MAXFILENAMEINZIP
-#define UNZ_MAXFILENAMEINZIP (256)
-#endif
-
-#ifndef ALLOC
-# define ALLOC(size) (malloc(size))
-#endif
-#ifndef TRYFREE
-# define TRYFREE(p) {if (p) free(p);}
-#endif
-
-#define SIZECENTRALDIRITEM (0x2e)
-#define SIZEZIPLOCALHEADER (0x1e)
-
-
-const char unz_copyright[] =
-" unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
-
-/* unz_file_info_interntal contain internal info about a file in zipfile*/
-typedef struct unz_file_info64_internal_s
-{
-   ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */
-} unz_file_info64_internal;
-
-
-/* file_in_zip_read_info_s contain internal information about a file in zipfile,
-   when reading and decompress it */
-typedef struct
-{
-   char  *read_buffer;         /* internal buffer for compressed data */
-   z_stream stream;            /* zLib stream structure for inflate */
-
-#ifdef HAVE_BZIP2
-   bz_stream bstream;          /* bzLib stream structure for bziped */
-#endif
-
-   ZPOS64_T pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
-   uLong stream_initialised;   /* flag set if stream structure is initialised*/
-
-   ZPOS64_T offset_local_extrafield;/* offset of the local extra field */
-   uInt  size_local_extrafield;/* size of the local extra field */
-   ZPOS64_T pos_local_extrafield;   /* position in the local extra field in read*/
-   ZPOS64_T total_out_64;
-
-   uLong crc32;                /* crc32 of all data uncompressed */
-   uLong crc32_wait;           /* crc32 we must obtain after decompress all */
-   ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */
-   ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/
-   zlib_filefunc64_32_def z_filefunc;
-   voidpf filestream;        /* io structore of the zipfile */
-   uLong compression_method;   /* compression method (0==store) */
-   ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
-   int   raw;
-} file_in_zip64_read_info_s;
-
-
-/* unz64_s contain internal information about the zipfile
-*/
-typedef struct
-{
-   zlib_filefunc64_32_def z_filefunc;
-   int is64bitOpenFunction;
-   voidpf filestream;        /* io structore of the zipfile */
-   unz_global_info64 gi;       /* public global information */
-   ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
-   ZPOS64_T num_file;             /* number of the current file in the zipfile*/
-   ZPOS64_T pos_in_central_dir;   /* pos of the current file in the central dir*/
-   ZPOS64_T current_file_ok;      /* flag about the usability of the current file*/
-   ZPOS64_T central_pos;          /* position of the beginning of the central dir*/
-
-   ZPOS64_T size_central_dir;     /* size of the central directory  */
-   ZPOS64_T offset_central_dir;   /* offset of start of central directory with
-                                     respect to the starting disk number */
-
-   unz_file_info64 cur_file_info; /* public info about the current file in zip*/
-   unz_file_info64_internal cur_file_info_internal; /* private info about it*/
-   file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current
-                                                    file if we are decompressing it */
-   int encrypted;
-
-   int isZip64;
-
-#    ifndef NOUNCRYPT
-   unsigned long keys[3];     /* keys defining the pseudo-random sequence */
-   const unsigned long* pcrc_32_tab;
-#    endif
-} unz64_s;
-
-
-#ifndef NOUNCRYPT
-#include "crypt.h"
-#endif
-
-/* ===========================================================================
-   Read a byte from a gz_stream; update next_in and avail_in. Return EOF
-   for end of file.
-   IN assertion: the stream s has been sucessfully opened for reading.
-   */
-
-
-local int unz64local_getByte OF((
-         const zlib_filefunc64_32_def* pzlib_filefunc_def,
-         voidpf filestream,
-         int *pi));
-
-local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,
-                             voidpf filestream, int *_pi)
-{
-   unsigned char c;
-   int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
-   if (err==1)
-   {
-      *_pi = (int)c;
-      return UNZ_OK;
-   }
-   else
-   {
-      if (ZERROR64(*pzlib_filefunc_def,filestream))
-         return UNZ_ERRNO;
-      else
-         return UNZ_EOF;
-   }
-}
-
-
-/* ===========================================================================
-   Reads a long in LSB order from the given gz_stream. Sets
-   */
-local int unz64local_getShort OF((
-         const zlib_filefunc64_32_def* pzlib_filefunc_def,
-         voidpf filestream,
-         uLong *pX));
-
-local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,
-      voidpf filestream,
-      uLong *pX)
-{
-   uLong x ;
-   int i = 0;
-   int err;
-
-   err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x = (uLong)i;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((uLong)i)<<8;
-
-   if (err==UNZ_OK)
-      *pX = x;
-   else
-      *pX = 0;
-   return err;
-}
-
-local int unz64local_getLong OF((
-         const zlib_filefunc64_32_def* pzlib_filefunc_def,
-         voidpf filestream,
-         uLong *pX));
-
-local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,
-      voidpf filestream,
-      uLong *pX)
-{
-   uLong x ;
-   int i = 0;
-   int err;
-
-   err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x = (uLong)i;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((uLong)i)<<8;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((uLong)i)<<16;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x += ((uLong)i)<<24;
-
-   if (err==UNZ_OK)
-      *pX = x;
-   else
-      *pX = 0;
-   return err;
-}
-
-local int unz64local_getLong64 OF((
-         const zlib_filefunc64_32_def* pzlib_filefunc_def,
-         voidpf filestream,
-         ZPOS64_T *pX));
-
-
-local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,
-      voidpf filestream,
-      ZPOS64_T *pX)
-{
-   ZPOS64_T x ;
-   int i = 0;
-   int err;
-
-   err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x = (ZPOS64_T)i;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((ZPOS64_T)i)<<8;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((ZPOS64_T)i)<<16;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((ZPOS64_T)i)<<24;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((ZPOS64_T)i)<<32;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((ZPOS64_T)i)<<40;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((ZPOS64_T)i)<<48;
-
-   if (err==UNZ_OK)
-      err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
-   x |= ((ZPOS64_T)i)<<56;
-
-   if (err==UNZ_OK)
-      *pX = x;
-   else
-      *pX = 0;
-   return err;
-}
-
-/* My own strcmpi / strcasecmp */
-local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)
-{
-   for (;;)
-   {
-      char c1=*(fileName1++);
-      char c2=*(fileName2++);
-      if ((c1>='a') && (c1<='z'))
-         c1 -= 0x20;
-      if ((c2>='a') && (c2<='z'))
-         c2 -= 0x20;
-      if (c1=='\0')
-         return ((c2=='\0') ? 0 : -1);
-      if (c2=='\0')
-         return 1;
-      if (c1<c2)
-         return -1;
-      if (c1>c2)
-         return 1;
-   }
-}
-
-
-#ifdef  CASESENSITIVITYDEFAULT_NO
-#define CASESENSITIVITYDEFAULTVALUE 2
-#else
-#define CASESENSITIVITYDEFAULTVALUE 1
-#endif
-
-#ifndef STRCMPCASENOSENTIVEFUNCTION
-#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
-#endif
-
-/*
-   Compare two filename (fileName1,fileName2).
-   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
-   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
-   or strcasecmp)
-   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
-   (like 1 on Unix, 2 on Windows)
-
-*/
-extern int ZEXPORT unzStringFileNameCompare (const char*  fileName1,
-      const char*  fileName2,
-      int iCaseSensitivity)
-
-{
-   if (iCaseSensitivity==0)
-      iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
-
-   if (iCaseSensitivity==1)
-      return strcmp(fileName1,fileName2);
-
-   return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
-}
-
-#ifndef BUFREADCOMMENT
-#define BUFREADCOMMENT (0x400)
-#endif
-
-/*
-   Locate the Central directory of a zipfile (at the end, just before
-   the global comment)
-   */
-local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
-local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
-{
-   unsigned char* buf;
-   ZPOS64_T uSizeFile;
-   ZPOS64_T uBackRead;
-   ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
-   ZPOS64_T uPosFound=0;
-
-   if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
-      return 0;
-
-
-   uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
-
-   if (uMaxBack>uSizeFile)
-      uMaxBack = uSizeFile;
-
-   buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
-   if (buf==NULL)
-      return 0;
-
-   uBackRead = 4;
-   while (uBackRead<uMaxBack)
-   {
-      uLong uReadSize;
-      ZPOS64_T uReadPos ;
-      int i;
-      if (uBackRead+BUFREADCOMMENT>uMaxBack)
-         uBackRead = uMaxBack;
-      else
-         uBackRead+=BUFREADCOMMENT;
-      uReadPos = uSizeFile-uBackRead ;
-
-      uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
-         (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
-      if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
-         break;
-
-      if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
-         break;
-
-      for (i=(int)uReadSize-3; (i--)>0;)
-         if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
-               ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
-         {
-            uPosFound = uReadPos+i;
-            break;
-         }
-
-      if (uPosFound!=0)
-         break;
-   }
-   TRYFREE(buf);
-   return uPosFound;
-}
-
-
-/*
-   Locate the Central directory 64 of a zipfile (at the end, just before
-   the global comment)
-   */
-local ZPOS64_T unz64local_SearchCentralDir64 OF((
-         const zlib_filefunc64_32_def* pzlib_filefunc_def,
-         voidpf filestream));
-
-local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
-      voidpf filestream)
-{
-   unsigned char* buf;
-   ZPOS64_T uSizeFile;
-   ZPOS64_T uBackRead;
-   ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
-   ZPOS64_T uPosFound=0;
-   uLong uL;
-   ZPOS64_T relativeOffset;
-
-   if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
-      return 0;
-
-
-   uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
-
-   if (uMaxBack>uSizeFile)
-      uMaxBack = uSizeFile;
-
-   buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
-   if (buf==NULL)
-      return 0;
-
-   uBackRead = 4;
-   while (uBackRead<uMaxBack)
-   {
-      uLong uReadSize;
-      ZPOS64_T uReadPos;
-      int i;
-      if (uBackRead+BUFREADCOMMENT>uMaxBack)
-         uBackRead = uMaxBack;
-      else
-         uBackRead+=BUFREADCOMMENT;
-      uReadPos = uSizeFile-uBackRead ;
-
-      uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
-         (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
-      if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
-         break;
-
-      if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
-         break;
-
-      for (i=(int)uReadSize-3; (i--)>0;)
-         if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
-               ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
-         {
-            uPosFound = uReadPos+i;
-            break;
-         }
-
-      if (uPosFound!=0)
-         break;
-   }
-   TRYFREE(buf);
-   if (uPosFound == 0)
-      return 0;
-
-   /* Zip64 end of central directory locator */
-   if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
-      return 0;
-
-   /* the signature, already checked */
-   if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
-      return 0;
-
-   /* number of the disk with the start of the zip64 end of  central directory */
-   if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
-      return 0;
-   if (uL != 0)
-      return 0;
-
-   /* relative offset of the zip64 end of central directory record */
-   if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
-      return 0;
-
-   /* total number of disks */
-   if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
-      return 0;
-   if (uL != 1)
-      return 0;
-
-   /* Goto end of central directory record */
-   if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
-      return 0;
-
-   /* the signature */
-   if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
-      return 0;
-
-   if (uL != 0x06064b50)
-      return 0;
-
-   return relativeOffset;
-}
-
-/*
-   Open a Zip file. path contain the full pathname (by example,
-   on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
-   "zlib/zlib114.zip".
-   If the zipfile cannot be opened (file doesn't exist or in not valid), the
-   return value is NULL.
-   Else, the return value is a unzFile Handle, usable with other function
-   of this unzip package.
-   */
-local unzFile unzOpenInternal (const void *path,
-      zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
-      int is64bitOpenFunction)
-{
-   unz64_s us;
-   unz64_s *s;
-   ZPOS64_T central_pos;
-   uLong   uL;
-
-   uLong number_disk;          /* number of the current dist, used for
-                                  spaning ZIP, unsupported, always 0*/
-   uLong number_disk_with_CD;  /* number the the disk with central dir, used
-                                  for spaning ZIP, unsupported, always 0*/
-   ZPOS64_T number_entry_CD;      /* total number of entries in
-                                     the central dir
-                                     (same than number_entry on nospan) */
-
-   int err=UNZ_OK;
-
-   if (unz_copyright[0]!=' ')
-      return NULL;
-
-   us.z_filefunc.zseek32_file = NULL;
-   us.z_filefunc.ztell32_file = NULL;
-   if (pzlib_filefunc64_32_def==NULL)
-      fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
-   else
-      us.z_filefunc = *pzlib_filefunc64_32_def;
-   us.is64bitOpenFunction = is64bitOpenFunction;
-
-
-
-   us.filestream = ZOPEN64(us.z_filefunc,
-         path,
-         ZLIB_FILEFUNC_MODE_READ |
-         ZLIB_FILEFUNC_MODE_EXISTING);
-   if (us.filestream==NULL)
-      return NULL;
-
-   central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
-   if (central_pos)
-   {
-      uLong uS;
-      ZPOS64_T uL64;
-
-      us.isZip64 = 1;
-
-      if (ZSEEK64(us.z_filefunc, us.filestream,
-               central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
-         err=UNZ_ERRNO;
-
-      /* the signature, already checked */
-      if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* size of zip64 end of central directory record */
-      if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* version made by */
-      if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* version needed to extract */
-      if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* number of this disk */
-      if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* number of the disk with the start of the central directory */
-      if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* total number of entries in the central directory on this disk */
-      if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* total number of entries in the central directory */
-      if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      if ((number_entry_CD!=us.gi.number_entry) ||
-            (number_disk_with_CD!=0) ||
-            (number_disk!=0))
-         err=UNZ_BADZIPFILE;
-
-      /* size of the central directory */
-      if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* offset of start of central directory with respect to the
-         starting disk number */
-      if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      us.gi.size_comment = 0;
-   }
-   else
-   {
-      central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
-      if (central_pos==0)
-         err=UNZ_ERRNO;
-
-      us.isZip64 = 0;
-
-      if (ZSEEK64(us.z_filefunc, us.filestream,
-               central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
-         err=UNZ_ERRNO;
-
-      /* the signature, already checked */
-      if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* number of this disk */
-      if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* number of the disk with the start of the central directory */
-      if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
-         err=UNZ_ERRNO;
-
-      /* total number of entries in the central dir on this disk */
-      if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
-         err=UNZ_ERRNO;
-      us.gi.number_entry = uL;
-
-      /* total number of entries in the central dir */
-      if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
-         err=UNZ_ERRNO;
-      number_entry_CD = uL;
-
-      if ((number_entry_CD!=us.gi.number_entry) ||
-            (number_disk_with_CD!=0) ||
-            (number_disk!=0))
-         err=UNZ_BADZIPFILE;
-
-      /* size of the central directory */
-      if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
-         err=UNZ_ERRNO;
-      us.size_central_dir = uL;
-
-      /* offset of start of central directory with respect to the
-         starting disk number */
-      if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
-         err=UNZ_ERRNO;
-      us.offset_central_dir = uL;
-
-      /* zipfile comment length */
-      if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
-         err=UNZ_ERRNO;
-   }
-
-   if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
-         (err==UNZ_OK))
-      err=UNZ_BADZIPFILE;
-
-   if (err!=UNZ_OK)
-   {
-      ZCLOSE64(us.z_filefunc, us.filestream);
-      return NULL;
-   }
-
-   us.byte_before_the_zipfile = central_pos -
-      (us.offset_central_dir+us.size_central_dir);
-   us.central_pos = central_pos;
-   us.pfile_in_zip_read = NULL;
-   us.encrypted = 0;
-
-
-   s=(unz64_s*)ALLOC(sizeof(unz64_s));
-   if( s != NULL)
-   {
-      *s=us;
-      unzGoToFirstFile((unzFile)s);
-   }
-   return (unzFile)s;
-}
-
-
-extern unzFile ZEXPORT unzOpen2 (const char *path,
-      zlib_filefunc_def* pzlib_filefunc32_def)
-{
-   if (pzlib_filefunc32_def != NULL)
-   {
-      zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
-      fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
-      return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
-   }
-   else
-      return unzOpenInternal(path, NULL, 0);
-}
-
-extern unzFile ZEXPORT unzOpen2_64 (const void *path,
-      zlib_filefunc64_def* pzlib_filefunc_def)
-{
-   if (pzlib_filefunc_def != NULL)
-   {
-      zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
-      zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
-      zlib_filefunc64_32_def_fill.ztell32_file = NULL;
-      zlib_filefunc64_32_def_fill.zseek32_file = NULL;
-      return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
-   }
-   else
-      return unzOpenInternal(path, NULL, 1);
-}
-
-extern unzFile ZEXPORT unzOpen (const char *path)
-{
-   return unzOpenInternal(path, NULL, 0);
-}
-
-extern unzFile ZEXPORT unzOpen64 (const void *path)
-{
-   return unzOpenInternal(path, NULL, 1);
-}
-
-/*
-   Close a ZipFile opened with unzipOpen.
-   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
-   these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
-   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzClose (unzFile file)
-{
-   unz64_s* s;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-
-   if (s->pfile_in_zip_read!=NULL)
-      unzCloseCurrentFile(file);
-
-   ZCLOSE64(s->z_filefunc, s->filestream);
-   TRYFREE(s);
-   return UNZ_OK;
-}
-
-
-/*
-   Write info about the ZipFile in the *pglobal_info structure.
-   No preparation of the structure is needed
-   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)
-{
-   unz64_s* s;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   *pglobal_info=s->gi;
-   return UNZ_OK;
-}
-
-extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)
-{
-   unz64_s* s;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   /* to do : check if number_entry is not truncated */
-   pglobal_info32->number_entry = (uLong)s->gi.number_entry;
-   pglobal_info32->size_comment = s->gi.size_comment;
-   return UNZ_OK;
-}
-/*
-   Translate date/time from Dos format to tm_unz (readable more easilty)
-   */
-local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
-{
-   ZPOS64_T uDate;
-   uDate = (ZPOS64_T)(ulDosDate>>16);
-   ptm->tm_mday = (uInt)(uDate&0x1f) ;
-   ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
-   ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
-
-   ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
-   ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
-   ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
-}
-
-/*
-   Get Info about the current file in the zipfile, with internal only info
-   */
-local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,
-         unz_file_info64 *pfile_info,
-         unz_file_info64_internal
-         *pfile_info_internal,
-         char *szFileName,
-         uLong fileNameBufferSize,
-         void *extraField,
-         uLong extraFieldBufferSize,
-         char *szComment,
-         uLong commentBufferSize));
-
-local int unz64local_GetCurrentFileInfoInternal (unzFile file,
-      unz_file_info64 *pfile_info,
-      unz_file_info64_internal
-      *pfile_info_internal,
-      char *szFileName,
-      uLong fileNameBufferSize,
-      void *extraField,
-      uLong extraFieldBufferSize,
-      char *szComment,
-      uLong commentBufferSize)
-{
-   unz64_s* s;
-   unz_file_info64 file_info;
-   unz_file_info64_internal file_info_internal;
-   int err=UNZ_OK;
-   uLong uMagic;
-   long lSeek=0;
-   uLong uL;
-
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   if (ZSEEK64(s->z_filefunc, s->filestream,
-            s->pos_in_central_dir+s->byte_before_the_zipfile,
-            ZLIB_FILEFUNC_SEEK_SET)!=0)
-      err=UNZ_ERRNO;
-
-
-   /* we check the magic */
-   if (err==UNZ_OK)
-   {
-      if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
-         err=UNZ_ERRNO;
-      else if (uMagic!=0x02014b50)
-         err=UNZ_BADZIPFILE;
-   }
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
-      err=UNZ_ERRNO;
-   file_info.compressed_size = uL;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
-      err=UNZ_ERRNO;
-   file_info.uncompressed_size = uL;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   // relative offset of local header
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
-      err=UNZ_ERRNO;
-   file_info_internal.offset_curfile = uL;
-
-   lSeek+=file_info.size_filename;
-   if ((err==UNZ_OK) && (szFileName!=NULL))
-   {
-      uLong uSizeRead ;
-      if (file_info.size_filename<fileNameBufferSize)
-      {
-         *(szFileName+file_info.size_filename)='\0';
-         uSizeRead = file_info.size_filename;
-      }
-      else
-         uSizeRead = fileNameBufferSize;
-
-      if ((file_info.size_filename>0) && (fileNameBufferSize>0))
-         if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
-            err=UNZ_ERRNO;
-      lSeek -= uSizeRead;
-   }
-
-   // Read extrafield
-   if ((err==UNZ_OK) && (extraField!=NULL))
-   {
-      ZPOS64_T uSizeRead ;
-      if (file_info.size_file_extra<extraFieldBufferSize)
-         uSizeRead = file_info.size_file_extra;
-      else
-         uSizeRead = extraFieldBufferSize;
-
-      if (lSeek!=0)
-      {
-         if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
-            lSeek=0;
-         else
-            err=UNZ_ERRNO;
-      }
-
-      if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
-         if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)
-            err=UNZ_ERRNO;
-
-      lSeek += file_info.size_file_extra - (uLong)uSizeRead;
-   }
-   else
-      lSeek += file_info.size_file_extra;
-
-
-   if ((err==UNZ_OK) && (file_info.size_file_extra != 0))
-   {
-      uLong acc = 0;
-
-      // since lSeek now points to after the extra field we need to move back
-      lSeek -= file_info.size_file_extra;
-
-      if (lSeek!=0)
-      {
-         if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
-            lSeek=0;
-         else
-            err=UNZ_ERRNO;
-      }
-
-      while(acc < file_info.size_file_extra)
-      {
-         uLong headerId;
-         uLong dataSize;
-
-         if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)
-            err=UNZ_ERRNO;
-
-         if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)
-            err=UNZ_ERRNO;
-
-         /* ZIP64 extra fields */
-         if (headerId == 0x0001)
-         {
-            uLong tmp;
-
-            if(file_info.uncompressed_size == (ZPOS64_T)(unsigned long)-1)
-            {
-               if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
-                  err=UNZ_ERRNO;
-            }
-
-            if(file_info.compressed_size == (ZPOS64_T)(unsigned long)-1)
-            {
-               if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
-                  err=UNZ_ERRNO;
-            }
-
-            if(file_info_internal.offset_curfile == (ZPOS64_T)(unsigned long)-1)
-            {
-               /* Relative Header offset */
-               if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
-                  err=UNZ_ERRNO;
-            }
-
-            if(file_info.disk_num_start == (unsigned long)-1)
-            {
-               /* Disk Start Number */
-               if (unz64local_getLong(&s->z_filefunc, s->filestream,&tmp) != UNZ_OK)
-                  err=UNZ_ERRNO;
-            }
-
-         }
-         else
-         {
-            if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)
-               err=UNZ_ERRNO;
-         }
-
-         acc += 2 + 2 + dataSize;
-      }
-   }
-
-   if ((err==UNZ_OK) && (szComment!=NULL))
-   {
-      uLong uSizeRead ;
-      if (file_info.size_file_comment<commentBufferSize)
-      {
-         *(szComment+file_info.size_file_comment)='\0';
-         uSizeRead = file_info.size_file_comment;
-      }
-      else
-         uSizeRead = commentBufferSize;
-
-      if (lSeek!=0)
-      {
-         if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
-            lSeek=0;
-         else
-            err=UNZ_ERRNO;
-      }
-
-      if ((file_info.size_file_comment>0) && (commentBufferSize>0))
-         if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
-            err=UNZ_ERRNO;
-      lSeek+=file_info.size_file_comment - uSizeRead;
-   }
-   else
-      lSeek+=file_info.size_file_comment;
-
-
-   if ((err==UNZ_OK) && (pfile_info!=NULL))
-      *pfile_info=file_info;
-
-   if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
-      *pfile_info_internal=file_info_internal;
-
-   return err;
-}
-
-
-
-/*
-   Write info about the ZipFile in the *pglobal_info structure.
-   No preparation of the structure is needed
-   return UNZ_OK if there is no problem.
-   */
-extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,
-      unz_file_info64 * pfile_info,
-      char * szFileName, uLong fileNameBufferSize,
-      void *extraField, uLong extraFieldBufferSize,
-      char* szComment,  uLong commentBufferSize)
-{
-   return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,
-         szFileName,fileNameBufferSize,
-         extraField,extraFieldBufferSize,
-         szComment,commentBufferSize);
-}
-
-extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,
-      unz_file_info * pfile_info,
-      char * szFileName, uLong fileNameBufferSize,
-      void *extraField, uLong extraFieldBufferSize,
-      char* szComment,  uLong commentBufferSize)
-{
-   int err;
-   unz_file_info64 file_info64;
-   err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,
-         szFileName,fileNameBufferSize,
-         extraField,extraFieldBufferSize,
-         szComment,commentBufferSize);
-   if (err==UNZ_OK)
-   {
-      pfile_info->version = file_info64.version;
-      pfile_info->version_needed = file_info64.version_needed;
-      pfile_info->flag = file_info64.flag;
-      pfile_info->compression_method = file_info64.compression_method;
-      pfile_info->dosDate = file_info64.dosDate;
-      pfile_info->crc = file_info64.crc;
-
-      pfile_info->size_filename = file_info64.size_filename;
-      pfile_info->size_file_extra = file_info64.size_file_extra;
-      pfile_info->size_file_comment = file_info64.size_file_comment;
-
-      pfile_info->disk_num_start = file_info64.disk_num_start;
-      pfile_info->internal_fa = file_info64.internal_fa;
-      pfile_info->external_fa = file_info64.external_fa;
-
-      pfile_info->tmu_date = file_info64.tmu_date,
-
-
-         pfile_info->compressed_size = (uLong)file_info64.compressed_size;
-      pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;
-
-   }
-   return err;
-}
-/*
-   Set the current file of the zipfile to the first file.
-   return UNZ_OK if there is no problem
-   */
-extern int ZEXPORT unzGoToFirstFile (unzFile file)
-{
-   int err=UNZ_OK;
-   unz64_s* s;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   s->pos_in_central_dir=s->offset_central_dir;
-   s->num_file=0;
-   err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-         &s->cur_file_info_internal,
-         NULL,0,NULL,0,NULL,0);
-   s->current_file_ok = (err == UNZ_OK);
-   return err;
-}
-
-/*
-   Set the current file of the zipfile to the next file.
-   return UNZ_OK if there is no problem
-   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
-   */
-extern int ZEXPORT unzGoToNextFile (unzFile  file)
-{
-   unz64_s* s;
-   int err;
-
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   if (!s->current_file_ok)
-      return UNZ_END_OF_LIST_OF_FILE;
-   if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
-      if (s->num_file+1==s->gi.number_entry)
-         return UNZ_END_OF_LIST_OF_FILE;
-
-   s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
-      s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
-   s->num_file++;
-   err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-         &s->cur_file_info_internal,
-         NULL,0,NULL,0,NULL,0);
-   s->current_file_ok = (err == UNZ_OK);
-   return err;
-}
-
-
-/*
-   Try locate the file szFileName in the zipfile.
-   For the iCaseSensitivity signification, see unzipStringFileNameCompare
-
-   return value :
-   UNZ_OK if the file is found. It becomes the current file.
-   UNZ_END_OF_LIST_OF_FILE if the file is not found
-   */
-extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
-{
-   unz64_s* s;
-   int err;
-
-   /* We remember the 'current' position in the file so that we can jump
-    * back there if we fail.
-    */
-   unz_file_info64 cur_file_infoSaved;
-   unz_file_info64_internal cur_file_info_internalSaved;
-   ZPOS64_T num_fileSaved;
-   ZPOS64_T pos_in_central_dirSaved;
-
-
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-
-   if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
-      return UNZ_PARAMERROR;
-
-   s=(unz64_s*)file;
-   if (!s->current_file_ok)
-      return UNZ_END_OF_LIST_OF_FILE;
-
-   /* Save the current state */
-   num_fileSaved = s->num_file;
-   pos_in_central_dirSaved = s->pos_in_central_dir;
-   cur_file_infoSaved = s->cur_file_info;
-   cur_file_info_internalSaved = s->cur_file_info_internal;
-
-   err = unzGoToFirstFile(file);
-
-   while (err == UNZ_OK)
-   {
-      char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
-      err = unzGetCurrentFileInfo64(file,NULL,
-            szCurrentFileName,sizeof(szCurrentFileName)-1,
-            NULL,0,NULL,0);
-      if (err == UNZ_OK)
-      {
-         if (unzStringFileNameCompare(szCurrentFileName,
-                  szFileName,iCaseSensitivity)==0)
-            return UNZ_OK;
-         err = unzGoToNextFile(file);
-      }
-   }
-
-   /* We failed, so restore the state of the 'current file' to where we
-    * were.
-    */
-   s->num_file = num_fileSaved ;
-   s->pos_in_central_dir = pos_in_central_dirSaved ;
-   s->cur_file_info = cur_file_infoSaved;
-   s->cur_file_info_internal = cur_file_info_internalSaved;
-   return err;
-}
-
-
-/*
-///////////////////////////////////////////
-// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
-// I need random access
-//
-// Further optimization could be realized by adding an ability
-// to cache the directory in memory. The goal being a single
-// comprehensive file read to put the file I need in a memory.
-*/
-
-/*
-   typedef struct unz_file_pos_s
-   {
-   ZPOS64_T pos_in_zip_directory;   // offset in file
-   ZPOS64_T num_of_file;            // # of file
-   } unz_file_pos;
-   */
-
-extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos*  file_pos)
-{
-   unz64_s* s;
-
-   if (file==NULL || file_pos==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   if (!s->current_file_ok)
-      return UNZ_END_OF_LIST_OF_FILE;
-
-   file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
-   file_pos->num_of_file           = s->num_file;
-
-   return UNZ_OK;
-}
-
-extern int ZEXPORT unzGetFilePos(
-      unzFile file,
-      unz_file_pos* file_pos)
-{
-   unz64_file_pos file_pos64;
-   int err = unzGetFilePos64(file,&file_pos64);
-   if (err==UNZ_OK)
-   {
-      file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;
-      file_pos->num_of_file = (uLong)file_pos64.num_of_file;
-   }
-   return err;
-}
-
-extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)
-{
-   unz64_s* s;
-   int err;
-
-   if (file==NULL || file_pos==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-
-   /* jump to the right spot */
-   s->pos_in_central_dir = file_pos->pos_in_zip_directory;
-   s->num_file           = file_pos->num_of_file;
-
-   /* set the current file */
-   err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-         &s->cur_file_info_internal,
-         NULL,0,NULL,0,NULL,0);
-   /* return results */
-   s->current_file_ok = (err == UNZ_OK);
-   return err;
-}
-
-extern int ZEXPORT unzGoToFilePos(
-      unzFile file,
-      unz_file_pos* file_pos)
-{
-   unz64_file_pos file_pos64;
-   if (file_pos == NULL)
-      return UNZ_PARAMERROR;
-
-   file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
-   file_pos64.num_of_file = file_pos->num_of_file;
-   return unzGoToFilePos64(file,&file_pos64);
-}
-
-/*
-// Unzip Helper Functions - should be here?
-///////////////////////////////////////////
-*/
-
-/*
-   Read the local header of the current zipfile
-   Check the coherency of the local header and info in the end of central
-   directory about this file
-   store in *piSizeVar the size of extra info in local header
-   (filename and size of extra field data)
-   */
-local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,
-      ZPOS64_T * poffset_local_extrafield,
-      uInt  * psize_local_extrafield)
-{
-   uLong uMagic,uData,uFlags;
-   uLong size_filename;
-   uLong size_extra_field;
-   int err=UNZ_OK;
-
-   *piSizeVar = 0;
-   *poffset_local_extrafield = 0;
-   *psize_local_extrafield = 0;
-
-   if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
-            s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
-      return UNZ_ERRNO;
-
-
-   if (err==UNZ_OK)
-   {
-      if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
-         err=UNZ_ERRNO;
-      else if (uMagic!=0x04034b50)
-         err=UNZ_BADZIPFILE;
-   }
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
-      err=UNZ_ERRNO;
-   /*
-      else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
-      err=UNZ_BADZIPFILE;
-      */
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
-      err=UNZ_ERRNO;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
-      err=UNZ_ERRNO;
-   else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
-      err=UNZ_BADZIPFILE;
-
-   if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
-         /* #ifdef HAVE_BZIP2 */
-         (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
-         /* #endif */
-         (s->cur_file_info.compression_method!=Z_DEFLATED))
-      err=UNZ_BADZIPFILE;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
-      err=UNZ_ERRNO;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
-      err=UNZ_ERRNO;
-   else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))
-      err=UNZ_BADZIPFILE;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
-      err=UNZ_ERRNO;
-   else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))
-      err=UNZ_BADZIPFILE;
-
-   if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
-      err=UNZ_ERRNO;
-   else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))
-      err=UNZ_BADZIPFILE;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
-      err=UNZ_ERRNO;
-   else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
-      err=UNZ_BADZIPFILE;
-
-   *piSizeVar += (uInt)size_filename;
-
-   if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
-      err=UNZ_ERRNO;
-   *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
-      SIZEZIPLOCALHEADER + size_filename;
-   *psize_local_extrafield = (uInt)size_extra_field;
-
-   *piSizeVar += (uInt)size_extra_field;
-
-   return err;
-}
-
-/*
-   Open for reading data the current file in the zipfile.
-   If there is no error and the file is opened, the return value is UNZ_OK.
-   */
-extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
-      int* level, int raw, const char* password)
-{
-   int err=UNZ_OK;
-   uInt iSizeVar;
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   ZPOS64_T offset_local_extrafield;  /* offset of the local extra field */
-   uInt  size_local_extrafield;    /* size of the local extra field */
-#    ifndef NOUNCRYPT
-   char source[12];
-#    else
-   if (password != NULL)
-      return UNZ_PARAMERROR;
-#    endif
-
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   if (!s->current_file_ok)
-      return UNZ_PARAMERROR;
-
-   if (s->pfile_in_zip_read != NULL)
-      unzCloseCurrentFile(file);
-
-   if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
-      return UNZ_BADZIPFILE;
-
-   pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
-   if (pfile_in_zip_read_info==NULL)
-      return UNZ_INTERNALERROR;
-
-   pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
-   pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
-   pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
-   pfile_in_zip_read_info->pos_local_extrafield=0;
-   pfile_in_zip_read_info->raw=raw;
-
-   if (pfile_in_zip_read_info->read_buffer==NULL)
-   {
-      TRYFREE(pfile_in_zip_read_info);
-      return UNZ_INTERNALERROR;
-   }
-
-   pfile_in_zip_read_info->stream_initialised=0;
-
-   if (method!=NULL)
-      *method = (int)s->cur_file_info.compression_method;
-
-   if (level!=NULL)
-   {
-      *level = 6;
-      switch (s->cur_file_info.flag & 0x06)
-      {
-         case 6 : *level = 1; break;
-         case 4 : *level = 2; break;
-         case 2 : *level = 9; break;
-      }
-   }
-
-   if ((s->cur_file_info.compression_method!=0) &&
-         /* #ifdef HAVE_BZIP2 */
-         (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
-         /* #endif */
-         (s->cur_file_info.compression_method!=Z_DEFLATED))
-
-      err=UNZ_BADZIPFILE;
-
-   pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
-   pfile_in_zip_read_info->crc32=0;
-   pfile_in_zip_read_info->total_out_64=0;
-   pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;
-   pfile_in_zip_read_info->filestream=s->filestream;
-   pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
-   pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
-
-   pfile_in_zip_read_info->stream.total_out = 0;
-
-   if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))
-   {
-#ifdef HAVE_BZIP2
-      pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
-      pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
-      pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
-      pfile_in_zip_read_info->bstream.state = (voidpf)0;
-
-      pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
-      pfile_in_zip_read_info->stream.zfree = (free_func)0;
-      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
-      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
-      pfile_in_zip_read_info->stream.avail_in = 0;
-
-      err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
-      if (err == Z_OK)
-         pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
-      else
-      {
-         TRYFREE(pfile_in_zip_read_info);
-         return err;
-      }
-#else
-      pfile_in_zip_read_info->raw=1;
-#endif
-   }
-   else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))
-   {
-      pfile_in_zip_read_info->stream.zalloc = Z_NULL;
-      pfile_in_zip_read_info->stream.zfree = Z_NULL;
-      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
-      pfile_in_zip_read_info->stream.next_in = 0;
-      pfile_in_zip_read_info->stream.avail_in = 0;
-
-      err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
-      if (err == Z_OK)
-         pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;
-      else
-      {
-         TRYFREE(pfile_in_zip_read_info);
-         return err;
-      }
-      /* windowBits is passed < 0 to tell that there is no zlib header.
-       * Note that in this case inflate *requires* an extra "dummy" byte
-       * after the compressed stream in order to complete decompression and
-       * return Z_STREAM_END.
-       * In unzip, i don't wait absolutely Z_STREAM_END because I known the
-       * size of both compressed and uncompressed data
-       */
-   }
-   pfile_in_zip_read_info->rest_read_compressed =
-      s->cur_file_info.compressed_size ;
-   pfile_in_zip_read_info->rest_read_uncompressed =
-      s->cur_file_info.uncompressed_size ;
-
-
-   pfile_in_zip_read_info->pos_in_zipfile =
-      s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
-      iSizeVar;
-
-   pfile_in_zip_read_info->stream.avail_in = (uInt)0;
-
-   s->pfile_in_zip_read = pfile_in_zip_read_info;
-   s->encrypted = 0;
-
-#    ifndef NOUNCRYPT
-   if (password != NULL)
-   {
-      int i;
-      s->pcrc_32_tab = get_crc_table();
-      init_keys(password,s->keys,s->pcrc_32_tab);
-      if (ZSEEK64(s->z_filefunc, s->filestream,
-               s->pfile_in_zip_read->pos_in_zipfile +
-               s->pfile_in_zip_read->byte_before_the_zipfile,
-               SEEK_SET)!=0)
-         return UNZ_INTERNALERROR;
-      if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)
-         return UNZ_INTERNALERROR;
-
-      for (i = 0; i<12; i++)
-         zdecode(s->keys,s->pcrc_32_tab,source[i]);
-
-      s->pfile_in_zip_read->pos_in_zipfile+=12;
-      s->encrypted=1;
-   }
-#    endif
-
-
-   return UNZ_OK;
-}
-
-extern int ZEXPORT unzOpenCurrentFile (unzFile file)
-{
-   return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
-}
-
-extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char*  password)
-{
-   return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
-}
-
-extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw)
-{
-   return unzOpenCurrentFile3(file, method, level, raw, NULL);
-}
-
-/** Addition for GDAL : START */
-
-extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file)
-{
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   s=(unz64_s*)file;
-   if (file==NULL)
-      return 0; //UNZ_PARAMERROR;
-   pfile_in_zip_read_info=s->pfile_in_zip_read;
-   if (pfile_in_zip_read_info==NULL)
-      return 0; //UNZ_PARAMERROR;
-   return pfile_in_zip_read_info->pos_in_zipfile +
-      pfile_in_zip_read_info->byte_before_the_zipfile;
-}
-
-/** Addition for GDAL : END */
-
-/*
-   Read bytes from the current file.
-   buf contain buffer where data must be copied
-   len the size of buf.
-
-   return the number of byte copied if somes bytes are copied
-   return 0 if the end of file was reached
-   return <0 with error code if there is an error
-   (UNZ_ERRNO for IO error, or zLib error for uncompress error)
-   */
-extern int ZEXPORT unzReadCurrentFile  (unzFile file, voidp buf, unsigned len)
-{
-   int err=UNZ_OK;
-   uInt iRead = 0;
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-   if (pfile_in_zip_read_info==NULL)
-      return UNZ_PARAMERROR;
-
-
-   if (pfile_in_zip_read_info->read_buffer == NULL)
-      return UNZ_END_OF_LIST_OF_FILE;
-   if (len==0)
-      return 0;
-
-   pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
-
-   pfile_in_zip_read_info->stream.avail_out = (uInt)len;
-
-   if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
-         (!(pfile_in_zip_read_info->raw)))
-      pfile_in_zip_read_info->stream.avail_out =
-         (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
-
-   if ((len>pfile_in_zip_read_info->rest_read_compressed+
-            pfile_in_zip_read_info->stream.avail_in) &&
-         (pfile_in_zip_read_info->raw))
-      pfile_in_zip_read_info->stream.avail_out =
-         (uInt)pfile_in_zip_read_info->rest_read_compressed+
-         pfile_in_zip_read_info->stream.avail_in;
-
-   while (pfile_in_zip_read_info->stream.avail_out>0)
-   {
-      if ((pfile_in_zip_read_info->stream.avail_in==0) &&
-            (pfile_in_zip_read_info->rest_read_compressed>0))
-      {
-         uInt uReadThis = UNZ_BUFSIZE;
-         if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
-            uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
-         if (uReadThis == 0)
-            return UNZ_EOF;
-         if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
-                  pfile_in_zip_read_info->filestream,
-                  pfile_in_zip_read_info->pos_in_zipfile +
-                  pfile_in_zip_read_info->byte_before_the_zipfile,
-                  ZLIB_FILEFUNC_SEEK_SET)!=0)
-            return UNZ_ERRNO;
-         if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
-                  pfile_in_zip_read_info->filestream,
-                  pfile_in_zip_read_info->read_buffer,
-                  uReadThis)!=uReadThis)
-            return UNZ_ERRNO;
-
-
-#            ifndef NOUNCRYPT
-         if(s->encrypted)
-         {
-            uInt i;
-            for(i=0;i<uReadThis;i++)
-               pfile_in_zip_read_info->read_buffer[i] =
-                  zdecode(s->keys,s->pcrc_32_tab,
-                        pfile_in_zip_read_info->read_buffer[i]);
-         }
-#            endif
-
-
-         pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
-
-         pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
-
-         pfile_in_zip_read_info->stream.next_in =
-            (Bytef*)pfile_in_zip_read_info->read_buffer;
-         pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
-      }
-
-      if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
-      {
-         uInt uDoCopy,i ;
-
-         if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
-               (pfile_in_zip_read_info->rest_read_compressed == 0))
-            return (iRead==0) ? UNZ_EOF : iRead;
-
-         if (pfile_in_zip_read_info->stream.avail_out <
-               pfile_in_zip_read_info->stream.avail_in)
-            uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
-         else
-            uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
-
-         for (i=0;i<uDoCopy;i++)
-            *(pfile_in_zip_read_info->stream.next_out+i) =
-               *(pfile_in_zip_read_info->stream.next_in+i);
-
-         pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;
-
-         pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
-               pfile_in_zip_read_info->stream.next_out,
-               uDoCopy);
-         pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
-         pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
-         pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
-         pfile_in_zip_read_info->stream.next_out += uDoCopy;
-         pfile_in_zip_read_info->stream.next_in += uDoCopy;
-         pfile_in_zip_read_info->stream.total_out += uDoCopy;
-         iRead += uDoCopy;
-      }
-      else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)
-      {
-#ifdef HAVE_BZIP2
-         uLong uTotalOutBefore,uTotalOutAfter;
-         const Bytef *bufBefore;
-         uLong uOutThis;
-
-         pfile_in_zip_read_info->bstream.next_in        = (char*)pfile_in_zip_read_info->stream.next_in;
-         pfile_in_zip_read_info->bstream.avail_in       = pfile_in_zip_read_info->stream.avail_in;
-         pfile_in_zip_read_info->bstream.total_in_lo32  = pfile_in_zip_read_info->stream.total_in;
-         pfile_in_zip_read_info->bstream.total_in_hi32  = 0;
-         pfile_in_zip_read_info->bstream.next_out       = (char*)pfile_in_zip_read_info->stream.next_out;
-         pfile_in_zip_read_info->bstream.avail_out      = pfile_in_zip_read_info->stream.avail_out;
-         pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;
-         pfile_in_zip_read_info->bstream.total_out_hi32 = 0;
-
-         uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;
-         bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;
-
-         err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);
-
-         uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;
-         uOutThis = uTotalOutAfter-uTotalOutBefore;
-
-         pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
-
-         pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));
-         pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
-         iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
-
-         pfile_in_zip_read_info->stream.next_in   = (Bytef*)pfile_in_zip_read_info->bstream.next_in;
-         pfile_in_zip_read_info->stream.avail_in  = pfile_in_zip_read_info->bstream.avail_in;
-         pfile_in_zip_read_info->stream.total_in  = pfile_in_zip_read_info->bstream.total_in_lo32;
-         pfile_in_zip_read_info->stream.next_out  = (Bytef*)pfile_in_zip_read_info->bstream.next_out;
-         pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;
-         pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;
-
-         if (err==BZ_STREAM_END)
-            return (iRead==0) ? UNZ_EOF : iRead;
-         if (err!=BZ_OK)
-            break;
-#endif
-      } // end Z_BZIP2ED
-      else
-      {
-         ZPOS64_T uTotalOutBefore,uTotalOutAfter;
-         const Bytef *bufBefore;
-         ZPOS64_T uOutThis;
-         int flush=Z_SYNC_FLUSH;
-
-         uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
-         bufBefore = pfile_in_zip_read_info->stream.next_out;
-
-         /*
-            if ((pfile_in_zip_read_info->rest_read_uncompressed ==
-            pfile_in_zip_read_info->stream.avail_out) &&
-            (pfile_in_zip_read_info->rest_read_compressed == 0))
-            flush = Z_FINISH;
-            */
-         err=inflate(&pfile_in_zip_read_info->stream,flush);
-
-         if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
-            err = Z_DATA_ERROR;
-
-         uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
-         uOutThis = uTotalOutAfter-uTotalOutBefore;
-
-         pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
-
-         pfile_in_zip_read_info->crc32 =
-            crc32(pfile_in_zip_read_info->crc32,bufBefore,
-                  (uInt)(uOutThis));
-
-         pfile_in_zip_read_info->rest_read_uncompressed -=
-            uOutThis;
-
-         iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
-
-         if (err==Z_STREAM_END)
-            return (iRead==0) ? UNZ_EOF : iRead;
-         if (err!=Z_OK)
-            break;
-      }
-   }
-
-   if (err==Z_OK)
-      return iRead;
-   return err;
-}
-
-
-/*
-   Give the current position in uncompressed data
-   */
-extern z_off_t ZEXPORT unztell (unzFile file)
-{
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-   if (pfile_in_zip_read_info==NULL)
-      return UNZ_PARAMERROR;
-
-   return (z_off_t)pfile_in_zip_read_info->stream.total_out;
-}
-
-extern ZPOS64_T ZEXPORT unztell64 (unzFile file)
-{
-
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   if (file==NULL)
-      return (ZPOS64_T)-1;
-   s=(unz64_s*)file;
-   pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-   if (pfile_in_zip_read_info==NULL)
-      return (ZPOS64_T)-1;
-
-   return pfile_in_zip_read_info->total_out_64;
-}
-
-
-/*
-   return 1 if the end of file was reached, 0 elsewhere
-   */
-extern int ZEXPORT unzeof (unzFile file)
-{
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-   if (pfile_in_zip_read_info==NULL)
-      return UNZ_PARAMERROR;
-
-   if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
-      return 1;
-   else
-      return 0;
-}
-
-
-
-/*
-   Read extra field from the current file (opened by unzOpenCurrentFile)
-   This is the local-header version of the extra field (sometimes, there is
-   more info in the local-header version than in the central-header)
-
-   if buf==NULL, it return the size of the local extra field that can be read
-
-   if buf!=NULL, len is the size of the buffer, the extra header is copied in
-   buf.
-   the return value is the number of bytes copied in buf, or (if <0)
-   the error code
-   */
-extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len)
-{
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   uInt read_now;
-   ZPOS64_T size_to_read;
-
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-   if (pfile_in_zip_read_info==NULL)
-      return UNZ_PARAMERROR;
-
-   size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
-         pfile_in_zip_read_info->pos_local_extrafield);
-
-   if (buf==NULL)
-      return (int)size_to_read;
-
-   if (len>size_to_read)
-      read_now = (uInt)size_to_read;
-   else
-      read_now = (uInt)len ;
-
-   if (read_now==0)
-      return 0;
-
-   if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
-            pfile_in_zip_read_info->filestream,
-            pfile_in_zip_read_info->offset_local_extrafield +
-            pfile_in_zip_read_info->pos_local_extrafield,
-            ZLIB_FILEFUNC_SEEK_SET)!=0)
-      return UNZ_ERRNO;
-
-   if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
-            pfile_in_zip_read_info->filestream,
-            buf,read_now)!=read_now)
-      return UNZ_ERRNO;
-
-   return (int)read_now;
-}
-
-/*
-   Close the file in zip opened with unzipOpenCurrentFile
-   Return UNZ_CRCERROR if all the file was read but the CRC is not good
-   */
-extern int ZEXPORT unzCloseCurrentFile (unzFile file)
-{
-   int err=UNZ_OK;
-
-   unz64_s* s;
-   file_in_zip64_read_info_s* pfile_in_zip_read_info;
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-   if (pfile_in_zip_read_info==NULL)
-      return UNZ_PARAMERROR;
-
-
-   if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
-         (!pfile_in_zip_read_info->raw))
-   {
-      if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
-         err=UNZ_CRCERROR;
-   }
-
-
-   TRYFREE(pfile_in_zip_read_info->read_buffer);
-   pfile_in_zip_read_info->read_buffer = NULL;
-   if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)
-      inflateEnd(&pfile_in_zip_read_info->stream);
-#ifdef HAVE_BZIP2
-   else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
-      BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
-#endif
-
-
-   pfile_in_zip_read_info->stream_initialised = 0;
-   TRYFREE(pfile_in_zip_read_info);
-
-   s->pfile_in_zip_read=NULL;
-
-   return err;
-}
-
-
-/*
-   Get the global comment string of the ZipFile, in the szComment buffer.
-   uSizeBuf is the size of the szComment buffer.
-   return the number of byte copied or an error code <0
-   */
-extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf)
-{
-   unz64_s* s;
-   uLong uReadThis ;
-   if (file==NULL)
-      return (int)UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-
-   uReadThis = uSizeBuf;
-   if (uReadThis>s->gi.size_comment)
-      uReadThis = s->gi.size_comment;
-
-   if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
-      return UNZ_ERRNO;
-
-   if (uReadThis>0)
-   {
-      *szComment='\0';
-      if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
-         return UNZ_ERRNO;
-   }
-
-   if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
-      *(szComment+s->gi.size_comment)='\0';
-   return (int)uReadThis;
-}
-
-/* Additions by RX '2004 */
-extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
-{
-   unz64_s* s;
-
-   if (file==NULL)
-      return 0; //UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-   if (!s->current_file_ok)
-      return 0;
-   if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
-      if (s->num_file==s->gi.number_entry)
-         return 0;
-   return s->pos_in_central_dir;
-}
-
-extern uLong ZEXPORT unzGetOffset (unzFile file)
-{
-   ZPOS64_T offset64;
-
-   if (file==NULL)
-      return 0; //UNZ_PARAMERROR;
-   offset64 = unzGetOffset64(file);
-   return (uLong)offset64;
-}
-
-extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
-{
-   unz64_s* s;
-   int err;
-
-   if (file==NULL)
-      return UNZ_PARAMERROR;
-   s=(unz64_s*)file;
-
-   s->pos_in_central_dir = pos;
-   s->num_file = s->gi.number_entry;      /* hack */
-   err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-         &s->cur_file_info_internal,
-         NULL,0,NULL,0,NULL,0);
-   s->current_file_ok = (err == UNZ_OK);
-   return err;
-}
-
-extern int ZEXPORT unzSetOffset (unzFile file, uLong pos)
-{
-   return unzSetOffset64(file,pos);
-}
diff --git a/deps/unzip.h b/deps/unzip.h
deleted file mode 100644
index 3183968..0000000
--- a/deps/unzip.h
+++ /dev/null
@@ -1,437 +0,0 @@
-/* unzip.h -- IO for uncompress .zip files using zlib
-   Version 1.1, February 14h, 2010
-   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
-
-         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
-
-         Modifications of Unzip for Zip64
-         Copyright (C) 2007-2008 Even Rouault
-
-         Modifications for Zip64 support on both zip and unzip
-         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
-
-         For more info read MiniZip_info.txt
-
-         ---------------------------------------------------------------------------------
-
-        Condition of use and distribution are the same than zlib :
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  ---------------------------------------------------------------------------------
-
-        Changes
-
-        See header of unzip64.c
-
-*/
-
-#ifndef _unz64_H
-#define _unz64_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef _ZLIB_H
-#include "zlib.h"
-#endif
-
-#ifndef  _ZLIBIOAPI_H
-#include "ioapi.h"
-#endif
-
-#ifdef HAVE_BZIP2
-#include "bzlib.h"
-#endif
-
-#define Z_BZIP2ED 12
-
-#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
-/* like the STRICT of WIN32, we define a pointer that cannot be converted
-    from (void*) without cast */
-typedef struct TagunzFile__ { int unused; } unzFile__;
-typedef unzFile__ *unzFile;
-#else
-typedef voidp unzFile;
-#endif
-
-
-#define UNZ_OK                          (0)
-#define UNZ_END_OF_LIST_OF_FILE         (-100)
-#define UNZ_ERRNO                       (Z_ERRNO)
-#define UNZ_EOF                         (0)
-#define UNZ_PARAMERROR                  (-102)
-#define UNZ_BADZIPFILE                  (-103)
-#define UNZ_INTERNALERROR               (-104)
-#define UNZ_CRCERROR                    (-105)
-
-/* tm_unz contain date/time info */
-typedef struct tm_unz_s
-{
-    uInt tm_sec;            /* seconds after the minute - [0,59] */
-    uInt tm_min;            /* minutes after the hour - [0,59] */
-    uInt tm_hour;           /* hours since midnight - [0,23] */
-    uInt tm_mday;           /* day of the month - [1,31] */
-    uInt tm_mon;            /* months since January - [0,11] */
-    uInt tm_year;           /* years - [1980..2044] */
-} tm_unz;
-
-/* unz_global_info structure contain global data about the ZIPfile
-   These data comes from the end of central dir */
-typedef struct unz_global_info64_s
-{
-    ZPOS64_T number_entry;         /* total number of entries in
-                                     the central dir on this disk */
-    uLong size_comment;         /* size of the global comment of the zipfile */
-} unz_global_info64;
-
-typedef struct unz_global_info_s
-{
-    uLong number_entry;         /* total number of entries in
-                                     the central dir on this disk */
-    uLong size_comment;         /* size of the global comment of the zipfile */
-} unz_global_info;
-
-/* unz_file_info contain information about a file in the zipfile */
-typedef struct unz_file_info64_s
-{
-    uLong version;              /* version made by                 2 bytes */
-    uLong version_needed;       /* version needed to extract       2 bytes */
-    uLong flag;                 /* general purpose bit flag        2 bytes */
-    uLong compression_method;   /* compression method              2 bytes */
-    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
-    uLong crc;                  /* crc-32                          4 bytes */
-    ZPOS64_T compressed_size;   /* compressed size                 8 bytes */
-    ZPOS64_T uncompressed_size; /* uncompressed size               8 bytes */
-    uLong size_filename;        /* filename length                 2 bytes */
-    uLong size_file_extra;      /* extra field length              2 bytes */
-    uLong size_file_comment;    /* file comment length             2 bytes */
-
-    uLong disk_num_start;       /* disk number start               2 bytes */
-    uLong internal_fa;          /* internal file attributes        2 bytes */
-    uLong external_fa;          /* external file attributes        4 bytes */
-
-    tm_unz tmu_date;
-} unz_file_info64;
-
-typedef struct unz_file_info_s
-{
-    uLong version;              /* version made by                 2 bytes */
-    uLong version_needed;       /* version needed to extract       2 bytes */
-    uLong flag;                 /* general purpose bit flag        2 bytes */
-    uLong compression_method;   /* compression method              2 bytes */
-    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
-    uLong crc;                  /* crc-32                          4 bytes */
-    uLong compressed_size;      /* compressed size                 4 bytes */
-    uLong uncompressed_size;    /* uncompressed size               4 bytes */
-    uLong size_filename;        /* filename length                 2 bytes */
-    uLong size_file_extra;      /* extra field length              2 bytes */
-    uLong size_file_comment;    /* file comment length             2 bytes */
-
-    uLong disk_num_start;       /* disk number start               2 bytes */
-    uLong internal_fa;          /* internal file attributes        2 bytes */
-    uLong external_fa;          /* external file attributes        4 bytes */
-
-    tm_unz tmu_date;
-} unz_file_info;
-
-extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
-                                                 const char* fileName2,
-                                                 int iCaseSensitivity));
-/*
-   Compare two filename (fileName1,fileName2).
-   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
-   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
-                                or strcasecmp)
-   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
-    (like 1 on Unix, 2 on Windows)
-*/
-
-
-extern unzFile ZEXPORT unzOpen OF((const char *path));
-extern unzFile ZEXPORT unzOpen64 OF((const void *path));
-/*
-  Open a Zip file. path contain the full pathname (by example,
-     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
-     "zlib/zlib113.zip".
-     If the zipfile cannot be opened (file don't exist or in not valid), the
-       return value is NULL.
-     Else, the return value is a unzFile Handle, usable with other function
-       of this unzip package.
-     the "64" function take a const void* pointer, because the path is just the
-       value passed to the open64_file_func callback.
-     Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path
-       is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char*
-       does not describe the reality
-*/
-
-
-extern unzFile ZEXPORT unzOpen2 OF((const char *path,
-                                    zlib_filefunc_def* pzlib_filefunc_def));
-/*
-   Open a Zip file, like unzOpen, but provide a set of file low level API
-      for read/write the zip file (see ioapi.h)
-*/
-
-extern unzFile ZEXPORT unzOpen2_64 OF((const void *path,
-                                    zlib_filefunc64_def* pzlib_filefunc_def));
-/*
-   Open a Zip file, like unz64Open, but provide a set of file low level API
-      for read/write the zip file (see ioapi.h)
-*/
-
-extern int ZEXPORT unzClose OF((unzFile file));
-/*
-  Close a ZipFile opened with unzipOpen.
-  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
-    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
-  return UNZ_OK if there is no problem. */
-
-extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
-                                        unz_global_info *pglobal_info));
-
-extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file,
-                                        unz_global_info64 *pglobal_info));
-/*
-  Write info about the ZipFile in the *pglobal_info structure.
-  No preparation of the structure is needed
-  return UNZ_OK if there is no problem. */
-
-
-extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
-                                           char *szComment,
-                                           uLong uSizeBuf));
-/*
-  Get the global comment string of the ZipFile, in the szComment buffer.
-  uSizeBuf is the size of the szComment buffer.
-  return the number of byte copied or an error code <0
-*/
-
-
-/***************************************************************************/
-/* Unzip package allow you browse the directory of the zipfile */
-
-extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
-/*
-  Set the current file of the zipfile to the first file.
-  return UNZ_OK if there is no problem
-*/
-
-extern int ZEXPORT unzGoToNextFile OF((unzFile file));
-/*
-  Set the current file of the zipfile to the next file.
-  return UNZ_OK if there is no problem
-  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
-*/
-
-extern int ZEXPORT unzLocateFile OF((unzFile file,
-                     const char *szFileName,
-                     int iCaseSensitivity));
-/*
-  Try locate the file szFileName in the zipfile.
-  For the iCaseSensitivity signification, see unzStringFileNameCompare
-
-  return value :
-  UNZ_OK if the file is found. It becomes the current file.
-  UNZ_END_OF_LIST_OF_FILE if the file is not found
-*/
-
-
-/* ****************************************** */
-/* Ryan supplied functions */
-/* unz_file_info contain information about a file in the zipfile */
-typedef struct unz_file_pos_s
-{
-    uLong pos_in_zip_directory;   /* offset in zip file directory */
-    uLong num_of_file;            /* # of file */
-} unz_file_pos;
-
-extern int ZEXPORT unzGetFilePos(
-    unzFile file,
-    unz_file_pos* file_pos);
-
-extern int ZEXPORT unzGoToFilePos(
-    unzFile file,
-    unz_file_pos* file_pos);
-
-typedef struct unz64_file_pos_s
-{
-    ZPOS64_T pos_in_zip_directory;   /* offset in zip file directory */
-    ZPOS64_T num_of_file;            /* # of file */
-} unz64_file_pos;
-
-extern int ZEXPORT unzGetFilePos64(
-    unzFile file,
-    unz64_file_pos* file_pos);
-
-extern int ZEXPORT unzGoToFilePos64(
-    unzFile file,
-    const unz64_file_pos* file_pos);
-
-/* ****************************************** */
-
-extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file,
-                         unz_file_info64 *pfile_info,
-                         char *szFileName,
-                         uLong fileNameBufferSize,
-                         void *extraField,
-                         uLong extraFieldBufferSize,
-                         char *szComment,
-                         uLong commentBufferSize));
-
-extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
-                         unz_file_info *pfile_info,
-                         char *szFileName,
-                         uLong fileNameBufferSize,
-                         void *extraField,
-                         uLong extraFieldBufferSize,
-                         char *szComment,
-                         uLong commentBufferSize));
-/*
-  Get Info about the current file
-  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
-        the current file
-  if szFileName!=NULL, the filemane string will be copied in szFileName
-            (fileNameBufferSize is the size of the buffer)
-  if extraField!=NULL, the extra field information will be copied in extraField
-            (extraFieldBufferSize is the size of the buffer).
-            This is the Central-header version of the extra field
-  if szComment!=NULL, the comment string of the file will be copied in szComment
-            (commentBufferSize is the size of the buffer)
-*/
-
-
-/** Addition for GDAL : START */
-
-extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file));
-
-/** Addition for GDAL : END */
-
-
-/***************************************************************************/
-/* for reading the content of the current zipfile, you can open it, read data
-   from it, and close it (you can close it before reading all the file)
-   */
-
-extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
-/*
-  Open for reading data the current file in the zipfile.
-  If there is no error, the return value is UNZ_OK.
-*/
-
-extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
-                                                  const char* password));
-/*
-  Open for reading data the current file in the zipfile.
-  password is a crypting password
-  If there is no error, the return value is UNZ_OK.
-*/
-
-extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
-                                           int* method,
-                                           int* level,
-                                           int raw));
-/*
-  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
-    if raw==1
-  *method will receive method of compression, *level will receive level of
-     compression
-  note : you can set level parameter as NULL (if you did not want known level,
-         but you CANNOT set method parameter as NULL
-*/
-
-extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
-                                           int* method,
-                                           int* level,
-                                           int raw,
-                                           const char* password));
-/*
-  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
-    if raw==1
-  *method will receive method of compression, *level will receive level of
-     compression
-  note : you can set level parameter as NULL (if you did not want known level,
-         but you CANNOT set method parameter as NULL
-*/
-
-
-extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
-/*
-  Close the file in zip opened with unzOpenCurrentFile
-  Return UNZ_CRCERROR if all the file was read but the CRC is not good
-*/
-
-extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
-                      voidp buf,
-                      unsigned len));
-/*
-  Read bytes from the current file (opened by unzOpenCurrentFile)
-  buf contain buffer where data must be copied
-  len the size of buf.
-
-  return the number of byte copied if somes bytes are copied
-  return 0 if the end of file was reached
-  return <0 with error code if there is an error
-    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
-*/
-
-extern z_off_t ZEXPORT unztell OF((unzFile file));
-
-extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file));
-/*
-  Give the current position in uncompressed data
-*/
-
-extern int ZEXPORT unzeof OF((unzFile file));
-/*
-  return 1 if the end of file was reached, 0 elsewhere
-*/
-
-extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
-                                             voidp buf,
-                                             unsigned len));
-/*
-  Read extra field from the current file (opened by unzOpenCurrentFile)
-  This is the local-header version of the extra field (sometimes, there is
-    more info in the local-header version than in the central-header)
-
-  if buf==NULL, it return the size of the local extra field
-
-  if buf!=NULL, len is the size of the buffer, the extra header is copied in
-    buf.
-  the return value is the number of bytes copied in buf, or (if <0)
-    the error code
-*/
-
-/***************************************************************************/
-
-/* Get the current file offset */
-extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file);
-extern uLong ZEXPORT unzGetOffset (unzFile file);
-
-/* Set the current file offset */
-extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos);
-extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
-
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _unz64_H */
diff --git a/deps/zconf.h b/deps/zconf.h
deleted file mode 100644
index 9987a77..0000000
--- a/deps/zconf.h
+++ /dev/null
@@ -1,511 +0,0 @@
-/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#ifndef ZCONF_H
-#define ZCONF_H
-
-/*
- * If you *really* need a unique prefix for all types and library functions,
- * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
- * Even better than compiling with -DZ_PREFIX would be to use configure to set
- * this permanently in zconf.h using "./configure --zprefix".
- */
-#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
-#  define Z_PREFIX_SET
-
-/* all linked symbols */
-#  define _dist_code            z__dist_code
-#  define _length_code          z__length_code
-#  define _tr_align             z__tr_align
-#  define _tr_flush_bits        z__tr_flush_bits
-#  define _tr_flush_block       z__tr_flush_block
-#  define _tr_init              z__tr_init
-#  define _tr_stored_block      z__tr_stored_block
-#  define _tr_tally             z__tr_tally
-#  define adler32               z_adler32
-#  define adler32_combine       z_adler32_combine
-#  define adler32_combine64     z_adler32_combine64
-#  ifndef Z_SOLO
-#    define compress              z_compress
-#    define compress2             z_compress2
-#    define compressBound         z_compressBound
-#  endif
-#  define crc32                 z_crc32
-#  define crc32_combine         z_crc32_combine
-#  define crc32_combine64       z_crc32_combine64
-#  define deflate               z_deflate
-#  define deflateBound          z_deflateBound
-#  define deflateCopy           z_deflateCopy
-#  define deflateEnd            z_deflateEnd
-#  define deflateInit2_         z_deflateInit2_
-#  define deflateInit_          z_deflateInit_
-#  define deflateParams         z_deflateParams
-#  define deflatePending        z_deflatePending
-#  define deflatePrime          z_deflatePrime
-#  define deflateReset          z_deflateReset
-#  define deflateResetKeep      z_deflateResetKeep
-#  define deflateSetDictionary  z_deflateSetDictionary
-#  define deflateSetHeader      z_deflateSetHeader
-#  define deflateTune           z_deflateTune
-#  define deflate_copyright     z_deflate_copyright
-#  define get_crc_table         z_get_crc_table
-#  ifndef Z_SOLO
-#    define gz_error              z_gz_error
-#    define gz_intmax             z_gz_intmax
-#    define gz_strwinerror        z_gz_strwinerror
-#    define gzbuffer              z_gzbuffer
-#    define gzclearerr            z_gzclearerr
-#    define gzclose               z_gzclose
-#    define gzclose_r             z_gzclose_r
-#    define gzclose_w             z_gzclose_w
-#    define gzdirect              z_gzdirect
-#    define gzdopen               z_gzdopen
-#    define gzeof                 z_gzeof
-#    define gzerror               z_gzerror
-#    define gzflush               z_gzflush
-#    define gzgetc                z_gzgetc
-#    define gzgetc_               z_gzgetc_
-#    define gzgets                z_gzgets
-#    define gzoffset              z_gzoffset
-#    define gzoffset64            z_gzoffset64
-#    define gzopen                z_gzopen
-#    define gzopen64              z_gzopen64
-#    ifdef _WIN32
-#      define gzopen_w              z_gzopen_w
-#    endif
-#    define gzprintf              z_gzprintf
-#    define gzvprintf             z_gzvprintf
-#    define gzputc                z_gzputc
-#    define gzputs                z_gzputs
-#    define gzread                z_gzread
-#    define gzrewind              z_gzrewind
-#    define gzseek                z_gzseek
-#    define gzseek64              z_gzseek64
-#    define gzsetparams           z_gzsetparams
-#    define gztell                z_gztell
-#    define gztell64              z_gztell64
-#    define gzungetc              z_gzungetc
-#    define gzwrite               z_gzwrite
-#  endif
-#  define inflate               z_inflate
-#  define inflateBack           z_inflateBack
-#  define inflateBackEnd        z_inflateBackEnd
-#  define inflateBackInit_      z_inflateBackInit_
-#  define inflateCopy           z_inflateCopy
-#  define inflateEnd            z_inflateEnd
-#  define inflateGetHeader      z_inflateGetHeader
-#  define inflateInit2_         z_inflateInit2_
-#  define inflateInit_          z_inflateInit_
-#  define inflateMark           z_inflateMark
-#  define inflatePrime          z_inflatePrime
-#  define inflateReset          z_inflateReset
-#  define inflateReset2         z_inflateReset2
-#  define inflateSetDictionary  z_inflateSetDictionary
-#  define inflateGetDictionary  z_inflateGetDictionary
-#  define inflateSync           z_inflateSync
-#  define inflateSyncPoint      z_inflateSyncPoint
-#  define inflateUndermine      z_inflateUndermine
-#  define inflateResetKeep      z_inflateResetKeep
-#  define inflate_copyright     z_inflate_copyright
-#  define inflate_fast          z_inflate_fast
-#  define inflate_table         z_inflate_table
-#  ifndef Z_SOLO
-#    define uncompress            z_uncompress
-#  endif
-#  define zError                z_zError
-#  ifndef Z_SOLO
-#    define zcalloc               z_zcalloc
-#    define zcfree                z_zcfree
-#  endif
-#  define zlibCompileFlags      z_zlibCompileFlags
-#  define zlibVersion           z_zlibVersion
-
-/* all zlib typedefs in zlib.h and zconf.h */
-#  define Byte                  z_Byte
-#  define Bytef                 z_Bytef
-#  define alloc_func            z_alloc_func
-#  define charf                 z_charf
-#  define free_func             z_free_func
-#  ifndef Z_SOLO
-#    define gzFile                z_gzFile
-#  endif
-#  define gz_header             z_gz_header
-#  define gz_headerp            z_gz_headerp
-#  define in_func               z_in_func
-#  define intf                  z_intf
-#  define out_func              z_out_func
-#  define uInt                  z_uInt
-#  define uIntf                 z_uIntf
-#  define uLong                 z_uLong
-#  define uLongf                z_uLongf
-#  define voidp                 z_voidp
-#  define voidpc                z_voidpc
-#  define voidpf                z_voidpf
-
-/* all zlib structs in zlib.h and zconf.h */
-#  define gz_header_s           z_gz_header_s
-#  define internal_state        z_internal_state
-
-#endif
-
-#if defined(__MSDOS__) && !defined(MSDOS)
-#  define MSDOS
-#endif
-#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
-#  define OS2
-#endif
-#if defined(_WINDOWS) && !defined(WINDOWS)
-#  define WINDOWS
-#endif
-#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
-#  ifndef WIN32
-#    define WIN32
-#  endif
-#endif
-#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
-#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
-#    ifndef SYS16BIT
-#      define SYS16BIT
-#    endif
-#  endif
-#endif
-
-/*
- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
- * than 64k bytes at a time (needed on systems with 16-bit int).
- */
-#ifdef SYS16BIT
-#  define MAXSEG_64K
-#endif
-#ifdef MSDOS
-#  define UNALIGNED_OK
-#endif
-
-#ifdef __STDC_VERSION__
-#  ifndef STDC
-#    define STDC
-#  endif
-#  if __STDC_VERSION__ >= 199901L
-#    ifndef STDC99
-#      define STDC99
-#    endif
-#  endif
-#endif
-#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
-#  define STDC
-#endif
-
-#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
-#  define STDC
-#endif
-
-#ifndef STDC
-#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
-#    define const       /* note: need a more gentle solution here */
-#  endif
-#endif
-
-#if defined(ZLIB_CONST) && !defined(z_const)
-#  define z_const const
-#else
-#  define z_const
-#endif
-
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-#  define NO_DUMMY_DECL
-#endif
-
-/* Maximum value for memLevel in deflateInit2 */
-#ifndef MAX_MEM_LEVEL
-#  ifdef MAXSEG_64K
-#    define MAX_MEM_LEVEL 8
-#  else
-#    define MAX_MEM_LEVEL 9
-#  endif
-#endif
-
-/* Maximum value for windowBits in deflateInit2 and inflateInit2.
- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
- * created by gzip. (Files created by minigzip can still be extracted by
- * gzip.)
- */
-#ifndef MAX_WBITS
-#  define MAX_WBITS   15 /* 32K LZ77 window */
-#endif
-
-/* The memory requirements for deflate are (in bytes):
-            (1 << (windowBits+2)) +  (1 << (memLevel+9))
- that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
- plus a few kilobytes for small objects. For example, if you want to reduce
- the default memory requirements from 256K to 128K, compile with
-     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
- Of course this will generally degrade compression (there's no free lunch).
-
-   The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
- for small objects.
-*/
-
-                        /* Type declarations */
-
-#ifndef OF /* function prototypes */
-#  ifdef STDC
-#    define OF(args)  args
-#  else
-#    define OF(args)  ()
-#  endif
-#endif
-
-#ifndef Z_ARG /* function prototypes for stdarg */
-#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#    define Z_ARG(args)  args
-#  else
-#    define Z_ARG(args)  ()
-#  endif
-#endif
-
-/* The following definitions for FAR are needed only for MSDOS mixed
- * model programming (small or medium model with some far allocations).
- * This was tested only with MSC; for other MSDOS compilers you may have
- * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
- * just define FAR to be empty.
- */
-#ifdef SYS16BIT
-#  if defined(M_I86SM) || defined(M_I86MM)
-     /* MSC small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef _MSC_VER
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
-#  if (defined(__SMALL__) || defined(__MEDIUM__))
-     /* Turbo C small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef __BORLANDC__
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
-#endif
-
-#if defined(WINDOWS) || defined(WIN32)
-   /* If building or using zlib as a DLL, define ZLIB_DLL.
-    * This is not mandatory, but it offers a little performance increase.
-    */
-#  ifdef ZLIB_DLL
-#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
-#      ifdef ZLIB_INTERNAL
-#        define ZEXTERN extern __declspec(dllexport)
-#      else
-#        define ZEXTERN extern __declspec(dllimport)
-#      endif
-#    endif
-#  endif  /* ZLIB_DLL */
-   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
-    * define ZLIB_WINAPI.
-    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
-    */
-#  ifdef ZLIB_WINAPI
-#    ifdef FAR
-#      undef FAR
-#    endif
-#    include <windows.h>
-     /* No need for _export, use ZLIB.DEF instead. */
-     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
-#    define ZEXPORT WINAPI
-#    ifdef WIN32
-#      define ZEXPORTVA WINAPIV
-#    else
-#      define ZEXPORTVA FAR CDECL
-#    endif
-#  endif
-#endif
-
-#if defined (__BEOS__)
-#  ifdef ZLIB_DLL
-#    ifdef ZLIB_INTERNAL
-#      define ZEXPORT   __declspec(dllexport)
-#      define ZEXPORTVA __declspec(dllexport)
-#    else
-#      define ZEXPORT   __declspec(dllimport)
-#      define ZEXPORTVA __declspec(dllimport)
-#    endif
-#  endif
-#endif
-
-#ifndef ZEXTERN
-#  define ZEXTERN extern
-#endif
-#ifndef ZEXPORT
-#  define ZEXPORT
-#endif
-#ifndef ZEXPORTVA
-#  define ZEXPORTVA
-#endif
-
-#ifndef FAR
-#  define FAR
-#endif
-
-#if !defined(__MACTYPES__)
-typedef unsigned char  Byte;  /* 8 bits */
-#endif
-typedef unsigned int   uInt;  /* 16 bits or more */
-typedef unsigned long  uLong; /* 32 bits or more */
-
-#ifdef SMALL_MEDIUM
-   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
-#  define Bytef Byte FAR
-#else
-   typedef Byte  FAR Bytef;
-#endif
-typedef char  FAR charf;
-typedef int   FAR intf;
-typedef uInt  FAR uIntf;
-typedef uLong FAR uLongf;
-
-#ifdef STDC
-   typedef void const *voidpc;
-   typedef void FAR   *voidpf;
-   typedef void       *voidp;
-#else
-   typedef Byte const *voidpc;
-   typedef Byte FAR   *voidpf;
-   typedef Byte       *voidp;
-#endif
-
-#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
-#  include <limits.h>
-#  if (UINT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned
-#  elif (ULONG_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned long
-#  elif (USHRT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned short
-#  endif
-#endif
-
-#ifdef Z_U4
-   typedef Z_U4 z_crc_t;
-#else
-   typedef unsigned long z_crc_t;
-#endif
-
-#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_UNISTD_H
-#endif
-
-#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_STDARG_H
-#endif
-
-#ifdef STDC
-#  ifndef Z_SOLO
-#    include <sys/types.h>      /* for off_t */
-#  endif
-#endif
-
-#if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#  ifndef Z_SOLO
-#    include <stdarg.h>         /* for va_list */
-#  endif
-#endif
-
-#ifdef _WIN32
-#  ifndef Z_SOLO
-#    include <stddef.h>         /* for wchar_t */
-#  endif
-#endif
-
-/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
- * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
- * though the former does not conform to the LFS document), but considering
- * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
- * equivalently requesting no 64-bit operations
- */
-#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
-#  undef _LARGEFILE64_SOURCE
-#endif
-
-#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
-#  define Z_HAVE_UNISTD_H
-#endif
-#ifndef Z_SOLO
-#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
-#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
-#    ifdef VMS
-#      include <unixio.h>       /* for off_t */
-#    endif
-#    ifndef z_off_t
-#      define z_off_t off_t
-#    endif
-#  endif
-#endif
-
-#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
-#  define Z_LFS64
-#endif
-
-#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
-#  define Z_LARGE64
-#endif
-
-#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
-#  define Z_WANT64
-#endif
-
-#if !defined(SEEK_SET) && !defined(Z_SOLO)
-#  define SEEK_SET        0       /* Seek from beginning of file.  */
-#  define SEEK_CUR        1       /* Seek from current position.  */
-#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
-#endif
-
-#ifndef z_off_t
-#  define z_off_t long
-#endif
-
-#if !defined(_WIN32) && defined(Z_LARGE64)
-#  define z_off64_t off64_t
-#else
-#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
-#    define z_off64_t __int64
-#  else
-#    define z_off64_t z_off_t
-#  endif
-#endif
-
-/* MVS linker does not support external names larger than 8 bytes */
-#if defined(__MVS__)
-  #pragma map(deflateInit_,"DEIN")
-  #pragma map(deflateInit2_,"DEIN2")
-  #pragma map(deflateEnd,"DEEND")
-  #pragma map(deflateBound,"DEBND")
-  #pragma map(inflateInit_,"ININ")
-  #pragma map(inflateInit2_,"ININ2")
-  #pragma map(inflateEnd,"INEND")
-  #pragma map(inflateSync,"INSY")
-  #pragma map(inflateSetDictionary,"INSEDI")
-  #pragma map(compressBound,"CMBND")
-  #pragma map(inflate_table,"INTABL")
-  #pragma map(inflate_fast,"INFA")
-  #pragma map(inflate_copyright,"INCOPY")
-#endif
-
-#endif /* ZCONF_H */
diff --git a/deps/zconf.h.in b/deps/zconf.h.in
deleted file mode 100644
index 9987a77..0000000
--- a/deps/zconf.h.in
+++ /dev/null
@@ -1,511 +0,0 @@
-/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#ifndef ZCONF_H
-#define ZCONF_H
-
-/*
- * If you *really* need a unique prefix for all types and library functions,
- * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
- * Even better than compiling with -DZ_PREFIX would be to use configure to set
- * this permanently in zconf.h using "./configure --zprefix".
- */
-#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
-#  define Z_PREFIX_SET
-
-/* all linked symbols */
-#  define _dist_code            z__dist_code
-#  define _length_code          z__length_code
-#  define _tr_align             z__tr_align
-#  define _tr_flush_bits        z__tr_flush_bits
-#  define _tr_flush_block       z__tr_flush_block
-#  define _tr_init              z__tr_init
-#  define _tr_stored_block      z__tr_stored_block
-#  define _tr_tally             z__tr_tally
-#  define adler32               z_adler32
-#  define adler32_combine       z_adler32_combine
-#  define adler32_combine64     z_adler32_combine64
-#  ifndef Z_SOLO
-#    define compress              z_compress
-#    define compress2             z_compress2
-#    define compressBound         z_compressBound
-#  endif
-#  define crc32                 z_crc32
-#  define crc32_combine         z_crc32_combine
-#  define crc32_combine64       z_crc32_combine64
-#  define deflate               z_deflate
-#  define deflateBound          z_deflateBound
-#  define deflateCopy           z_deflateCopy
-#  define deflateEnd            z_deflateEnd
-#  define deflateInit2_         z_deflateInit2_
-#  define deflateInit_          z_deflateInit_
-#  define deflateParams         z_deflateParams
-#  define deflatePending        z_deflatePending
-#  define deflatePrime          z_deflatePrime
-#  define deflateReset          z_deflateReset
-#  define deflateResetKeep      z_deflateResetKeep
-#  define deflateSetDictionary  z_deflateSetDictionary
-#  define deflateSetHeader      z_deflateSetHeader
-#  define deflateTune           z_deflateTune
-#  define deflate_copyright     z_deflate_copyright
-#  define get_crc_table         z_get_crc_table
-#  ifndef Z_SOLO
-#    define gz_error              z_gz_error
-#    define gz_intmax             z_gz_intmax
-#    define gz_strwinerror        z_gz_strwinerror
-#    define gzbuffer              z_gzbuffer
-#    define gzclearerr            z_gzclearerr
-#    define gzclose               z_gzclose
-#    define gzclose_r             z_gzclose_r
-#    define gzclose_w             z_gzclose_w
-#    define gzdirect              z_gzdirect
-#    define gzdopen               z_gzdopen
-#    define gzeof                 z_gzeof
-#    define gzerror               z_gzerror
-#    define gzflush               z_gzflush
-#    define gzgetc                z_gzgetc
-#    define gzgetc_               z_gzgetc_
-#    define gzgets                z_gzgets
-#    define gzoffset              z_gzoffset
-#    define gzoffset64            z_gzoffset64
-#    define gzopen                z_gzopen
-#    define gzopen64              z_gzopen64
-#    ifdef _WIN32
-#      define gzopen_w              z_gzopen_w
-#    endif
-#    define gzprintf              z_gzprintf
-#    define gzvprintf             z_gzvprintf
-#    define gzputc                z_gzputc
-#    define gzputs                z_gzputs
-#    define gzread                z_gzread
-#    define gzrewind              z_gzrewind
-#    define gzseek                z_gzseek
-#    define gzseek64              z_gzseek64
-#    define gzsetparams           z_gzsetparams
-#    define gztell                z_gztell
-#    define gztell64              z_gztell64
-#    define gzungetc              z_gzungetc
-#    define gzwrite               z_gzwrite
-#  endif
-#  define inflate               z_inflate
-#  define inflateBack           z_inflateBack
-#  define inflateBackEnd        z_inflateBackEnd
-#  define inflateBackInit_      z_inflateBackInit_
-#  define inflateCopy           z_inflateCopy
-#  define inflateEnd            z_inflateEnd
-#  define inflateGetHeader      z_inflateGetHeader
-#  define inflateInit2_         z_inflateInit2_
-#  define inflateInit_          z_inflateInit_
-#  define inflateMark           z_inflateMark
-#  define inflatePrime          z_inflatePrime
-#  define inflateReset          z_inflateReset
-#  define inflateReset2         z_inflateReset2
-#  define inflateSetDictionary  z_inflateSetDictionary
-#  define inflateGetDictionary  z_inflateGetDictionary
-#  define inflateSync           z_inflateSync
-#  define inflateSyncPoint      z_inflateSyncPoint
-#  define inflateUndermine      z_inflateUndermine
-#  define inflateResetKeep      z_inflateResetKeep
-#  define inflate_copyright     z_inflate_copyright
-#  define inflate_fast          z_inflate_fast
-#  define inflate_table         z_inflate_table
-#  ifndef Z_SOLO
-#    define uncompress            z_uncompress
-#  endif
-#  define zError                z_zError
-#  ifndef Z_SOLO
-#    define zcalloc               z_zcalloc
-#    define zcfree                z_zcfree
-#  endif
-#  define zlibCompileFlags      z_zlibCompileFlags
-#  define zlibVersion           z_zlibVersion
-
-/* all zlib typedefs in zlib.h and zconf.h */
-#  define Byte                  z_Byte
-#  define Bytef                 z_Bytef
-#  define alloc_func            z_alloc_func
-#  define charf                 z_charf
-#  define free_func             z_free_func
-#  ifndef Z_SOLO
-#    define gzFile                z_gzFile
-#  endif
-#  define gz_header             z_gz_header
-#  define gz_headerp            z_gz_headerp
-#  define in_func               z_in_func
-#  define intf                  z_intf
-#  define out_func              z_out_func
-#  define uInt                  z_uInt
-#  define uIntf                 z_uIntf
-#  define uLong                 z_uLong
-#  define uLongf                z_uLongf
-#  define voidp                 z_voidp
-#  define voidpc                z_voidpc
-#  define voidpf                z_voidpf
-
-/* all zlib structs in zlib.h and zconf.h */
-#  define gz_header_s           z_gz_header_s
-#  define internal_state        z_internal_state
-
-#endif
-
-#if defined(__MSDOS__) && !defined(MSDOS)
-#  define MSDOS
-#endif
-#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
-#  define OS2
-#endif
-#if defined(_WINDOWS) && !defined(WINDOWS)
-#  define WINDOWS
-#endif
-#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
-#  ifndef WIN32
-#    define WIN32
-#  endif
-#endif
-#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
-#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
-#    ifndef SYS16BIT
-#      define SYS16BIT
-#    endif
-#  endif
-#endif
-
-/*
- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
- * than 64k bytes at a time (needed on systems with 16-bit int).
- */
-#ifdef SYS16BIT
-#  define MAXSEG_64K
-#endif
-#ifdef MSDOS
-#  define UNALIGNED_OK
-#endif
-
-#ifdef __STDC_VERSION__
-#  ifndef STDC
-#    define STDC
-#  endif
-#  if __STDC_VERSION__ >= 199901L
-#    ifndef STDC99
-#      define STDC99
-#    endif
-#  endif
-#endif
-#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
-#  define STDC
-#endif
-
-#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
-#  define STDC
-#endif
-
-#ifndef STDC
-#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
-#    define const       /* note: need a more gentle solution here */
-#  endif
-#endif
-
-#if defined(ZLIB_CONST) && !defined(z_const)
-#  define z_const const
-#else
-#  define z_const
-#endif
-
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-#  define NO_DUMMY_DECL
-#endif
-
-/* Maximum value for memLevel in deflateInit2 */
-#ifndef MAX_MEM_LEVEL
-#  ifdef MAXSEG_64K
-#    define MAX_MEM_LEVEL 8
-#  else
-#    define MAX_MEM_LEVEL 9
-#  endif
-#endif
-
-/* Maximum value for windowBits in deflateInit2 and inflateInit2.
- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
- * created by gzip. (Files created by minigzip can still be extracted by
- * gzip.)
- */
-#ifndef MAX_WBITS
-#  define MAX_WBITS   15 /* 32K LZ77 window */
-#endif
-
-/* The memory requirements for deflate are (in bytes):
-            (1 << (windowBits+2)) +  (1 << (memLevel+9))
- that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
- plus a few kilobytes for small objects. For example, if you want to reduce
- the default memory requirements from 256K to 128K, compile with
-     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
- Of course this will generally degrade compression (there's no free lunch).
-
-   The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
- for small objects.
-*/
-
-                        /* Type declarations */
-
-#ifndef OF /* function prototypes */
-#  ifdef STDC
-#    define OF(args)  args
-#  else
-#    define OF(args)  ()
-#  endif
-#endif
-
-#ifndef Z_ARG /* function prototypes for stdarg */
-#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#    define Z_ARG(args)  args
-#  else
-#    define Z_ARG(args)  ()
-#  endif
-#endif
-
-/* The following definitions for FAR are needed only for MSDOS mixed
- * model programming (small or medium model with some far allocations).
- * This was tested only with MSC; for other MSDOS compilers you may have
- * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
- * just define FAR to be empty.
- */
-#ifdef SYS16BIT
-#  if defined(M_I86SM) || defined(M_I86MM)
-     /* MSC small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef _MSC_VER
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
-#  if (defined(__SMALL__) || defined(__MEDIUM__))
-     /* Turbo C small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef __BORLANDC__
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
-#endif
-
-#if defined(WINDOWS) || defined(WIN32)
-   /* If building or using zlib as a DLL, define ZLIB_DLL.
-    * This is not mandatory, but it offers a little performance increase.
-    */
-#  ifdef ZLIB_DLL
-#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
-#      ifdef ZLIB_INTERNAL
-#        define ZEXTERN extern __declspec(dllexport)
-#      else
-#        define ZEXTERN extern __declspec(dllimport)
-#      endif
-#    endif
-#  endif  /* ZLIB_DLL */
-   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
-    * define ZLIB_WINAPI.
-    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
-    */
-#  ifdef ZLIB_WINAPI
-#    ifdef FAR
-#      undef FAR
-#    endif
-#    include <windows.h>
-     /* No need for _export, use ZLIB.DEF instead. */
-     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
-#    define ZEXPORT WINAPI
-#    ifdef WIN32
-#      define ZEXPORTVA WINAPIV
-#    else
-#      define ZEXPORTVA FAR CDECL
-#    endif
-#  endif
-#endif
-
-#if defined (__BEOS__)
-#  ifdef ZLIB_DLL
-#    ifdef ZLIB_INTERNAL
-#      define ZEXPORT   __declspec(dllexport)
-#      define ZEXPORTVA __declspec(dllexport)
-#    else
-#      define ZEXPORT   __declspec(dllimport)
-#      define ZEXPORTVA __declspec(dllimport)
-#    endif
-#  endif
-#endif
-
-#ifndef ZEXTERN
-#  define ZEXTERN extern
-#endif
-#ifndef ZEXPORT
-#  define ZEXPORT
-#endif
-#ifndef ZEXPORTVA
-#  define ZEXPORTVA
-#endif
-
-#ifndef FAR
-#  define FAR
-#endif
-
-#if !defined(__MACTYPES__)
-typedef unsigned char  Byte;  /* 8 bits */
-#endif
-typedef unsigned int   uInt;  /* 16 bits or more */
-typedef unsigned long  uLong; /* 32 bits or more */
-
-#ifdef SMALL_MEDIUM
-   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
-#  define Bytef Byte FAR
-#else
-   typedef Byte  FAR Bytef;
-#endif
-typedef char  FAR charf;
-typedef int   FAR intf;
-typedef uInt  FAR uIntf;
-typedef uLong FAR uLongf;
-
-#ifdef STDC
-   typedef void const *voidpc;
-   typedef void FAR   *voidpf;
-   typedef void       *voidp;
-#else
-   typedef Byte const *voidpc;
-   typedef Byte FAR   *voidpf;
-   typedef Byte       *voidp;
-#endif
-
-#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
-#  include <limits.h>
-#  if (UINT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned
-#  elif (ULONG_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned long
-#  elif (USHRT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned short
-#  endif
-#endif
-
-#ifdef Z_U4
-   typedef Z_U4 z_crc_t;
-#else
-   typedef unsigned long z_crc_t;
-#endif
-
-#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_UNISTD_H
-#endif
-
-#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_STDARG_H
-#endif
-
-#ifdef STDC
-#  ifndef Z_SOLO
-#    include <sys/types.h>      /* for off_t */
-#  endif
-#endif
-
-#if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#  ifndef Z_SOLO
-#    include <stdarg.h>         /* for va_list */
-#  endif
-#endif
-
-#ifdef _WIN32
-#  ifndef Z_SOLO
-#    include <stddef.h>         /* for wchar_t */
-#  endif
-#endif
-
-/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
- * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
- * though the former does not conform to the LFS document), but considering
- * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
- * equivalently requesting no 64-bit operations
- */
-#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
-#  undef _LARGEFILE64_SOURCE
-#endif
-
-#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
-#  define Z_HAVE_UNISTD_H
-#endif
-#ifndef Z_SOLO
-#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
-#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
-#    ifdef VMS
-#      include <unixio.h>       /* for off_t */
-#    endif
-#    ifndef z_off_t
-#      define z_off_t off_t
-#    endif
-#  endif
-#endif
-
-#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
-#  define Z_LFS64
-#endif
-
-#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
-#  define Z_LARGE64
-#endif
-
-#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
-#  define Z_WANT64
-#endif
-
-#if !defined(SEEK_SET) && !defined(Z_SOLO)
-#  define SEEK_SET        0       /* Seek from beginning of file.  */
-#  define SEEK_CUR        1       /* Seek from current position.  */
-#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
-#endif
-
-#ifndef z_off_t
-#  define z_off_t long
-#endif
-
-#if !defined(_WIN32) && defined(Z_LARGE64)
-#  define z_off64_t off64_t
-#else
-#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
-#    define z_off64_t __int64
-#  else
-#    define z_off64_t z_off_t
-#  endif
-#endif
-
-/* MVS linker does not support external names larger than 8 bytes */
-#if defined(__MVS__)
-  #pragma map(deflateInit_,"DEIN")
-  #pragma map(deflateInit2_,"DEIN2")
-  #pragma map(deflateEnd,"DEEND")
-  #pragma map(deflateBound,"DEBND")
-  #pragma map(inflateInit_,"ININ")
-  #pragma map(inflateInit2_,"ININ2")
-  #pragma map(inflateEnd,"INEND")
-  #pragma map(inflateSync,"INSY")
-  #pragma map(inflateSetDictionary,"INSEDI")
-  #pragma map(compressBound,"CMBND")
-  #pragma map(inflate_table,"INTABL")
-  #pragma map(inflate_fast,"INFA")
-  #pragma map(inflate_copyright,"INCOPY")
-#endif
-
-#endif /* ZCONF_H */
diff --git a/deps/zutil.c b/deps/zutil.c
deleted file mode 100644
index c9353fe..0000000
--- a/deps/zutil.c
+++ /dev/null
@@ -1,305 +0,0 @@
-/* zutil.c -- target dependent utility functions for the compression library
- * Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#include "zutil.h"
-#ifndef Z_SOLO
-#  include "gzguts.h"
-#endif
-
-char * const z_errmsg[10] = {
-   "need dictionary",     /* Z_NEED_DICT       2  */
-   "stream end",          /* Z_STREAM_END      1  */
-   "",                    /* Z_OK              0  */
-   "file error",          /* Z_ERRNO         (-1) */
-   "stream error",        /* Z_STREAM_ERROR  (-2) */
-   "data error",          /* Z_DATA_ERROR    (-3) */
-   "insufficient memory", /* Z_MEM_ERROR     (-4) */
-   "buffer error",        /* Z_BUF_ERROR     (-5) */
-   "incompatible version",/* Z_VERSION_ERROR (-6) */
-   ""};
-
-
-const char * ZEXPORT zlibVersion(void)
-{
-   return ZLIB_VERSION;
-}
-
-uLong ZEXPORT zlibCompileFlags(void)
-{
-   uLong flags;
-
-   flags = 0;
-   switch ((int)(sizeof(uInt))) {
-      case 2:     break;
-      case 4:     flags += 1;     break;
-      case 8:     flags += 2;     break;
-      default:    flags += 3;
-   }
-   switch ((int)(sizeof(uLong))) {
-      case 2:     break;
-      case 4:     flags += 1 << 2;        break;
-      case 8:     flags += 2 << 2;        break;
-      default:    flags += 3 << 2;
-   }
-   switch ((int)(sizeof(voidpf))) {
-      case 2:     break;
-      case 4:     flags += 1 << 4;        break;
-      case 8:     flags += 2 << 4;        break;
-      default:    flags += 3 << 4;
-   }
-   switch ((int)(sizeof(z_off_t))) {
-      case 2:     break;
-      case 4:     flags += 1 << 6;        break;
-      case 8:     flags += 2 << 6;        break;
-      default:    flags += 3 << 6;
-   }
-#ifdef DEBUG
-   flags += 1 << 8;
-#endif
-#if defined(ASMV) || defined(ASMINF)
-   flags += 1 << 9;
-#endif
-#ifdef ZLIB_WINAPI
-   flags += 1 << 10;
-#endif
-#ifdef BUILDFIXED
-   flags += 1 << 12;
-#endif
-#ifdef DYNAMIC_CRC_TABLE
-   flags += 1 << 13;
-#endif
-#ifdef NO_GZCOMPRESS
-   flags += 1L << 16;
-#endif
-#ifdef NO_GZIP
-   flags += 1L << 17;
-#endif
-#ifdef PKZIP_BUG_WORKAROUND
-   flags += 1L << 20;
-#endif
-#ifdef FASTEST
-   flags += 1L << 21;
-#endif
-#if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#  ifdef NO_vsnprintf
-   flags += 1L << 25;
-#    ifdef HAS_vsprintf_void
-   flags += 1L << 26;
-#    endif
-#  else
-#    ifdef HAS_vsnprintf_void
-   flags += 1L << 26;
-#    endif
-#  endif
-#else
-   flags += 1L << 24;
-#  ifdef NO_snprintf
-   flags += 1L << 25;
-#    ifdef HAS_sprintf_void
-   flags += 1L << 26;
-#    endif
-#  else
-#    ifdef HAS_snprintf_void
-   flags += 1L << 26;
-#    endif
-#  endif
-#endif
-   return flags;
-}
-
-#ifdef DEBUG
-
-#  ifndef verbose
-#    define verbose 0
-#  endif
-int ZLIB_INTERNAL z_verbose = verbose;
-
-void ZLIB_INTERNAL z_error (char *m)
-{
-   fprintf(stderr, "%s\n", m);
-   exit(1);
-}
-#endif
-
-/* exported to allow conversion of error code to string for compress() and
- * uncompress()
- */
-const char * ZEXPORT zError(int err)
-{
-   return ERR_MSG(err);
-}
-
-#if defined(_WIN32_WCE)
-/* The Microsoft C Run-Time Library for Windows CE doesn't have
- * errno.  We define it as a global variable to simplify porting.
- * Its value is always 0 and should not be used.
- */
-int errno = 0;
-#endif
-
-#ifndef HAVE_MEMCPY
-
-void ZLIB_INTERNAL zmemcpy(Bytef *dest, const Bytef *source, uInt len)
-{
-   if (len == 0) return;
-   do {
-      *dest++ = *source++; /* ??? to be unrolled */
-   } while (--len != 0);
-}
-
-int ZLIB_INTERNAL zmemcmp(const Bytef *s1, const Bytef *s2, uInt len)
-{
-   uInt j;
-
-   for (j = 0; j < len; j++) {
-      if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
-   }
-   return 0;
-}
-
-void ZLIB_INTERNAL zmemzero(Bytef *dest, uInt len)
-{
-   if (len == 0) return;
-   do {
-      *dest++ = 0;  /* ??? to be unrolled */
-   } while (--len != 0);
-}
-#endif
-
-#ifndef Z_SOLO
-
-#ifdef SYS16BIT
-
-#ifdef __TURBOC__
-/* Turbo C in 16-bit mode */
-
-#  define MY_ZCALLOC
-
-/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
- * and farmalloc(64K) returns a pointer with an offset of 8, so we
- * must fix the pointer. Warning: the pointer must be put back to its
- * original form in order to free it, use zcfree().
- */
-
-#define MAX_PTR 10
-/* 10*64K = 640K */
-
-local int next_ptr = 0;
-
-typedef struct ptr_table_s {
-   voidpf org_ptr;
-   voidpf new_ptr;
-} ptr_table;
-
-local ptr_table table[MAX_PTR];
-/* This table is used to remember the original form of pointers
- * to large buffers (64K). Such pointers are normalized with a zero offset.
- * Since MSDOS is not a preemptive multitasking OS, this table is not
- * protected from concurrent access. This hack doesn't work anyway on
- * a protected system like OS/2. Use Microsoft C instead.
- */
-
-voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
-{
-   voidpf buf = opaque; /* just to make some compilers happy */
-   ulg bsize = (ulg)items*size;
-
-   /* If we allocate less than 65520 bytes, we assume that farmalloc
-    * will return a usable pointer which doesn't have to be normalized.
-    */
-   if (bsize < 65520L) {
-      buf = farmalloc(bsize);
-      if (*(ush*)&buf != 0) return buf;
-   } else {
-      buf = farmalloc(bsize + 16L);
-   }
-   if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
-   table[next_ptr].org_ptr = buf;
-
-   /* Normalize the pointer to seg:0 */
-   *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
-   *(ush*)&buf = 0;
-   table[next_ptr++].new_ptr = buf;
-   return buf;
-}
-
-void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
-{
-   int n;
-   if (*(ush*)&ptr != 0) { /* object < 64K */
-      farfree(ptr);
-      return;
-   }
-   /* Find the original pointer */
-   for (n = 0; n < next_ptr; n++) {
-      if (ptr != table[n].new_ptr) continue;
-
-      farfree(table[n].org_ptr);
-      while (++n < next_ptr) {
-         table[n-1] = table[n];
-      }
-      next_ptr--;
-      return;
-   }
-   ptr = opaque; /* just to make some compilers happy */
-   Assert(0, "zcfree: ptr not found");
-}
-
-#endif /* __TURBOC__ */
-
-
-#ifdef M_I86
-/* Microsoft C in 16-bit mode */
-
-#  define MY_ZCALLOC
-
-#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
-#  define _halloc  halloc
-#  define _hfree   hfree
-#endif
-
-voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
-{
-   if (opaque) opaque = 0; /* to make compiler happy */
-   return _halloc((long)items, size);
-}
-
-void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
-{
-   if (opaque) opaque = 0; /* to make compiler happy */
-   _hfree(ptr);
-}
-
-#endif /* M_I86 */
-
-#endif /* SYS16BIT */
-
-
-#ifndef MY_ZCALLOC /* Any system without a special alloc function */
-
-#ifndef STDC
-extern voidp  malloc OF((uInt size));
-extern voidp  calloc OF((uInt items, uInt size));
-extern void   free   OF((voidpf ptr));
-#endif
-
-voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
-{
-   if (opaque) items += size - size; /* make compiler happy */
-   return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
-      (voidpf)calloc(items, size);
-}
-
-void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
-{
-   free(ptr);
-   if (opaque) return; /* make compiler happy */
-}
-
-#endif /* MY_ZCALLOC */
-
-#endif /* !Z_SOLO */
diff --git a/deps/zutil.h b/deps/zutil.h
deleted file mode 100644
index 5c6929f..0000000
--- a/deps/zutil.h
+++ /dev/null
@@ -1,253 +0,0 @@
-/* zutil.h -- internal interface and configuration of the compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* @(#) $Id$ */
-
-#ifndef ZUTIL_H
-#define ZUTIL_H
-
-#ifdef HAVE_HIDDEN
-#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-#else
-#  define ZLIB_INTERNAL
-#endif
-
-#include "zlib.h"
-
-#if defined(STDC) && !defined(Z_SOLO)
-#  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
-#    include <stddef.h>
-#  endif
-#  include <string.h>
-#  include <stdlib.h>
-#endif
-
-#ifdef Z_SOLO
-   typedef long ptrdiff_t;  /* guess -- will be caught if guess is wrong */
-#endif
-
-#ifndef local
-#  define local static
-#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-typedef unsigned char  uch;
-typedef uch FAR uchf;
-typedef unsigned short ush;
-typedef ush FAR ushf;
-typedef unsigned long  ulg;
-
-extern char * const z_errmsg[10]; /* indexed by 2-zlib_error */
-/* (size given to avoid silly warnings with Visual C++) */
-
-#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
-
-#define ERR_RETURN(strm,err) \
-  return (strm->msg = ERR_MSG(err), (err))
-/* To be used only when the state is known to be valid */
-
-        /* common constants */
-
-#ifndef DEF_WBITS
-#  define DEF_WBITS MAX_WBITS
-#endif
-/* default windowBits for decompression. MAX_WBITS is for compression only */
-
-#if MAX_MEM_LEVEL >= 8
-#  define DEF_MEM_LEVEL 8
-#else
-#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#endif
-/* default memLevel */
-
-#define STORED_BLOCK 0
-#define STATIC_TREES 1
-#define DYN_TREES    2
-/* The three kinds of block type */
-
-#define MIN_MATCH  3
-#define MAX_MATCH  258
-/* The minimum and maximum match lengths */
-
-#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
-
-        /* target dependencies */
-
-#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
-#  define OS_CODE  0x00
-#  ifndef Z_SOLO
-#    if defined(__TURBOC__) || defined(__BORLANDC__)
-#      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
-         /* Allow compilation with ANSI keywords only enabled */
-         void _Cdecl farfree( void *block );
-         void *_Cdecl farmalloc( unsigned long nbytes );
-#      else
-#        include <alloc.h>
-#      endif
-#    else /* MSC or DJGPP */
-#      include <malloc.h>
-#    endif
-#  endif
-#endif
-
-#ifdef AMIGA
-#  define OS_CODE  0x01
-#endif
-
-#if defined(VAXC) || defined(VMS)
-#  define OS_CODE  0x02
-#  define F_OPEN(name, mode) \
-     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
-#endif
-
-#if defined(ATARI) || defined(atarist)
-#  define OS_CODE  0x05
-#endif
-
-#ifdef OS2
-#  define OS_CODE  0x06
-#  if defined(M_I86) && !defined(Z_SOLO)
-#    include <malloc.h>
-#  endif
-#endif
-
-#if defined(MACOS) || defined(TARGET_OS_MAC)
-#  define OS_CODE  0x07
-#  ifndef Z_SOLO
-#    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
-#      include <unix.h> /* for fdopen */
-#    else
-#      ifndef fdopen
-#        define fdopen(fd,mode) NULL /* No fdopen() */
-#      endif
-#    endif
-#  endif
-#endif
-
-#ifdef TOPS20
-#  define OS_CODE  0x0a
-#endif
-
-#ifdef WIN32
-#  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
-#    define OS_CODE  0x0b
-#  endif
-#endif
-
-#ifdef __50SERIES /* Prime/PRIMOS */
-#  define OS_CODE  0x0f
-#endif
-
-#if defined(_BEOS_) || defined(RISCOS)
-#  define fdopen(fd,mode) NULL /* No fdopen() */
-#endif
-
-#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
-#  if defined(_WIN32_WCE)
-#    define fdopen(fd,mode) NULL /* No fdopen() */
-#    ifndef _PTRDIFF_T_DEFINED
-       typedef int ptrdiff_t;
-#      define _PTRDIFF_T_DEFINED
-#    endif
-#  else
-#    define fdopen(fd,type)  _fdopen(fd,type)
-#  endif
-#endif
-
-#if defined(__BORLANDC__) && !defined(MSDOS)
-  #pragma warn -8004
-  #pragma warn -8008
-  #pragma warn -8066
-#endif
-
-/* provide prototypes for these when building zlib without LFS */
-#if !defined(_WIN32) && \
-    (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
-    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
-    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
-#endif
-
-        /* common defaults */
-
-#ifndef OS_CODE
-#  define OS_CODE  0x03  /* assume Unix */
-#endif
-
-#ifndef F_OPEN
-#  define F_OPEN(name, mode) fopen((name), (mode))
-#endif
-
-         /* functions */
-
-#if defined(pyr) || defined(Z_SOLO)
-#  define NO_MEMCPY
-#endif
-#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
- /* Use our own functions for small and medium model with MSC <= 5.0.
-  * You may have to use the same strategy for Borland C (untested).
-  * The __SC__ check is for Symantec.
-  */
-#  define NO_MEMCPY
-#endif
-#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
-#  define HAVE_MEMCPY
-#endif
-#ifdef HAVE_MEMCPY
-#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
-#    define zmemcpy _fmemcpy
-#    define zmemcmp _fmemcmp
-#    define zmemzero(dest, len) _fmemset(dest, 0, len)
-#  else
-#    define zmemcpy memcpy
-#    define zmemcmp memcmp
-#    define zmemzero(dest, len) memset(dest, 0, len)
-#  endif
-#else
-   void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
-   int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
-   void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
-#endif
-
-/* Diagnostic functions */
-#ifdef DEBUG
-#  include <stdio.h>
-   extern int ZLIB_INTERNAL z_verbose;
-   extern void ZLIB_INTERNAL z_error OF((char *m));
-#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
-#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
-#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
-#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
-#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
-#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
-#else
-#  define Assert(cond,msg)
-#  define Trace(x)
-#  define Tracev(x)
-#  define Tracevv(x)
-#  define Tracec(c,x)
-#  define Tracecv(c,x)
-#endif
-
-#ifndef Z_SOLO
-   voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
-                                    unsigned size));
-   void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
-#endif
-
-#define ZALLOC(strm, items, size) \
-           (*((strm)->zalloc))((strm)->opaque, (items), (size))
-#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
-#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
-
-/* Reverse the bytes in a 32-bit value */
-#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
-                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
-
-#endif /* ZUTIL_H */