Modernize project codebase (#906)

* Fixed boats falling and a TP glitch #266

* Replaced every C-style cast with C++ ones

* Replaced every C-style cast with C++ ones

* Fixed boats falling and a TP glitch #266

* Updated NULL to nullptr and fixing some type issues

* Modernized and fixed a few bugs

- Replaced most instances of `NULL` with `nullptr`.
- Replaced most `shared_ptr(new ...)` with `make_shared`.
- Removed the `nullptr` macro as it was interfering with the actual nullptr keyword in some instances.

* Fixing more conflicts

* Replace int loops with size_t and start work on overrides

* Add safety checks and fix a issue with vector going OOR

5 files changed, 4802 insertions, 4802 deletions

diff --git a/Minecraft.Client/Common/zlib/crc32.c b/Minecraft.Client/Common/zlib/crc32.c
index dce0c325..d9ade515 100644
--- a/Minecraft.Client/Common/zlib/crc32.c
+++ b/Minecraft.Client/Common/zlib/crc32.c
@@ -1,983 +1,983 @@
-/* crc32.c -- compute the CRC-32 of a data stream

- * Copyright (C) 1995-2026 Mark Adler

- * For conditions of distribution and use, see copyright notice in zlib.h

- *

- * This interleaved implementation of a CRC makes use of pipelined multiple

- * arithmetic-logic units, commonly found in modern CPU cores. It is due to

- * Kadatch and Jenkins (2010). See doc/crc-doc.1.0.pdf in this distribution.

- */

-

-/* @(#) $Id$ */

-

-/*

-  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore

-  protection on the static variables used to control the first-use generation

-  of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should

-  first call get_crc_table() to initialize the tables before allowing more than

-  one thread to use crc32().

-

-  MAKECRCH can be #defined to write out crc32.h. A main() routine is also

-  produced, so that this one source file can be compiled to an executable.

- */

-

-#ifdef MAKECRCH

-#  include <stdio.h>

-#  ifndef DYNAMIC_CRC_TABLE

-#    define DYNAMIC_CRC_TABLE

-#  endif

-#endif

-#ifdef DYNAMIC_CRC_TABLE

-#  define Z_ONCE

-#endif

-

-#include "zutil.h"      /* for Z_U4, Z_U8, z_crc_t, and FAR definitions */

-

-#ifdef HAVE_S390X_VX

-#  include "contrib/crc32vx/crc32_vx_hooks.h"

-#endif

-

- /*

-  A CRC of a message is computed on N braids of words in the message, where

-  each word consists of W bytes (4 or 8). If N is 3, for example, then three

-  running sparse CRCs are calculated respectively on each braid, at these

-  indices in the array of words: 0, 3, 6, ..., 1, 4, 7, ..., and 2, 5, 8, ...

-  This is done starting at a word boundary, and continues until as many blocks

-  of N * W bytes as are available have been processed. The results are combined

-  into a single CRC at the end. For this code, N must be in the range 1..6 and

-  W must be 4 or 8. The upper limit on N can be increased if desired by adding

-  more #if blocks, extending the patterns apparent in the code. In addition,

-  crc32.h would need to be regenerated, if the maximum N value is increased.

-

-  N and W are chosen empirically by benchmarking the execution time on a given

-  processor. The choices for N and W below were based on testing on Intel Kaby

-  Lake i7, AMD Ryzen 7, ARM Cortex-A57, Sparc64-VII, PowerPC POWER9, and MIPS64

-  Octeon II processors. The Intel, AMD, and ARM processors were all fastest

-  with N=5, W=8. The Sparc, PowerPC, and MIPS64 were all fastest at N=5, W=4.

-  They were all tested with either gcc or clang, all using the -O3 optimization

-  level. Your mileage may vary.

- */

-

-/* Define N */

-#ifdef Z_TESTN

-#  define N Z_TESTN

-#else

-#  define N 5

-#endif

-#if N < 1 || N > 6

-#  error N must be in 1..6

-#endif

-

-/*

-  z_crc_t must be at least 32 bits. z_word_t must be at least as long as

-  z_crc_t. It is assumed here that z_word_t is either 32 bits or 64 bits, and

-  that bytes are eight bits.

- */

-

-/*

-  Define W and the associated z_word_t type. If W is not defined, then a

-  braided calculation is not used, and the associated tables and code are not

-  compiled.

- */

-#ifdef Z_TESTW

-#  if Z_TESTW-1 != -1

-#    define W Z_TESTW

-#  endif

-#else

-#  ifdef MAKECRCH

-#    define W 8         /* required for MAKECRCH */

-#  else

-#    if defined(__x86_64__) || defined(__aarch64__)

-#      define W 8

-#    else

-#      define W 4

-#    endif

-#  endif

-#endif

-#ifdef W

-#  if W == 8 && defined(Z_U8)

-     typedef Z_U8 z_word_t;

-#  elif defined(Z_U4)

-#    undef W

-#    define W 4

-     typedef Z_U4 z_word_t;

-#  else

-#    undef W

-#  endif

-#endif

-

-/* If available, use the ARM processor CRC32 instruction. */

-#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && \

-    defined(W) && W == 8

-#  define ARMCRC32

-#endif

-

-#if defined(W) && (!defined(ARMCRC32) || defined(DYNAMIC_CRC_TABLE))

-/*

-  Swap the bytes in a z_word_t to convert between little and big endian. Any

-  self-respecting compiler will optimize this to a single machine byte-swap

-  instruction, if one is available. This assumes that word_t is either 32 bits

-  or 64 bits.

- */

-local z_word_t byte_swap(z_word_t word) {

-#  if W == 8

-    return

-        (word & 0xff00000000000000) >> 56 |

-        (word & 0xff000000000000) >> 40 |

-        (word & 0xff0000000000) >> 24 |

-        (word & 0xff00000000) >> 8 |

-        (word & 0xff000000) << 8 |

-        (word & 0xff0000) << 24 |

-        (word & 0xff00) << 40 |

-        (word & 0xff) << 56;

-#  else   /* W == 4 */

-    return

-        (word & 0xff000000) >> 24 |

-        (word & 0xff0000) >> 8 |

-        (word & 0xff00) << 8 |

-        (word & 0xff) << 24;

-#  endif

-}

-#endif

-

-#ifdef DYNAMIC_CRC_TABLE

-/* =========================================================================

- * Table of powers of x for combining CRC-32s, filled in by make_crc_table()

- * below.

- */

-   local z_crc_t FAR x2n_table[32];

-#else

-/* =========================================================================

- * Tables for byte-wise and braided CRC-32 calculations, and a table of powers

- * of x for combining CRC-32s, all made by make_crc_table().

- */

-#  include "crc32.h"

-#endif

-

-/* CRC polynomial. */

-#define POLY 0xedb88320         /* p(x) reflected, with x^32 implied */

-

-/*

-  Return a(x) multiplied by b(x) modulo p(x), where p(x) is the CRC polynomial,

-  reflected. For speed, this requires that a not be zero.

- */

-local uLong multmodp(uLong a, uLong b) {

-    uLong m, p;

-

-    m = (uLong)1 << 31;

-    p = 0;

-    for (;;) {

-        if (a & m) {

-            p ^= b;

-            if ((a & (m - 1)) == 0)

-                break;

-        }

-        m >>= 1;

-        b = b & 1 ? (b >> 1) ^ POLY : b >> 1;

-    }

-    return p;

-}

-

-/*

-  Return x^(n * 2^k) modulo p(x). Requires that x2n_table[] has been

-  initialized. n must not be negative.

- */

-local uLong x2nmodp(z_off64_t n, unsigned k) {

-    uLong p;

-

-    p = (uLong)1 << 31;             /* x^0 == 1 */

-    while (n) {

-        if (n & 1)

-            p = multmodp(x2n_table[k & 31], p);

-        n >>= 1;

-        k++;

-    }

-    return p;

-}

-

-#ifdef DYNAMIC_CRC_TABLE

-/* =========================================================================

- * Build the tables for byte-wise and braided CRC-32 calculations, and a table

- * of powers of x for combining CRC-32s.

- */

-local z_crc_t FAR crc_table[256];

-#ifdef W

-   local z_word_t FAR crc_big_table[256];

-   local z_crc_t FAR crc_braid_table[W][256];

-   local z_word_t FAR crc_braid_big_table[W][256];

-   local void braid(z_crc_t [][256], z_word_t [][256], int, int);

-#endif

-#ifdef MAKECRCH

-   local void write_table(FILE *, const z_crc_t FAR *, int);

-   local void write_table32hi(FILE *, const z_word_t FAR *, int);

-   local void write_table64(FILE *, const z_word_t FAR *, int);

-#endif /* MAKECRCH */

-

-/* State for once(). */

-local z_once_t made = Z_ONCE_INIT;

-

-/*

-  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:

-  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.

-

-  Polynomials over GF(2) are represented in binary, one bit per coefficient,

-  with the lowest powers in the most significant bit. Then adding polynomials

-  is just exclusive-or, and multiplying a polynomial by x is a right shift by

-  one. If we call the above polynomial p, and represent a byte as the

-  polynomial q, also with the lowest power in the most significant bit (so the

-  byte 0xb1 is the polynomial x^7+x^3+x^2+1), then the CRC is (q*x^32) mod p,

-  where a mod b means the remainder after dividing a by b.

-

-  This calculation is done using the shift-register method of multiplying and

-  taking the remainder. The register is initialized to zero, and for each

-  incoming bit, x^32 is added mod p to the register if the bit is a one (where

-  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by x

-  (which is shifting right by one and adding x^32 mod p if the bit shifted out

-  is a one). We start with the highest power (least significant bit) of q and

-  repeat for all eight bits of q.

-

-  The table is simply the CRC of all possible eight bit values. This is all the

-  information needed to generate CRCs on data a byte at a time for all

-  combinations of CRC register values and incoming bytes.

- */

-

-local void make_crc_table(void) {

-    unsigned i, j, n;

-    z_crc_t p;

-

-    /* initialize the CRC of bytes tables */

-    for (i = 0; i < 256; i++) {

-        p = i;

-        for (j = 0; j < 8; j++)

-            p = p & 1 ? (p >> 1) ^ POLY : p >> 1;

-        crc_table[i] = p;

-#ifdef W

-        crc_big_table[i] = byte_swap(p);

-#endif

-    }

-

-    /* initialize the x^2^n mod p(x) table */

-    p = (z_crc_t)1 << 30;         /* x^1 */

-    x2n_table[0] = p;

-    for (n = 1; n < 32; n++)

-        x2n_table[n] = p = (z_crc_t)multmodp(p, p);

-

-#ifdef W

-    /* initialize the braiding tables -- needs x2n_table[] */

-    braid(crc_braid_table, crc_braid_big_table, N, W);

-#endif

-

-#ifdef MAKECRCH

-    {

-        /*

-          The crc32.h header file contains tables for both 32-bit and 64-bit

-          z_word_t's, and so requires a 64-bit type be available. In that case,

-          z_word_t must be defined to be 64-bits. This code then also generates

-          and writes out the tables for the case that z_word_t is 32 bits.

-         */

-#if !defined(W) || W != 8

-#  error Need a 64-bit integer type in order to generate crc32.h.

-#endif

-        FILE *out;

-        int k, n;

-        z_crc_t ltl[8][256];

-        z_word_t big[8][256];

-

-        out = fopen("crc32.h", "w");

-        if (out == NULL) return;

-

-        /* write out little-endian CRC table to crc32.h */

-        fprintf(out,

-            "/* crc32.h -- tables for rapid CRC calculation\n"

-            " * Generated automatically by crc32.c\n */\n"

-            "\n"

-            "local const z_crc_t FAR crc_table[] = {\n"

-            "    ");

-        write_table(out, crc_table, 256);

-        fprintf(out,

-            "};\n");

-

-        /* write out big-endian CRC table for 64-bit z_word_t to crc32.h */

-        fprintf(out,

-            "\n"

-            "#ifdef W\n"

-            "\n"

-            "#if W == 8\n"

-            "\n"

-            "local const z_word_t FAR crc_big_table[] = {\n"

-            "    ");

-        write_table64(out, crc_big_table, 256);

-        fprintf(out,

-            "};\n");

-

-        /* write out big-endian CRC table for 32-bit z_word_t to crc32.h */

-        fprintf(out,

-            "\n"

-            "#else /* W == 4 */\n"

-            "\n"

-            "local const z_word_t FAR crc_big_table[] = {\n"

-            "    ");

-        write_table32hi(out, crc_big_table, 256);

-        fprintf(out,

-            "};\n"

-            "\n"

-            "#endif\n");

-

-        /* write out braid tables for each value of N */

-        for (n = 1; n <= 6; n++) {

-            fprintf(out,

-            "\n"

-            "#if N == %d\n", n);

-

-            /* compute braid tables for this N and 64-bit word_t */

-            braid(ltl, big, n, 8);

-

-            /* write out braid tables for 64-bit z_word_t to crc32.h */

-            fprintf(out,

-            "\n"

-            "#if W == 8\n"

-            "\n"

-            "local const z_crc_t FAR crc_braid_table[][256] = {\n");

-            for (k = 0; k < 8; k++) {

-                fprintf(out, "   {");

-                write_table(out, ltl[k], 256);

-                fprintf(out, "}%s", k < 7 ? ",\n" : "");

-            }

-            fprintf(out,

-            "};\n"

-            "\n"

-            "local const z_word_t FAR crc_braid_big_table[][256] = {\n");

-            for (k = 0; k < 8; k++) {

-                fprintf(out, "   {");

-                write_table64(out, big[k], 256);

-                fprintf(out, "}%s", k < 7 ? ",\n" : "");

-            }

-            fprintf(out,

-            "};\n");

-

-            /* compute braid tables for this N and 32-bit word_t */

-            braid(ltl, big, n, 4);

-

-            /* write out braid tables for 32-bit z_word_t to crc32.h */

-            fprintf(out,

-            "\n"

-            "#else /* W == 4 */\n"

-            "\n"

-            "local const z_crc_t FAR crc_braid_table[][256] = {\n");

-            for (k = 0; k < 4; k++) {

-                fprintf(out, "   {");

-                write_table(out, ltl[k], 256);

-                fprintf(out, "}%s", k < 3 ? ",\n" : "");

-            }

-            fprintf(out,

-            "};\n"

-            "\n"

-            "local const z_word_t FAR crc_braid_big_table[][256] = {\n");

-            for (k = 0; k < 4; k++) {

-                fprintf(out, "   {");

-                write_table32hi(out, big[k], 256);

-                fprintf(out, "}%s", k < 3 ? ",\n" : "");

-            }

-            fprintf(out,

-            "};\n"

-            "\n"

-            "#endif\n"

-            "\n"

-            "#endif\n");

-        }

-        fprintf(out,

-            "\n"

-            "#endif\n");

-

-        /* write out zeros operator table to crc32.h */

-        fprintf(out,

-            "\n"

-            "local const z_crc_t FAR x2n_table[] = {\n"

-            "    ");

-        write_table(out, x2n_table, 32);

-        fprintf(out,

-            "};\n");

-        fclose(out);

-    }

-#endif /* MAKECRCH */

-}

-

-#ifdef MAKECRCH

-

-/*

-   Write the 32-bit values in table[0..k-1] to out, five per line in

-   hexadecimal separated by commas.

- */

-local void write_table(FILE *out, const z_crc_t FAR *table, int k) {

-    int n;

-

-    for (n = 0; n < k; n++)

-        fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : "    ",

-                (unsigned long)(table[n]),

-                n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));

-}

-

-/*

-   Write the high 32-bits of each value in table[0..k-1] to out, five per line

-   in hexadecimal separated by commas.

- */

-local void write_table32hi(FILE *out, const z_word_t FAR *table, int k) {

-    int n;

-

-    for (n = 0; n < k; n++)

-        fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : "    ",

-                (unsigned long)(table[n] >> 32),

-                n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));

-}

-

-/*

-  Write the 64-bit values in table[0..k-1] to out, three per line in

-  hexadecimal separated by commas. This assumes that if there is a 64-bit

-  type, then there is also a long long integer type, and it is at least 64

-  bits. If not, then the type cast and format string can be adjusted

-  accordingly.

- */

-local void write_table64(FILE *out, const z_word_t FAR *table, int k) {

-    int n;

-

-    for (n = 0; n < k; n++)

-        fprintf(out, "%s0x%016llx%s", n == 0 || n % 3 ? "" : "    ",

-                (unsigned long long)(table[n]),

-                n == k - 1 ? "" : (n % 3 == 2 ? ",\n" : ", "));

-}

-

-/* Actually do the deed. */

-int main(void) {

-    make_crc_table();

-    return 0;

-}

-

-#endif /* MAKECRCH */

-

-#ifdef W

-/*

-  Generate the little and big-endian braid tables for the given n and z_word_t

-  size w. Each array must have room for w blocks of 256 elements.

- */

-local void braid(z_crc_t ltl[][256], z_word_t big[][256], int n, int w) {

-    int k;

-    z_crc_t i, p, q;

-    for (k = 0; k < w; k++) {

-        p = (z_crc_t)x2nmodp((n * w + 3 - k) << 3, 0);

-        ltl[k][0] = 0;

-        big[w - 1 - k][0] = 0;

-        for (i = 1; i < 256; i++) {

-            ltl[k][i] = q = (z_crc_t)multmodp(i << 24, p);

-            big[w - 1 - k][i] = byte_swap(q);

-        }

-    }

-}

-#endif

-

-#endif /* DYNAMIC_CRC_TABLE */

-

-/* =========================================================================

- * This function can be used by asm versions of crc32(), and to force the

- * generation of the CRC tables in a threaded application.

- */

-const z_crc_t FAR * ZEXPORT get_crc_table(void) {

-#ifdef DYNAMIC_CRC_TABLE

-    z_once(&made, make_crc_table);

-#endif /* DYNAMIC_CRC_TABLE */

-    return (const z_crc_t FAR *)crc_table;

-}

-

-/* =========================================================================

- * Use ARM machine instructions if available. This will compute the CRC about

- * ten times faster than the braided calculation. This code does not check for

- * the presence of the CRC instruction at run time. __ARM_FEATURE_CRC32 will

- * only be defined if the compilation specifies an ARM processor architecture

- * that has the instructions. For example, compiling with -march=armv8.1-a or

- * -march=armv8-a+crc, or -march=native if the compile machine has the crc32

- * instructions.

- */

-#ifdef ARMCRC32

-

-/*

-   Constants empirically determined to maximize speed. These values are from

-   measurements on a Cortex-A57. Your mileage may vary.

- */

-#define Z_BATCH 3990                /* number of words in a batch */

-#define Z_BATCH_ZEROS 0xa10d3d0c    /* computed from Z_BATCH = 3990 */

-#define Z_BATCH_MIN 800             /* fewest words in a final batch */

-

-uLong ZEXPORT crc32_z(uLong crc, const unsigned char FAR *buf, z_size_t len) {

-    uLong val;

-    z_word_t crc1, crc2;

-    const z_word_t *word;

-    z_word_t val0, val1, val2;

-    z_size_t last, last2, i;

-    z_size_t num;

-

-    /* Return initial CRC, if requested. */

-    if (buf == Z_NULL) return 0;

-

-#ifdef DYNAMIC_CRC_TABLE

-    z_once(&made, make_crc_table);

-#endif /* DYNAMIC_CRC_TABLE */

-

-    /* Pre-condition the CRC */

-    crc = (~crc) & 0xffffffff;

-

-    /* Compute the CRC up to a word boundary. */

-    while (len && ((z_size_t)buf & 7) != 0) {

-        len--;

-        val = *buf++;

-        __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));

-    }

-

-    /* Prepare to compute the CRC on full 64-bit words word[0..num-1]. */

-    word = (z_word_t const *)buf;

-    num = len >> 3;

-    len &= 7;

-

-    /* Do three interleaved CRCs to realize the throughput of one crc32x

-       instruction per cycle. Each CRC is calculated on Z_BATCH words. The

-       three CRCs are combined into a single CRC after each set of batches. */

-    while (num >= 3 * Z_BATCH) {

-        crc1 = 0;

-        crc2 = 0;

-        for (i = 0; i < Z_BATCH; i++) {

-            val0 = word[i];

-            val1 = word[i + Z_BATCH];

-            val2 = word[i + 2 * Z_BATCH];

-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));

-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));

-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));

-        }

-        word += 3 * Z_BATCH;

-        num -= 3 * Z_BATCH;

-        crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc1;

-        crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc2;

-    }

-

-    /* Do one last smaller batch with the remaining words, if there are enough

-       to pay for the combination of CRCs. */

-    last = num / 3;

-    if (last >= Z_BATCH_MIN) {

-        last2 = last << 1;

-        crc1 = 0;

-        crc2 = 0;

-        for (i = 0; i < last; i++) {

-            val0 = word[i];

-            val1 = word[i + last];

-            val2 = word[i + last2];

-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));

-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));

-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));

-        }

-        word += 3 * last;

-        num -= 3 * last;

-        val = x2nmodp((int)last, 6);

-        crc = multmodp(val, crc) ^ crc1;

-        crc = multmodp(val, crc) ^ crc2;

-    }

-

-    /* Compute the CRC on any remaining words. */

-    for (i = 0; i < num; i++) {

-        val0 = word[i];

-        __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));

-    }

-    word += num;

-

-    /* Complete the CRC on any remaining bytes. */

-    buf = (const unsigned char FAR *)word;

-    while (len) {

-        len--;

-        val = *buf++;

-        __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));

-    }

-

-    /* Return the CRC, post-conditioned. */

-    return crc ^ 0xffffffff;

-}

-

-#else

-

-#ifdef W

-

-/*

-  Return the CRC of the W bytes in the word_t data, taking the

-  least-significant byte of the word as the first byte of data, without any pre

-  or post conditioning. This is used to combine the CRCs of each braid.

- */

-local z_crc_t crc_word(z_word_t data) {

-    int k;

-    for (k = 0; k < W; k++)

-        data = (data >> 8) ^ crc_table[data & 0xff];

-    return (z_crc_t)data;

-}

-

-local z_word_t crc_word_big(z_word_t data) {

-    int k;

-    for (k = 0; k < W; k++)

-        data = (data << 8) ^

-            crc_big_table[(data >> ((W - 1) << 3)) & 0xff];

-    return data;

-}

-

-#endif

-

-/* ========================================================================= */

-uLong ZEXPORT crc32_z(uLong crc, const unsigned char FAR *buf, z_size_t len) {

-    /* Return initial CRC, if requested. */

-    if (buf == Z_NULL) return 0;

-

-#ifdef DYNAMIC_CRC_TABLE

-    z_once(&made, make_crc_table);

-#endif /* DYNAMIC_CRC_TABLE */

-

-    /* Pre-condition the CRC */

-    crc = (~crc) & 0xffffffff;

-

-#ifdef W

-

-    /* If provided enough bytes, do a braided CRC calculation. */

-    if (len >= N * W + W - 1) {

-        z_size_t blks;

-        z_word_t const *words;

-        unsigned endian;

-        int k;

-

-        /* Compute the CRC up to a z_word_t boundary. */

-        while (len && ((z_size_t)buf & (W - 1)) != 0) {

-            len--;

-            crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        }

-

-        /* Compute the CRC on as many N z_word_t blocks as are available. */

-        blks = len / (N * W);

-        len -= blks * N * W;

-        words = (z_word_t const *)buf;

-

-        /* Do endian check at execution time instead of compile time, since ARM

-           processors can change the endianness at execution time. If the

-           compiler knows what the endianness will be, it can optimize out the

-           check and the unused branch. */

-        endian = 1;

-        if (*(unsigned char *)&endian) {

-            /* Little endian. */

-

-            z_crc_t crc0;

-            z_word_t word0;

-#if N > 1

-            z_crc_t crc1;

-            z_word_t word1;

-#if N > 2

-            z_crc_t crc2;

-            z_word_t word2;

-#if N > 3

-            z_crc_t crc3;

-            z_word_t word3;

-#if N > 4

-            z_crc_t crc4;

-            z_word_t word4;

-#if N > 5

-            z_crc_t crc5;

-            z_word_t word5;

-#endif

-#endif

-#endif

-#endif

-#endif

-

-            /* Initialize the CRC for each braid. */

-            crc0 = crc;

-#if N > 1

-            crc1 = 0;

-#if N > 2

-            crc2 = 0;

-#if N > 3

-            crc3 = 0;

-#if N > 4

-            crc4 = 0;

-#if N > 5

-            crc5 = 0;

-#endif

-#endif

-#endif

-#endif

-#endif

-

-            /*

-              Process the first blks-1 blocks, computing the CRCs on each braid

-              independently.

-             */

-            while (--blks) {

-                /* Load the word for each braid into registers. */

-                word0 = crc0 ^ words[0];

-#if N > 1

-                word1 = crc1 ^ words[1];

-#if N > 2

-                word2 = crc2 ^ words[2];

-#if N > 3

-                word3 = crc3 ^ words[3];

-#if N > 4

-                word4 = crc4 ^ words[4];

-#if N > 5

-                word5 = crc5 ^ words[5];

-#endif

-#endif

-#endif

-#endif

-#endif

-                words += N;

-

-                /* Compute and update the CRC for each word. The loop should

-                   get unrolled. */

-                crc0 = crc_braid_table[0][word0 & 0xff];

-#if N > 1

-                crc1 = crc_braid_table[0][word1 & 0xff];

-#if N > 2

-                crc2 = crc_braid_table[0][word2 & 0xff];

-#if N > 3

-                crc3 = crc_braid_table[0][word3 & 0xff];

-#if N > 4

-                crc4 = crc_braid_table[0][word4 & 0xff];

-#if N > 5

-                crc5 = crc_braid_table[0][word5 & 0xff];

-#endif

-#endif

-#endif

-#endif

-#endif

-                for (k = 1; k < W; k++) {

-                    crc0 ^= crc_braid_table[k][(word0 >> (k << 3)) & 0xff];

-#if N > 1

-                    crc1 ^= crc_braid_table[k][(word1 >> (k << 3)) & 0xff];

-#if N > 2

-                    crc2 ^= crc_braid_table[k][(word2 >> (k << 3)) & 0xff];

-#if N > 3

-                    crc3 ^= crc_braid_table[k][(word3 >> (k << 3)) & 0xff];

-#if N > 4

-                    crc4 ^= crc_braid_table[k][(word4 >> (k << 3)) & 0xff];

-#if N > 5

-                    crc5 ^= crc_braid_table[k][(word5 >> (k << 3)) & 0xff];

-#endif

-#endif

-#endif

-#endif

-#endif

-                }

-            }

-

-            /*

-              Process the last block, combining the CRCs of the N braids at the

-              same time.

-             */

-            crc = crc_word(crc0 ^ words[0]);

-#if N > 1

-            crc = crc_word(crc1 ^ words[1] ^ crc);

-#if N > 2

-            crc = crc_word(crc2 ^ words[2] ^ crc);

-#if N > 3

-            crc = crc_word(crc3 ^ words[3] ^ crc);

-#if N > 4

-            crc = crc_word(crc4 ^ words[4] ^ crc);

-#if N > 5

-            crc = crc_word(crc5 ^ words[5] ^ crc);

-#endif

-#endif

-#endif

-#endif

-#endif

-            words += N;

-        }

-        else {

-            /* Big endian. */

-

-            z_word_t crc0, word0, comb;

-#if N > 1

-            z_word_t crc1, word1;

-#if N > 2

-            z_word_t crc2, word2;

-#if N > 3

-            z_word_t crc3, word3;

-#if N > 4

-            z_word_t crc4, word4;

-#if N > 5

-            z_word_t crc5, word5;

-#endif

-#endif

-#endif

-#endif

-#endif

-

-            /* Initialize the CRC for each braid. */

-            crc0 = byte_swap(crc);

-#if N > 1

-            crc1 = 0;

-#if N > 2

-            crc2 = 0;

-#if N > 3

-            crc3 = 0;

-#if N > 4

-            crc4 = 0;

-#if N > 5

-            crc5 = 0;

-#endif

-#endif

-#endif

-#endif

-#endif

-

-            /*

-              Process the first blks-1 blocks, computing the CRCs on each braid

-              independently.

-             */

-            while (--blks) {

-                /* Load the word for each braid into registers. */

-                word0 = crc0 ^ words[0];

-#if N > 1

-                word1 = crc1 ^ words[1];

-#if N > 2

-                word2 = crc2 ^ words[2];

-#if N > 3

-                word3 = crc3 ^ words[3];

-#if N > 4

-                word4 = crc4 ^ words[4];

-#if N > 5

-                word5 = crc5 ^ words[5];

-#endif

-#endif

-#endif

-#endif

-#endif

-                words += N;

-

-                /* Compute and update the CRC for each word. The loop should

-                   get unrolled. */

-                crc0 = crc_braid_big_table[0][word0 & 0xff];

-#if N > 1

-                crc1 = crc_braid_big_table[0][word1 & 0xff];

-#if N > 2

-                crc2 = crc_braid_big_table[0][word2 & 0xff];

-#if N > 3

-                crc3 = crc_braid_big_table[0][word3 & 0xff];

-#if N > 4

-                crc4 = crc_braid_big_table[0][word4 & 0xff];

-#if N > 5

-                crc5 = crc_braid_big_table[0][word5 & 0xff];

-#endif

-#endif

-#endif

-#endif

-#endif

-                for (k = 1; k < W; k++) {

-                    crc0 ^= crc_braid_big_table[k][(word0 >> (k << 3)) & 0xff];

-#if N > 1

-                    crc1 ^= crc_braid_big_table[k][(word1 >> (k << 3)) & 0xff];

-#if N > 2

-                    crc2 ^= crc_braid_big_table[k][(word2 >> (k << 3)) & 0xff];

-#if N > 3

-                    crc3 ^= crc_braid_big_table[k][(word3 >> (k << 3)) & 0xff];

-#if N > 4

-                    crc4 ^= crc_braid_big_table[k][(word4 >> (k << 3)) & 0xff];

-#if N > 5

-                    crc5 ^= crc_braid_big_table[k][(word5 >> (k << 3)) & 0xff];

-#endif

-#endif

-#endif

-#endif

-#endif

-                }

-            }

-

-            /*

-              Process the last block, combining the CRCs of the N braids at the

-              same time.

-             */

-            comb = crc_word_big(crc0 ^ words[0]);

-#if N > 1

-            comb = crc_word_big(crc1 ^ words[1] ^ comb);

-#if N > 2

-            comb = crc_word_big(crc2 ^ words[2] ^ comb);

-#if N > 3

-            comb = crc_word_big(crc3 ^ words[3] ^ comb);

-#if N > 4

-            comb = crc_word_big(crc4 ^ words[4] ^ comb);

-#if N > 5

-            comb = crc_word_big(crc5 ^ words[5] ^ comb);

-#endif

-#endif

-#endif

-#endif

-#endif

-            words += N;

-            crc = byte_swap(comb);

-        }

-

-        /*

-          Update the pointer to the remaining bytes to process.

-         */

-        buf = (unsigned char const *)words;

-    }

-

-#endif /* W */

-

-    /* Complete the computation of the CRC on any remaining bytes. */

-    while (len >= 8) {

-        len -= 8;

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-    }

-    while (len) {

-        len--;

-        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];

-    }

-

-    /* Return the CRC, post-conditioned. */

-    return crc ^ 0xffffffff;

-}

-

-#endif

-

-/* ========================================================================= */

-uLong ZEXPORT crc32(uLong crc, const unsigned char FAR *buf, uInt len) {

-    #ifdef HAVE_S390X_VX

-    return crc32_z_hook(crc, buf, len);

-    #endif

-    return crc32_z(crc, buf, len);

-}

-

-/* ========================================================================= */

-uLong ZEXPORT crc32_combine_gen64(z_off64_t len2) {

-    if (len2 < 0)

-        return 0;

-#ifdef DYNAMIC_CRC_TABLE

-    z_once(&made, make_crc_table);

-#endif /* DYNAMIC_CRC_TABLE */

-    return x2nmodp(len2, 3);

-}

-

-/* ========================================================================= */

-uLong ZEXPORT crc32_combine_gen(z_off_t len2) {

-    return crc32_combine_gen64((z_off64_t)len2);

-}

-

-/* ========================================================================= */

-uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op) {

-    if (op == 0)

-        return 0;

-    return multmodp(op, crc1 & 0xffffffff) ^ (crc2 & 0xffffffff);

-}

-

-/* ========================================================================= */

-uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) {

-    return crc32_combine_op(crc1, crc2, crc32_combine_gen64(len2));

-}

-

-/* ========================================================================= */

-uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2) {

-    return crc32_combine64(crc1, crc2, (z_off64_t)len2);

-}

+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * This interleaved implementation of a CRC makes use of pipelined multiple
+ * arithmetic-logic units, commonly found in modern CPU cores. It is due to
+ * Kadatch and Jenkins (2010). See doc/crc-doc.1.0.pdf in this distribution.
+ */
+
+/* @(#) $Id$ */
+
+/*
+  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+  protection on the static variables used to control the first-use generation
+  of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+  first call get_crc_table() to initialize the tables before allowing more than
+  one thread to use crc32().
+
+  MAKECRCH can be #defined to write out crc32.h. A main() routine is also
+  produced, so that this one source file can be compiled to an executable.
+ */
+
+#ifdef MAKECRCH
+#  include <stdio.h>
+#  ifndef DYNAMIC_CRC_TABLE
+#    define DYNAMIC_CRC_TABLE
+#  endif
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+#  define Z_ONCE
+#endif
+
+#include "zutil.h"      /* for Z_U4, Z_U8, z_crc_t, and FAR definitions */
+
+#ifdef HAVE_S390X_VX
+#  include "contrib/crc32vx/crc32_vx_hooks.h"
+#endif
+
+ /*
+  A CRC of a message is computed on N braids of words in the message, where
+  each word consists of W bytes (4 or 8). If N is 3, for example, then three
+  running sparse CRCs are calculated respectively on each braid, at these
+  indices in the array of words: 0, 3, 6, ..., 1, 4, 7, ..., and 2, 5, 8, ...
+  This is done starting at a word boundary, and continues until as many blocks
+  of N * W bytes as are available have been processed. The results are combined
+  into a single CRC at the end. For this code, N must be in the range 1..6 and
+  W must be 4 or 8. The upper limit on N can be increased if desired by adding
+  more #if blocks, extending the patterns apparent in the code. In addition,
+  crc32.h would need to be regenerated, if the maximum N value is increased.
+
+  N and W are chosen empirically by benchmarking the execution time on a given
+  processor. The choices for N and W below were based on testing on Intel Kaby
+  Lake i7, AMD Ryzen 7, ARM Cortex-A57, Sparc64-VII, PowerPC POWER9, and MIPS64
+  Octeon II processors. The Intel, AMD, and ARM processors were all fastest
+  with N=5, W=8. The Sparc, PowerPC, and MIPS64 were all fastest at N=5, W=4.
+  They were all tested with either gcc or clang, all using the -O3 optimization
+  level. Your mileage may vary.
+ */
+
+/* Define N */
+#ifdef Z_TESTN
+#  define N Z_TESTN
+#else
+#  define N 5
+#endif
+#if N < 1 || N > 6
+#  error N must be in 1..6
+#endif
+
+/*
+  z_crc_t must be at least 32 bits. z_word_t must be at least as long as
+  z_crc_t. It is assumed here that z_word_t is either 32 bits or 64 bits, and
+  that bytes are eight bits.
+ */
+
+/*
+  Define W and the associated z_word_t type. If W is not defined, then a
+  braided calculation is not used, and the associated tables and code are not
+  compiled.
+ */
+#ifdef Z_TESTW
+#  if Z_TESTW-1 != -1
+#    define W Z_TESTW
+#  endif
+#else
+#  ifdef MAKECRCH
+#    define W 8         /* required for MAKECRCH */
+#  else
+#    if defined(__x86_64__) || defined(__aarch64__)
+#      define W 8
+#    else
+#      define W 4
+#    endif
+#  endif
+#endif
+#ifdef W
+#  if W == 8 && defined(Z_U8)
+     typedef Z_U8 z_word_t;
+#  elif defined(Z_U4)
+#    undef W
+#    define W 4
+     typedef Z_U4 z_word_t;
+#  else
+#    undef W
+#  endif
+#endif
+
+/* If available, use the ARM processor CRC32 instruction. */
+#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && \
+    defined(W) && W == 8
+#  define ARMCRC32
+#endif
+
+#if defined(W) && (!defined(ARMCRC32) || defined(DYNAMIC_CRC_TABLE))
+/*
+  Swap the bytes in a z_word_t to convert between little and big endian. Any
+  self-respecting compiler will optimize this to a single machine byte-swap
+  instruction, if one is available. This assumes that word_t is either 32 bits
+  or 64 bits.
+ */
+local z_word_t byte_swap(z_word_t word) {
+#  if W == 8
+    return
+        (word & 0xff00000000000000) >> 56 |
+        (word & 0xff000000000000) >> 40 |
+        (word & 0xff0000000000) >> 24 |
+        (word & 0xff00000000) >> 8 |
+        (word & 0xff000000) << 8 |
+        (word & 0xff0000) << 24 |
+        (word & 0xff00) << 40 |
+        (word & 0xff) << 56;
+#  else   /* W == 4 */
+    return
+        (word & 0xff000000) >> 24 |
+        (word & 0xff0000) >> 8 |
+        (word & 0xff00) << 8 |
+        (word & 0xff) << 24;
+#  endif
+}
+#endif
+
+#ifdef DYNAMIC_CRC_TABLE
+/* =========================================================================
+ * Table of powers of x for combining CRC-32s, filled in by make_crc_table()
+ * below.
+ */
+   local z_crc_t FAR x2n_table[32];
+#else
+/* =========================================================================
+ * Tables for byte-wise and braided CRC-32 calculations, and a table of powers
+ * of x for combining CRC-32s, all made by make_crc_table().
+ */
+#  include "crc32.h"
+#endif
+
+/* CRC polynomial. */
+#define POLY 0xedb88320         /* p(x) reflected, with x^32 implied */
+
+/*
+  Return a(x) multiplied by b(x) modulo p(x), where p(x) is the CRC polynomial,
+  reflected. For speed, this requires that a not be zero.
+ */
+local uLong multmodp(uLong a, uLong b) {
+    uLong m, p;
+
+    m = (uLong)1 << 31;
+    p = 0;
+    for (;;) {
+        if (a & m) {
+            p ^= b;
+            if ((a & (m - 1)) == 0)
+                break;
+        }
+        m >>= 1;
+        b = b & 1 ? (b >> 1) ^ POLY : b >> 1;
+    }
+    return p;
+}
+
+/*
+  Return x^(n * 2^k) modulo p(x). Requires that x2n_table[] has been
+  initialized. n must not be negative.
+ */
+local uLong x2nmodp(z_off64_t n, unsigned k) {
+    uLong p;
+
+    p = (uLong)1 << 31;             /* x^0 == 1 */
+    while (n) {
+        if (n & 1)
+            p = multmodp(x2n_table[k & 31], p);
+        n >>= 1;
+        k++;
+    }
+    return p;
+}
+
+#ifdef DYNAMIC_CRC_TABLE
+/* =========================================================================
+ * Build the tables for byte-wise and braided CRC-32 calculations, and a table
+ * of powers of x for combining CRC-32s.
+ */
+local z_crc_t FAR crc_table[256];
+#ifdef W
+   local z_word_t FAR crc_big_table[256];
+   local z_crc_t FAR crc_braid_table[W][256];
+   local z_word_t FAR crc_braid_big_table[W][256];
+   local void braid(z_crc_t [][256], z_word_t [][256], int, int);
+#endif
+#ifdef MAKECRCH
+   local void write_table(FILE *, const z_crc_t FAR *, int);
+   local void write_table32hi(FILE *, const z_word_t FAR *, int);
+   local void write_table64(FILE *, const z_word_t FAR *, int);
+#endif /* MAKECRCH */
+
+/* State for once(). */
+local z_once_t made = Z_ONCE_INIT;
+
+/*
+  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+  Polynomials over GF(2) are represented in binary, one bit per coefficient,
+  with the lowest powers in the most significant bit. Then adding polynomials
+  is just exclusive-or, and multiplying a polynomial by x is a right shift by
+  one. If we call the above polynomial p, and represent a byte as the
+  polynomial q, also with the lowest power in the most significant bit (so the
+  byte 0xb1 is the polynomial x^7+x^3+x^2+1), then the CRC is (q*x^32) mod p,
+  where a mod b means the remainder after dividing a by b.
+
+  This calculation is done using the shift-register method of multiplying and
+  taking the remainder. The register is initialized to zero, and for each
+  incoming bit, x^32 is added mod p to the register if the bit is a one (where
+  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by x
+  (which is shifting right by one and adding x^32 mod p if the bit shifted out
+  is a one). We start with the highest power (least significant bit) of q and
+  repeat for all eight bits of q.
+
+  The table is simply the CRC of all possible eight bit values. This is all the
+  information needed to generate CRCs on data a byte at a time for all
+  combinations of CRC register values and incoming bytes.
+ */
+
+local void make_crc_table(void) {
+    unsigned i, j, n;
+    z_crc_t p;
+
+    /* initialize the CRC of bytes tables */
+    for (i = 0; i < 256; i++) {
+        p = i;
+        for (j = 0; j < 8; j++)
+            p = p & 1 ? (p >> 1) ^ POLY : p >> 1;
+        crc_table[i] = p;
+#ifdef W
+        crc_big_table[i] = byte_swap(p);
+#endif
+    }
+
+    /* initialize the x^2^n mod p(x) table */
+    p = (z_crc_t)1 << 30;         /* x^1 */
+    x2n_table[0] = p;
+    for (n = 1; n < 32; n++)
+        x2n_table[n] = p = (z_crc_t)multmodp(p, p);
+
+#ifdef W
+    /* initialize the braiding tables -- needs x2n_table[] */
+    braid(crc_braid_table, crc_braid_big_table, N, W);
+#endif
+
+#ifdef MAKECRCH
+    {
+        /*
+          The crc32.h header file contains tables for both 32-bit and 64-bit
+          z_word_t's, and so requires a 64-bit type be available. In that case,
+          z_word_t must be defined to be 64-bits. This code then also generates
+          and writes out the tables for the case that z_word_t is 32 bits.
+         */
+#if !defined(W) || W != 8
+#  error Need a 64-bit integer type in order to generate crc32.h.
+#endif
+        FILE *out;
+        int k, n;
+        z_crc_t ltl[8][256];
+        z_word_t big[8][256];
+
+        out = fopen("crc32.h", "w");
+        if (out == NULL) return;
+
+        /* write out little-endian CRC table to crc32.h */
+        fprintf(out,
+            "/* crc32.h -- tables for rapid CRC calculation\n"
+            " * Generated automatically by crc32.c\n */\n"
+            "\n"
+            "local const z_crc_t FAR crc_table[] = {\n"
+            "    ");
+        write_table(out, crc_table, 256);
+        fprintf(out,
+            "};\n");
+
+        /* write out big-endian CRC table for 64-bit z_word_t to crc32.h */
+        fprintf(out,
+            "\n"
+            "#ifdef W\n"
+            "\n"
+            "#if W == 8\n"
+            "\n"
+            "local const z_word_t FAR crc_big_table[] = {\n"
+            "    ");
+        write_table64(out, crc_big_table, 256);
+        fprintf(out,
+            "};\n");
+
+        /* write out big-endian CRC table for 32-bit z_word_t to crc32.h */
+        fprintf(out,
+            "\n"
+            "#else /* W == 4 */\n"
+            "\n"
+            "local const z_word_t FAR crc_big_table[] = {\n"
+            "    ");
+        write_table32hi(out, crc_big_table, 256);
+        fprintf(out,
+            "};\n"
+            "\n"
+            "#endif\n");
+
+        /* write out braid tables for each value of N */
+        for (n = 1; n <= 6; n++) {
+            fprintf(out,
+            "\n"
+            "#if N == %d\n", n);
+
+            /* compute braid tables for this N and 64-bit word_t */
+            braid(ltl, big, n, 8);
+
+            /* write out braid tables for 64-bit z_word_t to crc32.h */
+            fprintf(out,
+            "\n"
+            "#if W == 8\n"
+            "\n"
+            "local const z_crc_t FAR crc_braid_table[][256] = {\n");
+            for (k = 0; k < 8; k++) {
+                fprintf(out, "   {");
+                write_table(out, ltl[k], 256);
+                fprintf(out, "}%s", k < 7 ? ",\n" : "");
+            }
+            fprintf(out,
+            "};\n"
+            "\n"
+            "local const z_word_t FAR crc_braid_big_table[][256] = {\n");
+            for (k = 0; k < 8; k++) {
+                fprintf(out, "   {");
+                write_table64(out, big[k], 256);
+                fprintf(out, "}%s", k < 7 ? ",\n" : "");
+            }
+            fprintf(out,
+            "};\n");
+
+            /* compute braid tables for this N and 32-bit word_t */
+            braid(ltl, big, n, 4);
+
+            /* write out braid tables for 32-bit z_word_t to crc32.h */
+            fprintf(out,
+            "\n"
+            "#else /* W == 4 */\n"
+            "\n"
+            "local const z_crc_t FAR crc_braid_table[][256] = {\n");
+            for (k = 0; k < 4; k++) {
+                fprintf(out, "   {");
+                write_table(out, ltl[k], 256);
+                fprintf(out, "}%s", k < 3 ? ",\n" : "");
+            }
+            fprintf(out,
+            "};\n"
+            "\n"
+            "local const z_word_t FAR crc_braid_big_table[][256] = {\n");
+            for (k = 0; k < 4; k++) {
+                fprintf(out, "   {");
+                write_table32hi(out, big[k], 256);
+                fprintf(out, "}%s", k < 3 ? ",\n" : "");
+            }
+            fprintf(out,
+            "};\n"
+            "\n"
+            "#endif\n"
+            "\n"
+            "#endif\n");
+        }
+        fprintf(out,
+            "\n"
+            "#endif\n");
+
+        /* write out zeros operator table to crc32.h */
+        fprintf(out,
+            "\n"
+            "local const z_crc_t FAR x2n_table[] = {\n"
+            "    ");
+        write_table(out, x2n_table, 32);
+        fprintf(out,
+            "};\n");
+        fclose(out);
+    }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+
+/*
+   Write the 32-bit values in table[0..k-1] to out, five per line in
+   hexadecimal separated by commas.
+ */
+local void write_table(FILE *out, const z_crc_t FAR *table, int k) {
+    int n;
+
+    for (n = 0; n < k; n++)
+        fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : "    ",
+                (unsigned long)(table[n]),
+                n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));
+}
+
+/*
+   Write the high 32-bits of each value in table[0..k-1] to out, five per line
+   in hexadecimal separated by commas.
+ */
+local void write_table32hi(FILE *out, const z_word_t FAR *table, int k) {
+    int n;
+
+    for (n = 0; n < k; n++)
+        fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : "    ",
+                (unsigned long)(table[n] >> 32),
+                n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));
+}
+
+/*
+  Write the 64-bit values in table[0..k-1] to out, three per line in
+  hexadecimal separated by commas. This assumes that if there is a 64-bit
+  type, then there is also a long long integer type, and it is at least 64
+  bits. If not, then the type cast and format string can be adjusted
+  accordingly.
+ */
+local void write_table64(FILE *out, const z_word_t FAR *table, int k) {
+    int n;
+
+    for (n = 0; n < k; n++)
+        fprintf(out, "%s0x%016llx%s", n == 0 || n % 3 ? "" : "    ",
+                (unsigned long long)(table[n]),
+                n == k - 1 ? "" : (n % 3 == 2 ? ",\n" : ", "));
+}
+
+/* Actually do the deed. */
+int main(void) {
+    make_crc_table();
+    return 0;
+}
+
+#endif /* MAKECRCH */
+
+#ifdef W
+/*
+  Generate the little and big-endian braid tables for the given n and z_word_t
+  size w. Each array must have room for w blocks of 256 elements.
+ */
+local void braid(z_crc_t ltl[][256], z_word_t big[][256], int n, int w) {
+    int k;
+    z_crc_t i, p, q;
+    for (k = 0; k < w; k++) {
+        p = (z_crc_t)x2nmodp((n * w + 3 - k) << 3, 0);
+        ltl[k][0] = 0;
+        big[w - 1 - k][0] = 0;
+        for (i = 1; i < 256; i++) {
+            ltl[k][i] = q = (z_crc_t)multmodp(i << 24, p);
+            big[w - 1 - k][i] = byte_swap(q);
+        }
+    }
+}
+#endif
+
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32(), and to force the
+ * generation of the CRC tables in a threaded application.
+ */
+const z_crc_t FAR * ZEXPORT get_crc_table(void) {
+#ifdef DYNAMIC_CRC_TABLE
+    z_once(&made, make_crc_table);
+#endif /* DYNAMIC_CRC_TABLE */
+    return (const z_crc_t FAR *)crc_table;
+}
+
+/* =========================================================================
+ * Use ARM machine instructions if available. This will compute the CRC about
+ * ten times faster than the braided calculation. This code does not check for
+ * the presence of the CRC instruction at run time. __ARM_FEATURE_CRC32 will
+ * only be defined if the compilation specifies an ARM processor architecture
+ * that has the instructions. For example, compiling with -march=armv8.1-a or
+ * -march=armv8-a+crc, or -march=native if the compile machine has the crc32
+ * instructions.
+ */
+#ifdef ARMCRC32
+
+/*
+   Constants empirically determined to maximize speed. These values are from
+   measurements on a Cortex-A57. Your mileage may vary.
+ */
+#define Z_BATCH 3990                /* number of words in a batch */
+#define Z_BATCH_ZEROS 0xa10d3d0c    /* computed from Z_BATCH = 3990 */
+#define Z_BATCH_MIN 800             /* fewest words in a final batch */
+
+uLong ZEXPORT crc32_z(uLong crc, const unsigned char FAR *buf, z_size_t len) {
+    uLong val;
+    z_word_t crc1, crc2;
+    const z_word_t *word;
+    z_word_t val0, val1, val2;
+    z_size_t last, last2, i;
+    z_size_t num;
+
+    /* Return initial CRC, if requested. */
+    if (buf == Z_NULL) return 0;
+
+#ifdef DYNAMIC_CRC_TABLE
+    z_once(&made, make_crc_table);
+#endif /* DYNAMIC_CRC_TABLE */
+
+    /* Pre-condition the CRC */
+    crc = (~crc) & 0xffffffff;
+
+    /* Compute the CRC up to a word boundary. */
+    while (len && ((z_size_t)buf & 7) != 0) {
+        len--;
+        val = *buf++;
+        __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
+    }
+
+    /* Prepare to compute the CRC on full 64-bit words word[0..num-1]. */
+    word = (z_word_t const *)buf;
+    num = len >> 3;
+    len &= 7;
+
+    /* Do three interleaved CRCs to realize the throughput of one crc32x
+       instruction per cycle. Each CRC is calculated on Z_BATCH words. The
+       three CRCs are combined into a single CRC after each set of batches. */
+    while (num >= 3 * Z_BATCH) {
+        crc1 = 0;
+        crc2 = 0;
+        for (i = 0; i < Z_BATCH; i++) {
+            val0 = word[i];
+            val1 = word[i + Z_BATCH];
+            val2 = word[i + 2 * Z_BATCH];
+            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
+            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
+            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
+        }
+        word += 3 * Z_BATCH;
+        num -= 3 * Z_BATCH;
+        crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc1;
+        crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc2;
+    }
+
+    /* Do one last smaller batch with the remaining words, if there are enough
+       to pay for the combination of CRCs. */
+    last = num / 3;
+    if (last >= Z_BATCH_MIN) {
+        last2 = last << 1;
+        crc1 = 0;
+        crc2 = 0;
+        for (i = 0; i < last; i++) {
+            val0 = word[i];
+            val1 = word[i + last];
+            val2 = word[i + last2];
+            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
+            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
+            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
+        }
+        word += 3 * last;
+        num -= 3 * last;
+        val = x2nmodp((int)last, 6);
+        crc = multmodp(val, crc) ^ crc1;
+        crc = multmodp(val, crc) ^ crc2;
+    }
+
+    /* Compute the CRC on any remaining words. */
+    for (i = 0; i < num; i++) {
+        val0 = word[i];
+        __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
+    }
+    word += num;
+
+    /* Complete the CRC on any remaining bytes. */
+    buf = (const unsigned char FAR *)word;
+    while (len) {
+        len--;
+        val = *buf++;
+        __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
+    }
+
+    /* Return the CRC, post-conditioned. */
+    return crc ^ 0xffffffff;
+}
+
+#else
+
+#ifdef W
+
+/*
+  Return the CRC of the W bytes in the word_t data, taking the
+  least-significant byte of the word as the first byte of data, without any pre
+  or post conditioning. This is used to combine the CRCs of each braid.
+ */
+local z_crc_t crc_word(z_word_t data) {
+    int k;
+    for (k = 0; k < W; k++)
+        data = (data >> 8) ^ crc_table[data & 0xff];
+    return (z_crc_t)data;
+}
+
+local z_word_t crc_word_big(z_word_t data) {
+    int k;
+    for (k = 0; k < W; k++)
+        data = (data << 8) ^
+            crc_big_table[(data >> ((W - 1) << 3)) & 0xff];
+    return data;
+}
+
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_z(uLong crc, const unsigned char FAR *buf, z_size_t len) {
+    /* Return initial CRC, if requested. */
+    if (buf == Z_NULL) return 0;
+
+#ifdef DYNAMIC_CRC_TABLE
+    z_once(&made, make_crc_table);
+#endif /* DYNAMIC_CRC_TABLE */
+
+    /* Pre-condition the CRC */
+    crc = (~crc) & 0xffffffff;
+
+#ifdef W
+
+    /* If provided enough bytes, do a braided CRC calculation. */
+    if (len >= N * W + W - 1) {
+        z_size_t blks;
+        z_word_t const *words;
+        unsigned endian;
+        int k;
+
+        /* Compute the CRC up to a z_word_t boundary. */
+        while (len && ((z_size_t)buf & (W - 1)) != 0) {
+            len--;
+            crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        }
+
+        /* Compute the CRC on as many N z_word_t blocks as are available. */
+        blks = len / (N * W);
+        len -= blks * N * W;
+        words = (z_word_t const *)buf;
+
+        /* Do endian check at execution time instead of compile time, since ARM
+           processors can change the endianness at execution time. If the
+           compiler knows what the endianness will be, it can optimize out the
+           check and the unused branch. */
+        endian = 1;
+        if (*(unsigned char *)&endian) {
+            /* Little endian. */
+
+            z_crc_t crc0;
+            z_word_t word0;
+#if N > 1
+            z_crc_t crc1;
+            z_word_t word1;
+#if N > 2
+            z_crc_t crc2;
+            z_word_t word2;
+#if N > 3
+            z_crc_t crc3;
+            z_word_t word3;
+#if N > 4
+            z_crc_t crc4;
+            z_word_t word4;
+#if N > 5
+            z_crc_t crc5;
+            z_word_t word5;
+#endif
+#endif
+#endif
+#endif
+#endif
+
+            /* Initialize the CRC for each braid. */
+            crc0 = crc;
+#if N > 1
+            crc1 = 0;
+#if N > 2
+            crc2 = 0;
+#if N > 3
+            crc3 = 0;
+#if N > 4
+            crc4 = 0;
+#if N > 5
+            crc5 = 0;
+#endif
+#endif
+#endif
+#endif
+#endif
+
+            /*
+              Process the first blks-1 blocks, computing the CRCs on each braid
+              independently.
+             */
+            while (--blks) {
+                /* Load the word for each braid into registers. */
+                word0 = crc0 ^ words[0];
+#if N > 1
+                word1 = crc1 ^ words[1];
+#if N > 2
+                word2 = crc2 ^ words[2];
+#if N > 3
+                word3 = crc3 ^ words[3];
+#if N > 4
+                word4 = crc4 ^ words[4];
+#if N > 5
+                word5 = crc5 ^ words[5];
+#endif
+#endif
+#endif
+#endif
+#endif
+                words += N;
+
+                /* Compute and update the CRC for each word. The loop should
+                   get unrolled. */
+                crc0 = crc_braid_table[0][word0 & 0xff];
+#if N > 1
+                crc1 = crc_braid_table[0][word1 & 0xff];
+#if N > 2
+                crc2 = crc_braid_table[0][word2 & 0xff];
+#if N > 3
+                crc3 = crc_braid_table[0][word3 & 0xff];
+#if N > 4
+                crc4 = crc_braid_table[0][word4 & 0xff];
+#if N > 5
+                crc5 = crc_braid_table[0][word5 & 0xff];
+#endif
+#endif
+#endif
+#endif
+#endif
+                for (k = 1; k < W; k++) {
+                    crc0 ^= crc_braid_table[k][(word0 >> (k << 3)) & 0xff];
+#if N > 1
+                    crc1 ^= crc_braid_table[k][(word1 >> (k << 3)) & 0xff];
+#if N > 2
+                    crc2 ^= crc_braid_table[k][(word2 >> (k << 3)) & 0xff];
+#if N > 3
+                    crc3 ^= crc_braid_table[k][(word3 >> (k << 3)) & 0xff];
+#if N > 4
+                    crc4 ^= crc_braid_table[k][(word4 >> (k << 3)) & 0xff];
+#if N > 5
+                    crc5 ^= crc_braid_table[k][(word5 >> (k << 3)) & 0xff];
+#endif
+#endif
+#endif
+#endif
+#endif
+                }
+            }
+
+            /*
+              Process the last block, combining the CRCs of the N braids at the
+              same time.
+             */
+            crc = crc_word(crc0 ^ words[0]);
+#if N > 1
+            crc = crc_word(crc1 ^ words[1] ^ crc);
+#if N > 2
+            crc = crc_word(crc2 ^ words[2] ^ crc);
+#if N > 3
+            crc = crc_word(crc3 ^ words[3] ^ crc);
+#if N > 4
+            crc = crc_word(crc4 ^ words[4] ^ crc);
+#if N > 5
+            crc = crc_word(crc5 ^ words[5] ^ crc);
+#endif
+#endif
+#endif
+#endif
+#endif
+            words += N;
+        }
+        else {
+            /* Big endian. */
+
+            z_word_t crc0, word0, comb;
+#if N > 1
+            z_word_t crc1, word1;
+#if N > 2
+            z_word_t crc2, word2;
+#if N > 3
+            z_word_t crc3, word3;
+#if N > 4
+            z_word_t crc4, word4;
+#if N > 5
+            z_word_t crc5, word5;
+#endif
+#endif
+#endif
+#endif
+#endif
+
+            /* Initialize the CRC for each braid. */
+            crc0 = byte_swap(crc);
+#if N > 1
+            crc1 = 0;
+#if N > 2
+            crc2 = 0;
+#if N > 3
+            crc3 = 0;
+#if N > 4
+            crc4 = 0;
+#if N > 5
+            crc5 = 0;
+#endif
+#endif
+#endif
+#endif
+#endif
+
+            /*
+              Process the first blks-1 blocks, computing the CRCs on each braid
+              independently.
+             */
+            while (--blks) {
+                /* Load the word for each braid into registers. */
+                word0 = crc0 ^ words[0];
+#if N > 1
+                word1 = crc1 ^ words[1];
+#if N > 2
+                word2 = crc2 ^ words[2];
+#if N > 3
+                word3 = crc3 ^ words[3];
+#if N > 4
+                word4 = crc4 ^ words[4];
+#if N > 5
+                word5 = crc5 ^ words[5];
+#endif
+#endif
+#endif
+#endif
+#endif
+                words += N;
+
+                /* Compute and update the CRC for each word. The loop should
+                   get unrolled. */
+                crc0 = crc_braid_big_table[0][word0 & 0xff];
+#if N > 1
+                crc1 = crc_braid_big_table[0][word1 & 0xff];
+#if N > 2
+                crc2 = crc_braid_big_table[0][word2 & 0xff];
+#if N > 3
+                crc3 = crc_braid_big_table[0][word3 & 0xff];
+#if N > 4
+                crc4 = crc_braid_big_table[0][word4 & 0xff];
+#if N > 5
+                crc5 = crc_braid_big_table[0][word5 & 0xff];
+#endif
+#endif
+#endif
+#endif
+#endif
+                for (k = 1; k < W; k++) {
+                    crc0 ^= crc_braid_big_table[k][(word0 >> (k << 3)) & 0xff];
+#if N > 1
+                    crc1 ^= crc_braid_big_table[k][(word1 >> (k << 3)) & 0xff];
+#if N > 2
+                    crc2 ^= crc_braid_big_table[k][(word2 >> (k << 3)) & 0xff];
+#if N > 3
+                    crc3 ^= crc_braid_big_table[k][(word3 >> (k << 3)) & 0xff];
+#if N > 4
+                    crc4 ^= crc_braid_big_table[k][(word4 >> (k << 3)) & 0xff];
+#if N > 5
+                    crc5 ^= crc_braid_big_table[k][(word5 >> (k << 3)) & 0xff];
+#endif
+#endif
+#endif
+#endif
+#endif
+                }
+            }
+
+            /*
+              Process the last block, combining the CRCs of the N braids at the
+              same time.
+             */
+            comb = crc_word_big(crc0 ^ words[0]);
+#if N > 1
+            comb = crc_word_big(crc1 ^ words[1] ^ comb);
+#if N > 2
+            comb = crc_word_big(crc2 ^ words[2] ^ comb);
+#if N > 3
+            comb = crc_word_big(crc3 ^ words[3] ^ comb);
+#if N > 4
+            comb = crc_word_big(crc4 ^ words[4] ^ comb);
+#if N > 5
+            comb = crc_word_big(crc5 ^ words[5] ^ comb);
+#endif
+#endif
+#endif
+#endif
+#endif
+            words += N;
+            crc = byte_swap(comb);
+        }
+
+        /*
+          Update the pointer to the remaining bytes to process.
+         */
+        buf = (unsigned char const *)words;
+    }
+
+#endif /* W */
+
+    /* Complete the computation of the CRC on any remaining bytes. */
+    while (len >= 8) {
+        len -= 8;
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+    }
+    while (len) {
+        len--;
+        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+    }
+
+    /* Return the CRC, post-conditioned. */
+    return crc ^ 0xffffffff;
+}
+
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT crc32(uLong crc, const unsigned char FAR *buf, uInt len) {
+    #ifdef HAVE_S390X_VX
+    return crc32_z_hook(crc, buf, len);
+    #endif
+    return crc32_z(crc, buf, len);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine_gen64(z_off64_t len2) {
+    if (len2 < 0)
+        return 0;
+#ifdef DYNAMIC_CRC_TABLE
+    z_once(&made, make_crc_table);
+#endif /* DYNAMIC_CRC_TABLE */
+    return x2nmodp(len2, 3);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine_gen(z_off_t len2) {
+    return crc32_combine_gen64((z_off64_t)len2);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op) {
+    if (op == 0)
+        return 0;
+    return multmodp(op, crc1 & 0xffffffff) ^ (crc2 & 0xffffffff);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) {
+    return crc32_combine_op(crc1, crc2, crc32_combine_gen64(len2));
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2) {
+    return crc32_combine64(crc1, crc2, (z_off64_t)len2);
+}
diff --git a/Minecraft.Client/Common/zlib/trees.c b/Minecraft.Client/Common/zlib/trees.c
index fa31c0fa..8e4da01e 100644
--- a/Minecraft.Client/Common/zlib/trees.c
+++ b/Minecraft.Client/Common/zlib/trees.c
@@ -1,1119 +1,1119 @@
-/* trees.c -- output deflated data using Huffman coding

- * Copyright (C) 1995-2026 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 ZLIB_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 /* defined(GEN_TREES_H) || !defined(STDC) */

-

-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 */

-};

-

-#ifdef NO_INIT_GLOBAL_POINTERS

-#  define TCONST

-#else

-#  define TCONST const

-#endif

-

-local TCONST static_tree_desc static_l_desc =

-{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};

-

-local TCONST static_tree_desc static_d_desc =

-{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};

-

-local TCONST static_tree_desc static_bl_desc =

-{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};

-

-/* ===========================================================================

- * 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)); \

-}

-

-/* ===========================================================================

- * 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 code, int len) {

-    unsigned res = 0;

-    do {

-        res |= code & 1;

-        code >>= 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_used = ((s->bi_valid - 1) & 7) + 1;

-    s->bi_buf = 0;

-    s->bi_valid = 0;

-#ifdef ZLIB_DEBUG

-    s->bits_sent = (s->bits_sent + 7) & ~(ulg)7;

-#endif

-}

-

-/* ===========================================================================

- * 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 */

-    unsigned code = 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++) {

-        code = (code + bl_count[bits - 1]) << 1;

-        next_code[bits] = (ush)code;

-    }

-    /* Check that the bit counts in bl_count are consistent. The last code

-     * must be all ones.

-     */

-    Assert (code + 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 = (ush)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));

-    }

-}

-

-#ifdef GEN_TREES_H

-local void gen_trees_header(void);

-#endif

-

-#ifndef ZLIB_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 /* !ZLIB_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

-

-/* ===========================================================================

- * Send a value on a given number of bits.

- * IN assertion: length <= 16 and value fits in length bits.

- */

-#ifdef ZLIB_DEBUG

-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 /* !ZLIB_DEBUG */

-

-#define send_bits(s, value, length) \

-{ int len = length;\

-  if (s->bi_valid > (int)Buf_size - len) {\

-    int val = (int)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 /* ZLIB_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 code;     /* 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 (code = 0; code < LENGTH_CODES-1; code++) {

-        base_length[code] = length;

-        for (n = 0; n < (1 << extra_lbits[code]); n++) {

-            _length_code[length++] = (uch)code;

-        }

-    }

-    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)code;

-

-    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */

-    dist = 0;

-    for (code = 0 ; code < 16; code++) {

-        base_dist[code] = dist;

-        for (n = 0; n < (1 << extra_dbits[code]); n++) {

-            _dist_code[dist++] = (uch)code;

-        }

-    }

-    Assert (dist == 256, "tr_static_init: dist != 256");

-    dist >>= 7; /* from now on, all distances are divided by 128 */

-    for ( ; code < D_CODES; code++) {

-        base_dist[code] = dist << 7;

-        for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {

-            _dist_code[256 + dist++] = (uch)code;

-        }

-    }

-    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) */

-}

-

-/* ===========================================================================

- * Generate the file trees.h describing the static trees.

- */

-#ifdef GEN_TREES_H

-#  ifndef ZLIB_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 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->sym_next = s->matches = 0;

-}

-

-/* ===========================================================================

- * 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;

-    s->bi_used = 0;

-#ifdef ZLIB_DEBUG

-    s->compressed_len = 0L;

-    s->bits_sent = 0L;

-#endif

-

-    /* Initialize the first block of the first file: */

-    init_block(s);

-}

-

-#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 * (unsigned)(bits + xbits);

-        if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);

-    }

-    if (overflow == 0) return;

-

-    Tracev((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) {

-                Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));

-                s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;

-                tree[m].Len = (ush)bits;

-            }

-            n--;

-        }

-    }

-}

-

-#ifdef DUMP_BL_TREE

-#  include <stdio.h>

-#endif

-

-/* ===========================================================================

- * 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 += (ush)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*((ulg)max_blindex + 1) + 5 + 5 + 4;

-    Tracev((stderr, "\ndyn trees: dyn %lu, stat %lu",

-            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 %lu", s->bits_sent));

-

-    send_tree(s, (ct_data *)s->dyn_ltree, lcodes - 1);  /* literal tree */

-    Tracev((stderr, "\nlit tree: sent %lu", s->bits_sent));

-

-    send_tree(s, (ct_data *)s->dyn_dtree, dcodes - 1);  /* distance tree */

-    Tracev((stderr, "\ndist tree: sent %lu", 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 */

-    bi_windup(s);        /* align on byte boundary */

-    put_short(s, (ush)stored_len);

-    put_short(s, (ush)~stored_len);

-    if (stored_len)

-        zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);

-    s->pending += stored_len;

-#ifdef ZLIB_DEBUG

-    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;

-    s->compressed_len += (stored_len + 4) << 3;

-    s->bits_sent += 2*16;

-    s->bits_sent += stored_len << 3;

-#endif

-}

-

-/* ===========================================================================

- * 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 ZLIB_DEBUG

-    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */

-#endif

-    bi_flush(s);

-}

-

-/* ===========================================================================

- * 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 sx = 0;    /* running index in symbol buffers */

-    unsigned code;      /* the code to send */

-    int extra;          /* number of extra bits to send */

-

-    if (s->sym_next != 0) do {

-#ifdef LIT_MEM

-        dist = s->d_buf[sx];

-        lc = s->l_buf[sx++];

-#else

-        dist = s->sym_buf[sx++] & 0xff;

-        dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8;

-        lc = s->sym_buf[sx++];

-#endif

-        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 */

-            code = _length_code[lc];

-            send_code(s, code + LITERALS + 1, ltree);   /* send length code */

-            extra = extra_lbits[code];

-            if (extra != 0) {

-                lc -= base_length[code];

-                send_bits(s, lc, extra);       /* send the extra length bits */

-            }

-            dist--; /* dist is now the match distance - 1 */

-            code = d_code(dist);

-            Assert (code < D_CODES, "bad d_code");

-

-            send_code(s, code, dtree);       /* send the distance code */

-            extra = extra_dbits[code];

-            if (extra != 0) {

-                dist -= (unsigned)base_dist[code];

-                send_bits(s, (int)dist, extra); /* send the extra bits */

-            }

-        } /* literal or match pair ? */

-

-        /* Check for no overlay of pending_buf on needed symbols */

-#ifdef LIT_MEM

-        Assert(s->pending < 2 * (s->lit_bufsize + sx), "pendingBuf overflow");

-#else

-        Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow");

-#endif

-

-    } while (sx < s->sym_next);

-

-    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

- *       "block list" (0..6, 14..25, 28..31).

- *    b) There is at least one printable character belonging to the

- *       "allow 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) {

-    /* block_mask is the bit mask of block-listed bytes

-     * set bits 0..6, 14..25, and 28..31

-     * 0xf3ffc07f = binary 11110011111111111100000001111111

-     */

-    unsigned long block_mask = 0xf3ffc07fUL;

-    int n;

-

-    /* Check for non-textual ("block-listed") bytes. */

-    for (n = 0; n <= 31; n++, block_mask >>= 1)

-        if ((block_mask & 1) && (s->dyn_ltree[n].Freq != 0))

-            return Z_BINARY;

-

-    /* Check for textual ("allow-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 "block-listed" or "allow-listed" bytes:

-     * this stream either is empty or has tolerated ("gray-listed") bytes only.

-     */

-    return Z_BINARY;

-}

-

-/* ===========================================================================

- * Determine the best encoding for the current block: dynamic trees, static

- * trees or store, and write out the encoded block.

- */

-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 %lu, stat %lu", s->opt_len,

-                s->static_len));

-

-        build_tree(s, (tree_desc *)(&(s->d_desc)));

-        Tracev((stderr, "\ndist data: dyn %lu, stat %lu", 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->sym_next / 3));

-

-#ifndef FORCE_STATIC

-        if (static_lenb <= opt_lenb || s->strategy == Z_FIXED)

-#endif

-            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);

-

-    } else if (static_lenb == opt_lenb) {

-        send_bits(s, (STATIC_TREES<<1) + last, 3);

-        compress_block(s, (const ct_data *)static_ltree,

-                       (const ct_data *)static_dtree);

-#ifdef ZLIB_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 ZLIB_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 ZLIB_DEBUG

-        s->compressed_len += 7;  /* align on byte boundary */

-#endif

-    }

-    Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len >> 3,

-           s->compressed_len - 7*(ulg)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) {

-#ifdef LIT_MEM

-    s->d_buf[s->sym_next] = (ush)dist;

-    s->l_buf[s->sym_next++] = (uch)lc;

-#else

-    s->sym_buf[s->sym_next++] = (uch)dist;

-    s->sym_buf[s->sym_next++] = (uch)(dist >> 8);

-    s->sym_buf[s->sym_next++] = (uch)lc;

-#endif

-    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++;

-    }

-    return (s->sym_next == s->sym_end);

-}

+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2026 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 ZLIB_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 /* defined(GEN_TREES_H) || !defined(STDC) */
+
+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 */
+};
+
+#ifdef NO_INIT_GLOBAL_POINTERS
+#  define TCONST
+#else
+#  define TCONST const
+#endif
+
+local TCONST static_tree_desc static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local TCONST static_tree_desc static_d_desc =
+{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};
+
+local TCONST static_tree_desc static_bl_desc =
+{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};
+
+/* ===========================================================================
+ * 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)); \
+}
+
+/* ===========================================================================
+ * 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 code, int len) {
+    unsigned res = 0;
+    do {
+        res |= code & 1;
+        code >>= 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_used = ((s->bi_valid - 1) & 7) + 1;
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+#ifdef ZLIB_DEBUG
+    s->bits_sent = (s->bits_sent + 7) & ~(ulg)7;
+#endif
+}
+
+/* ===========================================================================
+ * 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 */
+    unsigned code = 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++) {
+        code = (code + bl_count[bits - 1]) << 1;
+        next_code[bits] = (ush)code;
+    }
+    /* Check that the bit counts in bl_count are consistent. The last code
+     * must be all ones.
+     */
+    Assert (code + 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 = (ush)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));
+    }
+}
+
+#ifdef GEN_TREES_H
+local void gen_trees_header(void);
+#endif
+
+#ifndef ZLIB_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 /* !ZLIB_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
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef ZLIB_DEBUG
+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 /* !ZLIB_DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+  if (s->bi_valid > (int)Buf_size - len) {\
+    int val = (int)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 /* ZLIB_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 code;     /* 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 (code = 0; code < LENGTH_CODES-1; code++) {
+        base_length[code] = length;
+        for (n = 0; n < (1 << extra_lbits[code]); n++) {
+            _length_code[length++] = (uch)code;
+        }
+    }
+    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)code;
+
+    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+    dist = 0;
+    for (code = 0 ; code < 16; code++) {
+        base_dist[code] = dist;
+        for (n = 0; n < (1 << extra_dbits[code]); n++) {
+            _dist_code[dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: dist != 256");
+    dist >>= 7; /* from now on, all distances are divided by 128 */
+    for ( ; code < D_CODES; code++) {
+        base_dist[code] = dist << 7;
+        for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
+            _dist_code[256 + dist++] = (uch)code;
+        }
+    }
+    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) */
+}
+
+/* ===========================================================================
+ * Generate the file trees.h describing the static trees.
+ */
+#ifdef GEN_TREES_H
+#  ifndef ZLIB_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 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->sym_next = s->matches = 0;
+}
+
+/* ===========================================================================
+ * 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;
+    s->bi_used = 0;
+#ifdef ZLIB_DEBUG
+    s->compressed_len = 0L;
+    s->bits_sent = 0L;
+#endif
+
+    /* Initialize the first block of the first file: */
+    init_block(s);
+}
+
+#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 * (unsigned)(bits + xbits);
+        if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
+    }
+    if (overflow == 0) return;
+
+    Tracev((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) {
+                Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+                s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
+                tree[m].Len = (ush)bits;
+            }
+            n--;
+        }
+    }
+}
+
+#ifdef DUMP_BL_TREE
+#  include <stdio.h>
+#endif
+
+/* ===========================================================================
+ * 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 += (ush)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*((ulg)max_blindex + 1) + 5 + 5 + 4;
+    Tracev((stderr, "\ndyn trees: dyn %lu, stat %lu",
+            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 %lu", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_ltree, lcodes - 1);  /* literal tree */
+    Tracev((stderr, "\nlit tree: sent %lu", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_dtree, dcodes - 1);  /* distance tree */
+    Tracev((stderr, "\ndist tree: sent %lu", 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 */
+    bi_windup(s);        /* align on byte boundary */
+    put_short(s, (ush)stored_len);
+    put_short(s, (ush)~stored_len);
+    if (stored_len)
+        zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
+    s->pending += stored_len;
+#ifdef ZLIB_DEBUG
+    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+    s->compressed_len += (stored_len + 4) << 3;
+    s->bits_sent += 2*16;
+    s->bits_sent += stored_len << 3;
+#endif
+}
+
+/* ===========================================================================
+ * 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 ZLIB_DEBUG
+    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
+    bi_flush(s);
+}
+
+/* ===========================================================================
+ * 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 sx = 0;    /* running index in symbol buffers */
+    unsigned code;      /* the code to send */
+    int extra;          /* number of extra bits to send */
+
+    if (s->sym_next != 0) do {
+#ifdef LIT_MEM
+        dist = s->d_buf[sx];
+        lc = s->l_buf[sx++];
+#else
+        dist = s->sym_buf[sx++] & 0xff;
+        dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8;
+        lc = s->sym_buf[sx++];
+#endif
+        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 */
+            code = _length_code[lc];
+            send_code(s, code + LITERALS + 1, ltree);   /* send length code */
+            extra = extra_lbits[code];
+            if (extra != 0) {
+                lc -= base_length[code];
+                send_bits(s, lc, extra);       /* send the extra length bits */
+            }
+            dist--; /* dist is now the match distance - 1 */
+            code = d_code(dist);
+            Assert (code < D_CODES, "bad d_code");
+
+            send_code(s, code, dtree);       /* send the distance code */
+            extra = extra_dbits[code];
+            if (extra != 0) {
+                dist -= (unsigned)base_dist[code];
+                send_bits(s, (int)dist, extra); /* send the extra bits */
+            }
+        } /* literal or match pair ? */
+
+        /* Check for no overlay of pending_buf on needed symbols */
+#ifdef LIT_MEM
+        Assert(s->pending < 2 * (s->lit_bufsize + sx), "pendingBuf overflow");
+#else
+        Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow");
+#endif
+
+    } while (sx < s->sym_next);
+
+    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
+ *       "block list" (0..6, 14..25, 28..31).
+ *    b) There is at least one printable character belonging to the
+ *       "allow 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) {
+    /* block_mask is the bit mask of block-listed bytes
+     * set bits 0..6, 14..25, and 28..31
+     * 0xf3ffc07f = binary 11110011111111111100000001111111
+     */
+    unsigned long block_mask = 0xf3ffc07fUL;
+    int n;
+
+    /* Check for non-textual ("block-listed") bytes. */
+    for (n = 0; n <= 31; n++, block_mask >>= 1)
+        if ((block_mask & 1) && (s->dyn_ltree[n].Freq != 0))
+            return Z_BINARY;
+
+    /* Check for textual ("allow-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 "block-listed" or "allow-listed" bytes:
+     * this stream either is empty or has tolerated ("gray-listed") bytes only.
+     */
+    return Z_BINARY;
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and write out the encoded block.
+ */
+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 %lu, stat %lu", s->opt_len,
+                s->static_len));
+
+        build_tree(s, (tree_desc *)(&(s->d_desc)));
+        Tracev((stderr, "\ndist data: dyn %lu, stat %lu", 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->sym_next / 3));
+
+#ifndef FORCE_STATIC
+        if (static_lenb <= opt_lenb || s->strategy == Z_FIXED)
+#endif
+            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);
+
+    } else if (static_lenb == opt_lenb) {
+        send_bits(s, (STATIC_TREES<<1) + last, 3);
+        compress_block(s, (const ct_data *)static_ltree,
+                       (const ct_data *)static_dtree);
+#ifdef ZLIB_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 ZLIB_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 ZLIB_DEBUG
+        s->compressed_len += 7;  /* align on byte boundary */
+#endif
+    }
+    Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len >> 3,
+           s->compressed_len - 7*(ulg)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) {
+#ifdef LIT_MEM
+    s->d_buf[s->sym_next] = (ush)dist;
+    s->l_buf[s->sym_next++] = (uch)lc;
+#else
+    s->sym_buf[s->sym_next++] = (uch)dist;
+    s->sym_buf[s->sym_next++] = (uch)(dist >> 8);
+    s->sym_buf[s->sym_next++] = (uch)lc;
+#endif
+    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++;
+    }
+    return (s->sym_next == s->sym_end);
+}
diff --git a/Minecraft.Client/Common/zlib/zlib.h b/Minecraft.Client/Common/zlib/zlib.h
index 398a431a..0a9e7909 100644
--- a/Minecraft.Client/Common/zlib/zlib.h
+++ b/Minecraft.Client/Common/zlib/zlib.h
@@ -1,2057 +1,2057 @@
-/* zlib.h -- interface of the 'zlib' general purpose compression library

-  version 1.3.2.1, February xxth, 2026

-

-  Copyright (C) 1995-2026 Jean-loup Gailly and Mark Adler

-

-  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.

-

-  Jean-loup Gailly        Mark Adler

-  jloup@gzip.org          madler@alumni.caltech.edu

-

-

-  The data format used by the zlib library is described by RFCs (Request for

-  Comments) 1950 to 1952 at https://datatracker.ietf.org/doc/html/rfc1950

-  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).

-*/

-

-#ifndef ZLIB_H

-#define ZLIB_H

-

-#ifdef ZLIB_BUILD

-#  include <zconf.h>

-#else

-# include "zconf.h"

-#endif

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-#define ZLIB_VERSION "1.3.2.1-motley"

-#define ZLIB_VERNUM 0x1321

-#define ZLIB_VER_MAJOR 1

-#define ZLIB_VER_MINOR 3

-#define ZLIB_VER_REVISION 2

-#define ZLIB_VER_SUBREVISION 1

-

-/*

-    The 'zlib' compression library provides in-memory compression and

-  decompression functions, including integrity checks of the uncompressed data.

-  This version of the library supports only one compression method (deflation)

-  but other algorithms will be added later and will have the same stream

-  interface.

-

-    Compression can be done in a single step if the buffers are large enough,

-  or can be done by repeated calls of the compression function.  In the latter

-  case, the application must provide more input and/or consume the output

-  (providing more output space) before each call.

-

-    The compressed data format used by default by the in-memory functions is

-  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped

-  around a deflate stream, which is itself documented in RFC 1951.

-

-    The library also supports reading and writing files in gzip (.gz) format

-  with an interface similar to that of stdio using the functions that start

-  with "gz".  The gzip format is different from the zlib format.  gzip is a

-  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.

-

-    This library can optionally read and write gzip and raw deflate streams in

-  memory as well.

-

-    The zlib format was designed to be compact and fast for use in memory

-  and on communications channels.  The gzip format was designed for single-

-  file compression on file systems, has a larger header than zlib to maintain

-  directory information, and uses a different, slower check method than zlib.

-

-    The library does not install any signal handler.  The decoder checks

-  the consistency of the compressed data, so the library should never crash

-  even in the case of corrupted input.

-*/

-

-typedef voidpf (*alloc_func)(voidpf opaque, uInt items, uInt size);

-typedef void   (*free_func)(voidpf opaque, voidpf address);

-

-struct internal_state;

-

-typedef struct z_stream_s {

-    z_const Bytef *next_in;     /* next input byte */

-    uInt     avail_in;  /* number of bytes available at next_in */

-    uLong    total_in;  /* total number of input bytes read so far */

-

-    Bytef    *next_out; /* next output byte will go here */

-    uInt     avail_out; /* remaining free space at next_out */

-    uLong    total_out; /* total number of bytes output so far */

-

-    z_const char *msg;  /* last error message, NULL if no error */

-    struct internal_state FAR *state; /* not visible by applications */

-

-    alloc_func zalloc;  /* used to allocate the internal state */

-    free_func  zfree;   /* used to free the internal state */

-    voidpf     opaque;  /* private data object passed to zalloc and zfree */

-

-    int     data_type;  /* best guess about the data type: binary or text

-                           for deflate, or the decoding state for inflate */

-    uLong   adler;      /* Adler-32 or CRC-32 value of the uncompressed data */

-    uLong   reserved;   /* reserved for future use */

-} z_stream;

-

-typedef z_stream FAR *z_streamp;

-

-/*

-     gzip header information passed to and from zlib routines.  See RFC 1952

-  for more details on the meanings of these fields.

-*/

-typedef struct gz_header_s {

-    int     text;       /* true if compressed data believed to be text */

-    uLong   time;       /* modification time */

-    int     xflags;     /* extra flags (not used when writing a gzip file) */

-    int     os;         /* operating system */

-    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */

-    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */

-    uInt    extra_max;  /* space at extra (only when reading header) */

-    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */

-    uInt    name_max;   /* space at name (only when reading header) */

-    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */

-    uInt    comm_max;   /* space at comment (only when reading header) */

-    int     hcrc;       /* true if there was or will be a header crc */

-    int     done;       /* true when done reading gzip header (not used

-                           when writing a gzip file) */

-} gz_header;

-

-typedef gz_header FAR *gz_headerp;

-

-/*

-     The application must update next_in and avail_in when avail_in has dropped

-   to zero.  It must update next_out and avail_out when avail_out has dropped

-   to zero.  The application must initialize zalloc, zfree and opaque before

-   calling the init function.  All other fields are set by the compression

-   library and must not be updated by the application.

-

-     The opaque value provided by the application will be passed as the first

-   parameter for calls of zalloc and zfree.  This can be useful for custom

-   memory management.  The compression library attaches no meaning to the

-   opaque value.

-

-     zalloc must return Z_NULL if there is not enough memory for the object.

-   If zlib is used in a multi-threaded application, zalloc and zfree must be

-   thread safe.  In that case, zlib is thread-safe.  When zalloc and zfree are

-   Z_NULL on entry to the initialization function, they are set to internal

-   routines that use the standard library functions malloc() and free().

-

-     On 16-bit systems, the functions zalloc and zfree must be able to allocate

-   exactly 65536 bytes, but will not be required to allocate more than this if

-   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers

-   returned by zalloc for objects of exactly 65536 bytes *must* have their

-   offset normalized to zero.  The default allocation function provided by this

-   library ensures this (see zutil.c).  To reduce memory requirements and avoid

-   any allocation of 64K objects, at the expense of compression ratio, compile

-   the library with -DMAX_WBITS=14 (see zconf.h).

-

-     The fields total_in and total_out can be used for statistics or progress

-   reports.  After compression, total_in holds the total size of the

-   uncompressed data and may be saved for use by the decompressor (particularly

-   if the decompressor wants to decompress everything in a single step).

-*/

-

-                        /* constants */

-

-#define Z_NO_FLUSH      0

-#define Z_PARTIAL_FLUSH 1

-#define Z_SYNC_FLUSH    2

-#define Z_FULL_FLUSH    3

-#define Z_FINISH        4

-#define Z_BLOCK         5

-#define Z_TREES         6

-/* Allowed flush values; see deflate() and inflate() below for details */

-

-#define Z_OK            0

-#define Z_STREAM_END    1

-#define Z_NEED_DICT     2

-#define Z_ERRNO        (-1)

-#define Z_STREAM_ERROR (-2)

-#define Z_DATA_ERROR   (-3)

-#define Z_MEM_ERROR    (-4)

-#define Z_BUF_ERROR    (-5)

-#define Z_VERSION_ERROR (-6)

-/* Return codes for the compression/decompression functions. Negative values

- * are errors, positive values are used for special but normal events.

- */

-

-#define Z_NO_COMPRESSION         0

-#define Z_BEST_SPEED             1

-#define Z_BEST_COMPRESSION       9

-#define Z_DEFAULT_COMPRESSION  (-1)

-/* compression levels */

-

-#define Z_FILTERED            1

-#define Z_HUFFMAN_ONLY        2

-#define Z_RLE                 3

-#define Z_FIXED               4

-#define Z_DEFAULT_STRATEGY    0

-/* compression strategy; see deflateInit2() below for details */

-

-#define Z_BINARY   0

-#define Z_TEXT     1

-#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */

-#define Z_UNKNOWN  2

-/* Possible values of the data_type field for deflate() */

-

-#define Z_DEFLATED   8

-/* The deflate compression method (the only one supported in this version) */

-

-#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */

-

-#define zlib_version zlibVersion()

-/* for compatibility with versions < 1.0.2 */

-

-

-                        /* basic functions */

-

-ZEXTERN const char * ZEXPORT zlibVersion(void);

-/* The application can compare zlibVersion and ZLIB_VERSION for consistency.

-   If the first character differs, the library code actually used is not

-   compatible with the zlib.h header file used by the application.  This check

-   is automatically made by deflateInit and inflateInit.

- */

-

-/*

-ZEXTERN int ZEXPORT deflateInit(z_streamp strm, int level);

-

-     Initializes the internal stream state for compression.  The fields

-   zalloc, zfree and opaque must be initialized before by the caller.  If

-   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default

-   allocation functions.  total_in, total_out, adler, and msg are initialized.

-

-     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:

-   1 gives best speed, 9 gives best compression, 0 gives no compression at all

-   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION

-   requests a default compromise between speed and compression (currently

-   equivalent to level 6).

-

-     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough

-   memory, Z_STREAM_ERROR if level is not a valid compression level, or

-   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible

-   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null

-   if there is no error message.  deflateInit does not perform any compression:

-   this will be done by deflate().

-*/

-

-

-ZEXTERN int ZEXPORT deflate(z_streamp strm, int flush);

-/*

-    deflate compresses as much data as possible, and stops when the input

-  buffer becomes empty or the output buffer becomes full.  It may introduce

-  some output latency (reading input without producing any output) except when

-  forced to flush.

-

-    The detailed semantics are as follows.  deflate performs one or both of the

-  following actions:

-

-  - Compress more input starting at next_in and update next_in and avail_in

-    accordingly.  If not all input can be processed (because there is not

-    enough room in the output buffer), next_in and avail_in are updated and

-    processing will resume at this point for the next call of deflate().

-

-  - Generate more output starting at next_out and update next_out and avail_out

-    accordingly.  This action is forced if the parameter flush is non zero.

-    Forcing flush frequently degrades the compression ratio, so this parameter

-    should be set only when necessary.  Some output may be provided even if

-    flush is zero.

-

-    Before the call of deflate(), the application should ensure that at least

-  one of the actions is possible, by providing more input and/or consuming more

-  output, and updating avail_in or avail_out accordingly; avail_out should

-  never be zero before the call.  The application can consume the compressed

-  output when it wants, for example when the output buffer is full (avail_out

-  == 0), or after each call of deflate().  If deflate returns Z_OK and with

-  zero avail_out, it must be called again after making room in the output

-  buffer because there might be more output pending. See deflatePending(),

-  which can be used if desired to determine whether or not there is more output

-  in that case.

-

-    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to

-  decide how much data to accumulate before producing output, in order to

-  maximize compression.

-

-    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is

-  flushed to the output buffer and the output is aligned on a byte boundary, so

-  that the decompressor can get all input data available so far.  (In

-  particular avail_in is zero after the call if enough output space has been

-  provided before the call.) Flushing may degrade compression for some

-  compression algorithms and so it should be used only when necessary.  This

-  completes the current deflate block and follows it with an empty stored block

-  that is three bits plus filler bits to the next byte, followed by four bytes

-  (00 00 ff ff).

-

-    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the

-  output buffer, but the output is not aligned to a byte boundary.  All of the

-  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.

-  This completes the current deflate block and follows it with an empty fixed

-  codes block that is 10 bits long.  This assures that enough bytes are output

-  in order for the decompressor to finish the block before the empty fixed

-  codes block.

-

-    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as

-  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to

-  seven bits of the current block are held to be written as the next byte after

-  the next deflate block is completed.  In this case, the decompressor may not

-  be provided enough bits at this point in order to complete decompression of

-  the data provided so far to the compressor.  It may need to wait for the next

-  block to be emitted.  This is for advanced applications that need to control

-  the emission of deflate blocks.

-

-    If flush is set to Z_FULL_FLUSH, all output is flushed as with

-  Z_SYNC_FLUSH, and the compression state is reset so that decompression can

-  restart from this point if previous compressed data has been damaged or if

-  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade

-  compression.

-

-    If deflate returns with avail_out == 0, this function must be called again

-  with the same value of the flush parameter and more output space (updated

-  avail_out), until the flush is complete (deflate returns with non-zero

-  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that

-  avail_out is greater than six when the flush marker begins, in order to avoid

-  repeated flush markers upon calling deflate() again when avail_out == 0.

-

-    If the parameter flush is set to Z_FINISH, pending input is processed,

-  pending output is flushed and deflate returns with Z_STREAM_END if there was

-  enough output space.  If deflate returns with Z_OK or Z_BUF_ERROR, this

-  function must be called again with Z_FINISH and more output space (updated

-  avail_out) but no more input data, until it returns with Z_STREAM_END or an

-  error.  After deflate has returned Z_STREAM_END, the only possible operations

-  on the stream are deflateReset or deflateEnd.

-

-    Z_FINISH can be used in the first deflate call after deflateInit if all the

-  compression is to be done in a single step.  In order to complete in one

-  call, avail_out must be at least the value returned by deflateBound (see

-  below).  Then deflate is guaranteed to return Z_STREAM_END.  If not enough

-  output space is provided, deflate will not return Z_STREAM_END, and it must

-  be called again as described above.

-

-    deflate() sets strm->adler to the Adler-32 checksum of all input read

-  so far (that is, total_in bytes).  If a gzip stream is being generated, then

-  strm->adler will be the CRC-32 checksum of the input read so far.  (See

-  deflateInit2 below.)

-

-    deflate() may update strm->data_type if it can make a good guess about

-  the input data type (Z_BINARY or Z_TEXT).  If in doubt, the data is

-  considered binary.  This field is only for information purposes and does not

-  affect the compression algorithm in any manner.

-

-    deflate() returns Z_OK if some progress has been made (more input

-  processed or more output produced), Z_STREAM_END if all input has been

-  consumed and all output has been produced (only when flush is set to

-  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example

-  if next_in or next_out was Z_NULL or the state was inadvertently written over

-  by the application), or Z_BUF_ERROR if no progress is possible (for example

-  avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not fatal, and

-  deflate() can be called again with more input and more output space to

-  continue compressing.

-*/

-

-

-ZEXTERN int ZEXPORT deflateEnd(z_streamp strm);

-/*

-     All dynamically allocated data structures for this stream are freed.

-   This function discards any unprocessed input and does not flush any pending

-   output.

-

-     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the

-   stream state was inconsistent, Z_DATA_ERROR if the stream was freed

-   prematurely (some input or output was discarded).  In the error case, msg

-   may be set but then points to a static string (which must not be

-   deallocated).

-*/

-

-

-/*

-ZEXTERN int ZEXPORT inflateInit(z_streamp strm);

-

-     Initializes the internal stream state for decompression.  The fields

-   next_in, avail_in, zalloc, zfree and opaque must be initialized before by

-   the caller.  In the current version of inflate, the provided input is not

-   read or consumed.  The allocation of a sliding window will be deferred to

-   the first call of inflate (if the decompression does not complete on the

-   first call).  If zalloc and zfree are set to Z_NULL, inflateInit updates

-   them to use default allocation functions.  total_in, total_out, adler, and

-   msg are initialized.

-

-     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough

-   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the

-   version assumed by the caller, or Z_STREAM_ERROR if the parameters are

-   invalid, such as a null pointer to the structure.  msg is set to null if

-   there is no error message.  inflateInit does not perform any decompression.

-   Actual decompression will be done by inflate().  So next_in, and avail_in,

-   next_out, and avail_out are unused and unchanged.  The current

-   implementation of inflateInit() does not process any header information --

-   that is deferred until inflate() is called.

-*/

-

-

-ZEXTERN int ZEXPORT inflate(z_streamp strm, int flush);

-/*

-    inflate decompresses as much data as possible, and stops when the input

-  buffer becomes empty or the output buffer becomes full.  It may introduce

-  some output latency (reading input without producing any output) except when

-  forced to flush.

-

-  The detailed semantics are as follows.  inflate performs one or both of the

-  following actions:

-

-  - Decompress more input starting at next_in and update next_in and avail_in

-    accordingly.  If not all input can be processed (because there is not

-    enough room in the output buffer), then next_in and avail_in are updated

-    accordingly, and processing will resume at this point for the next call of

-    inflate().

-

-  - Generate more output starting at next_out and update next_out and avail_out

-    accordingly.  inflate() provides as much output as possible, until there is

-    no more input data or no more space in the output buffer (see below about

-    the flush parameter).

-

-    Before the call of inflate(), the application should ensure that at least

-  one of the actions is possible, by providing more input and/or consuming more

-  output, and updating the next_* and avail_* values accordingly.  If the

-  caller of inflate() does not provide both available input and available

-  output space, it is possible that there will be no progress made.  The

-  application can consume the uncompressed output when it wants, for example

-  when the output buffer is full (avail_out == 0), or after each call of

-  inflate().  If inflate returns Z_OK and with zero avail_out, it must be

-  called again after making room in the output buffer because there might be

-  more output pending.

-

-    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,

-  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much

-  output as possible to the output buffer.  Z_BLOCK requests that inflate()

-  stop if and when it gets to the next deflate block boundary.  When decoding

-  the zlib or gzip format, this will cause inflate() to return immediately

-  after the header and before the first block.  When doing a raw inflate,

-  inflate() will go ahead and process the first block, and will return when it

-  gets to the end of that block, or when it runs out of data.

-

-    The Z_BLOCK option assists in appending to or combining deflate streams.

-  To assist in this, on return inflate() always sets strm->data_type to the

-  number of unused bits in the input taken from strm->next_in, plus 64 if

-  inflate() is currently decoding the last block in the deflate stream, plus

-  128 if inflate() returned immediately after decoding an end-of-block code or

-  decoding the complete header up to just before the first byte of the deflate

-  stream.  The end-of-block will not be indicated until all of the uncompressed

-  data from that block has been written to strm->next_out.  The number of

-  unused bits may in general be greater than seven, except when bit 7 of

-  data_type is set, in which case the number of unused bits will be less than

-  eight.  data_type is set as noted here every time inflate() returns for all

-  flush options, and so can be used to determine the amount of currently

-  consumed input in bits.

-

-    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the

-  end of each deflate block header is reached, before any actual data in that

-  block is decoded.  This allows the caller to determine the length of the

-  deflate block header for later use in random access within a deflate block.

-  256 is added to the value of strm->data_type when inflate() returns

-  immediately after reaching the end of the deflate block header.

-

-    inflate() should normally be called until it returns Z_STREAM_END or an

-  error.  However if all decompression is to be performed in a single step (a

-  single call of inflate), the parameter flush should be set to Z_FINISH.  In

-  this case all pending input is processed and all pending output is flushed;

-  avail_out must be large enough to hold all of the uncompressed data for the

-  operation to complete.  (The size of the uncompressed data may have been

-  saved by the compressor for this purpose.)  The use of Z_FINISH is not

-  required to perform an inflation in one step.  However it may be used to

-  inform inflate that a faster approach can be used for the single inflate()

-  call.  Z_FINISH also informs inflate to not maintain a sliding window if the

-  stream completes, which reduces inflate's memory footprint.  If the stream

-  does not complete, either because not all of the stream is provided or not

-  enough output space is provided, then a sliding window will be allocated and

-  inflate() can be called again to continue the operation as if Z_NO_FLUSH had

-  been used.

-

-     In this implementation, inflate() always flushes as much output as

-  possible to the output buffer, and always uses the faster approach on the

-  first call.  So the effects of the flush parameter in this implementation are

-  on the return value of inflate() as noted below, when inflate() returns early

-  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of

-  memory for a sliding window when Z_FINISH is used.

-

-     If a preset dictionary is needed after this call (see inflateSetDictionary

-  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary

-  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets

-  strm->adler to the Adler-32 checksum of all output produced so far (that is,

-  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described

-  below.  At the end of the stream, inflate() checks that its computed Adler-32

-  checksum is equal to that saved by the compressor and returns Z_STREAM_END

-  only if the checksum is correct.

-

-    inflate() can decompress and check either zlib-wrapped or gzip-wrapped

-  deflate data.  The header type is detected automatically, if requested when

-  initializing with inflateInit2().  Any information contained in the gzip

-  header is not retained unless inflateGetHeader() is used.  When processing

-  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output

-  produced so far.  The CRC-32 is checked against the gzip trailer, as is the

-  uncompressed length, modulo 2^32.

-

-    inflate() returns Z_OK if some progress has been made (more input processed

-  or more output produced), Z_STREAM_END if the end of the compressed data has

-  been reached and all uncompressed output has been produced, Z_NEED_DICT if a

-  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was

-  corrupted (input stream not conforming to the zlib format or incorrect check

-  value, in which case strm->msg points to a string with a more specific

-  error), Z_STREAM_ERROR if the stream structure was inconsistent (for example

-  next_in or next_out was Z_NULL, or the state was inadvertently written over

-  by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR

-  if no progress was possible or if there was not enough room in the output

-  buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and

-  inflate() can be called again with more input and more output space to

-  continue decompressing.  If Z_DATA_ERROR is returned, the application may

-  then call inflateSync() to look for a good compression block if a partial

-  recovery of the data is to be attempted.

-*/

-

-

-ZEXTERN int ZEXPORT inflateEnd(z_streamp strm);

-/*

-     All dynamically allocated data structures for this stream are freed.

-   This function discards any unprocessed input and does not flush any pending

-   output.

-

-     inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state

-   was inconsistent.

-*/

-

-

-                        /* Advanced functions */

-

-/*

-    The following functions are needed only in some special applications.

-*/

-

-/*

-ZEXTERN int ZEXPORT deflateInit2(z_streamp strm,

-                                 int level,

-                                 int method,

-                                 int windowBits,

-                                 int memLevel,

-                                 int strategy);

-

-     This is another version of deflateInit with more compression options.  The

-   fields zalloc, zfree and opaque must be initialized before by the caller.

-

-     The method parameter is the compression method.  It must be Z_DEFLATED in

-   this version of the library.

-

-     The windowBits parameter is the base two logarithm of the window size

-   (the size of the history buffer).  It should be in the range 8..15 for this

-   version of the library.  Larger values of this parameter result in better

-   compression at the expense of memory usage.  The default value is 15 if

-   deflateInit is used instead.

-

-     For the current implementation of deflate(), a windowBits value of 8 (a

-   window size of 256 bytes) is not supported.  As a result, a request for 8

-   will result in 9 (a 512-byte window).  In that case, providing 8 to

-   inflateInit2() will result in an error when the zlib header with 9 is

-   checked against the initialization of inflate().  The remedy is to not use 8

-   with deflateInit2() with this initialization, or at least in that case use 9

-   with inflateInit2().

-

-     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits

-   determines the window size.  deflate() will then generate raw deflate data

-   with no zlib header or trailer, and will not compute a check value.

-

-     windowBits can also be greater than 15 for optional gzip encoding.  Add

-   16 to windowBits to write a simple gzip header and trailer around the

-   compressed data instead of a zlib wrapper.  The gzip header will have no

-   file name, no extra data, no comment, no modification time (set to zero), no

-   header crc, and the operating system will be set to the appropriate value,

-   if the operating system was determined at compile time.  If a gzip stream is

-   being written, strm->adler is a CRC-32 instead of an Adler-32.

-

-     For raw deflate or gzip encoding, a request for a 256-byte window is

-   rejected as invalid, since only the zlib header provides a means of

-   transmitting the window size to the decompressor.

-

-     The memLevel parameter specifies how much memory should be allocated

-   for the internal compression state.  memLevel=1 uses minimum memory but is

-   slow and reduces compression ratio; memLevel=9 uses maximum memory for

-   optimal speed.  The default value is 8.  See zconf.h for total memory usage

-   as a function of windowBits and memLevel.

-

-     The strategy parameter is used to tune the compression algorithm.  Use the

-   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a

-   filter (or predictor), Z_RLE to limit match distances to one (run-length

-   encoding), or Z_HUFFMAN_ONLY to force Huffman encoding only (no string

-   matching).  Filtered data consists mostly of small values with a somewhat

-   random distribution, as produced by the PNG filters.  In this case, the

-   compression algorithm is tuned to compress them better.  The effect of

-   Z_FILTERED is to force more Huffman coding and less string matching than the

-   default; it is intermediate between Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.

-   Z_RLE is almost as fast as Z_HUFFMAN_ONLY, but should give better

-   compression for PNG image data than Huffman only.  The degree of string

-   matching from most to none is: Z_DEFAULT_STRATEGY, Z_FILTERED, Z_RLE, then

-   Z_HUFFMAN_ONLY. The strategy parameter affects the compression ratio but

-   never the correctness of the compressed output, even if it is not set

-   optimally for the given data.  Z_FIXED uses the default string matching, but

-   prevents the use of dynamic Huffman codes, allowing for a simpler decoder

-   for special applications.

-

-     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough

-   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid

-   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is

-   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is

-   set to null if there is no error message.  deflateInit2 does not perform any

-   compression: this will be done by deflate().

-*/

-

-ZEXTERN int ZEXPORT deflateSetDictionary(z_streamp strm,

-                                         const Bytef *dictionary,

-                                         uInt  dictLength);

-/*

-     Initializes the compression dictionary from the given byte sequence

-   without producing any compressed output.  When using the zlib format, this

-   function must be called immediately after deflateInit, deflateInit2 or

-   deflateReset, and before any call of deflate.  When doing raw deflate, this

-   function must be called either before any call of deflate, or immediately

-   after the completion of a deflate block, i.e. after all input has been

-   consumed and all output has been delivered when using any of the flush

-   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The

-   compressor and decompressor must use exactly the same dictionary (see

-   inflateSetDictionary).

-

-     The dictionary should consist of strings (byte sequences) that are likely

-   to be encountered later in the data to be compressed, with the most commonly

-   used strings preferably put towards the end of the dictionary.  Using a

-   dictionary is most useful when the data to be compressed is short and can be

-   predicted with good accuracy; the data can then be compressed better than

-   with the default empty dictionary.

-

-     Depending on the size of the compression data structures selected by

-   deflateInit or deflateInit2, a part of the dictionary may in effect be

-   discarded, for example if the dictionary is larger than the window size

-   provided in deflateInit or deflateInit2.  Thus the strings most likely to be

-   useful should be put at the end of the dictionary, not at the front.  In

-   addition, the current implementation of deflate will use at most the window

-   size minus 262 bytes of the provided dictionary.

-

-     Upon return of this function, strm->adler is set to the Adler-32 value

-   of the dictionary; the decompressor may later use this value to determine

-   which dictionary has been used by the compressor.  (The Adler-32 value

-   applies to the whole dictionary even if only a subset of the dictionary is

-   actually used by the compressor.) If a raw deflate was requested, then the

-   Adler-32 value is not computed and strm->adler is not set.

-

-     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a

-   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is

-   inconsistent (for example if deflate has already been called for this stream

-   or if not at a block boundary for raw deflate).  deflateSetDictionary does

-   not perform any compression: this will be done by deflate().

-*/

-

-ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm,

-                                         Bytef *dictionary,

-                                         uInt  *dictLength);

-/*

-     Returns the sliding dictionary being maintained by deflate.  dictLength is

-   set to the number of bytes in the dictionary, and that many bytes are copied

-   to dictionary.  dictionary must have enough space, where 32768 bytes is

-   always enough.  If deflateGetDictionary() is called with dictionary equal to

-   Z_NULL, then only the dictionary length is returned, and nothing is copied.

-   Similarly, if dictLength is Z_NULL, then it is not set.

-

-     deflateGetDictionary() may return a length less than the window size, even

-   when more than the window size in input has been provided. It may return up

-   to 258 bytes less in that case, due to how zlib's implementation of deflate

-   manages the sliding window and lookahead for matches, where matches can be

-   up to 258 bytes long. If the application needs the last window-size bytes of

-   input, then that would need to be saved by the application outside of zlib.

-

-     deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the

-   stream state is inconsistent.

-*/

-

-ZEXTERN int ZEXPORT deflateCopy(z_streamp dest,

-                                z_streamp source);

-/*

-     Sets the destination stream as a complete copy of the source stream.

-

-     This function can be useful when several compression strategies will be

-   tried, for example when there are several ways of pre-processing the input

-   data with a filter.  The streams that will be discarded should then be freed

-   by calling deflateEnd.  Note that deflateCopy duplicates the internal

-   compression state which can be quite large, so this strategy is slow and can

-   consume lots of memory.

-

-     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not

-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent

-   (such as zalloc being Z_NULL).  msg is left unchanged in both source and

-   destination.

-*/

-

-ZEXTERN int ZEXPORT deflateReset(z_streamp strm);

-/*

-     This function is equivalent to deflateEnd followed by deflateInit, but

-   does not free and reallocate the internal compression state.  The stream

-   will leave the compression level and any other attributes that may have been

-   set unchanged.  total_in, total_out, adler, and msg are initialized.

-

-     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent (such as zalloc or state being Z_NULL).

-*/

-

-ZEXTERN int ZEXPORT deflateParams(z_streamp strm,

-                                  int level,

-                                  int strategy);

-/*

-     Dynamically update the compression level and compression strategy.  The

-   interpretation of level and strategy is as in deflateInit2().  This can be

-   used to switch between compression and straight copy of the input data, or

-   to switch to a different kind of input data requiring a different strategy.

-   If the compression approach (which is a function of the level) or the

-   strategy is changed, and if there have been any deflate() calls since the

-   state was initialized or reset, then the input available so far is

-   compressed with the old level and strategy using deflate(strm, Z_BLOCK).

-   There are three approaches for the compression levels 0, 1..3, and 4..9

-   respectively.  The new level and strategy will take effect at the next call

-   of deflate().

-

-     If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does

-   not have enough output space to complete, then the parameter change will not

-   take effect.  In this case, deflateParams() can be called again with the

-   same parameters and more output space to try again.

-

-     In order to assure a change in the parameters on the first try, the

-   deflate stream should be flushed using deflate() with Z_BLOCK or other flush

-   request until strm.avail_out is not zero, before calling deflateParams().

-   Then no more input data should be provided before the deflateParams() call.

-   If this is done, the old level and strategy will be applied to the data

-   compressed before deflateParams(), and the new level and strategy will be

-   applied to the data compressed after deflateParams().

-

-     deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream

-   state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if

-   there was not enough output space to complete the compression of the

-   available input data before a change in the strategy or approach.  Note that

-   in the case of a Z_BUF_ERROR, the parameters are not changed.  A return

-   value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be

-   retried with more output space.

-*/

-

-ZEXTERN int ZEXPORT deflateTune(z_streamp strm,

-                                int good_length,

-                                int max_lazy,

-                                int nice_length,

-                                int max_chain);

-/*

-     Fine tune deflate's internal compression parameters.  This should only be

-   used by someone who understands the algorithm used by zlib's deflate for

-   searching for the best matching string, and even then only by the most

-   fanatic optimizer trying to squeeze out the last compressed bit for their

-   specific input data.  Read the deflate.c source code for the meaning of the

-   max_lazy, good_length, nice_length, and max_chain parameters.

-

-     deflateTune() can be called after deflateInit() or deflateInit2(), and

-   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.

- */

-

-ZEXTERN uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen);

-ZEXTERN z_size_t ZEXPORT deflateBound_z(z_streamp strm, z_size_t sourceLen);

-/*

-     deflateBound() returns an upper bound on the compressed size after

-   deflation of sourceLen bytes.  It must be called after deflateInit() or

-   deflateInit2(), and after deflateSetHeader(), if used.  This would be used

-   to allocate an output buffer for deflation in a single pass, and so would be

-   called before deflate().  If that first deflate() call is provided the

-   sourceLen input bytes, an output buffer allocated to the size returned by

-   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed

-   to return Z_STREAM_END.  Note that it is possible for the compressed size to

-   be larger than the value returned by deflateBound() if flush options other

-   than Z_FINISH or Z_NO_FLUSH are used.

-

-     delfateBound_z() is the same, but takes and returns a size_t length.  Note

-   that a long is 32 bits on Windows.

-*/

-

-ZEXTERN int ZEXPORT deflatePending(z_streamp strm,

-                                   unsigned *pending,

-                                   int *bits);

-/*

-     deflatePending() returns the number of bytes and bits of output that have

-   been generated, but not yet provided in the available output.  The bytes not

-   provided would be due to the available output space having being consumed.

-   The number of bits of output not provided are between 0 and 7, where they

-   await more bits to join them in order to fill out a full byte.  If pending

-   or bits are Z_NULL, then those values are not set.

-

-     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent.  If an int is 16 bits and memLevel is 9, then

-   it is possible for the number of pending bytes to not fit in an unsigned. In

-   that case Z_BUF_ERROR is returned and *pending is set to the maximum value

-   of an unsigned.

- */

-

-ZEXTERN int ZEXPORT deflateUsed(z_streamp strm,

-                                int *bits);

-/*

-     deflateUsed() returns in *bits the most recent number of deflate bits used

-   in the last byte when flushing to a byte boundary. The result is in 1..8, or

-   0 if there has not yet been a flush. This helps determine the location of

-   the last bit of a deflate stream.

-

-     deflateUsed returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent.

- */

-

-ZEXTERN int ZEXPORT deflatePrime(z_streamp strm,

-                                 int bits,

-                                 int value);

-/*

-     deflatePrime() inserts bits in the deflate output stream.  The intent

-   is that this function is used to start off the deflate output with the bits

-   leftover from a previous deflate stream when appending to it.  As such, this

-   function can only be used for raw deflate, and must be used before the first

-   deflate() call after a deflateInit2() or deflateReset().  bits must be less

-   than or equal to 16, and that many of the least significant bits of value

-   will be inserted in the output.

-

-     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough

-   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the

-   source stream state was inconsistent.

-*/

-

-ZEXTERN int ZEXPORT deflateSetHeader(z_streamp strm,

-                                     gz_headerp head);

-/*

-     deflateSetHeader() provides gzip header information for when a gzip

-   stream is requested by deflateInit2().  deflateSetHeader() may be called

-   after deflateInit2() or deflateReset() and before the first call of

-   deflate().  The text, time, os, extra field, name, and comment information

-   in the provided gz_header structure are written to the gzip header (xflag is

-   ignored -- the extra flags are set according to the compression level).  The

-   caller must assure that, if not Z_NULL, name and comment are terminated with

-   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are

-   available there.  If hcrc is true, a gzip header crc is included.  Note that

-   the current versions of the command-line version of gzip (up through version

-   1.3.x) do not support header crc's, and will report that it is a "multi-part

-   gzip file" and give up.

-

-     If deflateSetHeader is not used, the default gzip header has text false,

-   the time set to zero, and os set to the current operating system, with no

-   extra, name, or comment fields.  The gzip header is returned to the default

-   state by deflateReset().

-

-     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent.

-*/

-

-/*

-ZEXTERN int ZEXPORT inflateInit2(z_streamp strm,

-                                 int windowBits);

-

-     This is another version of inflateInit with an extra parameter.  The

-   fields next_in, avail_in, zalloc, zfree and opaque must be initialized

-   before by the caller.

-

-     The windowBits parameter is the base two logarithm of the maximum window

-   size (the size of the history buffer).  It should be in the range 8..15 for

-   this version of the library.  The default value is 15 if inflateInit is used

-   instead.  windowBits must be greater than or equal to the windowBits value

-   provided to deflateInit2() while compressing, or it must be equal to 15 if

-   deflateInit2() was not used.  If a compressed stream with a larger window

-   size is given as input, inflate() will return with the error code

-   Z_DATA_ERROR instead of trying to allocate a larger window.

-

-     windowBits can also be zero to request that inflate use the window size in

-   the zlib header of the compressed stream.

-

-     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits

-   determines the window size.  inflate() will then process raw deflate data,

-   not looking for a zlib or gzip header, not generating a check value, and not

-   looking for any check values for comparison at the end of the stream.  This

-   is for use with other formats that use the deflate compressed data format

-   such as zip.  Those formats provide their own check values.  If a custom

-   format is developed using the raw deflate format for compressed data, it is

-   recommended that a check value such as an Adler-32 or a CRC-32 be applied to

-   the uncompressed data as is done in the zlib, gzip, and zip formats.  For

-   most applications, the zlib format should be used as is.  Note that comments

-   above on the use in deflateInit2() applies to the magnitude of windowBits.

-

-     windowBits can also be greater than 15 for optional gzip decoding.  Add

-   32 to windowBits to enable zlib and gzip decoding with automatic header

-   detection, or add 16 to decode only the gzip format (the zlib format will

-   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a

-   CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see

-   below), inflate() will *not* automatically decode concatenated gzip members.

-   inflate() will return Z_STREAM_END at the end of the gzip member.  The state

-   would need to be reset to continue decoding a subsequent gzip member.  This

-   *must* be done if there is more data after a gzip member, in order for the

-   decompression to be compliant with the gzip standard (RFC 1952).

-

-     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough

-   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the

-   version assumed by the caller, or Z_STREAM_ERROR if the parameters are

-   invalid, such as a null pointer to the structure.  msg is set to null if

-   there is no error message.  inflateInit2 does not perform any decompression

-   apart from possibly reading the zlib header if present: actual decompression

-   will be done by inflate().  (So next_in and avail_in may be modified, but

-   next_out and avail_out are unused and unchanged.) The current implementation

-   of inflateInit2() does not process any header information -- that is

-   deferred until inflate() is called.

-*/

-

-ZEXTERN int ZEXPORT inflateSetDictionary(z_streamp strm,

-                                         const Bytef *dictionary,

-                                         uInt  dictLength);

-/*

-     Initializes the decompression dictionary from the given uncompressed byte

-   sequence.  This function must be called immediately after a call of inflate,

-   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor

-   can be determined from the Adler-32 value returned by that call of inflate.

-   The compressor and decompressor must use exactly the same dictionary (see

-   deflateSetDictionary).  For raw inflate, this function can be called at any

-   time to set the dictionary.  If the provided dictionary is smaller than the

-   window and there is already data in the window, then the provided dictionary

-   will amend what's there.  The application must insure that the dictionary

-   that was used for compression is provided.

-

-     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a

-   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is

-   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the

-   expected one (incorrect Adler-32 value).  inflateSetDictionary does not

-   perform any decompression: this will be done by subsequent calls of

-   inflate().

-*/

-

-ZEXTERN int ZEXPORT inflateGetDictionary(z_streamp strm,

-                                         Bytef *dictionary,

-                                         uInt  *dictLength);

-/*

-     Returns the sliding dictionary being maintained by inflate.  dictLength is

-   set to the number of bytes in the dictionary, and that many bytes are copied

-   to dictionary.  dictionary must have enough space, where 32768 bytes is

-   always enough.  If inflateGetDictionary() is called with dictionary equal to

-   Z_NULL, then only the dictionary length is returned, and nothing is copied.

-   Similarly, if dictLength is Z_NULL, then it is not set.

-

-     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the

-   stream state is inconsistent.

-*/

-

-ZEXTERN int ZEXPORT inflateSync(z_streamp strm);

-/*

-     Skips invalid compressed data until a possible full flush point (see above

-   for the description of deflate with Z_FULL_FLUSH) can be found, or until all

-   available input is skipped.  No output is provided.

-

-     inflateSync searches for a 00 00 FF FF pattern in the compressed data.

-   All full flush points have this pattern, but not all occurrences of this

-   pattern are full flush points.

-

-     inflateSync returns Z_OK if a possible full flush point has been found,

-   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point

-   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.

-   In the success case, the application may save the current value of total_in

-   which indicates where valid compressed data was found.  In the error case,

-   the application may repeatedly call inflateSync, providing more input each

-   time, until success or end of the input data.

-*/

-

-ZEXTERN int ZEXPORT inflateCopy(z_streamp dest,

-                                z_streamp source);

-/*

-     Sets the destination stream as a complete copy of the source stream.

-

-     This function can be useful when randomly accessing a large stream.  The

-   first pass through the stream can periodically record the inflate state,

-   allowing restarting inflate at those points when randomly accessing the

-   stream.

-

-     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not

-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent

-   (such as zalloc being Z_NULL).  msg is left unchanged in both source and

-   destination.

-*/

-

-ZEXTERN int ZEXPORT inflateReset(z_streamp strm);

-/*

-     This function is equivalent to inflateEnd followed by inflateInit,

-   but does not free and reallocate the internal decompression state.  The

-   stream will keep attributes that may have been set by inflateInit2.

-   total_in, total_out, adler, and msg are initialized.

-

-     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent (such as zalloc or state being Z_NULL).

-*/

-

-ZEXTERN int ZEXPORT inflateReset2(z_streamp strm,

-                                  int windowBits);

-/*

-     This function is the same as inflateReset, but it also permits changing

-   the wrap and window size requests.  The windowBits parameter is interpreted

-   the same as it is for inflateInit2.  If the window size is changed, then the

-   memory allocated for the window is freed, and the window will be reallocated

-   by inflate() if needed.

-

-     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent (such as zalloc or state being Z_NULL), or if

-   the windowBits parameter is invalid.

-*/

-

-ZEXTERN int ZEXPORT inflatePrime(z_streamp strm,

-                                 int bits,

-                                 int value);

-/*

-     This function inserts bits in the inflate input stream.  The intent is to

-   use inflatePrime() to start inflating at a bit position in the middle of a

-   byte.  The provided bits will be used before any bytes are used from

-   next_in.  This function should be used with raw inflate, before the first

-   inflate() call, after inflateInit2() or inflateReset().  It can also be used

-   after an inflate() return indicates the end of a deflate block or header

-   when using Z_BLOCK.  bits must be less than or equal to 16, and that many of

-   the least significant bits of value will be inserted in the input.  The

-   other bits in value can be non-zero, and will be ignored.

-

-     If bits is negative, then the input stream bit buffer is emptied.  Then

-   inflatePrime() can be called again to put bits in the buffer.  This is used

-   to clear out bits leftover after feeding inflate a block description prior

-   to feeding inflate codes.

-

-     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent, or if bits is out of range.  If inflate was

-   in the middle of processing a header, trailer, or stored block lengths, then

-   it is possible for there to be only eight bits available in the bit buffer.

-   In that case, bits > 8 is considered out of range.  However, when used as

-   outlined above, there will always be 16 bits available in the buffer for

-   insertion.  As noted in its documentation above, inflate records the number

-   of bits in the bit buffer on return in data_type. 32 minus that is the

-   number of bits available for insertion.  inflatePrime does not update

-   data_type with the new number of bits in buffer.

-*/

-

-ZEXTERN long ZEXPORT inflateMark(z_streamp strm);

-/*

-     This function returns two values, one in the lower 16 bits of the return

-   value, and the other in the remaining upper bits, obtained by shifting the

-   return value down 16 bits.  If the upper value is -1 and the lower value is

-   zero, then inflate() is currently decoding information outside of a block.

-   If the upper value is -1 and the lower value is non-zero, then inflate is in

-   the middle of a stored block, with the lower value equaling the number of

-   bytes from the input remaining to copy.  If the upper value is not -1, then

-   it is the number of bits back from the current bit position in the input of

-   the code (literal or length/distance pair) currently being processed.  In

-   that case the lower value is the number of bytes already emitted for that

-   code.

-

-     A code is being processed if inflate is waiting for more input to complete

-   decoding of the code, or if it has completed decoding but is waiting for

-   more output space to write the literal or match data.

-

-     inflateMark() is used to mark locations in the input data for random

-   access, which may be at bit positions, and to note those cases where the

-   output of a code may span boundaries of random access blocks.  The current

-   location in the input stream can be determined from avail_in and data_type

-   as noted in the description for the Z_BLOCK flush parameter for inflate.

-

-     inflateMark returns the value noted above, or -65536 if the provided

-   source stream state was inconsistent.

-*/

-

-ZEXTERN int ZEXPORT inflateGetHeader(z_streamp strm,

-                                     gz_headerp head);

-/*

-     inflateGetHeader() requests that gzip header information be stored in the

-   provided gz_header structure.  inflateGetHeader() may be called after

-   inflateInit2() or inflateReset(), and before the first call of inflate().

-   As inflate() processes the gzip stream, head->done is zero until the header

-   is completed, at which time head->done is set to one.  If a zlib stream is

-   being decoded, then head->done is set to -1 to indicate that there will be

-   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be

-   used to force inflate() to return immediately after header processing is

-   complete and before any actual data is decompressed.

-

-     The text, time, xflags, and os fields are filled in with the gzip header

-   contents.  hcrc is set to true if there is a header CRC.  (The header CRC

-   was valid if done is set to one.)  The extra, name, and comment pointers

-   much each be either Z_NULL or point to space to store that information from

-   the header.  If extra is not Z_NULL, then extra_max contains the maximum

-   number of bytes that can be written to extra.  Once done is true, extra_len

-   contains the actual extra field length, and extra contains the extra field,

-   or that field truncated if extra_max is less than extra_len.  If name is not

-   Z_NULL, then up to name_max characters, including the terminating zero, are

-   written there.  If comment is not Z_NULL, then up to comm_max characters,

-   including the terminating zero, are written there.  The application can tell

-   that the name or comment did not fit in the provided space by the absence of

-   a terminating zero.  If any of extra, name, or comment are not present in

-   the header, then that field's pointer is set to Z_NULL.  This allows the use

-   of deflateSetHeader() with the returned structure to duplicate the header.

-   Note that if those fields initially pointed to allocated memory, then the

-   application will need to save them elsewhere so that they can be eventually

-   freed.

-

-     If inflateGetHeader is not used, then the header information is simply

-   discarded.  The header is always checked for validity, including the header

-   CRC if present.  inflateReset() will reset the process to discard the header

-   information.  The application would need to call inflateGetHeader() again to

-   retrieve the header from the next gzip stream.

-

-     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source

-   stream state was inconsistent.

-*/

-

-/*

-ZEXTERN int ZEXPORT inflateBackInit(z_streamp strm, int windowBits,

-                                    unsigned char FAR *window);

-

-     Initialize the internal stream state for decompression using inflateBack()

-   calls.  The fields zalloc, zfree and opaque in strm must be initialized

-   before the call.  If zalloc and zfree are Z_NULL, then the default library-

-   derived memory allocation routines are used.  windowBits is the base two

-   logarithm of the window size, in the range 8..15.  window is a caller

-   supplied buffer of that size.  Except for special applications where it is

-   assured that deflate was used with small window sizes, windowBits must be 15

-   and a 32K byte window must be supplied to be able to decompress general

-   deflate streams.

-

-     See inflateBack() for the usage of these routines.

-

-     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of

-   the parameters are invalid, Z_MEM_ERROR if the internal state could not be

-   allocated, or Z_VERSION_ERROR if the version of the library does not match

-   the version of the header file.

-*/

-

-typedef unsigned (*in_func)(void FAR *,

-                            z_const unsigned char FAR * FAR *);

-typedef int (*out_func)(void FAR *, unsigned char FAR *, unsigned);

-

-ZEXTERN int ZEXPORT inflateBack(z_streamp strm,

-                                in_func in, void FAR *in_desc,

-                                out_func out, void FAR *out_desc);

-/*

-     inflateBack() does a raw inflate with a single call using a call-back

-   interface for input and output.  This is potentially more efficient than

-   inflate() for file i/o applications, in that it avoids copying between the

-   output and the sliding window by simply making the window itself the output

-   buffer.  inflate() can be faster on modern CPUs when used with large

-   buffers.  inflateBack() trusts the application to not change the output

-   buffer passed by the output function, at least until inflateBack() returns.

-

-     inflateBackInit() must be called first to allocate the internal state

-   and to initialize the state with the user-provided window buffer.

-   inflateBack() may then be used multiple times to inflate a complete, raw

-   deflate stream with each call.  inflateBackEnd() is then called to free the

-   allocated state.

-

-     A raw deflate stream is one with no zlib or gzip header or trailer.

-   This routine would normally be used in a utility that reads zip or gzip

-   files and writes out uncompressed files.  The utility would decode the

-   header and process the trailer on its own, hence this routine expects only

-   the raw deflate stream to decompress.  This is different from the default

-   behavior of inflate(), which expects a zlib header and trailer around the

-   deflate stream.

-

-     inflateBack() uses two subroutines supplied by the caller that are then

-   called by inflateBack() for input and output.  inflateBack() calls those

-   routines until it reads a complete deflate stream and writes out all of the

-   uncompressed data, or until it encounters an error.  The function's

-   parameters and return types are defined above in the in_func and out_func

-   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the

-   number of bytes of provided input, and a pointer to that input in buf.  If

-   there is no input available, in() must return zero -- buf is ignored in that

-   case -- and inflateBack() will return a buffer error.  inflateBack() will

-   call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].

-   out() should return zero on success, or non-zero on failure.  If out()

-   returns non-zero, inflateBack() will return with an error.  Neither in() nor

-   out() are permitted to change the contents of the window provided to

-   inflateBackInit(), which is also the buffer that out() uses to write from.

-   The length written by out() will be at most the window size.  Any non-zero

-   amount of input may be provided by in().

-

-     For convenience, inflateBack() can be provided input on the first call by

-   setting strm->next_in and strm->avail_in.  If that input is exhausted, then

-   in() will be called.  Therefore strm->next_in must be initialized before

-   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called

-   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in

-   must also be initialized, and then if strm->avail_in is not zero, input will

-   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].

-

-     The in_desc and out_desc parameters of inflateBack() is passed as the

-   first parameter of in() and out() respectively when they are called.  These

-   descriptors can be optionally used to pass any information that the caller-

-   supplied in() and out() functions need to do their job.

-

-     On return, inflateBack() will set strm->next_in and strm->avail_in to

-   pass back any unused input that was provided by the last in() call.  The

-   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR

-   if in() or out() returned an error, Z_DATA_ERROR if there was a format error

-   in the deflate stream (in which case strm->msg is set to indicate the nature

-   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.

-   In the case of Z_BUF_ERROR, an input or output error can be distinguished

-   using strm->next_in which will be Z_NULL only if in() returned an error.  If

-   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning

-   non-zero.  (in() will always be called before out(), so strm->next_in is

-   assured to be defined if out() returns non-zero.)  Note that inflateBack()

-   cannot return Z_OK.

-*/

-

-ZEXTERN int ZEXPORT inflateBackEnd(z_streamp strm);

-/*

-     All memory allocated by inflateBackInit() is freed.

-

-     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream

-   state was inconsistent.

-*/

-

-ZEXTERN uLong ZEXPORT zlibCompileFlags(void);

-/* Return flags indicating compile-time options.

-

-    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:

-     1.0: size of uInt

-     3.2: size of uLong

-     5.4: size of voidpf (pointer)

-     7.6: size of z_off_t

-

-    Compiler, assembler, and debug options:

-     8: ZLIB_DEBUG

-     9: ASMV or ASMINF -- use ASM code

-     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention

-     11: 0 (reserved)

-

-    One-time table building (smaller code, but not thread-safe if true):

-     12: BUILDFIXED -- build static block decoding tables when needed

-     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed

-     14,15: 0 (reserved)

-

-    Library content (indicates missing functionality):

-     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking

-                          deflate code when not needed)

-     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect

-                    and decode gzip streams (to avoid linking crc code)

-     18-19: 0 (reserved)

-

-    Operation variations (changes in library functionality):

-     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate

-     21: FASTEST -- deflate algorithm with only one, lowest compression level

-     22,23: 0 (reserved)

-

-    The sprintf variant used by gzprintf (all zeros is best):

-     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format

-     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() is not secure!

-     26: 0 = returns value, 1 = void -- 1 means inferred string length returned

-     27: 0 = gzprintf() present, 1 = not -- 1 means gzprintf() returns an error

-

-    Remainder:

-     28-31: 0 (reserved)

- */

-

-#ifndef Z_SOLO

-

-                        /* utility functions */

-

-/*

-     The following utility functions are implemented on top of the basic

-   stream-oriented functions.  To simplify the interface, some default options

-   are assumed (compression level and memory usage, standard memory allocation

-   functions).  The source code of these utility functions can be modified if

-   you need special options.  The _z versions of the functions use the size_t

-   type for lengths.  Note that a long is 32 bits on Windows.

-*/

-

-ZEXTERN int ZEXPORT compress(Bytef *dest, uLongf *destLen,

-                             const Bytef *source, uLong sourceLen);

-ZEXTERN int ZEXPORT compress_z(Bytef *dest, z_size_t *destLen,

-                               const Bytef *source, z_size_t sourceLen);

-/*

-     Compresses 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 at least the value returned by

-   compressBound(sourceLen).  Upon exit, destLen is the actual size of the

-   compressed data.  compress() is equivalent to compress2() with a level

-   parameter of Z_DEFAULT_COMPRESSION.

-

-     compress 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.

-*/

-

-ZEXTERN int ZEXPORT compress2(Bytef *dest, uLongf *destLen,

-                              const Bytef *source, uLong sourceLen,

-                              int level);

-ZEXTERN int ZEXPORT compress2_z(Bytef *dest, z_size_t *destLen,

-                                const Bytef *source, z_size_t sourceLen,

-                                int level);

-/*

-     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 the value returned by

-   compressBound(sourceLen).  Upon exit, destLen is the actual size of the

-   compressed data.

-

-     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.

-*/

-

-ZEXTERN uLong ZEXPORT compressBound(uLong sourceLen);

-ZEXTERN z_size_t ZEXPORT compressBound_z(z_size_t sourceLen);

-/*

-     compressBound() returns an upper bound on the compressed size after

-   compress() or compress2() on sourceLen bytes.  It would be used before a

-   compress() or compress2() call to allocate the destination buffer.

-*/

-

-ZEXTERN int ZEXPORT uncompress(Bytef *dest, uLongf *destLen,

-                               const Bytef *source, uLong sourceLen);

-ZEXTERN int ZEXPORT uncompress_z(Bytef *dest, z_size_t *destLen,

-                                 const Bytef *source, z_size_t sourceLen);

-/*

-     Decompresses the source buffer into the destination buffer.  sourceLen is

-   the byte length of the source buffer.  On 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.)  On exit, *destLen

-   is the actual size of the uncompressed data.

-

-     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 or incomplete.  In

-   the case where there is not enough room, uncompress() will fill the output

-   buffer with the uncompressed data up to that point.

-*/

-

-ZEXTERN int ZEXPORT uncompress2(Bytef *dest, uLongf *destLen,

-                                const Bytef *source, uLong *sourceLen);

-ZEXTERN int ZEXPORT uncompress2_z(Bytef *dest, z_size_t *destLen,

-                                  const Bytef *source, z_size_t *sourceLen);

-/*

-     Same as uncompress, except that sourceLen is a pointer, where the

-   length of the source is *sourceLen.  On return, *sourceLen is the number of

-   source bytes consumed.

-*/

-

-                        /* gzip file access functions */

-

-/*

-     This library supports reading and writing files in gzip (.gz) format with

-   an interface similar to that of stdio, using the functions that start with

-   "gz".  The gzip format is different from the zlib format.  gzip is a gzip

-   wrapper, documented in RFC 1952, wrapped around a deflate stream.

-*/

-

-typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */

-

-/*

-ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode);

-

-     Open the gzip (.gz) file at path for reading and decompressing, or

-   compressing and writing.  The mode parameter is as in fopen ("rb" or "wb")

-   but can also include a compression level ("wb9") or a strategy: 'f' for

-   filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h",

-   'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression

-   as in "wb9F".  (See the description of deflateInit2 for more information

-   about the strategy parameter.)  'T' will request transparent writing or

-   appending with no compression and not using the gzip format. 'T' cannot be

-   used to force transparent reading. Transparent reading is automatically

-   performed if there is no gzip header at the start. Transparent reading can

-   be disabled with the 'G' option, which will instead return an error if there

-   is no gzip header. 'N' will open the file in non-blocking mode.

-

-     'a' can be used instead of 'w' to request that the gzip stream that will

-   be written be appended to the file.  '+' will result in an error, since

-   reading and writing to the same gzip file is not supported.  The addition of

-   'x' when writing will create the file exclusively, which fails if the file

-   already exists.  On systems that support it, the addition of 'e' when

-   reading or writing will set the flag to close the file on an execve() call.

-

-     These functions, as well as gzip, will read and decode a sequence of gzip

-   streams in a file.  The append function of gzopen() can be used to create

-   such a file.  (Also see gzflush() for another way to do this.)  When

-   appending, gzopen does not test whether the file begins with a gzip stream,

-   nor does it look for the end of the gzip streams to begin appending.  gzopen

-   will simply append a gzip stream to the existing file.

-

-     gzopen can be used to read a file which is not in gzip format; in this

-   case gzread will directly read from the file without decompression.  When

-   reading, this will be detected automatically by looking for the magic two-

-   byte gzip header.

-

-     gzopen returns NULL if the file could not be opened, if there was

-   insufficient memory to allocate the gzFile state, or if an invalid mode was

-   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).

-   errno can be checked to determine if the reason gzopen failed was that the

-   file could not be opened. Note that if 'N' is in mode for non-blocking, the

-   open() itself can fail in order to not block. In that case gzopen() will

-   return NULL and errno will be EAGAIN or ENONBLOCK. The call to gzopen() can

-   then be re-tried. If the application would like to block on opening the

-   file, then it can use open() without O_NONBLOCK, and then gzdopen() with the

-   resulting file descriptor and 'N' in the mode, which will set it to non-

-   blocking.

-*/

-

-ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode);

-/*

-     Associate a gzFile with the file descriptor fd.  File descriptors are

-   obtained from calls like open, dup, creat, pipe or fileno (if the file has

-   been previously opened with fopen).  The mode parameter is as in gzopen. An

-   'e' in mode will set fd's flag to close the file on an execve() call. An 'N'

-   in mode will set fd's non-blocking flag.

-

-     The next call of gzclose on the returned gzFile will also close the file

-   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor

-   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,

-   mode);.  The duplicated descriptor should be saved to avoid a leak, since

-   gzdopen does not close fd if it fails.  If you are using fileno() to get the

-   file descriptor from a FILE *, then you will have to use dup() to avoid

-   double-close()ing the file descriptor.  Both gzclose() and fclose() will

-   close the associated file descriptor, so they need to have different file

-   descriptors.

-

-     gzdopen returns NULL if there was insufficient memory to allocate the

-   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not

-   provided, or '+' was provided), or if fd is -1.  The file descriptor is not

-   used until the next gz* read, write, seek, or close operation, so gzdopen

-   will not detect if fd is invalid (unless fd is -1).

-*/

-

-ZEXTERN int ZEXPORT gzbuffer(gzFile file, unsigned size);

-/*

-     Set the internal buffer size used by this library's functions for file to

-   size.  The default buffer size is 8192 bytes.  This function must be called

-   after gzopen() or gzdopen(), and before any other calls that read or write

-   the file.  The buffer memory allocation is always deferred to the first read

-   or write.  Three times that size in buffer space is allocated.  A larger

-   buffer size of, for example, 64K or 128K bytes will noticeably increase the

-   speed of decompression (reading).

-

-     The new buffer size also affects the maximum length for gzprintf().

-

-     gzbuffer() returns 0 on success, or -1 on failure, such as being called

-   too late.

-*/

-

-ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy);

-/*

-     Dynamically update the compression level and strategy for file.  See the

-   description of deflateInit2 for the meaning of these parameters. Previously

-   provided data is flushed before applying the parameter changes.

-

-     gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not

-   opened for writing, Z_ERRNO if there is an error writing the flushed data,

-   or Z_MEM_ERROR if there is a memory allocation error.

-*/

-

-ZEXTERN int ZEXPORT gzread(gzFile file, voidp buf, unsigned len);

-/*

-     Read and decompress up to len uncompressed bytes from file into buf.  If

-   the input file is not in gzip format, gzread copies the given number of

-   bytes into the buffer directly from the file.

-

-     After reaching the end of a gzip stream in the input, gzread will continue

-   to read, looking for another gzip stream.  Any number of gzip streams may be

-   concatenated in the input file, and will all be decompressed by gzread().

-   If something other than a gzip stream is encountered after a gzip stream,

-   that remaining trailing garbage is ignored (and no error is returned).

-

-     gzread can be used to read a gzip file that is being concurrently written.

-   Upon reaching the end of the input, gzread will return with the available

-   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then

-   gzclearerr can be used to clear the end of file indicator in order to permit

-   gzread to be tried again.  Z_OK indicates that a gzip stream was completed

-   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the

-   middle of a gzip stream.  Note that gzread does not return -1 in the event

-   of an incomplete gzip stream.  This error is deferred until gzclose(), which

-   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip

-   stream.  Alternatively, gzerror can be used before gzclose to detect this

-   case.

-

-     gzread can be used to read a gzip file on a non-blocking device. If the

-   input stalls and there is no uncompressed data to return, then gzread() will

-   return -1, and errno will be EAGAIN or EWOULDBLOCK. gzread() can then be

-   called again.

-

-     gzread returns the number of uncompressed bytes actually read, less than

-   len for end of file, or -1 for error.  If len is too large to fit in an int,

-   then nothing is read, -1 is returned, and the error state is set to

-   Z_STREAM_ERROR. If some data was read before an error, then that data is

-   returned until exhausted, after which the next call will signal the error.

-*/

-

-ZEXTERN z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems,

-                                 gzFile file);

-/*

-     Read and decompress up to nitems items of size size from file into buf,

-   otherwise operating as gzread() does.  This duplicates the interface of

-   stdio's fread(), with size_t request and return types.  If the library

-   defines size_t, then z_size_t is identical to size_t.  If not, then z_size_t

-   is an unsigned integer type that can contain a pointer.

-

-     gzfread() returns the number of full items read of size size, or zero if

-   the end of the file was reached and a full item could not be read, or if

-   there was an error.  gzerror() must be consulted if zero is returned in

-   order to determine if there was an error.  If the multiplication of size and

-   nitems overflows, i.e. the product does not fit in a z_size_t, then nothing

-   is read, zero is returned, and the error state is set to Z_STREAM_ERROR.

-

-     In the event that the end of file is reached and only a partial item is

-   available at the end, i.e. the remaining uncompressed data length is not a

-   multiple of size, then the final partial item is nevertheless read into buf

-   and the end-of-file flag is set.  The length of the partial item read is not

-   provided, but could be inferred from the result of gztell().  This behavior

-   is the same as that of fread() implementations in common libraries. This

-   could result in data loss if used with size != 1 when reading a concurrently

-   written file or a non-blocking file. In that case, use size == 1 or gzread()

-   instead.

-*/

-

-ZEXTERN int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len);

-/*

-     Compress and write the len uncompressed bytes at buf to file. gzwrite

-   returns the number of uncompressed bytes written, or 0 in case of error or

-   if len is 0.  If the write destination is non-blocking, then gzwrite() may

-   return a number of bytes written that is not 0 and less than len.

-

-     If len does not fit in an int, then 0 is returned and nothing is written.

-*/

-

-ZEXTERN z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size,

-                                  z_size_t nitems, gzFile file);

-/*

-     Compress and write nitems items of size size from buf to file, duplicating

-   the interface of stdio's fwrite(), with size_t request and return types.  If

-   the library defines size_t, then z_size_t is identical to size_t.  If not,

-   then z_size_t is an unsigned integer type that can contain a pointer.

-

-     gzfwrite() returns the number of full items written of size size, or zero

-   if there was an error.  If the multiplication of size and nitems overflows,

-   i.e. the product does not fit in a z_size_t, then nothing is written, zero

-   is returned, and the error state is set to Z_STREAM_ERROR.

-

-     If writing a concurrently read file or a non-blocking file with size != 1,

-   a partial item could be written, with no way of knowing how much of it was

-   not written, resulting in data loss.  In that case, use size == 1 or

-   gzwrite() instead.

-*/

-

-#if defined(STDC) || defined(Z_HAVE_STDARG_H)

-ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...);

-#else

-ZEXTERN int ZEXPORTVA gzprintf();

-#endif

-/*

-     Convert, format, compress, and write the arguments (...) to file under

-   control of the string format, as in fprintf.  gzprintf returns the number of

-   uncompressed bytes actually written, or a negative zlib error code in case

-   of error.  The number of uncompressed bytes written is limited to 8191, or

-   one less than the buffer size given to gzbuffer().  The caller should assure

-   that this limit is not exceeded.  If it is exceeded, then gzprintf() will

-   return an error (0) with nothing written.

-

-     In that last case, there may also be a buffer overflow with unpredictable

-   consequences, which is possible only if zlib was compiled with the insecure

-   functions sprintf() or vsprintf(), because the secure snprintf() and

-   vsnprintf() functions were not available. That would only be the case for

-   a non-ANSI C compiler. zlib may have been built without gzprintf() because

-   secure functions were not available and having gzprintf() be insecure was

-   not an option, in which case, gzprintf() returns Z_STREAM_ERROR. All of

-   these possibilities can be determined using zlibCompileFlags().

-

-     If a Z_BUF_ERROR is returned, then nothing was written due to a stall on

-   the non-blocking write destination.

-*/

-

-ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s);

-/*

-     Compress and write the given null-terminated string s to file, excluding

-   the terminating null character.

-

-     gzputs returns the number of characters written, or -1 in case of error.

-   The number of characters written may be less than the length of the string

-   if the write destination is non-blocking.

-

-     If the length of the string does not fit in an int, then -1 is returned

-   and nothing is written.

-*/

-

-ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len);

-/*

-     Read and decompress bytes from file into buf, until len-1 characters are

-   read, or until a newline character is read and transferred to buf, or an

-   end-of-file condition is encountered.  If any characters are read or if len

-   is one, the string is terminated with a null character.  If no characters

-   are read due to an end-of-file or len is less than one, then the buffer is

-   left untouched.

-

-     gzgets returns buf which is a null-terminated string, or it returns NULL

-   for end-of-file or in case of error. If some data was read before an error,

-   then that data is returned until exhausted, after which the next call will

-   return NULL to signal the error.

-

-     gzgets can be used on a file being concurrently written, and on a non-

-   blocking device, both as for gzread(). However lines may be broken in the

-   middle, leaving it up to the application to reassemble them as needed.

-*/

-

-ZEXTERN int ZEXPORT gzputc(gzFile file, int c);

-/*

-     Compress and write c, converted to an unsigned char, into file.  gzputc

-   returns the value that was written, or -1 in case of error.

-*/

-

-ZEXTERN int ZEXPORT gzgetc(gzFile file);

-/*

-     Read and decompress one byte from file. gzgetc returns this byte or -1 in

-   case of end of file or error. If some data was read before an error, then

-   that data is returned until exhausted, after which the next call will return

-   -1 to signal the error.

-

-     This is implemented as a macro for speed. As such, it does not do all of

-   the checking the other functions do. I.e. it does not check to see if file

-   is NULL, nor whether the structure file points to has been clobbered or not.

-

-     gzgetc can be used to read a gzip file on a non-blocking device. If the

-   input stalls and there is no uncompressed data to return, then gzgetc() will

-   return -1, and errno will be EAGAIN or EWOULDBLOCK. gzread() can then be

-   called again.

-*/

-

-ZEXTERN int ZEXPORT gzungetc(int c, gzFile file);

-/*

-     Push c back onto the stream for file to be read as the first character on

-   the next read.  At least one character of push-back is always allowed.

-   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will

-   fail if c is -1, and may fail if a character has been pushed but not read

-   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the

-   output buffer size of pushed characters is allowed.  (See gzbuffer above.)

-   The pushed character will be discarded if the stream is repositioned with

-   gzseek() or gzrewind().

-

-     gzungetc(-1, file) will force any pending seek to execute. Then gztell()

-   will report the position, even if the requested seek reached end of file.

-   This can be used to determine the number of uncompressed bytes in a gzip

-   file without having to read it into a buffer.

-*/

-

-ZEXTERN int ZEXPORT gzflush(gzFile file, int flush);

-/*

-     Flush all pending output to file.  The parameter flush is as in the

-   deflate() function.  The return value is the zlib error number (see function

-   gzerror below).  gzflush is only permitted when writing.

-

-     If the flush parameter is Z_FINISH, the remaining data is written and the

-   gzip stream is completed in the output.  If gzwrite() is called again, a new

-   gzip stream will be started in the output.  gzread() is able to read such

-   concatenated gzip streams.

-

-     gzflush should be called only when strictly necessary because it will

-   degrade compression if called too often.

-*/

-

-/*

-ZEXTERN z_off_t ZEXPORT gzseek(gzFile file,

-                               z_off_t offset, int whence);

-

-     Set the starting position to offset relative to whence for the next gzread

-   or gzwrite on file.  The offset represents a number of bytes in the

-   uncompressed data stream.  The whence parameter is defined as in lseek(2);

-   the value SEEK_END is not supported.

-

-     If the file is opened for reading, this function is emulated but can be

-   extremely slow.  If the file is opened for writing, only forward seeks are

-   supported; gzseek then compresses a sequence of zeroes up to the new

-   starting position. For reading or writing, any actual seeking is deferred

-   until the next read or write operation, or close operation when writing.

-

-     gzseek returns the resulting offset location as measured in bytes from

-   the beginning of the uncompressed stream, or -1 in case of error, in

-   particular if the file is opened for writing and the new starting position

-   would be before the current position.

-*/

-

-ZEXTERN int ZEXPORT gzrewind(gzFile file);

-/*

-     Rewind file. This function is supported only for reading.

-

-     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET).

-*/

-

-/*

-ZEXTERN z_off_t ZEXPORT gztell(gzFile file);

-

-     Return the starting position for the next gzread or gzwrite on file.

-   This position represents a number of bytes in the uncompressed data stream,

-   and is zero when starting, even if appending or reading a gzip stream from

-   the middle of a file using gzdopen().

-

-     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)

-*/

-

-/*

-ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file);

-

-     Return the current compressed (actual) read or write offset of file.  This

-   offset includes the count of bytes that precede the gzip stream, for example

-   when appending or when using gzdopen() for reading.  When reading, the

-   offset does not include as yet unused buffered input.  This information can

-   be used for a progress indicator.  On error, gzoffset() returns -1.

-*/

-

-ZEXTERN int ZEXPORT gzeof(gzFile file);

-/*

-     Return true (1) if the end-of-file indicator for file has been set while

-   reading, false (0) otherwise.  Note that the end-of-file indicator is set

-   only if the read tried to go past the end of the input, but came up short.

-   Therefore, just like feof(), gzeof() may return false even if there is no

-   more data to read, in the event that the last read request was for the exact

-   number of bytes remaining in the input file.  This will happen if the input

-   file size is an exact multiple of the buffer size.

-

-     If gzeof() returns true, then the read functions will return no more data,

-   unless the end-of-file indicator is reset by gzclearerr() and the input file

-   has grown since the previous end of file was detected.

-*/

-

-ZEXTERN int ZEXPORT gzdirect(gzFile file);

-/*

-     Return true (1) if file is being copied directly while reading, or false

-   (0) if file is a gzip stream being decompressed.

-

-     If the input file is empty, gzdirect() will return true, since the input

-   does not contain a gzip stream.

-

-     If gzdirect() is used immediately after gzopen() or gzdopen() it will

-   cause buffers to be allocated to allow reading the file to determine if it

-   is a gzip file. Therefore if gzbuffer() is used, it should be called before

-   gzdirect(). If the input is being written concurrently or the device is non-

-   blocking, then gzdirect() may give a different answer once four bytes of

-   input have been accumulated, which is what is needed to confirm or deny a

-   gzip header. Before this, gzdirect() will return true (1).

-

-     When writing, gzdirect() returns true (1) if transparent writing was

-   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:

-   gzdirect() is not needed when writing.  Transparent writing must be

-   explicitly requested, so the application already knows the answer.  When

-   linking statically, using gzdirect() will include all of the zlib code for

-   gzip file reading and decompression, which may not be desired.)

-*/

-

-ZEXTERN int ZEXPORT gzclose(gzFile file);

-/*

-     Flush all pending output for file, if necessary, close file and

-   deallocate the (de)compression state.  Note that once file is closed, you

-   cannot call gzerror with file, since its structures have been deallocated.

-   gzclose must not be called more than once on the same file, just as free

-   must not be called more than once on the same allocation.

-

-     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a

-   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the

-   last read ended in the middle of a gzip stream, or Z_OK on success.

-*/

-

-ZEXTERN int ZEXPORT gzclose_r(gzFile file);

-ZEXTERN int ZEXPORT gzclose_w(gzFile file);

-/*

-     Same as gzclose(), but gzclose_r() is only for use when reading, and

-   gzclose_w() is only for use when writing or appending.  The advantage to

-   using these instead of gzclose() is that they avoid linking in zlib

-   compression or decompression code that is not used when only reading or only

-   writing respectively.  If gzclose() is used, then both compression and

-   decompression code will be included the application when linking to a static

-   zlib library.

-*/

-

-ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum);

-/*

-     Return the error message for the last error which occurred on file.

-   If errnum is not NULL, *errnum is set to zlib error number.  If an error

-   occurred in the file system and not in the compression library, *errnum is

-   set to Z_ERRNO and the application may consult errno to get the exact error

-   code.

-

-     The application must not modify the returned string.  Future calls to

-   this function may invalidate the previously returned string.  If file is

-   closed, then the string previously returned by gzerror will no longer be

-   available.

-

-     gzerror() should be used to distinguish errors from end-of-file for those

-   functions above that do not distinguish those cases in their return values.

-*/

-

-ZEXTERN void ZEXPORT gzclearerr(gzFile file);

-/*

-     Clear the error and end-of-file flags for file.  This is analogous to the

-   clearerr() function in stdio.  This is useful for continuing to read a gzip

-   file that is being written concurrently.

-*/

-

-#endif /* !Z_SOLO */

-

-                        /* checksum functions */

-

-/*

-     These functions are not related to compression but are exported

-   anyway because they might be useful in applications using the compression

-   library.

-*/

-

-ZEXTERN uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len);

-/*

-     Update a running Adler-32 checksum with the bytes buf[0..len-1] and

-   return the updated checksum. An Adler-32 value is in the range of a 32-bit

-   unsigned integer. If buf is Z_NULL, this function returns the required

-   initial value for the checksum.

-

-     An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed

-   much faster.

-

-   Usage example:

-

-     uLong adler = adler32(0L, Z_NULL, 0);

-

-     while (read_buffer(buffer, length) != EOF) {

-       adler = adler32(adler, buffer, length);

-     }

-     if (adler != original_adler) error();

-*/

-

-ZEXTERN uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf,

-                                z_size_t len);

-/*

-     Same as adler32(), but with a size_t length.  Note that a long is 32 bits

-   on Windows.

-*/

-

-/*

-ZEXTERN uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2,

-                                      z_off_t len2);

-

-     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1

-   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for

-   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of

-   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note

-   that the z_off_t type (like off_t) is a signed integer.  If len2 is

-   negative, the result has no meaning or utility.

-*/

-

-ZEXTERN uLong ZEXPORT crc32(uLong crc, const Bytef *buf, uInt len);

-/*

-     Update a running CRC-32 with the bytes buf[0..len-1] and return the

-   updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer.

-   If buf is Z_NULL, this function returns the required initial value for the

-   crc. Pre- and post-conditioning (one's complement) is performed within this

-   function so it shouldn't be done by the application.

-

-   Usage example:

-

-     uLong crc = crc32(0L, Z_NULL, 0);

-

-     while (read_buffer(buffer, length) != EOF) {

-       crc = crc32(crc, buffer, length);

-     }

-     if (crc != original_crc) error();

-*/

-

-ZEXTERN uLong ZEXPORT crc32_z(uLong crc, const Bytef *buf,

-                              z_size_t len);

-/*

-     Same as crc32(), but with a size_t length.  Note that a long is 32 bits on

-   Windows.

-*/

-

-/*

-ZEXTERN uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2);

-

-     Combine two CRC-32 check values into one.  For two sequences of bytes,

-   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were

-   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32

-   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and

-   len2. len2 must be non-negative, otherwise zero is returned.

-*/

-

-/*

-ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t len2);

-

-     Return the operator corresponding to length len2, to be used with

-   crc32_combine_op(). len2 must be non-negative, otherwise zero is returned.

-*/

-

-ZEXTERN uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op);

-/*

-     Give the same result as crc32_combine(), using op in place of len2. op is

-   is generated from len2 by crc32_combine_gen(). This will be faster than

-   crc32_combine() if the generated op is used more than once.

-*/

-

-

-                        /* various hacks, don't look :) */

-

-/* deflateInit and inflateInit are macros to allow checking the zlib version

- * and the compiler's view of z_stream:

- */

-ZEXTERN int ZEXPORT deflateInit_(z_streamp strm, int level,

-                                 const char *version, int stream_size);

-ZEXTERN int ZEXPORT inflateInit_(z_streamp strm,

-                                 const char *version, int stream_size);

-ZEXTERN int ZEXPORT deflateInit2_(z_streamp strm, int  level, int  method,

-                                  int windowBits, int memLevel,

-                                  int strategy, const char *version,

-                                  int stream_size);

-ZEXTERN int ZEXPORT inflateInit2_(z_streamp strm, int  windowBits,

-                                  const char *version, int stream_size);

-ZEXTERN int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits,

-                                     unsigned char FAR *window,

-                                     const char *version,

-                                     int stream_size);

-#ifdef Z_PREFIX_SET

-#  define z_deflateInit(strm, level) \

-          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))

-#  define z_inflateInit(strm) \

-          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))

-#  define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \

-          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\

-                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))

-#  define z_inflateInit2(strm, windowBits) \

-          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \

-                        (int)sizeof(z_stream))

-#  define z_inflateBackInit(strm, windowBits, window) \

-          inflateBackInit_((strm), (windowBits), (window), \

-                           ZLIB_VERSION, (int)sizeof(z_stream))

-#else

-#  define deflateInit(strm, level) \

-          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))

-#  define inflateInit(strm) \

-          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))

-#  define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \

-          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\

-                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))

-#  define inflateInit2(strm, windowBits) \

-          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \

-                        (int)sizeof(z_stream))

-#  define inflateBackInit(strm, windowBits, window) \

-          inflateBackInit_((strm), (windowBits), (window), \

-                           ZLIB_VERSION, (int)sizeof(z_stream))

-#endif

-

-#ifndef Z_SOLO

-

-/* gzgetc() macro and its supporting function and exposed data structure.  Note

- * that the real internal state is much larger than the exposed structure.

- * This abbreviated structure exposes just enough for the gzgetc() macro.  The

- * user should not mess with these exposed elements, since their names or

- * behavior could change in the future, perhaps even capriciously.  They can

- * only be used by the gzgetc() macro.  You have been warned.

- */

-struct gzFile_s {

-    unsigned have;

-    unsigned char *next;

-    z_off64_t pos;

-};

-ZEXTERN int ZEXPORT gzgetc_(gzFile file);       /* backward compatibility */

-#ifdef Z_PREFIX_SET

-#  undef z_gzgetc

-#  define z_gzgetc(g) \

-          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))

-#else

-#  define gzgetc(g) \

-          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))

-#endif

-

-/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or

- * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if

- * both are true, the application gets the *64 functions, and the regular

- * functions are changed to 64 bits) -- in case these are set on systems

- * without large file support, _LFS64_LARGEFILE must also be true

- */

-#ifdef Z_LARGE64

-   ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);

-   ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int);

-   ZEXTERN z_off64_t ZEXPORT gztell64(gzFile);

-   ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile);

-   ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);

-   ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);

-   ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);

-#endif

-

-#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)

-#  ifdef Z_PREFIX_SET

-#    define z_gzopen z_gzopen64

-#    define z_gzseek z_gzseek64

-#    define z_gztell z_gztell64

-#    define z_gzoffset z_gzoffset64

-#    define z_adler32_combine z_adler32_combine64

-#    define z_crc32_combine z_crc32_combine64

-#    define z_crc32_combine_gen z_crc32_combine_gen64

-#  else

-#    define gzopen gzopen64

-#    define gzseek gzseek64

-#    define gztell gztell64

-#    define gzoffset gzoffset64

-#    define adler32_combine adler32_combine64

-#    define crc32_combine crc32_combine64

-#    define crc32_combine_gen crc32_combine_gen64

-#  endif

-#  ifndef Z_LARGE64

-     ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);

-     ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int);

-     ZEXTERN z_off_t ZEXPORT gztell64(gzFile);

-     ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile);

-     ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);

-     ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);

-     ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);

-#  endif

-#else

-   ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *);

-   ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int);

-   ZEXTERN z_off_t ZEXPORT gztell(gzFile);

-   ZEXTERN z_off_t ZEXPORT gzoffset(gzFile);

-   ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t);

-   ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t);

-   ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t);

-#endif

-

-#else /* Z_SOLO */

-

-   ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t);

-   ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t);

-   ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t);

-

-#endif /* !Z_SOLO */

-

-/* undocumented functions */

-ZEXTERN const char   * ZEXPORT zError(int);

-ZEXTERN int            ZEXPORT inflateSyncPoint(z_streamp);

-ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table(void);

-ZEXTERN int            ZEXPORT inflateUndermine(z_streamp, int);

-ZEXTERN int            ZEXPORT inflateValidate(z_streamp, int);

-ZEXTERN unsigned long  ZEXPORT inflateCodesUsed(z_streamp);

-ZEXTERN int            ZEXPORT inflateResetKeep(z_streamp);

-ZEXTERN int            ZEXPORT deflateResetKeep(z_streamp);

-#if defined(_WIN32) && !defined(Z_SOLO)

-ZEXTERN gzFile         ZEXPORT gzopen_w(const wchar_t *path,

-                                        const char *mode);

-#endif

-#if defined(STDC) || defined(Z_HAVE_STDARG_H)

-#  ifndef Z_SOLO

-ZEXTERN int            ZEXPORTVA gzvprintf(gzFile file,

-                                           const char *format,

-                                           va_list va);

-#  endif

-#endif

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif /* ZLIB_H */

+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.3.2.1, February xxth, 2026
+
+  Copyright (C) 1995-2026 Jean-loup Gailly and Mark Adler
+
+  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.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 at https://datatracker.ietf.org/doc/html/rfc1950
+  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#ifdef ZLIB_BUILD
+#  include <zconf.h>
+#else
+# include "zconf.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.3.2.1-motley"
+#define ZLIB_VERNUM 0x1321
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 3
+#define ZLIB_VER_REVISION 2
+#define ZLIB_VER_SUBREVISION 1
+
+/*
+    The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed data.
+  This version of the library supports only one compression method (deflation)
+  but other algorithms will be added later and will have the same stream
+  interface.
+
+    Compression can be done in a single step if the buffers are large enough,
+  or can be done by repeated calls of the compression function.  In the latter
+  case, the application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+    The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+    The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+    This library can optionally read and write gzip and raw deflate streams in
+  memory as well.
+
+    The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+    The library does not install any signal handler.  The decoder checks
+  the consistency of the compressed data, so the library should never crash
+  even in the case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func)(voidpf opaque, uInt items, uInt size);
+typedef void   (*free_func)(voidpf opaque, voidpf address);
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    z_const Bytef *next_in;     /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total number of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte will go here */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total number of bytes output so far */
+
+    z_const char *msg;  /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text
+                           for deflate, or the decoding state for inflate */
+    uLong   adler;      /* Adler-32 or CRC-32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+     The application must update next_in and avail_in when avail_in has dropped
+   to zero.  It must update next_out and avail_out when avail_out has dropped
+   to zero.  The application must initialize zalloc, zfree and opaque before
+   calling the init function.  All other fields are set by the compression
+   library and must not be updated by the application.
+
+     The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree.  This can be useful for custom
+   memory management.  The compression library attaches no meaning to the
+   opaque value.
+
+     zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.  In that case, zlib is thread-safe.  When zalloc and zfree are
+   Z_NULL on entry to the initialization function, they are set to internal
+   routines that use the standard library functions malloc() and free().
+
+     On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this if
+   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+   returned by zalloc for objects of exactly 65536 bytes *must* have their
+   offset normalized to zero.  The default allocation function provided by this
+   library ensures this (see zutil.c).  To reduce memory requirements and avoid
+   any allocation of 64K objects, at the expense of compression ratio, compile
+   the library with -DMAX_WBITS=14 (see zconf.h).
+
+     The fields total_in and total_out can be used for statistics or progress
+   reports.  After compression, total_in holds the total size of the
+   uncompressed data and may be saved for use by the decompressor (particularly
+   if the decompressor wants to decompress everything in a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+#define Z_TREES         6
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field for deflate() */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion(void);
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is not
+   compatible with the zlib.h header file used by the application.  This check
+   is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit(z_streamp strm, int level);
+
+     Initializes the internal stream state for compression.  The fields
+   zalloc, zfree and opaque must be initialized before by the caller.  If
+   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+   allocation functions.  total_in, total_out, adler, and msg are initialized.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at all
+   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+   requests a default compromise between speed and compression (currently
+   equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if level is not a valid compression level, or
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+   if there is no error message.  deflateInit does not perform any compression:
+   this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate(z_streamp strm, int flush);
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows.  deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Generate more output starting at next_out and update next_out and avail_out
+    accordingly.  This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary.  Some output may be provided even if
+    flush is zero.
+
+    Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating avail_in or avail_out accordingly; avail_out should
+  never be zero before the call.  The application can consume the compressed
+  output when it wants, for example when the output buffer is full (avail_out
+  == 0), or after each call of deflate().  If deflate returns Z_OK and with
+  zero avail_out, it must be called again after making room in the output
+  buffer because there might be more output pending. See deflatePending(),
+  which can be used if desired to determine whether or not there is more output
+  in that case.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumulate before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far.  (In
+  particular avail_in is zero after the call if enough output space has been
+  provided before the call.) Flushing may degrade compression for some
+  compression algorithms and so it should be used only when necessary.  This
+  completes the current deflate block and follows it with an empty stored block
+  that is three bits plus filler bits to the next byte, followed by four bytes
+  (00 00 ff ff).
+
+    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+  output buffer, but the output is not aligned to a byte boundary.  All of the
+  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+  This completes the current deflate block and follows it with an empty fixed
+  codes block that is 10 bits long.  This assures that enough bytes are output
+  in order for the decompressor to finish the block before the empty fixed
+  codes block.
+
+    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+  seven bits of the current block are held to be written as the next byte after
+  the next deflate block is completed.  In this case, the decompressor may not
+  be provided enough bits at this point in order to complete decompression of
+  the data provided so far to the compressor.  It may need to wait for the next
+  block to be emitted.  This is for advanced applications that need to control
+  the emission of deflate blocks.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six when the flush marker begins, in order to avoid
+  repeated flush markers upon calling deflate() again when avail_out == 0.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there was
+  enough output space.  If deflate returns with Z_OK or Z_BUF_ERROR, this
+  function must be called again with Z_FINISH and more output space (updated
+  avail_out) but no more input data, until it returns with Z_STREAM_END or an
+  error.  After deflate has returned Z_STREAM_END, the only possible operations
+  on the stream are deflateReset or deflateEnd.
+
+    Z_FINISH can be used in the first deflate call after deflateInit if all the
+  compression is to be done in a single step.  In order to complete in one
+  call, avail_out must be at least the value returned by deflateBound (see
+  below).  Then deflate is guaranteed to return Z_STREAM_END.  If not enough
+  output space is provided, deflate will not return Z_STREAM_END, and it must
+  be called again as described above.
+
+    deflate() sets strm->adler to the Adler-32 checksum of all input read
+  so far (that is, total_in bytes).  If a gzip stream is being generated, then
+  strm->adler will be the CRC-32 checksum of the input read so far.  (See
+  deflateInit2 below.)
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT).  If in doubt, the data is
+  considered binary.  This field is only for information purposes and does not
+  affect the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was Z_NULL or the state was inadvertently written over
+  by the application), or Z_BUF_ERROR if no progress is possible (for example
+  avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not fatal, and
+  deflate() can be called again with more input and more output space to
+  continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd(z_streamp strm);
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded).  In the error case, msg
+   may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit(z_streamp strm);
+
+     Initializes the internal stream state for decompression.  The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller.  In the current version of inflate, the provided input is not
+   read or consumed.  The allocation of a sliding window will be deferred to
+   the first call of inflate (if the decompression does not complete on the
+   first call).  If zalloc and zfree are set to Z_NULL, inflateInit updates
+   them to use default allocation functions.  total_in, total_out, adler, and
+   msg are initialized.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit does not perform any decompression.
+   Actual decompression will be done by inflate().  So next_in, and avail_in,
+   next_out, and avail_out are unused and unchanged.  The current
+   implementation of inflateInit() does not process any header information --
+   that is deferred until inflate() is called.
+*/
+
+
+ZEXTERN int ZEXPORT inflate(z_streamp strm, int flush);
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows.  inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), then next_in and avail_in are updated
+    accordingly, and processing will resume at this point for the next call of
+    inflate().
+
+  - Generate more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there is
+    no more input data or no more space in the output buffer (see below about
+    the flush parameter).
+
+    Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating the next_* and avail_* values accordingly.  If the
+  caller of inflate() does not provide both available input and available
+  output space, it is possible that there will be no progress made.  The
+  application can consume the uncompressed output when it wants, for example
+  when the output buffer is full (avail_out == 0), or after each call of
+  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+  called again after making room in the output buffer because there might be
+  more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer.  Z_BLOCK requests that inflate()
+  stop if and when it gets to the next deflate block boundary.  When decoding
+  the zlib or gzip format, this will cause inflate() to return immediately
+  after the header and before the first block.  When doing a raw inflate,
+  inflate() will go ahead and process the first block, and will return when it
+  gets to the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  To assist in this, on return inflate() always sets strm->data_type to the
+  number of unused bits in the input taken from strm->next_in, plus 64 if
+  inflate() is currently decoding the last block in the deflate stream, plus
+  128 if inflate() returned immediately after decoding an end-of-block code or
+  decoding the complete header up to just before the first byte of the deflate
+  stream.  The end-of-block will not be indicated until all of the uncompressed
+  data from that block has been written to strm->next_out.  The number of
+  unused bits may in general be greater than seven, except when bit 7 of
+  data_type is set, in which case the number of unused bits will be less than
+  eight.  data_type is set as noted here every time inflate() returns for all
+  flush options, and so can be used to determine the amount of currently
+  consumed input in bits.
+
+    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+  end of each deflate block header is reached, before any actual data in that
+  block is decoded.  This allows the caller to determine the length of the
+  deflate block header for later use in random access within a deflate block.
+  256 is added to the value of strm->data_type when inflate() returns
+  immediately after reaching the end of the deflate block header.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error.  However if all decompression is to be performed in a single step (a
+  single call of inflate), the parameter flush should be set to Z_FINISH.  In
+  this case all pending input is processed and all pending output is flushed;
+  avail_out must be large enough to hold all of the uncompressed data for the
+  operation to complete.  (The size of the uncompressed data may have been
+  saved by the compressor for this purpose.)  The use of Z_FINISH is not
+  required to perform an inflation in one step.  However it may be used to
+  inform inflate that a faster approach can be used for the single inflate()
+  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
+  stream completes, which reduces inflate's memory footprint.  If the stream
+  does not complete, either because not all of the stream is provided or not
+  enough output space is provided, then a sliding window will be allocated and
+  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
+  been used.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call.  So the effects of the flush parameter in this implementation are
+  on the return value of inflate() as noted below, when inflate() returns early
+  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
+  memory for a sliding window when Z_FINISH is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the Adler-32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below.  At the end of the stream, inflate() checks that its computed Adler-32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained unless inflateGetHeader() is used.  When processing
+  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
+  produced so far.  The CRC-32 is checked against the gzip trailer, as is the
+  uncompressed length, modulo 2^32.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value, in which case strm->msg points to a string with a more specific
+  error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  next_in or next_out was Z_NULL, or the state was inadvertently written over
+  by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
+  if no progress was possible or if there was not enough room in the output
+  buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing.  If Z_DATA_ERROR is returned, the application may
+  then call inflateSync() to look for a good compression block if a partial
+  recovery of the data is to be attempted.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd(z_streamp strm);
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
+   was inconsistent.
+*/
+
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2(z_streamp strm,
+                                 int level,
+                                 int method,
+                                 int windowBits,
+                                 int memLevel,
+                                 int strategy);
+
+     This is another version of deflateInit with more compression options.  The
+   fields zalloc, zfree and opaque must be initialized before by the caller.
+
+     The method parameter is the compression method.  It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library.  Larger values of this parameter result in better
+   compression at the expense of memory usage.  The default value is 15 if
+   deflateInit is used instead.
+
+     For the current implementation of deflate(), a windowBits value of 8 (a
+   window size of 256 bytes) is not supported.  As a result, a request for 8
+   will result in 9 (a 512-byte window).  In that case, providing 8 to
+   inflateInit2() will result in an error when the zlib header with 9 is
+   checked against the initialization of inflate().  The remedy is to not use 8
+   with deflateInit2() with this initialization, or at least in that case use 9
+   with inflateInit2().
+
+     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+   determines the window size.  deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute a check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding.  Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper.  The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero), no
+   header crc, and the operating system will be set to the appropriate value,
+   if the operating system was determined at compile time.  If a gzip stream is
+   being written, strm->adler is a CRC-32 instead of an Adler-32.
+
+     For raw deflate or gzip encoding, a request for a 256-byte window is
+   rejected as invalid, since only the zlib header provides a means of
+   transmitting the window size to the decompressor.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state.  memLevel=1 uses minimum memory but is
+   slow and reduces compression ratio; memLevel=9 uses maximum memory for
+   optimal speed.  The default value is 8.  See zconf.h for total memory usage
+   as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm.  Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_RLE to limit match distances to one (run-length
+   encoding), or Z_HUFFMAN_ONLY to force Huffman encoding only (no string
+   matching).  Filtered data consists mostly of small values with a somewhat
+   random distribution, as produced by the PNG filters.  In this case, the
+   compression algorithm is tuned to compress them better.  The effect of
+   Z_FILTERED is to force more Huffman coding and less string matching than the
+   default; it is intermediate between Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.
+   Z_RLE is almost as fast as Z_HUFFMAN_ONLY, but should give better
+   compression for PNG image data than Huffman only.  The degree of string
+   matching from most to none is: Z_DEFAULT_STRATEGY, Z_FILTERED, Z_RLE, then
+   Z_HUFFMAN_ONLY. The strategy parameter affects the compression ratio but
+   never the correctness of the compressed output, even if it is not set
+   optimally for the given data.  Z_FIXED uses the default string matching, but
+   prevents the use of dynamic Huffman codes, allowing for a simpler decoder
+   for special applications.
+
+     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+   set to null if there is no error message.  deflateInit2 does not perform any
+   compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary(z_streamp strm,
+                                         const Bytef *dictionary,
+                                         uInt  dictLength);
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output.  When using the zlib format, this
+   function must be called immediately after deflateInit, deflateInit2 or
+   deflateReset, and before any call of deflate.  When doing raw deflate, this
+   function must be called either before any call of deflate, or immediately
+   after the completion of a deflate block, i.e. after all input has been
+   consumed and all output has been delivered when using any of the flush
+   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
+   compressor and decompressor must use exactly the same dictionary (see
+   inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary.  Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size
+   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+   useful should be put at the end of the dictionary, not at the front.  In
+   addition, the current implementation of deflate will use at most the window
+   size minus 262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the Adler-32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor.  (The Adler-32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   Adler-32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if not at a block boundary for raw deflate).  deflateSetDictionary does
+   not perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm,
+                                         Bytef *dictionary,
+                                         uInt  *dictLength);
+/*
+     Returns the sliding dictionary being maintained by deflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If deflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similarly, if dictLength is Z_NULL, then it is not set.
+
+     deflateGetDictionary() may return a length less than the window size, even
+   when more than the window size in input has been provided. It may return up
+   to 258 bytes less in that case, due to how zlib's implementation of deflate
+   manages the sliding window and lookahead for matches, where matches can be
+   up to 258 bytes long. If the application needs the last window-size bytes of
+   input, then that would need to be saved by the application outside of zlib.
+
+     deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateCopy(z_streamp dest,
+                                z_streamp source);
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter.  The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and can
+   consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset(z_streamp strm);
+/*
+     This function is equivalent to deflateEnd followed by deflateInit, but
+   does not free and reallocate the internal compression state.  The stream
+   will leave the compression level and any other attributes that may have been
+   set unchanged.  total_in, total_out, adler, and msg are initialized.
+
+     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams(z_streamp strm,
+                                  int level,
+                                  int strategy);
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2().  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different strategy.
+   If the compression approach (which is a function of the level) or the
+   strategy is changed, and if there have been any deflate() calls since the
+   state was initialized or reset, then the input available so far is
+   compressed with the old level and strategy using deflate(strm, Z_BLOCK).
+   There are three approaches for the compression levels 0, 1..3, and 4..9
+   respectively.  The new level and strategy will take effect at the next call
+   of deflate().
+
+     If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+   not have enough output space to complete, then the parameter change will not
+   take effect.  In this case, deflateParams() can be called again with the
+   same parameters and more output space to try again.
+
+     In order to assure a change in the parameters on the first try, the
+   deflate stream should be flushed using deflate() with Z_BLOCK or other flush
+   request until strm.avail_out is not zero, before calling deflateParams().
+   Then no more input data should be provided before the deflateParams() call.
+   If this is done, the old level and strategy will be applied to the data
+   compressed before deflateParams(), and the new level and strategy will be
+   applied to the data compressed after deflateParams().
+
+     deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
+   state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
+   there was not enough output space to complete the compression of the
+   available input data before a change in the strategy or approach.  Note that
+   in the case of a Z_BUF_ERROR, the parameters are not changed.  A return
+   value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
+   retried with more output space.
+*/
+
+ZEXTERN int ZEXPORT deflateTune(z_streamp strm,
+                                int good_length,
+                                int max_lazy,
+                                int nice_length,
+                                int max_chain);
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen);
+ZEXTERN z_size_t ZEXPORT deflateBound_z(z_streamp strm, z_size_t sourceLen);
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit() or
+   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+   to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().  If that first deflate() call is provided the
+   sourceLen input bytes, an output buffer allocated to the size returned by
+   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
+   to return Z_STREAM_END.  Note that it is possible for the compressed size to
+   be larger than the value returned by deflateBound() if flush options other
+   than Z_FINISH or Z_NO_FLUSH are used.
+
+     delfateBound_z() is the same, but takes and returns a size_t length.  Note
+   that a long is 32 bits on Windows.
+*/
+
+ZEXTERN int ZEXPORT deflatePending(z_streamp strm,
+                                   unsigned *pending,
+                                   int *bits);
+/*
+     deflatePending() returns the number of bytes and bits of output that have
+   been generated, but not yet provided in the available output.  The bytes not
+   provided would be due to the available output space having being consumed.
+   The number of bits of output not provided are between 0 and 7, where they
+   await more bits to join them in order to fill out a full byte.  If pending
+   or bits are Z_NULL, then those values are not set.
+
+     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.  If an int is 16 bits and memLevel is 9, then
+   it is possible for the number of pending bytes to not fit in an unsigned. In
+   that case Z_BUF_ERROR is returned and *pending is set to the maximum value
+   of an unsigned.
+ */
+
+ZEXTERN int ZEXPORT deflateUsed(z_streamp strm,
+                                int *bits);
+/*
+     deflateUsed() returns in *bits the most recent number of deflate bits used
+   in the last byte when flushing to a byte boundary. The result is in 1..8, or
+   0 if there has not yet been a flush. This helps determine the location of
+   the last bit of a deflate stream.
+
+     deflateUsed returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+ */
+
+ZEXTERN int ZEXPORT deflatePrime(z_streamp strm,
+                                 int bits,
+                                 int value);
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+   is that this function is used to start off the deflate output with the bits
+   leftover from a previous deflate stream when appending to it.  As such, this
+   function can only be used for raw deflate, and must be used before the first
+   deflate() call after a deflateInit2() or deflateReset().  bits must be less
+   than or equal to 16, and that many of the least significant bits of value
+   will be inserted in the output.
+
+     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
+   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader(z_streamp strm,
+                                     gz_headerp head);
+/*
+     deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+     If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to the current operating system, with no
+   extra, name, or comment fields.  The gzip header is returned to the default
+   state by deflateReset().
+
+     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2(z_streamp strm,
+                                 int windowBits);
+
+     This is another version of inflateInit with an extra parameter.  The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library.  The default value is 15 if inflateInit is used
+   instead.  windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used.  If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be zero to request that inflate use the window size in
+   the zlib header of the compressed stream.
+
+     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+   determines the window size.  inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream.  This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values.  If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an Adler-32 or a CRC-32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is.  Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding.  Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+   CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see
+   below), inflate() will *not* automatically decode concatenated gzip members.
+   inflate() will return Z_STREAM_END at the end of the gzip member.  The state
+   would need to be reset to continue decoding a subsequent gzip member.  This
+   *must* be done if there is more data after a gzip member, in order for the
+   decompression to be compliant with the gzip standard (RFC 1952).
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit2 does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit2() does not process any header information -- that is
+   deferred until inflate() is called.
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary(z_streamp strm,
+                                         const Bytef *dictionary,
+                                         uInt  dictLength);
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence.  This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+   can be determined from the Adler-32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called at any
+   time to set the dictionary.  If the provided dictionary is smaller than the
+   window and there is already data in the window, then the provided dictionary
+   will amend what's there.  The application must insure that the dictionary
+   that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler-32 value).  inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateGetDictionary(z_streamp strm,
+                                         Bytef *dictionary,
+                                         uInt  *dictLength);
+/*
+     Returns the sliding dictionary being maintained by inflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If inflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similarly, if dictLength is Z_NULL, then it is not set.
+
+     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateSync(z_streamp strm);
+/*
+     Skips invalid compressed data until a possible full flush point (see above
+   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+
+     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
+   All full flush points have this pattern, but not all occurrences of this
+   pattern are full flush points.
+
+     inflateSync returns Z_OK if a possible full flush point has been found,
+   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
+   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
+   In the success case, the application may save the current value of total_in
+   which indicates where valid compressed data was found.  In the error case,
+   the application may repeatedly call inflateSync, providing more input each
+   time, until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy(z_streamp dest,
+                                z_streamp source);
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset(z_streamp strm);
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate the internal decompression state.  The
+   stream will keep attributes that may have been set by inflateInit2.
+   total_in, total_out, adler, and msg are initialized.
+
+     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT inflateReset2(z_streamp strm,
+                                  int windowBits);
+/*
+     This function is the same as inflateReset, but it also permits changing
+   the wrap and window size requests.  The windowBits parameter is interpreted
+   the same as it is for inflateInit2.  If the window size is changed, then the
+   memory allocated for the window is freed, and the window will be reallocated
+   by inflate() if needed.
+
+     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+   the windowBits parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT inflatePrime(z_streamp strm,
+                                 int bits,
+                                 int value);
+/*
+     This function inserts bits in the inflate input stream.  The intent is to
+   use inflatePrime() to start inflating at a bit position in the middle of a
+   byte.  The provided bits will be used before any bytes are used from
+   next_in.  This function should be used with raw inflate, before the first
+   inflate() call, after inflateInit2() or inflateReset().  It can also be used
+   after an inflate() return indicates the end of a deflate block or header
+   when using Z_BLOCK.  bits must be less than or equal to 16, and that many of
+   the least significant bits of value will be inserted in the input.  The
+   other bits in value can be non-zero, and will be ignored.
+
+     If bits is negative, then the input stream bit buffer is emptied.  Then
+   inflatePrime() can be called again to put bits in the buffer.  This is used
+   to clear out bits leftover after feeding inflate a block description prior
+   to feeding inflate codes.
+
+     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent, or if bits is out of range.  If inflate was
+   in the middle of processing a header, trailer, or stored block lengths, then
+   it is possible for there to be only eight bits available in the bit buffer.
+   In that case, bits > 8 is considered out of range.  However, when used as
+   outlined above, there will always be 16 bits available in the buffer for
+   insertion.  As noted in its documentation above, inflate records the number
+   of bits in the bit buffer on return in data_type. 32 minus that is the
+   number of bits available for insertion.  inflatePrime does not update
+   data_type with the new number of bits in buffer.
+*/
+
+ZEXTERN long ZEXPORT inflateMark(z_streamp strm);
+/*
+     This function returns two values, one in the lower 16 bits of the return
+   value, and the other in the remaining upper bits, obtained by shifting the
+   return value down 16 bits.  If the upper value is -1 and the lower value is
+   zero, then inflate() is currently decoding information outside of a block.
+   If the upper value is -1 and the lower value is non-zero, then inflate is in
+   the middle of a stored block, with the lower value equaling the number of
+   bytes from the input remaining to copy.  If the upper value is not -1, then
+   it is the number of bits back from the current bit position in the input of
+   the code (literal or length/distance pair) currently being processed.  In
+   that case the lower value is the number of bytes already emitted for that
+   code.
+
+     A code is being processed if inflate is waiting for more input to complete
+   decoding of the code, or if it has completed decoding but is waiting for
+   more output space to write the literal or match data.
+
+     inflateMark() is used to mark locations in the input data for random
+   access, which may be at bit positions, and to note those cases where the
+   output of a code may span boundaries of random access blocks.  The current
+   location in the input stream can be determined from avail_in and data_type
+   as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+     inflateMark returns the value noted above, or -65536 if the provided
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader(z_streamp strm,
+                                     gz_headerp head);
+/*
+     inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+   used to force inflate() to return immediately after header processing is
+   complete and before any actual data is decompressed.
+
+     The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.)  The extra, name, and comment pointers
+   much each be either Z_NULL or point to space to store that information from
+   the header.  If extra is not Z_NULL, then extra_max contains the maximum
+   number of bytes that can be written to extra.  Once done is true, extra_len
+   contains the actual extra field length, and extra contains the extra field,
+   or that field truncated if extra_max is less than extra_len.  If name is not
+   Z_NULL, then up to name_max characters, including the terminating zero, are
+   written there.  If comment is not Z_NULL, then up to comm_max characters,
+   including the terminating zero, are written there.  The application can tell
+   that the name or comment did not fit in the provided space by the absence of
+   a terminating zero.  If any of extra, name, or comment are not present in
+   the header, then that field's pointer is set to Z_NULL.  This allows the use
+   of deflateSetHeader() with the returned structure to duplicate the header.
+   Note that if those fields initially pointed to allocated memory, then the
+   application will need to save them elsewhere so that they can be eventually
+   freed.
+
+     If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit(z_streamp strm, int windowBits,
+                                    unsigned char FAR *window);
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
+   allocated, or Z_VERSION_ERROR if the version of the library does not match
+   the version of the header file.
+*/
+
+typedef unsigned (*in_func)(void FAR *,
+                            z_const unsigned char FAR * FAR *);
+typedef int (*out_func)(void FAR *, unsigned char FAR *, unsigned);
+
+ZEXTERN int ZEXPORT inflateBack(z_streamp strm,
+                                in_func in, void FAR *in_desc,
+                                out_func out, void FAR *out_desc);
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is potentially more efficient than
+   inflate() for file i/o applications, in that it avoids copying between the
+   output and the sliding window by simply making the window itself the output
+   buffer.  inflate() can be faster on modern CPUs when used with large
+   buffers.  inflateBack() trusts the application to not change the output
+   buffer passed by the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free the
+   allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects only
+   the raw deflate stream to decompress.  This is different from the default
+   behavior of inflate(), which expects a zlib header and trailer around the
+   deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero -- buf is ignored in that
+   case -- and inflateBack() will return a buffer error.  inflateBack() will
+   call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
+   out() should return zero on success, or non-zero on failure.  If out()
+   returns non-zero, inflateBack() will return with an error.  Neither in() nor
+   out() are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+   in the deflate stream (in which case strm->msg is set to indicate the nature
+   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+   In the case of Z_BUF_ERROR, an input or output error can be distinguished
+   using strm->next_in which will be Z_NULL only if in() returned an error.  If
+   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+   non-zero.  (in() will always be called before out(), so strm->next_in is
+   assured to be defined if out() returns non-zero.)  Note that inflateBack()
+   cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd(z_streamp strm);
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags(void);
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: ZLIB_DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (all zeros is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() is not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+     27: 0 = gzprintf() present, 1 = not -- 1 means gzprintf() returns an error
+
+    Remainder:
+     28-31: 0 (reserved)
+ */
+
+#ifndef Z_SOLO
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the basic
+   stream-oriented functions.  To simplify the interface, some default options
+   are assumed (compression level and memory usage, standard memory allocation
+   functions).  The source code of these utility functions can be modified if
+   you need special options.  The _z versions of the functions use the size_t
+   type for lengths.  Note that a long is 32 bits on Windows.
+*/
+
+ZEXTERN int ZEXPORT compress(Bytef *dest, uLongf *destLen,
+                             const Bytef *source, uLong sourceLen);
+ZEXTERN int ZEXPORT compress_z(Bytef *dest, z_size_t *destLen,
+                               const Bytef *source, z_size_t sourceLen);
+/*
+     Compresses 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 at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed data.  compress() is equivalent to compress2() with a level
+   parameter of Z_DEFAULT_COMPRESSION.
+
+     compress 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.
+*/
+
+ZEXTERN int ZEXPORT compress2(Bytef *dest, uLongf *destLen,
+                              const Bytef *source, uLong sourceLen,
+                              int level);
+ZEXTERN int ZEXPORT compress2_z(Bytef *dest, z_size_t *destLen,
+                                const Bytef *source, z_size_t sourceLen,
+                                int level);
+/*
+     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 the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed data.
+
+     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.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound(uLong sourceLen);
+ZEXTERN z_size_t ZEXPORT compressBound_z(z_size_t sourceLen);
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before a
+   compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress(Bytef *dest, uLongf *destLen,
+                               const Bytef *source, uLong sourceLen);
+ZEXTERN int ZEXPORT uncompress_z(Bytef *dest, z_size_t *destLen,
+                                 const Bytef *source, z_size_t sourceLen);
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  On 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.)  On exit, *destLen
+   is the actual size of the uncompressed data.
+
+     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 or incomplete.  In
+   the case where there is not enough room, uncompress() will fill the output
+   buffer with the uncompressed data up to that point.
+*/
+
+ZEXTERN int ZEXPORT uncompress2(Bytef *dest, uLongf *destLen,
+                                const Bytef *source, uLong *sourceLen);
+ZEXTERN int ZEXPORT uncompress2_z(Bytef *dest, z_size_t *destLen,
+                                  const Bytef *source, z_size_t *sourceLen);
+/*
+     Same as uncompress, except that sourceLen is a pointer, where the
+   length of the source is *sourceLen.  On return, *sourceLen is the number of
+   source bytes consumed.
+*/
+
+                        /* gzip file access functions */
+
+/*
+     This library supports reading and writing files in gzip (.gz) format with
+   an interface similar to that of stdio, using the functions that start with
+   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+   wrapper, documented in RFC 1952, wrapped around a deflate stream.
+*/
+
+typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
+
+/*
+ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode);
+
+     Open the gzip (.gz) file at path for reading and decompressing, or
+   compressing and writing.  The mode parameter is as in fopen ("rb" or "wb")
+   but can also include a compression level ("wb9") or a strategy: 'f' for
+   filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h",
+   'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression
+   as in "wb9F".  (See the description of deflateInit2 for more information
+   about the strategy parameter.)  'T' will request transparent writing or
+   appending with no compression and not using the gzip format. 'T' cannot be
+   used to force transparent reading. Transparent reading is automatically
+   performed if there is no gzip header at the start. Transparent reading can
+   be disabled with the 'G' option, which will instead return an error if there
+   is no gzip header. 'N' will open the file in non-blocking mode.
+
+     'a' can be used instead of 'w' to request that the gzip stream that will
+   be written be appended to the file.  '+' will result in an error, since
+   reading and writing to the same gzip file is not supported.  The addition of
+   'x' when writing will create the file exclusively, which fails if the file
+   already exists.  On systems that support it, the addition of 'e' when
+   reading or writing will set the flag to close the file on an execve() call.
+
+     These functions, as well as gzip, will read and decode a sequence of gzip
+   streams in a file.  The append function of gzopen() can be used to create
+   such a file.  (Also see gzflush() for another way to do this.)  When
+   appending, gzopen does not test whether the file begins with a gzip stream,
+   nor does it look for the end of the gzip streams to begin appending.  gzopen
+   will simply append a gzip stream to the existing file.
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.  When
+   reading, this will be detected automatically by looking for the magic two-
+   byte gzip header.
+
+     gzopen returns NULL if the file could not be opened, if there was
+   insufficient memory to allocate the gzFile state, or if an invalid mode was
+   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+   errno can be checked to determine if the reason gzopen failed was that the
+   file could not be opened. Note that if 'N' is in mode for non-blocking, the
+   open() itself can fail in order to not block. In that case gzopen() will
+   return NULL and errno will be EAGAIN or ENONBLOCK. The call to gzopen() can
+   then be re-tried. If the application would like to block on opening the
+   file, then it can use open() without O_NONBLOCK, and then gzdopen() with the
+   resulting file descriptor and 'N' in the mode, which will set it to non-
+   blocking.
+*/
+
+ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode);
+/*
+     Associate a gzFile with the file descriptor fd.  File descriptors are
+   obtained from calls like open, dup, creat, pipe or fileno (if the file has
+   been previously opened with fopen).  The mode parameter is as in gzopen. An
+   'e' in mode will set fd's flag to close the file on an execve() call. An 'N'
+   in mode will set fd's non-blocking flag.
+
+     The next call of gzclose on the returned gzFile will also close the file
+   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+   mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.  If you are using fileno() to get the
+   file descriptor from a FILE *, then you will have to use dup() to avoid
+   double-close()ing the file descriptor.  Both gzclose() and fclose() will
+   close the associated file descriptor, so they need to have different file
+   descriptors.
+
+     gzdopen returns NULL if there was insufficient memory to allocate the
+   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+   used until the next gz* read, write, seek, or close operation, so gzdopen
+   will not detect if fd is invalid (unless fd is -1).
+*/
+
+ZEXTERN int ZEXPORT gzbuffer(gzFile file, unsigned size);
+/*
+     Set the internal buffer size used by this library's functions for file to
+   size.  The default buffer size is 8192 bytes.  This function must be called
+   after gzopen() or gzdopen(), and before any other calls that read or write
+   the file.  The buffer memory allocation is always deferred to the first read
+   or write.  Three times that size in buffer space is allocated.  A larger
+   buffer size of, for example, 64K or 128K bytes will noticeably increase the
+   speed of decompression (reading).
+
+     The new buffer size also affects the maximum length for gzprintf().
+
+     gzbuffer() returns 0 on success, or -1 on failure, such as being called
+   too late.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy);
+/*
+     Dynamically update the compression level and strategy for file.  See the
+   description of deflateInit2 for the meaning of these parameters. Previously
+   provided data is flushed before applying the parameter changes.
+
+     gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
+   opened for writing, Z_ERRNO if there is an error writing the flushed data,
+   or Z_MEM_ERROR if there is a memory allocation error.
+*/
+
+ZEXTERN int ZEXPORT gzread(gzFile file, voidp buf, unsigned len);
+/*
+     Read and decompress up to len uncompressed bytes from file into buf.  If
+   the input file is not in gzip format, gzread copies the given number of
+   bytes into the buffer directly from the file.
+
+     After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream.  Any number of gzip streams may be
+   concatenated in the input file, and will all be decompressed by gzread().
+   If something other than a gzip stream is encountered after a gzip stream,
+   that remaining trailing garbage is ignored (and no error is returned).
+
+     gzread can be used to read a gzip file that is being concurrently written.
+   Upon reaching the end of the input, gzread will return with the available
+   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
+   gzclearerr can be used to clear the end of file indicator in order to permit
+   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
+   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
+   middle of a gzip stream.  Note that gzread does not return -1 in the event
+   of an incomplete gzip stream.  This error is deferred until gzclose(), which
+   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
+   stream.  Alternatively, gzerror can be used before gzclose to detect this
+   case.
+
+     gzread can be used to read a gzip file on a non-blocking device. If the
+   input stalls and there is no uncompressed data to return, then gzread() will
+   return -1, and errno will be EAGAIN or EWOULDBLOCK. gzread() can then be
+   called again.
+
+     gzread returns the number of uncompressed bytes actually read, less than
+   len for end of file, or -1 for error.  If len is too large to fit in an int,
+   then nothing is read, -1 is returned, and the error state is set to
+   Z_STREAM_ERROR. If some data was read before an error, then that data is
+   returned until exhausted, after which the next call will signal the error.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems,
+                                 gzFile file);
+/*
+     Read and decompress up to nitems items of size size from file into buf,
+   otherwise operating as gzread() does.  This duplicates the interface of
+   stdio's fread(), with size_t request and return types.  If the library
+   defines size_t, then z_size_t is identical to size_t.  If not, then z_size_t
+   is an unsigned integer type that can contain a pointer.
+
+     gzfread() returns the number of full items read of size size, or zero if
+   the end of the file was reached and a full item could not be read, or if
+   there was an error.  gzerror() must be consulted if zero is returned in
+   order to determine if there was an error.  If the multiplication of size and
+   nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
+   is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
+
+     In the event that the end of file is reached and only a partial item is
+   available at the end, i.e. the remaining uncompressed data length is not a
+   multiple of size, then the final partial item is nevertheless read into buf
+   and the end-of-file flag is set.  The length of the partial item read is not
+   provided, but could be inferred from the result of gztell().  This behavior
+   is the same as that of fread() implementations in common libraries. This
+   could result in data loss if used with size != 1 when reading a concurrently
+   written file or a non-blocking file. In that case, use size == 1 or gzread()
+   instead.
+*/
+
+ZEXTERN int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len);
+/*
+     Compress and write the len uncompressed bytes at buf to file. gzwrite
+   returns the number of uncompressed bytes written, or 0 in case of error or
+   if len is 0.  If the write destination is non-blocking, then gzwrite() may
+   return a number of bytes written that is not 0 and less than len.
+
+     If len does not fit in an int, then 0 is returned and nothing is written.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size,
+                                  z_size_t nitems, gzFile file);
+/*
+     Compress and write nitems items of size size from buf to file, duplicating
+   the interface of stdio's fwrite(), with size_t request and return types.  If
+   the library defines size_t, then z_size_t is identical to size_t.  If not,
+   then z_size_t is an unsigned integer type that can contain a pointer.
+
+     gzfwrite() returns the number of full items written of size size, or zero
+   if there was an error.  If the multiplication of size and nitems overflows,
+   i.e. the product does not fit in a z_size_t, then nothing is written, zero
+   is returned, and the error state is set to Z_STREAM_ERROR.
+
+     If writing a concurrently read file or a non-blocking file with size != 1,
+   a partial item could be written, with no way of knowing how much of it was
+   not written, resulting in data loss.  In that case, use size == 1 or
+   gzwrite() instead.
+*/
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...);
+#else
+ZEXTERN int ZEXPORTVA gzprintf();
+#endif
+/*
+     Convert, format, compress, and write the arguments (...) to file under
+   control of the string format, as in fprintf.  gzprintf returns the number of
+   uncompressed bytes actually written, or a negative zlib error code in case
+   of error.  The number of uncompressed bytes written is limited to 8191, or
+   one less than the buffer size given to gzbuffer().  The caller should assure
+   that this limit is not exceeded.  If it is exceeded, then gzprintf() will
+   return an error (0) with nothing written.
+
+     In that last case, there may also be a buffer overflow with unpredictable
+   consequences, which is possible only if zlib was compiled with the insecure
+   functions sprintf() or vsprintf(), because the secure snprintf() and
+   vsnprintf() functions were not available. That would only be the case for
+   a non-ANSI C compiler. zlib may have been built without gzprintf() because
+   secure functions were not available and having gzprintf() be insecure was
+   not an option, in which case, gzprintf() returns Z_STREAM_ERROR. All of
+   these possibilities can be determined using zlibCompileFlags().
+
+     If a Z_BUF_ERROR is returned, then nothing was written due to a stall on
+   the non-blocking write destination.
+*/
+
+ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s);
+/*
+     Compress and write the given null-terminated string s to file, excluding
+   the terminating null character.
+
+     gzputs returns the number of characters written, or -1 in case of error.
+   The number of characters written may be less than the length of the string
+   if the write destination is non-blocking.
+
+     If the length of the string does not fit in an int, then -1 is returned
+   and nothing is written.
+*/
+
+ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len);
+/*
+     Read and decompress bytes from file into buf, until len-1 characters are
+   read, or until a newline character is read and transferred to buf, or an
+   end-of-file condition is encountered.  If any characters are read or if len
+   is one, the string is terminated with a null character.  If no characters
+   are read due to an end-of-file or len is less than one, then the buffer is
+   left untouched.
+
+     gzgets returns buf which is a null-terminated string, or it returns NULL
+   for end-of-file or in case of error. If some data was read before an error,
+   then that data is returned until exhausted, after which the next call will
+   return NULL to signal the error.
+
+     gzgets can be used on a file being concurrently written, and on a non-
+   blocking device, both as for gzread(). However lines may be broken in the
+   middle, leaving it up to the application to reassemble them as needed.
+*/
+
+ZEXTERN int ZEXPORT gzputc(gzFile file, int c);
+/*
+     Compress and write c, converted to an unsigned char, into file.  gzputc
+   returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc(gzFile file);
+/*
+     Read and decompress one byte from file. gzgetc returns this byte or -1 in
+   case of end of file or error. If some data was read before an error, then
+   that data is returned until exhausted, after which the next call will return
+   -1 to signal the error.
+
+     This is implemented as a macro for speed. As such, it does not do all of
+   the checking the other functions do. I.e. it does not check to see if file
+   is NULL, nor whether the structure file points to has been clobbered or not.
+
+     gzgetc can be used to read a gzip file on a non-blocking device. If the
+   input stalls and there is no uncompressed data to return, then gzgetc() will
+   return -1, and errno will be EAGAIN or EWOULDBLOCK. gzread() can then be
+   called again.
+*/
+
+ZEXTERN int ZEXPORT gzungetc(int c, gzFile file);
+/*
+     Push c back onto the stream for file to be read as the first character on
+   the next read.  At least one character of push-back is always allowed.
+   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+   fail if c is -1, and may fail if a character has been pushed but not read
+   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+   The pushed character will be discarded if the stream is repositioned with
+   gzseek() or gzrewind().
+
+     gzungetc(-1, file) will force any pending seek to execute. Then gztell()
+   will report the position, even if the requested seek reached end of file.
+   This can be used to determine the number of uncompressed bytes in a gzip
+   file without having to read it into a buffer.
+*/
+
+ZEXTERN int ZEXPORT gzflush(gzFile file, int flush);
+/*
+     Flush all pending output to file.  The parameter flush is as in the
+   deflate() function.  The return value is the zlib error number (see function
+   gzerror below).  gzflush is only permitted when writing.
+
+     If the flush parameter is Z_FINISH, the remaining data is written and the
+   gzip stream is completed in the output.  If gzwrite() is called again, a new
+   gzip stream will be started in the output.  gzread() is able to read such
+   concatenated gzip streams.
+
+     gzflush should be called only when strictly necessary because it will
+   degrade compression if called too often.
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzseek(gzFile file,
+                               z_off_t offset, int whence);
+
+     Set the starting position to offset relative to whence for the next gzread
+   or gzwrite on file.  The offset represents a number of bytes in the
+   uncompressed data stream.  The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow.  If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position. For reading or writing, any actual seeking is deferred
+   until the next read or write operation, or close operation when writing.
+
+     gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT gzrewind(gzFile file);
+/*
+     Rewind file. This function is supported only for reading.
+
+     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET).
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gztell(gzFile file);
+
+     Return the starting position for the next gzread or gzwrite on file.
+   This position represents a number of bytes in the uncompressed data stream,
+   and is zero when starting, even if appending or reading a gzip stream from
+   the middle of a file using gzdopen().
+
+     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file);
+
+     Return the current compressed (actual) read or write offset of file.  This
+   offset includes the count of bytes that precede the gzip stream, for example
+   when appending or when using gzdopen() for reading.  When reading, the
+   offset does not include as yet unused buffered input.  This information can
+   be used for a progress indicator.  On error, gzoffset() returns -1.
+*/
+
+ZEXTERN int ZEXPORT gzeof(gzFile file);
+/*
+     Return true (1) if the end-of-file indicator for file has been set while
+   reading, false (0) otherwise.  Note that the end-of-file indicator is set
+   only if the read tried to go past the end of the input, but came up short.
+   Therefore, just like feof(), gzeof() may return false even if there is no
+   more data to read, in the event that the last read request was for the exact
+   number of bytes remaining in the input file.  This will happen if the input
+   file size is an exact multiple of the buffer size.
+
+     If gzeof() returns true, then the read functions will return no more data,
+   unless the end-of-file indicator is reset by gzclearerr() and the input file
+   has grown since the previous end of file was detected.
+*/
+
+ZEXTERN int ZEXPORT gzdirect(gzFile file);
+/*
+     Return true (1) if file is being copied directly while reading, or false
+   (0) if file is a gzip stream being decompressed.
+
+     If the input file is empty, gzdirect() will return true, since the input
+   does not contain a gzip stream.
+
+     If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file. Therefore if gzbuffer() is used, it should be called before
+   gzdirect(). If the input is being written concurrently or the device is non-
+   blocking, then gzdirect() may give a different answer once four bytes of
+   input have been accumulated, which is what is needed to confirm or deny a
+   gzip header. Before this, gzdirect() will return true (1).
+
+     When writing, gzdirect() returns true (1) if transparent writing was
+   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
+   gzdirect() is not needed when writing.  Transparent writing must be
+   explicitly requested, so the application already knows the answer.  When
+   linking statically, using gzdirect() will include all of the zlib code for
+   gzip file reading and decompression, which may not be desired.)
+*/
+
+ZEXTERN int ZEXPORT gzclose(gzFile file);
+/*
+     Flush all pending output for file, if necessary, close file and
+   deallocate the (de)compression state.  Note that once file is closed, you
+   cannot call gzerror with file, since its structures have been deallocated.
+   gzclose must not be called more than once on the same file, just as free
+   must not be called more than once on the same allocation.
+
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
+   last read ended in the middle of a gzip stream, or Z_OK on success.
+*/
+
+ZEXTERN int ZEXPORT gzclose_r(gzFile file);
+ZEXTERN int ZEXPORT gzclose_w(gzFile file);
+/*
+     Same as gzclose(), but gzclose_r() is only for use when reading, and
+   gzclose_w() is only for use when writing or appending.  The advantage to
+   using these instead of gzclose() is that they avoid linking in zlib
+   compression or decompression code that is not used when only reading or only
+   writing respectively.  If gzclose() is used, then both compression and
+   decompression code will be included the application when linking to a static
+   zlib library.
+*/
+
+ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum);
+/*
+     Return the error message for the last error which occurred on file.
+   If errnum is not NULL, *errnum is set to zlib error number.  If an error
+   occurred in the file system and not in the compression library, *errnum is
+   set to Z_ERRNO and the application may consult errno to get the exact error
+   code.
+
+     The application must not modify the returned string.  Future calls to
+   this function may invalidate the previously returned string.  If file is
+   closed, then the string previously returned by gzerror will no longer be
+   available.
+
+     gzerror() should be used to distinguish errors from end-of-file for those
+   functions above that do not distinguish those cases in their return values.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr(gzFile file);
+/*
+     Clear the error and end-of-file flags for file.  This is analogous to the
+   clearerr() function in stdio.  This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+#endif /* !Z_SOLO */
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the compression
+   library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len);
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. An Adler-32 value is in the range of a 32-bit
+   unsigned integer. If buf is Z_NULL, this function returns the required
+   initial value for the checksum.
+
+     An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
+   much faster.
+
+   Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf,
+                                z_size_t len);
+/*
+     Same as adler32(), but with a size_t length.  Note that a long is 32 bits
+   on Windows.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2,
+                                      z_off_t len2);
+
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+   that the z_off_t type (like off_t) is a signed integer.  If len2 is
+   negative, the result has no meaning or utility.
+*/
+
+ZEXTERN uLong ZEXPORT crc32(uLong crc, const Bytef *buf, uInt len);
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer.
+   If buf is Z_NULL, this function returns the required initial value for the
+   crc. Pre- and post-conditioning (one's complement) is performed within this
+   function so it shouldn't be done by the application.
+
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_z(uLong crc, const Bytef *buf,
+                              z_size_t len);
+/*
+     Same as crc32(), but with a size_t length.  Note that a long is 32 bits on
+   Windows.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2);
+
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2. len2 must be non-negative, otherwise zero is returned.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t len2);
+
+     Return the operator corresponding to length len2, to be used with
+   crc32_combine_op(). len2 must be non-negative, otherwise zero is returned.
+*/
+
+ZEXTERN uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op);
+/*
+     Give the same result as crc32_combine(), using op in place of len2. op is
+   is generated from len2 by crc32_combine_gen(). This will be faster than
+   crc32_combine() if the generated op is used more than once.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_(z_streamp strm, int level,
+                                 const char *version, int stream_size);
+ZEXTERN int ZEXPORT inflateInit_(z_streamp strm,
+                                 const char *version, int stream_size);
+ZEXTERN int ZEXPORT deflateInit2_(z_streamp strm, int  level, int  method,
+                                  int windowBits, int memLevel,
+                                  int strategy, const char *version,
+                                  int stream_size);
+ZEXTERN int ZEXPORT inflateInit2_(z_streamp strm, int  windowBits,
+                                  const char *version, int stream_size);
+ZEXTERN int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits,
+                                     unsigned char FAR *window,
+                                     const char *version,
+                                     int stream_size);
+#ifdef Z_PREFIX_SET
+#  define z_deflateInit(strm, level) \
+          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_inflateInit(strm) \
+          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_inflateInit2(strm, windowBits) \
+          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+                        (int)sizeof(z_stream))
+#  define z_inflateBackInit(strm, windowBits, window) \
+          inflateBackInit_((strm), (windowBits), (window), \
+                           ZLIB_VERSION, (int)sizeof(z_stream))
+#else
+#  define deflateInit(strm, level) \
+          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define inflateInit(strm) \
+          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define inflateInit2(strm, windowBits) \
+          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+                        (int)sizeof(z_stream))
+#  define inflateBackInit(strm, windowBits, window) \
+          inflateBackInit_((strm), (windowBits), (window), \
+                           ZLIB_VERSION, (int)sizeof(z_stream))
+#endif
+
+#ifndef Z_SOLO
+
+/* gzgetc() macro and its supporting function and exposed data structure.  Note
+ * that the real internal state is much larger than the exposed structure.
+ * This abbreviated structure exposes just enough for the gzgetc() macro.  The
+ * user should not mess with these exposed elements, since their names or
+ * behavior could change in the future, perhaps even capriciously.  They can
+ * only be used by the gzgetc() macro.  You have been warned.
+ */
+struct gzFile_s {
+    unsigned have;
+    unsigned char *next;
+    z_off64_t pos;
+};
+ZEXTERN int ZEXPORT gzgetc_(gzFile file);       /* backward compatibility */
+#ifdef Z_PREFIX_SET
+#  undef z_gzgetc
+#  define z_gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#else
+#  define gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#endif
+
+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
+ * both are true, the application gets the *64 functions, and the regular
+ * functions are changed to 64 bits) -- in case these are set on systems
+ * without large file support, _LFS64_LARGEFILE must also be true
+ */
+#ifdef Z_LARGE64
+   ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);
+   ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int);
+   ZEXTERN z_off64_t ZEXPORT gztell64(gzFile);
+   ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile);
+   ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);
+   ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);
+   ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);
+#endif
+
+#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
+#  ifdef Z_PREFIX_SET
+#    define z_gzopen z_gzopen64
+#    define z_gzseek z_gzseek64
+#    define z_gztell z_gztell64
+#    define z_gzoffset z_gzoffset64
+#    define z_adler32_combine z_adler32_combine64
+#    define z_crc32_combine z_crc32_combine64
+#    define z_crc32_combine_gen z_crc32_combine_gen64
+#  else
+#    define gzopen gzopen64
+#    define gzseek gzseek64
+#    define gztell gztell64
+#    define gzoffset gzoffset64
+#    define adler32_combine adler32_combine64
+#    define crc32_combine crc32_combine64
+#    define crc32_combine_gen crc32_combine_gen64
+#  endif
+#  ifndef Z_LARGE64
+     ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);
+     ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int);
+     ZEXTERN z_off_t ZEXPORT gztell64(gzFile);
+     ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile);
+     ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);
+     ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);
+     ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);
+#  endif
+#else
+   ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *);
+   ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int);
+   ZEXTERN z_off_t ZEXPORT gztell(gzFile);
+   ZEXTERN z_off_t ZEXPORT gzoffset(gzFile);
+   ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t);
+   ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t);
+   ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t);
+#endif
+
+#else /* Z_SOLO */
+
+   ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t);
+   ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t);
+   ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t);
+
+#endif /* !Z_SOLO */
+
+/* undocumented functions */
+ZEXTERN const char   * ZEXPORT zError(int);
+ZEXTERN int            ZEXPORT inflateSyncPoint(z_streamp);
+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table(void);
+ZEXTERN int            ZEXPORT inflateUndermine(z_streamp, int);
+ZEXTERN int            ZEXPORT inflateValidate(z_streamp, int);
+ZEXTERN unsigned long  ZEXPORT inflateCodesUsed(z_streamp);
+ZEXTERN int            ZEXPORT inflateResetKeep(z_streamp);
+ZEXTERN int            ZEXPORT deflateResetKeep(z_streamp);
+#if defined(_WIN32) && !defined(Z_SOLO)
+ZEXTERN gzFile         ZEXPORT gzopen_w(const wchar_t *path,
+                                        const char *mode);
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+ZEXTERN int            ZEXPORTVA gzvprintf(gzFile file,
+                                           const char *format,
+                                           va_list va);
+#  endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/Minecraft.Client/Common/zlib/zutil.c b/Minecraft.Client/Common/zlib/zutil.c
index 22f29aea..0e30c566 100644
--- a/Minecraft.Client/Common/zlib/zutil.c
+++ b/Minecraft.Client/Common/zlib/zutil.c
@@ -1,312 +1,312 @@
-/* zutil.c -- target dependent utility functions for the compression library

- * Copyright (C) 1995-2026 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

-

-z_const char * const z_errmsg[10] = {

-    (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */

-    (z_const char *)"stream end",          /* Z_STREAM_END      1  */

-    (z_const char *)"",                    /* Z_OK              0  */

-    (z_const char *)"file error",          /* Z_ERRNO         (-1) */

-    (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */

-    (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */

-    (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */

-    (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */

-    (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */

-    (z_const char *)""

-};

-

-

-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 ZLIB_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

-#       ifdef ZLIB_INSECURE

-            flags += 1L << 25;

-#       else

-            flags += 1L << 27;

-#       endif

-#       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

-#       ifdef ZLIB_INSECURE

-            flags += 1L << 25;

-#       else

-            flags += 1L << 27;

-#       endif

-#       ifdef HAS_sprintf_void

-            flags += 1L << 26;

-#       endif

-#   else

-#       ifdef HAS_snprintf_void

-            flags += 1L << 26;

-#       endif

-#   endif

-#endif

-    return flags;

-}

-

-#ifdef ZLIB_DEBUG

-#include <stdlib.h>

-#  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) && _WIN32_WCE < 0x800

-    /* The older 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(void FAR *dst, const void FAR *src, z_size_t n) {

-    uchf *p = dst;

-    const uchf *q = src;

-    while (n) {

-        *p++ = *q++;

-        n--;

-    }

-}

-

-int ZLIB_INTERNAL zmemcmp(const void FAR *s1, const void FAR *s2, z_size_t n) {

-    const uchf *p = s1, *q = s2;

-    while (n) {

-        if (*p++ != *q++)

-            return (int)p[-1] - (int)q[-1];

-        n--;

-    }

-    return 0;

-}

-

-void ZLIB_INTERNAL zmemzero(void FAR *b, z_size_t len) {

-    uchf *p = b;

-    while (len) {

-        *p++ = 0;

-        len--;

-    }

-}

-

-#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;

-    ulg bsize = (ulg)items*size;

-

-    (void)opaque;

-

-    /* 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;

-

-    (void)opaque;

-

-    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;

-    }

-    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) {

-    (void)opaque;

-    return _halloc((long)items, size);

-}

-

-void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) {

-    (void)opaque;

-    _hfree(ptr);

-}

-

-#endif /* M_I86 */

-

-#endif /* SYS16BIT */

-

-

-#ifndef MY_ZCALLOC /* Any system without a special alloc function */

-

-#ifndef STDC

-extern voidp malloc(uInt size);

-extern voidp calloc(uInt items, uInt size);

-extern void free(voidpf ptr);

-#endif

-

-voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size) {

-    (void)opaque;

-    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :

-                              (voidpf)calloc(items, size);

-}

-

-void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) {

-    (void)opaque;

-    free(ptr);

-}

-

-#endif /* MY_ZCALLOC */

-

-#endif /* !Z_SOLO */

+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2026 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
+
+z_const char * const z_errmsg[10] = {
+    (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
+    (z_const char *)"stream end",          /* Z_STREAM_END      1  */
+    (z_const char *)"",                    /* Z_OK              0  */
+    (z_const char *)"file error",          /* Z_ERRNO         (-1) */
+    (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
+    (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
+    (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
+    (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
+    (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
+    (z_const char *)""
+};
+
+
+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 ZLIB_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
+#       ifdef ZLIB_INSECURE
+            flags += 1L << 25;
+#       else
+            flags += 1L << 27;
+#       endif
+#       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
+#       ifdef ZLIB_INSECURE
+            flags += 1L << 25;
+#       else
+            flags += 1L << 27;
+#       endif
+#       ifdef HAS_sprintf_void
+            flags += 1L << 26;
+#       endif
+#   else
+#       ifdef HAS_snprintf_void
+            flags += 1L << 26;
+#       endif
+#   endif
+#endif
+    return flags;
+}
+
+#ifdef ZLIB_DEBUG
+#include <stdlib.h>
+#  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) && _WIN32_WCE < 0x800
+    /* The older 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(void FAR *dst, const void FAR *src, z_size_t n) {
+    uchf *p = dst;
+    const uchf *q = src;
+    while (n) {
+        *p++ = *q++;
+        n--;
+    }
+}
+
+int ZLIB_INTERNAL zmemcmp(const void FAR *s1, const void FAR *s2, z_size_t n) {
+    const uchf *p = s1, *q = s2;
+    while (n) {
+        if (*p++ != *q++)
+            return (int)p[-1] - (int)q[-1];
+        n--;
+    }
+    return 0;
+}
+
+void ZLIB_INTERNAL zmemzero(void FAR *b, z_size_t len) {
+    uchf *p = b;
+    while (len) {
+        *p++ = 0;
+        len--;
+    }
+}
+
+#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;
+    ulg bsize = (ulg)items*size;
+
+    (void)opaque;
+
+    /* 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;
+
+    (void)opaque;
+
+    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;
+    }
+    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) {
+    (void)opaque;
+    return _halloc((long)items, size);
+}
+
+void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) {
+    (void)opaque;
+    _hfree(ptr);
+}
+
+#endif /* M_I86 */
+
+#endif /* SYS16BIT */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp malloc(uInt size);
+extern voidp calloc(uInt items, uInt size);
+extern void free(voidpf ptr);
+#endif
+
+voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size) {
+    (void)opaque;
+    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+                              (voidpf)calloc(items, size);
+}
+
+void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) {
+    (void)opaque;
+    free(ptr);
+}
+
+#endif /* MY_ZCALLOC */
+
+#endif /* !Z_SOLO */
diff --git a/Minecraft.Client/Common/zlib/zutil.h b/Minecraft.Client/Common/zlib/zutil.h
index 179ca92c..a9bc23ca 100644
--- a/Minecraft.Client/Common/zlib/zutil.h
+++ b/Minecraft.Client/Common/zlib/zutil.h
@@ -1,331 +1,331 @@
-/* zutil.h -- internal interface and configuration of the compression library

- * Copyright (C) 1995-2026 Jean-loup Gailly, 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.

- */

-

-/* @(#) $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

-

-#ifndef local

-#  define local static

-#endif

-/* since "static" is used to mean two completely different things in C, we

-   define "local" for the non-static meaning of "static", for readability

-   (compile with -Dlocal if your debugger can't find static symbols) */

-

-extern const char deflate_copyright[];

-extern const char inflate_copyright[];

-extern const char inflate9_copyright[];

-

-typedef unsigned char  uch;

-typedef uch FAR uchf;

-typedef unsigned short ush;

-typedef ush FAR ushf;

-typedef unsigned long  ulg;

-

-#if !defined(Z_U8) && !defined(Z_SOLO) && defined(STDC)

-#  include <limits.h>

-#  if (ULONG_MAX == 0xffffffffffffffff)

-#    define Z_U8 unsigned long

-#  elif (ULLONG_MAX == 0xffffffffffffffff)

-#    define Z_U8 unsigned long long

-#  elif (ULONG_LONG_MAX == 0xffffffffffffffff)

-#    define Z_U8 unsigned long long

-#  elif (UINT_MAX == 0xffffffffffffffff)

-#    define Z_U8 unsigned

-#  endif

-#endif

-

-extern z_const 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[(err) < -6 || (err) > 2 ? 9 : 2 - (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 */

-#if MAX_WBITS < 9 || MAX_WBITS > 15

-#  error MAX_WBITS must be in 9..15

-#endif

-#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  1

-#endif

-

-#if defined(VAXC) || defined(VMS)

-#  define OS_CODE  2

-#  define F_OPEN(name, mode) \

-     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")

-#endif

-

-#ifdef __370__

-#  if __TARGET_LIB__ < 0x20000000

-#    define OS_CODE 4

-#  elif __TARGET_LIB__ < 0x40000000

-#    define OS_CODE 11

-#  else

-#    define OS_CODE 8

-#  endif

-#endif

-

-#if defined(ATARI) || defined(atarist)

-#  define OS_CODE  5

-#endif

-

-#ifdef OS2

-#  define OS_CODE  6

-#  if defined(M_I86) && !defined(Z_SOLO)

-#    include <malloc.h>

-#  endif

-#endif

-

-#if defined(MACOS)

-#  define OS_CODE  7

-#endif

-

-#if defined(__acorn) || defined(__riscos)

-#  define OS_CODE 13

-#endif

-

-#if defined(WIN32) && !defined(__CYGWIN__)

-#  define OS_CODE  10

-#endif

-

-#ifdef _BEOS_

-#  define OS_CODE  16

-#endif

-

-#ifdef __TOS_OS400__

-#  define OS_CODE 18

-#endif

-

-#ifdef __APPLE__

-#  define OS_CODE 19

-#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 */

-#ifndef Z_LARGE64

-   ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);

-   ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);

-   ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);

-#endif

-

-        /* common defaults */

-

-#ifndef OS_CODE

-#  define OS_CODE  3     /* 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(void FAR *, const void FAR *, z_size_t);

-   int ZLIB_INTERNAL zmemcmp(const void FAR *, const void FAR *, z_size_t);

-   void ZLIB_INTERNAL zmemzero(void FAR *, z_size_t);

-#endif

-

-/* Diagnostic functions */

-#ifdef ZLIB_DEBUG

-#  include <stdio.h>

-   extern int ZLIB_INTERNAL z_verbose;

-   extern void ZLIB_INTERNAL z_error(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(voidpf opaque, unsigned items,

-                                unsigned size);

-   void ZLIB_INTERNAL zcfree(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))

-

-#ifdef Z_ONCE

-/*

-  Create a local z_once() function depending on the availability of atomics.

- */

-

-/* Check for the availability of atomics. */

-#if defined(__STDC__) && __STDC_VERSION__ >= 201112L && \

-    !defined(__STDC_NO_ATOMICS__)

-

-#include <stdatomic.h>

-typedef struct {

-    atomic_flag begun;

-    atomic_int done;

-} z_once_t;

-#define Z_ONCE_INIT {ATOMIC_FLAG_INIT, 0}

-

-/*

-  Run the provided init() function exactly once, even if multiple threads

-  invoke once() at the same time. The state must be a once_t initialized with

-  Z_ONCE_INIT.

- */

-local void z_once(z_once_t *state, void (*init)(void)) {

-    if (!atomic_load(&state->done)) {

-        if (atomic_flag_test_and_set(&state->begun))

-            while (!atomic_load(&state->done))

-                ;

-        else {

-            init();

-            atomic_store(&state->done, 1);

-        }

-    }

-}

-

-#else   /* no atomics */

-

-#warning zlib not thread-safe

-

-typedef struct z_once_s {

-    volatile int begun;

-    volatile int done;

-} z_once_t;

-#define Z_ONCE_INIT {0, 0}

-

-/* Test and set. Alas, not atomic, but tries to limit the period of

-   vulnerability. */

-local int test_and_set(int volatile *flag) {

-    int was;

-

-    was = *flag;

-    *flag = 1;

-    return was;

-}

-

-/* Run the provided init() function once. This is not thread-safe. */

-local void z_once(z_once_t *state, void (*init)(void)) {

-    if (!state->done) {

-        if (test_and_set(&state->begun))

-            while (!state->done)

-                ;

-        else {

-            init();

-            state->done = 1;

-        }

-    }

-}

-

-#endif /* ?atomics */

-

-#endif /* Z_ONCE */

-

-#endif /* ZUTIL_H */

+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2026 Jean-loup Gailly, 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.
+ */
+
+/* @(#) $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
+
+#ifndef local
+#  define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+   define "local" for the non-static meaning of "static", for readability
+   (compile with -Dlocal if your debugger can't find static symbols) */
+
+extern const char deflate_copyright[];
+extern const char inflate_copyright[];
+extern const char inflate9_copyright[];
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+#if !defined(Z_U8) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (ULONG_MAX == 0xffffffffffffffff)
+#    define Z_U8 unsigned long
+#  elif (ULLONG_MAX == 0xffffffffffffffff)
+#    define Z_U8 unsigned long long
+#  elif (ULONG_LONG_MAX == 0xffffffffffffffff)
+#    define Z_U8 unsigned long long
+#  elif (UINT_MAX == 0xffffffffffffffff)
+#    define Z_U8 unsigned
+#  endif
+#endif
+
+extern z_const 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[(err) < -6 || (err) > 2 ? 9 : 2 - (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 */
+#if MAX_WBITS < 9 || MAX_WBITS > 15
+#  error MAX_WBITS must be in 9..15
+#endif
+#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  1
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  2
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef __370__
+#  if __TARGET_LIB__ < 0x20000000
+#    define OS_CODE 4
+#  elif __TARGET_LIB__ < 0x40000000
+#    define OS_CODE 11
+#  else
+#    define OS_CODE 8
+#  endif
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  5
+#endif
+
+#ifdef OS2
+#  define OS_CODE  6
+#  if defined(M_I86) && !defined(Z_SOLO)
+#    include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS)
+#  define OS_CODE  7
+#endif
+
+#if defined(__acorn) || defined(__riscos)
+#  define OS_CODE 13
+#endif
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+#  define OS_CODE  10
+#endif
+
+#ifdef _BEOS_
+#  define OS_CODE  16
+#endif
+
+#ifdef __TOS_OS400__
+#  define OS_CODE 18
+#endif
+
+#ifdef __APPLE__
+#  define OS_CODE 19
+#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 */
+#ifndef Z_LARGE64
+   ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);
+   ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);
+   ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  3     /* 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(void FAR *, const void FAR *, z_size_t);
+   int ZLIB_INTERNAL zmemcmp(const void FAR *, const void FAR *, z_size_t);
+   void ZLIB_INTERNAL zmemzero(void FAR *, z_size_t);
+#endif
+
+/* Diagnostic functions */
+#ifdef ZLIB_DEBUG
+#  include <stdio.h>
+   extern int ZLIB_INTERNAL z_verbose;
+   extern void ZLIB_INTERNAL z_error(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(voidpf opaque, unsigned items,
+                                unsigned size);
+   void ZLIB_INTERNAL zcfree(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))
+
+#ifdef Z_ONCE
+/*
+  Create a local z_once() function depending on the availability of atomics.
+ */
+
+/* Check for the availability of atomics. */
+#if defined(__STDC__) && __STDC_VERSION__ >= 201112L && \
+    !defined(__STDC_NO_ATOMICS__)
+
+#include <stdatomic.h>
+typedef struct {
+    atomic_flag begun;
+    atomic_int done;
+} z_once_t;
+#define Z_ONCE_INIT {ATOMIC_FLAG_INIT, 0}
+
+/*
+  Run the provided init() function exactly once, even if multiple threads
+  invoke once() at the same time. The state must be a once_t initialized with
+  Z_ONCE_INIT.
+ */
+local void z_once(z_once_t *state, void (*init)(void)) {
+    if (!atomic_load(&state->done)) {
+        if (atomic_flag_test_and_set(&state->begun))
+            while (!atomic_load(&state->done))
+                ;
+        else {
+            init();
+            atomic_store(&state->done, 1);
+        }
+    }
+}
+
+#else   /* no atomics */
+
+#warning zlib not thread-safe
+
+typedef struct z_once_s {
+    volatile int begun;
+    volatile int done;
+} z_once_t;
+#define Z_ONCE_INIT {0, 0}
+
+/* Test and set. Alas, not atomic, but tries to limit the period of
+   vulnerability. */
+local int test_and_set(int volatile *flag) {
+    int was;
+
+    was = *flag;
+    *flag = 1;
+    return was;
+}
+
+/* Run the provided init() function once. This is not thread-safe. */
+local void z_once(z_once_t *state, void (*init)(void)) {
+    if (!state->done) {
+        if (test_and_set(&state->begun))
+            while (!state->done)
+                ;
+        else {
+            init();
+            state->done = 1;
+        }
+    }
+}
+
+#endif /* ?atomics */
+
+#endif /* Z_ONCE */
+
+#endif /* ZUTIL_H */