windowBits = 15;        else if (windowBits < 8)            windowBits = 8;        G.dstrm.zalloc = (alloc_func)Z_NULL;        G.dstrm.zfree = (free_func)Z_NULL;        Trace((stderr, "initializing inflate()\n"));        err = inflateInit2(&G.dstrm, -windowBits);        if (err == Z_MEM_ERROR)            return 3;        else if (err != Z_OK)            Trace((stderr, "oops!  (inflateInit2() err = %d)\n", err));        G.inflInit = 1;    }#ifdef FUNZIP    while (err != Z_STREAM_END) {#else /* !FUNZIP */    while (G.csize > 0) {        Trace((stderr, "first loop:  G.csize = %ld\n", G.csize));#endif /* ?FUNZIP */        while (G.dstrm.avail_out > 0) {            err = inflate(&G.dstrm, Z_PARTIAL_FLUSH);            if (err == Z_DATA_ERROR) {                retval = 2; goto uzinflate_cleanup_exit;            } else if (err == Z_MEM_ERROR) {                retval = 3; goto uzinflate_cleanup_exit;            } else if (err != Z_OK && err != Z_STREAM_END)                Trace((stderr, "oops!  (inflate(first loop) err = %d)\n", err));#ifdef FUNZIP            if (err == Z_STREAM_END)    /* "END-of-entry-condition" ? */#else /* !FUNZIP */            if (G.csize <= 0L)          /* "END-of-entry-condition" ? */#endif /* ?FUNZIP */                break;            if (G.dstrm.avail_in <= 0) {                if (fillinbuf(__G) == 0) {                    /* no "END-condition" yet, but no more data */                    retval = 2; goto uzinflate_cleanup_exit;                }                G.dstrm.next_in = G.inptr;                G.dstrm.avail_in = G.incnt;            }            Trace((stderr, "     avail_in = %d\n", G.dstrm.avail_in));        }        /* flush slide[] */        if ((retval = FLUSH(wsize - G.dstrm.avail_out)) != 0)            goto uzinflate_cleanup_exit;        Trace((stderr, "inside loop:  flushing %ld bytes (ptr diff = %ld)\n",          (long)(wsize - G.dstrm.avail_out),          (long)(G.dstrm.next_out-(Bytef *)redirSlide)));        G.dstrm.next_out = redirSlide;        G.dstrm.avail_out = wsize;    }    /* no more input, so loop until we have all output */    Trace((stderr, "beginning final loop:  err = %d\n", err));    while (err != Z_STREAM_END) {        err = inflate(&G.dstrm, Z_PARTIAL_FLUSH);        if (err == Z_DATA_ERROR) {            retval = 2; goto uzinflate_cleanup_exit;        } else if (err == Z_MEM_ERROR) {            retval = 3; goto uzinflate_cleanup_exit;        } else if (err == Z_BUF_ERROR) {                /* DEBUG */            Trace((stderr,                   "zlib inflate() did not detect stream end (%s, %s)\n",                   G.zipfn, G.filename));            break;        } else if (err != Z_OK && err != Z_STREAM_END) {            Trace((stderr, "oops!  (inflate(final loop) err = %d)\n", err));            DESTROYGLOBALS();            EXIT(PK_MEM3);        }        /* final flush of slide[] */        if ((retval = FLUSH(wsize - G.dstrm.avail_out)) != 0)            goto uzinflate_cleanup_exit;        Trace((stderr, "final loop:  flushing %ld bytes (ptr diff = %ld)\n",          (long)(wsize - G.dstrm.avail_out),          (long)(G.dstrm.next_out-(Bytef *)redirSlide)));        G.dstrm.next_out = redirSlide;        G.dstrm.avail_out = wsize;    }    Trace((stderr, "total in = %ld, total out = %ld\n", G.dstrm.total_in,      G.dstrm.total_out));    G.inptr = (uch *)G.dstrm.next_in;    G.incnt = (G.inbuf + INBUFSIZ) - G.inptr;  /* reset for other routines */uzinflate_cleanup_exit:    err = inflateReset(&G.dstrm);    if (err != Z_OK)        Trace((stderr, "oops!  (inflateReset() err = %d)\n", err));    return retval;}/*---------------------------------------------------------------------------*/#else /* !USE_ZLIB *//* Function prototypes */#ifndef OF#  ifdef __STDC__#    define OF(a) a#  else#    define OF(a) ()#  endif#endif /* !OF */int inflate_codes OF((__GPRO__ struct huft *tl, struct huft *td,                      int bl, int bd));static int inflate_stored OF((__GPRO));static int inflate_fixed OF((__GPRO));static int inflate_dynamic OF((__GPRO));static int inflate_block OF((__GPRO__ int *e));/* The inflate algorithm uses a sliding 32K byte window on the uncompressed   stream to find repeated byte strings.  This is implemented here as a   circular buffer.  The index is updated simply by incrementing and then   and'ing with 0x7fff (32K-1). *//* It is left to other modules to supply the 32K area.  It is assumed   to be usable as if it were declared "uch slide[32768];" or as just   "uch *slide;" and then malloc'ed in the latter case.  The definition   must be in unzip.h, included above. *//* unsigned wp;  moved to globals.h */     /* current position in slide *//* Tables for deflate from PKZIP's appnote.txt. *//* - Order of the bit length code lengths */static ZCONST unsigned border[] = {        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};/* - Copy lengths for literal codes 257..285 */#ifdef USE_DEFLATE64static ZCONST ush cplens64[] = {        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, 3, 0, 0};        /* For Deflate64, the code 285 is defined differently. */#else#  define cplens32 cplens#endifstatic ZCONST ush cplens32[] = {        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};        /* note: see note #13 above about the 258 in this list. *//* - Extra bits for literal codes 257..285 */#ifdef USE_DEFLATE64static ZCONST uch cplext64[] = {        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, 16, INVALID_CODE, INVALID_CODE};#else#  define cplext32 cplext#endifstatic ZCONST uch cplext32[] = {        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, INVALID_CODE, INVALID_CODE};/* - Copy offsets for distance codes 0..29 (0..31 for Deflate64) */static ZCONST ush cpdist[] = {        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,#if (defined(USE_DEFLATE64) || defined(PKZIP_BUG_WORKAROUND))        8193, 12289, 16385, 24577, 32769, 49153};#else        8193, 12289, 16385, 24577};#endif/* - Extra bits for distance codes 0..29 (0..31 for Deflate64) */#ifdef USE_DEFLATE64static ZCONST uch cpdext64[] = {        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, 14, 14};#else#  define cpdext32 cpdext#endifstatic ZCONST uch cpdext32[] = {        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,#ifdef PKZIP_BUG_WORKAROUND        12, 12, 13, 13, INVALID_CODE, INVALID_CODE};#else        12, 12, 13, 13};#endif#ifdef PKZIP_BUG_WORKAROUND#  define MAXLITLENS 288#else#  define MAXLITLENS 286#endif#if (defined(USE_DEFLATE64) || defined(PKZIP_BUG_WORKAROUND))#  define MAXDISTS 32#else#  define MAXDISTS 30#endif/* moved to consts.h (included in unzip.c), resp. funzip.c */#if 0/* And'ing with mask_bits[n] masks the lower n bits */ZCONST ush near mask_bits[] = {    0x0000,    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff};#endif /* 0 *//* Macros for inflate() bit peeking and grabbing.   The usage is:        NEEDBITS(j)        x = b & mask_bits[j];        DUMPBITS(j)   where NEEDBITS makes sure that b has at least j bits in it, and   DUMPBITS removes the bits from b.  The macros use the variable k   for the number of bits in b.  Normally, b and k are register   variables for speed and are initialized at the begining of a   routine that uses these macros from a global bit buffer and count.   In order to not ask for more bits than there are in the compressed   stream, the Huffman tables are constructed to only ask for just   enough bits to make up the end-of-block code (value 256).  Then no   bytes need to be "returned" to the buffer at the end of the last   block.  See the huft_build() routine. *//* These have been moved to globals.h */#if 0ulg bb;                         /* bit buffer */unsigned bk;                    /* bits in bit buffer */#endif#ifndef CHECK_EOF#  define CHECK_EOF   /* default as of 5.13/5.2 */#endif#ifndef CHECK_EOF#  define NEEDBITS(n) {while(k<(n)){b|=((ulg)NEXTBYTE)<<k;k+=8;}}#else#  define NEEDBITS(n) {while(k<(n)){int c=NEXTBYTE;\    if(c==EOF){retval=1;goto cleanup_and_exit;}\    b|=((ulg)c)<<k;k+=8;}}#endif#define DUMPBITS(n) {b>>=(n);k-=(n);}/*   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   are 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. */static ZCONST int lbits = 9;    /* bits in base literal/length lookup table */static ZCONST int dbits = 6;    /* bits in base distance lookup table */#ifndef ASM_INFLATECODESint inflate_codes(__G__ tl, td, bl, bd)     __GDEFstruct 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 d;           /* index for copy */  UINT_D64 n;           /* length for copy (deflate64: might be 64k+2) */  UINT_D64 w;           /* current window position (deflate64: up to 64k) */  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 */  int retval = 0;       /* error code returned: initialized to "no error" */  /* make local copies of globals */  b = G.bb;                       /* initialize bit buffer */  k = G.bk;  w = G.wp;                       /* initialize window position */  /* inflate the coded data */  ml = mask_bits[bl];           /* precompute masks for speed */  md = mask_bits[bd];  while (1)                     /* do until end of block */  {    NEEDBITS((unsigned)bl)    t = tl + ((unsigned)b & ml);    while (1) {      DUMPBITS(t->b)      if ((e = t->e) == 32)     /* then it's a literal */      {        redirSlide[w++] = (uch)t->v.n;        if (w == wsize)        {          if ((retval = FLUSH(w)) != 0) goto cleanup_and_exit;          w = 0;        }        break;      }      if (e < 31)               /* then it's a length */      {        /* 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)        t = td + ((unsigned)b & md);        while (1) {          DUMPBITS(t->b)          if ((e = t->e) < 32)            break;          if (IS_INVALID_CODE(e))            return 1;          e &= 31;          NEEDBITS(e)          t = t->v.t + ((unsigned)b & mask_bits[e]);        }        NEEDBITS(e)        d = (unsigned)w - t->v.n - ((unsigned)b & mask_bits[e]);        DUMPBITS(e)        /* do the copy */        do {#if (defined(DLL) && !defined(NO_SLIDE_REDIR))          if (G.redirect_slide) {            /* &= w/ wsize unnecessary & wrong if redirect */            if ((UINT_D64)d >= wsize)              return 1;         /* invalid compressed data */            e = (unsigned)(wsize - (d > (unsigned)w ? (UINT_D64)d : w));          }          else