h++;        w += l;                 /* previous table always l bits */        /* compute minimum size table less than or equal to l bits */        z = (z = g - w) > (unsigned)l ? l : z;  /* upper limit on table size */        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */        {                       /* too few codes for k-w bit table */DEBG1("2 ");          f -= a + 1;           /* deduct codes from patterns left */          xp = c + k;          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 */          }        }DEBG1("3 ");        z = 1 << j;             /* table entries for j-bit table */        /* allocate and link in new table */        if ((q = (struct huft *)malloc((z + 1)*sizeof(struct huft))) ==            (struct huft *)NULL)        {          if (h)            huft_free(u[0]);          return 3;             /* not enough memory */        }DEBG1("4 ");        hufts += z + 1;         /* track memory usage */        *t = q + 1;             /* link to list for huft_free() */        *(t = &(q->v.t)) = (struct huft *)NULL;        u[h] = ++q;             /* table starts after link */DEBG1("5 ");        /* connect to last table, if there is one */        if (h)        {          x[h] = i;             /* save pattern for backing up */          r.b = (uch)l;         /* bits to dump before this table */          r.e = (uch)(16 + j);  /* bits in this table */          r.v.t = q;            /* pointer to this table */          j = i >> (w - l);     /* (get around Turbo C bug) */          u[h-1][j] = r;        /* connect to last table */        }DEBG1("6 ");      }DEBG("h6c ");      /* set up table entry in r */      r.b = (uch)(k - w);      if (p >= v + n)        r.e = 99;               /* out of values--invalid code */      else if (*p < s)      {        r.e = (uch)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */        r.v.n = (ush)(*p);             /* simple code is just the value */	p++;                           /* one compiler does not like *p++ */      }      else      {        r.e = (uch)e[*p - s];   /* non-simple--look up in lists */        r.v.n = d[*p++ - s];      }DEBG("h6d ");      /* 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 */      while ((i & ((1 << w) - 1)) != x[h])      {        h--;                    /* don't need to update q */        w -= l;      }DEBG("h6e ");    }DEBG("h6f ");  }DEBG("huft7 ");  /* Return true (1) if we were given an incomplete table */  return y != 0 && g != 1;}STATIC int huft_free(t)struct huft *t;         /* table to free *//* Free the malloc'ed tables built by huft_build(), which makes a linked   list of the tables it made, with the links in a dummy first entry of   each table. */{  register struct huft *p, *q;  /* Go through linked list, freeing from the malloced (t[-1]) address. */  p = t;  while (p != (struct huft *)NULL)  {    q = (--p)->v.t;    free((char*)p);    p = q;  }   return 0;}STATIC int inflate_codes(tl, td, bl, bd)struct huft *tl, *td;   /* literal/length and distance decoder tables */int bl, bd;             /* number of bits decoded by tl[] and td[] *//* inflate (decompress) the codes in a deflated (compressed) block.   Return an error code or zero if it all goes ok. */{  register unsigned e;  /* table entry flag/number of extra bits */  unsigned n, d;        /* length and index for copy */  unsigned w;           /* current window position */  struct huft *t;       /* pointer to table entry */  unsigned ml, md;      /* masks for bl and bd bits */  register ulg b;       /* bit buffer */  register unsigned k;  /* number of bits in bit buffer */  /* make local copies of globals */  b = bb;                       /* initialize bit buffer */  k = bk;  w = wp;                       /* initialize window position */  /* inflate the coded data */  ml = mask_bits[bl];           /* precompute masks for speed */  md = mask_bits[bd];  for (;;)                      /* do until end of block */  {    NEEDBITS((unsigned)bl)    if ((e = (t = tl + ((unsigned)b & ml))->e) > 16)      do {        if (e == 99)          return 1;        DUMPBITS(t->b)        e -= 16;        NEEDBITS(e)      } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);    DUMPBITS(t->b)    if (e == 16)                /* then it's a literal */    {      slide[w++] = (uch)t->v.n;      Tracevv((stderr, "%c", slide[w-1]));      if (w == WSIZE)      {        flush_output(w);        w = 0;      }    }    else                        /* it's an EOB or a length */    {      /* exit if end of block */      if (e == 15)        break;      /* get length of block to copy */      NEEDBITS(e)      n = t->v.n + ((unsigned)b & mask_bits[e]);      DUMPBITS(e);      /* decode distance of block to copy */      NEEDBITS((unsigned)bd)      if ((e = (t = td + ((unsigned)b & md))->e) > 16)        do {          if (e == 99)            return 1;          DUMPBITS(t->b)          e -= 16;          NEEDBITS(e)        } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);      DUMPBITS(t->b)      NEEDBITS(e)      d = w - t->v.n - ((unsigned)b & mask_bits[e]);      DUMPBITS(e)      Tracevv((stderr,"\\[%d,%d]", w-d, n));      /* do the copy */      do {        n -= (e = (e = WSIZE - ((d &= WSIZE-1) > w ? d : w)) > n ? n : e);#if !defined(NOMEMCPY) && !defined(DEBUG)        if (w - d >= e)         /* (this test assumes unsigned comparison) */        {          memcpy(slide + w, slide + d, e);          w += e;          d += e;        }        else                      /* do it slow to avoid memcpy() overlap */#endif /* !NOMEMCPY */          do {            slide[w++] = slide[d++];	    Tracevv((stderr, "%c", slide[w-1]));          } while (--e);        if (w == WSIZE)        {          flush_output(w);          w = 0;        }      } while (n);    }  }  /* restore the globals from the locals */  wp = w;                       /* restore global window pointer */  bb = b;                       /* restore global bit buffer */  bk = k;  /* done */  return 0;}STATIC int inflate_stored()/* "decompress" an inflated type 0 (stored) block. */{  unsigned n;           /* number of bytes in block */  unsigned w;           /* current window position */  register ulg b;       /* bit buffer */  register unsigned k;  /* number of bits in bit buffer */DEBG("<stor");  /* make local copies of globals */  b = bb;                       /* initialize bit buffer */  k = bk;  w = wp;                       /* initialize window position */  /* go to byte boundary */  n = k & 7;  DUMPBITS(n);  /* get the length and its complement */  NEEDBITS(16)  n = ((unsigned)b & 0xffff);  DUMPBITS(16)  NEEDBITS(16)  if (n != (unsigned)((~b) & 0xffff))    return 1;                   /* error in compressed data */  DUMPBITS(16)  /* read and output the compressed data */  while (n--)  {    NEEDBITS(8)    slide[w++] = (uch)b;    if (w == WSIZE)    {      flush_output(w);      w = 0;    }    DUMPBITS(8)  }  /* restore the globals from the locals */  wp = w;                       /* restore global window pointer */  bb = b;                       /* restore global bit buffer */  bk = k;  DEBG(">");  return 0;}STATIC int inflate_fixed()/* decompress an inflated type 1 (fixed Huffman codes) block.  We should   either replace this with a custom decoder, or at least precompute the   Huffman tables. */{  int i;                /* temporary variable */  struct huft *tl;      /* literal/length code table */  struct huft *td;      /* distance code table */  int bl;               /* lookup bits for tl */  int bd;               /* lookup bits for td */  unsigned l[288];      /* length list for huft_build */DEBG("<fix");  /* set up literal table */  for (i = 0; i < 144; i++)    l[i] = 8;  for (; i < 256; i++)    l[i] = 9;  for (; i < 280; i++)    l[i] = 7;  for (; i < 288; i++)          /* make a complete, but wrong code set */    l[i] = 8;  bl = 7;  if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0)    return i;  /* set up distance table */  for (i = 0; i < 30; i++)      /* make an incomplete code set */    l[i] = 5;  bd = 5;  if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1)  {    huft_free(tl);    DEBG(">");    return i;  }  /* decompress until an end-of-block code */  if (inflate_codes(tl, td, bl, bd))    return 1;  /* free the decoding tables, return */  huft_free(tl);  huft_free(td);  return 0;}STATIC int inflate_dynamic()/* decompress an inflated type 2 (dynamic Huffman codes) block. */{  int i;                /* temporary variables */  unsigned j;  unsigned l;           /* last length */  unsigned m;           /* mask for bit lengths table */  unsigned n;           /* number of lengths to get */  struct huft *tl;      /* literal/length code table */  struct huft *td;      /* distance code table */  int bl;               /* lookup bits for tl */  int bd;               /* lookup bits for td */  unsigned nb;          /* number of bit length codes */  unsigned nl;          /* number of literal/length codes */  unsigned nd;          /* number of distance codes */#ifdef PKZIP_BUG_WORKAROUND  unsigned ll[288+32];  /* literal/length and distance code lengths */#else  unsigned ll[286+30];  /* literal/length and distance code lengths */#endif  register ulg b;       /* bit buffer */  register unsigned k;  /* number of bits in bit buffer */DEBG("<dyn");  /* make local bit buffer */  b = bb;  k = bk;  /* read in table lengths */  NEEDBITS(5)  nl = 257 + ((unsigned)b & 0x1f);      /* number of literal/length codes */  DUMPBITS(5)  NEEDBITS(5)  nd = 1 + ((unsigned)b & 0x1f);        /* number of distance codes */  DUMPBITS(5)  NEEDBITS(4)  nb = 4 + ((unsigned)b & 0xf);         /* number of bit length codes */  DUMPBITS(4)#ifdef PKZIP_BUG_WORKAROUND  if (nl > 288 || nd > 32)#else  if (nl > 286 || nd > 30)#endif    return 1;                   /* bad lengths */DEBG("dyn1 ");  /* read in bit-length-code lengths */  for (j = 0; j < nb; j++)  {    NEEDBITS(3)    ll[border[j]] = (unsigned)b & 7;    DUMPBITS(3)