{          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++];          } 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;}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;}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;}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)  }  for (; j < 19; j++)    ll[border[j]] = 0;DEBG("dyn2 ");  /* build decoding table for trees--single level, 7 bit lookup */  bl = 7;  if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0)  {    if (i == 1)      huft_free(tl);    return i;                   /* incomplete code set */  }DEBG("dyn3 ");  /* read in literal and distance code lengths */  n = nl + nd;  m = mask_bits[bl];  i = l = 0;  while ((unsigned)i < n)  {    NEEDBITS((unsigned)bl)    j = (td = tl + ((unsigned)b & m))->b;    DUMPBITS(j)    j = td->v.n;    if (j < 16)                 /* length of code in bits (0..15) */      ll[i++] = l = j;          /* save last length in l */    else if (j == 16)           /* repeat last length 3 to 6 times */    {      NEEDBITS(2)      j = 3 + ((unsigned)b & 3);      DUMPBITS(2)      if ((unsigned)i + j > n)        return 1;      while (j--)        ll[i++] = l;    }    else if (j == 17)           /* 3 to 10 zero length codes */    {      NEEDBITS(3)      j = 3 + ((unsigned)b & 7);      DUMPBITS(3)      if ((unsigned)i + j > n)        return 1;      while (j--)        ll[i++] = 0;      l = 0;    }    else                        /* j == 18: 11 to 138 zero length codes */    {      NEEDBITS(7)      j = 11 + ((unsigned)b & 0x7f);      DUMPBITS(7)      if ((unsigned)i + j > n)        return 1;      while (j--)        ll[i++] = 0;      l = 0;    }  }DEBG("dyn4 ");  /* free decoding table for trees */  huft_free(tl);DEBG("dyn5 ");  /* restore the global bit buffer */  bb = b;  bk = k;DEBG("dyn5a ");  /* build the decoding tables for literal/length and distance codes */  bl = lbits;  if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0)  {DEBG("dyn5b ");    if (i == 1) {      error(" incomplete literal tree\n");      huft_free(tl);    }    return i;                   /* incomplete code set */  }DEBG("dyn5c ");  bd = dbits;  if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0)  {DEBG("dyn5d ");    if (i == 1) {      error(" incomplete distance tree\n");#ifdef PKZIP_BUG_WORKAROUND      i = 0;    }#else      huft_free(td);    }    huft_free(tl);    return i;                   /* incomplete code set */#endif  }DEBG("dyn6 ");  /* decompress until an end-of-block code */  if (inflate_codes(tl, td, bl, bd))    return 1;DEBG("dyn7 ");  /* free the decoding tables, return */  huft_free(tl);  huft_free(td);  DEBG(">");  return 0;}int inflate_block(e)int *e;                 /* last block flag *//* decompress an inflated block */{  unsigned t;           /* block type */  register ulg b;       /* bit buffer */  register unsigned k;  /* number of bits in bit buffer */  DEBG("<blk");  /* make local bit buffer */  b = bb;  k = bk;  /* read in last block bit */  NEEDBITS(1)  *e = (int)b & 1;  DUMPBITS(1)  /* read in block type */  NEEDBITS(2)  t = (unsigned)b & 3;  DUMPBITS(2)  /* restore the global bit buffer */  bb = b;  bk = k;  /* inflate that block type */  if (t == 2)    return inflate_dynamic();  if (t == 0)    return inflate_stored();  if (t == 1)    return inflate_fixed();  DEBG(">");  /* bad block type */  return 2;}int inflate()/* decompress an inflated entry */{  int e;                /* last block flag */  int r;                /* result code */  unsigned h;           /* maximum struct huft's malloc'ed */  /* initialize window, bit buffer */  wp = 0;  bk = 0;  bb = 0;  /* decompress until the last block */  h = 0;  do {    hufts = 0;    if ((r = inflate_block(&e)) != 0)      return r;    if (hufts > h)      h = hufts;  } while (!e);  /* Undo too much lookahead. The next read will be byte aligned so we   * can discard unused bits in the last meaningful byte.   */  while (bk >= 8) {    bk -= 8;    inptr--;  }  /* flush out slide */  flush_output(wp);  /* return success */#ifdef DEBUG  fprintf(stderr, "<%u> ", h);#endif /* DEBUG */  return 0;}