Large dos2unix commit...

1 files changed, 454 insertions, 454 deletions

diff --git a/lib/zlib/src/inftrees.c b/lib/zlib/src/inftrees.c
index f89e801..4c32ca3 100644
--- a/lib/zlib/src/inftrees.c
+++ b/lib/zlib/src/inftrees.c
@@ -1,454 +1,454 @@
-/* inftrees.c -- generate Huffman trees for efficient decoding

- * Copyright (C) 1995-2002 Mark Adler

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

- */

-

-#include "zutil.h"

-#include "inftrees.h"

-

-#if !defined(BUILDFIXED) && !defined(STDC)

-#  define BUILDFIXED   /* non ANSI compilers may not accept inffixed.h */

-#endif

-

-const char inflate_copyright[] =

-   " inflate 1.1.4 Copyright 1995-2002 Mark Adler ";

-/*

-  If you use the zlib library in a product, an acknowledgment is welcome

-  in the documentation of your product. If for some reason you cannot

-  include such an acknowledgment, I would appreciate that you keep this

-  copyright string in the executable of your product.

- */

-struct internal_state  {int dummy;}; /* for buggy compilers */

-

-/* simplify the use of the inflate_huft type with some defines */

-#define exop word.what.Exop

-#define bits word.what.Bits

-

-

-local int huft_build OF((

-    uIntf *,            /* code lengths in bits */

-    uInt,               /* number of codes */

-    uInt,               /* number of "simple" codes */

-    const uIntf *,      /* list of base values for non-simple codes */

-    const uIntf *,      /* list of extra bits for non-simple codes */

-    inflate_huft * FAR*,/* result: starting table */

-    uIntf *,            /* maximum lookup bits (returns actual) */

-    inflate_huft *,     /* space for trees */

-    uInt *,             /* hufts used in space */

-    uIntf * ));         /* space for values */

-

-/* Tables for deflate from PKZIP's appnote.txt. */

-local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */

-        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,

-        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};

-        /* see note #13 above about 258 */

-local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */

-        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, 112, 112}; /* 112==invalid */

-local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */

-        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,

-        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,

-        8193, 12289, 16385, 24577};

-local const uInt cpdext[30] = { /* Extra bits for distance codes */

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

-

-/*

-   Huffman code decoding is performed using a multi-level table lookup.

-   The fastest way to decode is to simply build a lookup table whose

-   size is determined by the longest code.  However, the time it takes

-   to build this table can also be a factor if the data being decoded

-   is not very long.  The most common codes are necessarily the

-   shortest codes, so those codes dominate the decoding time, and hence

-   the speed.  The idea is you can have a shorter table that decodes the

-   shorter, more probable codes, and then point to subsidiary tables for

-   the longer codes.  The time it costs to decode the longer codes is

-   then traded against the time it takes to make longer tables.

-

-   This results of this trade are in the variables lbits and dbits

-   below.  lbits is the number of bits the first level table for literal/

-   length codes can decode in one step, and dbits is the same thing for

-   the distance codes.  Subsequent tables are also less than or equal to

-   those sizes.  These values may be adjusted either when all of the

-   codes are shorter than that, in which case the longest code length in

-   bits is used, or when the shortest code is *longer* than the requested

-   table size, in which case the length of the shortest code in bits is

-   used.

-

-   There are two different values for the two tables, since they code a

-   different number of possibilities each.  The literal/length table

-   codes 286 possible values, or in a flat code, a little over eight

-   bits.  The distance table codes 30 possible values, or a little less

-   than five bits, flat.  The optimum values for speed end up being

-   about one bit more than those, so lbits is 8+1 and dbits is 5+1.

-   The optimum values may differ though from machine to machine, and

-   possibly even between compilers.  Your mileage may vary.

- */

-

-

-/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */

-#define BMAX 15         /* maximum bit length of any code */

-

-local int huft_build(b, n, s, d, e, t, m, hp, hn, v)

-uIntf *b;               /* code lengths in bits (all assumed <= BMAX) */

-uInt n;                 /* number of codes (assumed <= 288) */

-uInt s;                 /* number of simple-valued codes (0..s-1) */

-const uIntf *d;         /* list of base values for non-simple codes */

-const uIntf *e;         /* list of extra bits for non-simple codes */

-inflate_huft * FAR *t;  /* result: starting table */

-uIntf *m;               /* maximum lookup bits, returns actual */

-inflate_huft *hp;       /* space for trees */

-uInt *hn;               /* hufts used in space */

-uIntf *v;               /* working area: values in order of bit length */

-/* Given a list of code lengths and a maximum table size, make a set of

-   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR

-   if the given code set is incomplete (the tables are still built in this

-   case), or Z_DATA_ERROR if the input is invalid. */

-{

-

-  uInt a;                       /* counter for codes of length k */

-  uInt c[BMAX+1];               /* bit length count table */

-  uInt f;                       /* i repeats in table every f entries */

-  int g;                        /* maximum code length */

-  int h;                        /* table level */

-  register uInt i;              /* counter, current code */

-  register uInt j;              /* counter */

-  register int k;               /* number of bits in current code */

-  int l;                        /* bits per table (returned in m) */

-  uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */

-  register uIntf *p;            /* pointer into c[], b[], or v[] */

-  inflate_huft *q;              /* points to current table */

-  struct inflate_huft_s r;      /* table entry for structure assignment */

-  inflate_huft *u[BMAX];        /* table stack */

-  register int w;               /* bits before this table == (l * h) */

-  uInt x[BMAX+1];               /* bit offsets, then code stack */

-  uIntf *xp;                    /* pointer into x */

-  int y;                        /* number of dummy codes added */

-  uInt z;                       /* number of entries in current table */

-

-

-  /* Generate counts for each bit length */

-  p = c;

-#define C0 *p++ = 0;

-#define C2 C0 C0 C0 C0

-#define C4 C2 C2 C2 C2

-  C4                            /* clear c[]--assume BMAX+1 is 16 */

-  p = b;  i = n;

-  do {

-    c[*p++]++;                  /* assume all entries <= BMAX */

-  } while (--i);

-  if (c[0] == n)                /* null input--all zero length codes */

-  {

-    *t = (inflate_huft *)Z_NULL;

-    *m = 0;

-    return Z_OK;

-  }

-

-

-  /* Find minimum and maximum length, bound *m by those */

-  l = *m;

-  for (j = 1; j <= BMAX; j++)

-    if (c[j])

-      break;

-  k = j;                        /* minimum code length */

-  if ((uInt)l < j)

-    l = j;

-  for (i = BMAX; i; i--)

-    if (c[i])

-      break;

-  g = i;                        /* maximum code length */

-  if ((uInt)l > i)

-    l = i;

-  *m = l;

-

-

-  /* Adjust last length count to fill out codes, if needed */

-  for (y = 1 << j; j < i; j++, y <<= 1)

-    if ((y -= c[j]) < 0)

-      return Z_DATA_ERROR;

-  if ((y -= c[i]) < 0)

-    return Z_DATA_ERROR;

-  c[i] += y;

-

-

-  /* Generate starting offsets into the value table for each length */

-  x[1] = j = 0;

-  p = c + 1;  xp = x + 2;

-  while (--i) {                 /* note that i == g from above */

-    *xp++ = (j += *p++);

-  }

-

-

-  /* Make a table of values in order of bit lengths */

-  p = b;  i = 0;

-  do {

-    if ((j = *p++) != 0)

-      v[x[j]++] = i;

-  } while (++i < n);

-  n = x[g];                     /* set n to length of v */

-

-

-  /* Generate the Huffman codes and for each, make the table entries */

-  x[0] = i = 0;                 /* first Huffman code is zero */

-  p = v;                        /* grab values in bit order */

-  h = -1;                       /* no tables yet--level -1 */

-  w = -l;                       /* bits decoded == (l * h) */

-  u[0] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */

-  q = (inflate_huft *)Z_NULL;   /* ditto */

-  z = 0;                        /* ditto */

-

-  /* go through the bit lengths (k already is bits in shortest code) */

-  for (; k <= g; k++)

-  {

-    a = c[k];

-    while (a--)

-    {

-      /* here i is the Huffman code of length k bits for value *p */

-      /* make tables up to required level */

-      while (k > w + l)

-      {

-        h++;

-        w += l;                 /* previous table always l bits */

-

-        /* compute minimum size table less than or equal to l bits */

-        z = g - w;

-        z = z > (uInt)l ? l : z;        /* table size upper limit */

-        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */

-        {                       /* too few codes for k-w bit table */

-          f -= a + 1;           /* deduct codes from patterns left */

-          xp = c + k;

-          if (j < z)

-            while (++j < z)     /* try smaller tables up to z bits */

-            {

-              if ((f <<= 1) <= *++xp)

-                break;          /* enough codes to use up j bits */

-              f -= *xp;         /* else deduct codes from patterns */

-            }

-        }

-        z = 1 << j;             /* table entries for j-bit table */

-

-        /* allocate new table */

-        if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */

-          return Z_DATA_ERROR;  /* overflow of MANY */

-        u[h] = q = hp + *hn;

-        *hn += z;

-

-        /* connect to last table, if there is one */

-        if (h)

-        {

-          x[h] = i;             /* save pattern for backing up */

-          r.bits = (Byte)l;     /* bits to dump before this table */

-          r.exop = (Byte)j;     /* bits in this table */

-          j = i >> (w - l);

-          r.base = (uInt)(q - u[h-1] - j);   /* offset to this table */

-          u[h-1][j] = r;        /* connect to last table */

-        }

-        else

-          *t = q;               /* first table is returned result */

-      }

-

-      /* set up table entry in r */

-      r.bits = (Byte)(k - w);

-      if (p >= v + n)

-        r.exop = 128 + 64;      /* out of values--invalid code */

-      else if (*p < s)

-      {

-        r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     /* 256 is end-of-block */

-        r.base = *p++;          /* simple code is just the value */

-      }

-      else

-      {

-        r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */

-        r.base = d[*p++ - s];

-      }

-

-      /* fill code-like entries with r */

-      f = 1 << (k - w);

-      for (j = i >> w; j < z; j += f)

-        q[j] = r;

-

-      /* backwards increment the k-bit code i */

-      for (j = 1 << (k - 1); i & j; j >>= 1)

-        i ^= j;

-      i ^= j;

-

-      /* backup over finished tables */

-      mask = (1 << w) - 1;      /* needed on HP, cc -O bug */

-      while ((i & mask) != x[h])

-      {

-        h--;                    /* don't need to update q */

-        w -= l;

-        mask = (1 << w) - 1;

-      }

-    }

-  }

-

-

-  /* Return Z_BUF_ERROR if we were given an incomplete table */

-  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;

-}

-

-

-int inflate_trees_bits(c, bb, tb, hp, z)

-uIntf *c;               /* 19 code lengths */

-uIntf *bb;              /* bits tree desired/actual depth */

-inflate_huft * FAR *tb; /* bits tree result */

-inflate_huft *hp;       /* space for trees */

-z_streamp z;            /* for messages */

-{

-  int r;

-  uInt hn = 0;          /* hufts used in space */

-  uIntf *v;             /* work area for huft_build */

-

-  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)

-    return Z_MEM_ERROR;

-  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,

-                 tb, bb, hp, &hn, v);

-  if (r == Z_DATA_ERROR)

-    z->msg = (char*)"oversubscribed dynamic bit lengths tree";

-  else if (r == Z_BUF_ERROR || *bb == 0)

-  {

-    z->msg = (char*)"incomplete dynamic bit lengths tree";

-    r = Z_DATA_ERROR;

-  }

-  ZFREE(z, v);

-  return r;

-}

-

-

-int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)

-uInt nl;                /* number of literal/length codes */

-uInt nd;                /* number of distance codes */

-uIntf *c;               /* that many (total) code lengths */

-uIntf *bl;              /* literal desired/actual bit depth */

-uIntf *bd;              /* distance desired/actual bit depth */

-inflate_huft * FAR *tl; /* literal/length tree result */

-inflate_huft * FAR *td; /* distance tree result */

-inflate_huft *hp;       /* space for trees */

-z_streamp z;            /* for messages */

-{

-  int r;

-  uInt hn = 0;          /* hufts used in space */

-  uIntf *v;             /* work area for huft_build */

-

-  /* allocate work area */

-  if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)

-    return Z_MEM_ERROR;

-

-  /* build literal/length tree */

-  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);

-  if (r != Z_OK || *bl == 0)

-  {

-    if (r == Z_DATA_ERROR)

-      z->msg = (char*)"oversubscribed literal/length tree";

-    else if (r != Z_MEM_ERROR)

-    {

-      z->msg = (char*)"incomplete literal/length tree";

-      r = Z_DATA_ERROR;

-    }

-    ZFREE(z, v);

-    return r;

-  }

-

-  /* build distance tree */

-  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);

-  if (r != Z_OK || (*bd == 0 && nl > 257))

-  {

-    if (r == Z_DATA_ERROR)

-      z->msg = (char*)"oversubscribed distance tree";

-    else if (r == Z_BUF_ERROR) {

-#ifdef PKZIP_BUG_WORKAROUND

-      r = Z_OK;

-    }

-#else

-      z->msg = (char*)"incomplete distance tree";

-      r = Z_DATA_ERROR;

-    }

-    else if (r != Z_MEM_ERROR)

-    {

-      z->msg = (char*)"empty distance tree with lengths";

-      r = Z_DATA_ERROR;

-    }

-    ZFREE(z, v);

-    return r;

-#endif

-  }

-

-  /* done */

-  ZFREE(z, v);

-  return Z_OK;

-}

-

-

-/* build fixed tables only once--keep them here */

-#ifdef BUILDFIXED

-local int fixed_built = 0;

-#define FIXEDH 544      /* number of hufts used by fixed tables */

-local inflate_huft fixed_mem[FIXEDH];

-local uInt fixed_bl;

-local uInt fixed_bd;

-local inflate_huft *fixed_tl;

-local inflate_huft *fixed_td;

-#else

-#include "inffixed.h"

-#endif

-

-

-int inflate_trees_fixed(bl, bd, tl, td, z)

-uIntf *bl;               /* literal desired/actual bit depth */

-uIntf *bd;               /* distance desired/actual bit depth */

-inflate_huft * FAR *tl;  /* literal/length tree result */

-inflate_huft * FAR *td;  /* distance tree result */

-z_streamp z;             /* for memory allocation */

-{

-#ifdef BUILDFIXED

-  /* build fixed tables if not already */

-  if (!fixed_built)

-  {

-    int k;              /* temporary variable */

-    uInt f = 0;         /* number of hufts used in fixed_mem */

-    uIntf *c;           /* length list for huft_build */

-    uIntf *v;           /* work area for huft_build */

-

-    /* allocate memory */

-    if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)

-      return Z_MEM_ERROR;

-    if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)

-    {

-      ZFREE(z, c);

-      return Z_MEM_ERROR;

-    }

-

-    /* literal table */

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

-      c[k] = 8;

-    for (; k < 256; k++)

-      c[k] = 9;

-    for (; k < 280; k++)

-      c[k] = 7;

-    for (; k < 288; k++)

-      c[k] = 8;

-    fixed_bl = 9;

-    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,

-               fixed_mem, &f, v);

-

-    /* distance table */

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

-      c[k] = 5;

-    fixed_bd = 5;

-    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,

-               fixed_mem, &f, v);

-

-    /* done */

-    ZFREE(z, v);

-    ZFREE(z, c);

-    fixed_built = 1;

-  }

-#endif

-  *bl = fixed_bl;

-  *bd = fixed_bd;

-  *tl = fixed_tl;

-  *td = fixed_td;

-  return Z_OK;

-}

+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#if !defined(BUILDFIXED) && !defined(STDC)
+#  define BUILDFIXED   /* non ANSI compilers may not accept inffixed.h */
+#endif
+
+const char inflate_copyright[] =
+   " inflate 1.1.4 Copyright 1995-2002 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+struct internal_state  {int dummy;}; /* for buggy compilers */
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+
+local int huft_build OF((
+    uIntf *,            /* code lengths in bits */
+    uInt,               /* number of codes */
+    uInt,               /* number of "simple" codes */
+    const uIntf *,      /* list of base values for non-simple codes */
+    const uIntf *,      /* list of extra bits for non-simple codes */
+    inflate_huft * FAR*,/* result: starting table */
+    uIntf *,            /* maximum lookup bits (returns actual) */
+    inflate_huft *,     /* space for trees */
+    uInt *,             /* hufts used in space */
+    uIntf * ));         /* space for values */
+
+/* Tables for deflate from PKZIP's appnote.txt. */
+local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+        /* see note #13 above about 258 */
+local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
+        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, 112, 112}; /* 112==invalid */
+local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577};
+local const uInt cpdext[30] = { /* Extra bits for distance codes */
+        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};
+
+/*
+   Huffman code decoding is performed using a multi-level table lookup.
+   The fastest way to decode is to simply build a lookup table whose
+   size is determined by the longest code.  However, the time it takes
+   to build this table can also be a factor if the data being decoded
+   is not very long.  The most common codes are necessarily the
+   shortest codes, so those codes dominate the decoding time, and hence
+   the speed.  The idea is you can have a shorter table that decodes the
+   shorter, more probable codes, and then point to subsidiary tables for
+   the longer codes.  The time it costs to decode the longer codes is
+   then traded against the time it takes to make longer tables.
+
+   This results of this trade are in the variables lbits and dbits
+   below.  lbits is the number of bits the first level table for literal/
+   length codes can decode in one step, and dbits is the same thing for
+   the distance codes.  Subsequent tables are also less than or equal to
+   those sizes.  These values may be adjusted either when all of the
+   codes are shorter than that, in which case the longest code length in
+   bits is used, or when the shortest code is *longer* than the requested
+   table size, in which case the length of the shortest code in bits is
+   used.
+
+   There are two different values for the two tables, since they code a
+   different number of possibilities each.  The literal/length table
+   codes 286 possible values, or in a flat code, a little over eight
+   bits.  The distance table codes 30 possible values, or a little less
+   than five bits, flat.  The optimum values for speed end up being
+   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
+   The optimum values may differ though from machine to machine, and
+   possibly even between compilers.  Your mileage may vary.
+ */
+
+
+/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
+#define BMAX 15         /* maximum bit length of any code */
+
+local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
+uIntf *b;               /* code lengths in bits (all assumed <= BMAX) */
+uInt n;                 /* number of codes (assumed <= 288) */
+uInt s;                 /* number of simple-valued codes (0..s-1) */
+const uIntf *d;         /* list of base values for non-simple codes */
+const uIntf *e;         /* list of extra bits for non-simple codes */
+inflate_huft * FAR *t;  /* result: starting table */
+uIntf *m;               /* maximum lookup bits, returns actual */
+inflate_huft *hp;       /* space for trees */
+uInt *hn;               /* hufts used in space */
+uIntf *v;               /* working area: values in order of bit length */
+/* Given a list of code lengths and a maximum table size, make a set of
+   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+   if the given code set is incomplete (the tables are still built in this
+   case), or Z_DATA_ERROR if the input is invalid. */
+{
+
+  uInt a;                       /* counter for codes of length k */
+  uInt c[BMAX+1];               /* bit length count table */
+  uInt f;                       /* i repeats in table every f entries */
+  int g;                        /* maximum code length */
+  int h;                        /* table level */
+  register uInt i;              /* counter, current code */
+  register uInt j;              /* counter */
+  register int k;               /* number of bits in current code */
+  int l;                        /* bits per table (returned in m) */
+  uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
+  register uIntf *p;            /* pointer into c[], b[], or v[] */
+  inflate_huft *q;              /* points to current table */
+  struct inflate_huft_s r;      /* table entry for structure assignment */
+  inflate_huft *u[BMAX];        /* table stack */
+  register int w;               /* bits before this table == (l * h) */
+  uInt x[BMAX+1];               /* bit offsets, then code stack */
+  uIntf *xp;                    /* pointer into x */
+  int y;                        /* number of dummy codes added */
+  uInt z;                       /* number of entries in current table */
+
+
+  /* Generate counts for each bit length */
+  p = c;
+#define C0 *p++ = 0;
+#define C2 C0 C0 C0 C0
+#define C4 C2 C2 C2 C2
+  C4                            /* clear c[]--assume BMAX+1 is 16 */
+  p = b;  i = n;
+  do {
+    c[*p++]++;                  /* assume all entries <= BMAX */
+  } while (--i);
+  if (c[0] == n)                /* null input--all zero length codes */
+  {
+    *t = (inflate_huft *)Z_NULL;
+    *m = 0;
+    return Z_OK;
+  }
+
+
+  /* Find minimum and maximum length, bound *m by those */
+  l = *m;
+  for (j = 1; j <= BMAX; j++)
+    if (c[j])
+      break;
+  k = j;                        /* minimum code length */
+  if ((uInt)l < j)
+    l = j;
+  for (i = BMAX; i; i--)
+    if (c[i])
+      break;
+  g = i;                        /* maximum code length */
+  if ((uInt)l > i)
+    l = i;
+  *m = l;
+
+
+  /* Adjust last length count to fill out codes, if needed */
+  for (y = 1 << j; j < i; j++, y <<= 1)
+    if ((y -= c[j]) < 0)
+      return Z_DATA_ERROR;
+  if ((y -= c[i]) < 0)
+    return Z_DATA_ERROR;
+  c[i] += y;
+
+
+  /* Generate starting offsets into the value table for each length */
+  x[1] = j = 0;
+  p = c + 1;  xp = x + 2;
+  while (--i) {                 /* note that i == g from above */
+    *xp++ = (j += *p++);
+  }
+
+
+  /* Make a table of values in order of bit lengths */
+  p = b;  i = 0;
+  do {
+    if ((j = *p++) != 0)
+      v[x[j]++] = i;
+  } while (++i < n);
+  n = x[g];                     /* set n to length of v */
+
+
+  /* Generate the Huffman codes and for each, make the table entries */
+  x[0] = i = 0;                 /* first Huffman code is zero */
+  p = v;                        /* grab values in bit order */
+  h = -1;                       /* no tables yet--level -1 */
+  w = -l;                       /* bits decoded == (l * h) */
+  u[0] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */
+  q = (inflate_huft *)Z_NULL;   /* ditto */
+  z = 0;                        /* ditto */
+
+  /* go through the bit lengths (k already is bits in shortest code) */
+  for (; k <= g; k++)
+  {
+    a = c[k];
+    while (a--)
+    {
+      /* here i is the Huffman code of length k bits for value *p */
+      /* make tables up to required level */
+      while (k > w + l)
+      {
+        h++;
+        w += l;                 /* previous table always l bits */
+
+        /* compute minimum size table less than or equal to l bits */
+        z = g - w;
+        z = z > (uInt)l ? l : z;        /* table size upper limit */
+        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */
+        {                       /* too few codes for k-w bit table */
+          f -= a + 1;           /* deduct codes from patterns left */
+          xp = c + k;
+          if (j < z)
+            while (++j < z)     /* try smaller tables up to z bits */
+            {
+              if ((f <<= 1) <= *++xp)
+                break;          /* enough codes to use up j bits */
+              f -= *xp;         /* else deduct codes from patterns */
+            }
+        }
+        z = 1 << j;             /* table entries for j-bit table */
+
+        /* allocate new table */
+        if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */
+          return Z_DATA_ERROR;  /* overflow of MANY */
+        u[h] = q = hp + *hn;
+        *hn += z;
+
+        /* connect to last table, if there is one */
+        if (h)
+        {
+          x[h] = i;             /* save pattern for backing up */
+          r.bits = (Byte)l;     /* bits to dump before this table */
+          r.exop = (Byte)j;     /* bits in this table */
+          j = i >> (w - l);
+          r.base = (uInt)(q - u[h-1] - j);   /* offset to this table */
+          u[h-1][j] = r;        /* connect to last table */
+        }
+        else
+          *t = q;               /* first table is returned result */
+      }
+
+      /* set up table entry in r */
+      r.bits = (Byte)(k - w);
+      if (p >= v + n)
+        r.exop = 128 + 64;      /* out of values--invalid code */
+      else if (*p < s)
+      {
+        r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     /* 256 is end-of-block */
+        r.base = *p++;          /* simple code is just the value */
+      }
+      else
+      {
+        r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
+        r.base = d[*p++ - s];
+      }
+
+      /* fill code-like entries with r */
+      f = 1 << (k - w);
+      for (j = i >> w; j < z; j += f)
+        q[j] = r;
+
+      /* backwards increment the k-bit code i */
+      for (j = 1 << (k - 1); i & j; j >>= 1)
+        i ^= j;
+      i ^= j;
+
+      /* backup over finished tables */
+      mask = (1 << w) - 1;      /* needed on HP, cc -O bug */
+      while ((i & mask) != x[h])
+      {
+        h--;                    /* don't need to update q */
+        w -= l;
+        mask = (1 << w) - 1;
+      }
+    }
+  }
+
+
+  /* Return Z_BUF_ERROR if we were given an incomplete table */
+  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
+}
+
+
+int inflate_trees_bits(c, bb, tb, hp, z)
+uIntf *c;               /* 19 code lengths */
+uIntf *bb;              /* bits tree desired/actual depth */
+inflate_huft * FAR *tb; /* bits tree result */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
+                 tb, bb, hp, &hn, v);
+  if (r == Z_DATA_ERROR)
+    z->msg = (char*)"oversubscribed dynamic bit lengths tree";
+  else if (r == Z_BUF_ERROR || *bb == 0)
+  {
+    z->msg = (char*)"incomplete dynamic bit lengths tree";
+    r = Z_DATA_ERROR;
+  }
+  ZFREE(z, v);
+  return r;
+}
+
+
+int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
+uInt nl;                /* number of literal/length codes */
+uInt nd;                /* number of distance codes */
+uIntf *c;               /* that many (total) code lengths */
+uIntf *bl;              /* literal desired/actual bit depth */
+uIntf *bd;              /* distance desired/actual bit depth */
+inflate_huft * FAR *tl; /* literal/length tree result */
+inflate_huft * FAR *td; /* distance tree result */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  /* allocate work area */
+  if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+
+  /* build literal/length tree */
+  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
+  if (r != Z_OK || *bl == 0)
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed literal/length tree";
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"incomplete literal/length tree";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+  }
+
+  /* build distance tree */
+  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
+  if (r != Z_OK || (*bd == 0 && nl > 257))
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed distance tree";
+    else if (r == Z_BUF_ERROR) {
+#ifdef PKZIP_BUG_WORKAROUND
+      r = Z_OK;
+    }
+#else
+      z->msg = (char*)"incomplete distance tree";
+      r = Z_DATA_ERROR;
+    }
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"empty distance tree with lengths";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+#endif
+  }
+
+  /* done */
+  ZFREE(z, v);
+  return Z_OK;
+}
+
+
+/* build fixed tables only once--keep them here */
+#ifdef BUILDFIXED
+local int fixed_built = 0;
+#define FIXEDH 544      /* number of hufts used by fixed tables */
+local inflate_huft fixed_mem[FIXEDH];
+local uInt fixed_bl;
+local uInt fixed_bd;
+local inflate_huft *fixed_tl;
+local inflate_huft *fixed_td;
+#else
+#include "inffixed.h"
+#endif
+
+
+int inflate_trees_fixed(bl, bd, tl, td, z)
+uIntf *bl;               /* literal desired/actual bit depth */
+uIntf *bd;               /* distance desired/actual bit depth */
+inflate_huft * FAR *tl;  /* literal/length tree result */
+inflate_huft * FAR *td;  /* distance tree result */
+z_streamp z;             /* for memory allocation */
+{
+#ifdef BUILDFIXED
+  /* build fixed tables if not already */
+  if (!fixed_built)
+  {
+    int k;              /* temporary variable */
+    uInt f = 0;         /* number of hufts used in fixed_mem */
+    uIntf *c;           /* length list for huft_build */
+    uIntf *v;           /* work area for huft_build */
+
+    /* allocate memory */
+    if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+      return Z_MEM_ERROR;
+    if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    {
+      ZFREE(z, c);
+      return Z_MEM_ERROR;
+    }
+
+    /* literal table */
+    for (k = 0; k < 144; k++)
+      c[k] = 8;
+    for (; k < 256; k++)
+      c[k] = 9;
+    for (; k < 280; k++)
+      c[k] = 7;
+    for (; k < 288; k++)
+      c[k] = 8;
+    fixed_bl = 9;
+    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
+               fixed_mem, &f, v);
+
+    /* distance table */
+    for (k = 0; k < 30; k++)
+      c[k] = 5;
+    fixed_bd = 5;
+    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
+               fixed_mem, &f, v);
+
+    /* done */
+    ZFREE(z, v);
+    ZFREE(z, c);
+    fixed_built = 1;
+  }
+#endif
+  *bl = fixed_bl;
+  *bd = fixed_bd;
+  *tl = fixed_tl;
+  *td = fixed_td;
+  return Z_OK;
+}