*/ static voidp falloc    (    voidp	q,	/* opaque pointer */    uInt	n,      /* number of items */    uInt	s       /* size of item */    )    {    *(int *)q -= n;    return (voidp)(fixed_mem + *(int *)q);    }/******************************************************************************** inflate_trees_fixed - do something*/ static int inflate_trees_fixed    (    uInt *	bl,	/* literal desired/actual bit depth */    uInt *	bd,     /* distance desired/actual bit depth */    inflate_huft ** tl, /* literal/length tree result */    inflate_huft ** td  /* distance tree result */    )    {    /* build fixed tables if not already (multiple overlapped executions ok) */    if (!fixed_built)	{	int k;              /* temporary variable */	unsigned *c = (unsigned *)zcalloc (0, 288, sizeof (unsigned));			    /* length list for huft_build */	z_stream z;         /* for falloc function */	int f = FIXEDH;     /* number of hufts left in fixed_mem */	/* set up fake z_stream for memory routines */	z.zalloc = falloc;	z.zfree = Z_NULL;	z.opaque = (voidp)&f;	/* 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 = 7;	huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z);	/* distance table */	for (k = 0; k < 30; k++)#if	CPU_FAMILY==MC680X0	    ((volatile unsigned *)c)[k] = 5;#else	    c[k] = 5;#endif	fixed_bd = 5;	huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z);	/* done */	fixed_built = 1;	zcfree (0, c);	}    *bl = fixed_bl;    *bd = fixed_bd;    *tl = fixed_tl;    *td = fixed_td;    return Z_OK;    }/******************************************************************************** inflate_trees_free - frees inflate trees** 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.*/ static int inflate_trees_free    (    inflate_huft *	t,	/* table to free */    z_streamp		z       /* for zfree function */    )    {    register inflate_huft *p, *q, *r;    /* Reverse linked list */    p = Z_NULL;    q = t;    while (q != Z_NULL)	{	r = (q - 1)->next;	(q - 1)->next = p;	p = q;	q = r;	}    /* Go through linked list, freeing from the malloced (t[-1]) address. */    while (p != Z_NULL)	{	q = (--p)->next;	ZFREE(z,p);	p = q;	}     return Z_OK;    }/******************************************************************************** inflate_flush - flushes inflate** copy as much as possible from the sliding window to the output area*/ static int inflate_flush    (    inflate_blocks_statef * s,    z_streamp		z,    int 		r    )    {    uInt n;    Byte *p;    Byte *q;    /* local copies of source and destination pointers */    p = z->next_out;    q = s->read;    /* compute number of bytes to copy as far as end of window */    n = (uInt)((q <= s->write ? s->write : s->end) - q);    if (n > z->avail_out)	n = z->avail_out;    if (n && r == Z_BUF_ERROR)	r = Z_OK;    /* update counters */    z->avail_out -= n;    z->total_out += n;    /* update check information */    if (s->checkfn != Z_NULL)	z->adler = s->check = (*s->checkfn)(s->check, q, n);    /* copy as far as end of window */    memcpy(p, q, n);    p += n;    q += n;    /* see if more to copy at beginning of window */    if (q == s->end)	{	/* wrap pointers */	q = s->window;	if (s->write == s->end)	    s->write = s->window;	/* compute bytes to copy */	n = (uInt)(s->write - q);	if (n > z->avail_out)	    n = z->avail_out;	if (n && r == Z_BUF_ERROR)	    r = Z_OK;	/* update counters */	z->avail_out -= n;	z->total_out += n;	/* update check information */	if (s->checkfn != Z_NULL)	    z->adler = s->check = (*s->checkfn)(s->check, q, n);	/* copy */	memcpy(p, q, n);	p += n;	q += n;	}    /* update pointers */    z->next_out = p;    s->read = q;    /* done */    return r;    }/******************************************************************************** inflate_fast - inflate fast** Called with number of bytes left to write in window at least 258* (the maximum string length) and number of input bytes available* at least ten.  The ten bytes are six bytes for the longest length/* distance pair plus four bytes for overloading the bit buffer.*/ static int inflate_fast    (    uInt	bl,    uInt	bd,    inflate_huft * tl,    inflate_huft * td,    inflate_blocks_statef * s,    z_streamp	z    )    {    inflate_huft *t;	/* temporary pointer */    uInt e;             /* extra bits or operation */    uLong b;            /* bit buffer */    uInt k;             /* bits in bit buffer */    Byte *p;            /* input data pointer */    uInt n;             /* bytes available there */    Byte *q;            /* output window write pointer */    uInt m;             /* bytes to end of window or read pointer */    uInt ml;            /* mask for literal/length tree */    uInt md;            /* mask for distance tree */    uInt c;             /* bytes to copy */    uInt d;             /* distance back to copy from */    Byte *r;            /* copy source pointer */  /* load input, output, bit values */  LOAD  /* initialize masks */  ml = inflate_mask[bl];  md = inflate_mask[bd];  /* do until not enough input or output space for fast loop */  do {                          /* assume called with m >= 258 && n >= 10 */    /* get literal/length code */    GRABBITS(20)                /* max bits for literal/length code */    if ((e = (t = tl + ((uInt)b & ml))->exop) == 0)    {      DUMPBITS(t->bits)      Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?                "inflate:         * literal '%c'\n" :                "inflate:         * literal 0x%02x\n", t->base));      *q++ = (Byte)t->base;      m--;      continue;    }    do {      DUMPBITS(t->bits)      if (e & 16)      {        /* get extra bits for length */        e &= 15;        c = t->base + ((uInt)b & inflate_mask[e]);        DUMPBITS(e)        Tracevv((stderr, "inflate:         * length %u\n", c));        /* decode distance base of block to copy */        GRABBITS(15);           /* max bits for distance code */        e = (t = td + ((uInt)b & md))->exop;        do {          DUMPBITS(t->bits)          if (e & 16)          {            /* get extra bits to add to distance base */            e &= 15;            GRABBITS(e)         /* get extra bits (up to 13) */            d = t->base + ((uInt)b & inflate_mask[e]);            DUMPBITS(e)            Tracevv((stderr, "inflate:         * distance %u\n", d));            /* do the copy */            m -= c;            if ((uInt)(q - s->window) >= d)     /* offset before dest */            {                                   /*  just copy */              r = q - d;              *q++ = *r++;  c--;        /* minimum count is three, */              *q++ = *r++;  c--;        /*  so unroll loop a little */            }            else                        /* else offset after destination */            {              e = d - (uInt)(q - s->window); /* bytes from offset to end */              r = s->end - e;           /* pointer to offset */              if (c > e)                /* if source crosses, */              {                c -= e;                 /* copy to end of window */                do {                  *q++ = *r++;                } while (--e);                r = s->window;          /* copy rest from start of window */              }            }            do {                        /* copy all or what's left */              *q++ = *r++;            } while (--c);            break;          }          else if ((e & 64) == 0)            e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop;          else          {            z->msg = (char*)"invalid distance code";            UNGRAB            UPDATE            return Z_DATA_ERROR;          }        } while (1);        break;      }      if ((e & 64) == 0)      {        if ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) == 0)        {          DUMPBITS(t->bits)          Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?                    "inflate:         * literal '%c'\n" :                    "inflate:         * literal 0x%02x\n", t->base));          *q++ = (Byte)t->base;          m--;          break;        }      }      else if (e & 32)      {        Tracevv((stderr, "inflate:         * end of block\n"));        UNGRAB        UPDATE        return Z_STREAM_END;      }      else      {        z->msg = (char*)"invalid literal/length code";        UNGRAB        UPDATE        return Z_DATA_ERROR;      }    } while (1);  } while (m >= 258 && n >= 10);  /* not enough input or output--restore pointers and return */  UNGRAB  UPDATE  return Z_OK;}/******************************************************************************** inflate_codes_new - inflate codes new** NOMANUAL*/ static inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z)uInt bl, bd;inflate_huft *tl;inflate_huft *td; /* need separate declaration for Borland C++ */z_streamp z;{  inflate_codes_statef *c;  if ((c = (inflate_codes_statef *)       ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)  {    c->mode = START;    c->lbits = (Byte)bl;    c->dbits = (Byte)bd;    c->ltree = tl;    c->dtree = td;    Tracev((stderr, "inflate:       codes new\n"));  }  return c;}/******************************************************************************** inflate_codes - inflate codes**/ static int inflate_codes(s, z, r)inflate_blocks_statef *s;z_streamp z;int r;{  uInt j;               /* temporary storage */  inflate_huft *t;      /* temporary pointer */  uInt e;               /* extra bits or operation */  uLong b;              /* bit buffer */  uInt k;               /* bits in bit buffer */  Byte *p;             /* input data pointer */  uInt n;               /* bytes available there */  Byte *q;             /* output window write pointer */  uInt m;               /* bytes to end of window or read pointer */  Byte *f;             /* pointer to copy strings from */  inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */  /* copy input/output information to locals (UPDATE macro restores) */  LOAD  /* process input and output based on current state */  while (1) switch (c->mode)  {             /* waiting for "i:"=input, "o:"=output, "x:"=nothing */    case START:         /* x: set up for LEN */#ifndef SLOW      if (m >= 258 && n >= 10)      {        UPDATE        r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);        LOAD        if (r != Z_OK)        {          c->mode = r == Z_STREAM_END ? WASH : BADCODE;          break;        }      }#endif /* !SLOW */      c->sub.code.need = c->lbits;      c->sub.code.tree = c->ltree;      c->mode = LEN;    case LEN:           /* i: get length/literal/eob next */      j = c->sub.code.need;