state->mode = BAD;            }            DROPBITS(2);            break;        case STORED:            /* get and verify stored block length */            BYTEBITS();                         /* go to byte boundary */            NEEDBITS(32);            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {                strm->msg = (char *)"invalid stored block lengths";                state->mode = BAD;                break;            }            state->length = (unsigned)hold & 0xffff;            Tracev((stderr, "inflate:       stored length %u\n",                    state->length));            INITBITS();            /* copy stored block from input to output */            while (state->length != 0) {                copy = state->length;                PULL();                ROOM();                if (copy > have) copy = have;                if (copy > left) copy = left;                zmemcpy(put, next, copy);                have -= copy;                next += copy;                left -= copy;                put += copy;                state->length -= copy;            }            Tracev((stderr, "inflate:       stored end\n"));            state->mode = TYPE;            break;        case TABLE:            /* get dynamic table entries descriptor */            NEEDBITS(14);            state->nlen = BITS(5) + 257;            DROPBITS(5);            state->ndist = BITS(5) + 1;            DROPBITS(5);            state->ncode = BITS(4) + 4;            DROPBITS(4);#ifndef PKZIP_BUG_WORKAROUND            if (state->nlen > 286 || state->ndist > 30) {                strm->msg = (char *)"too many length or distance symbols";                state->mode = BAD;                break;            }#endif            Tracev((stderr, "inflate:       table sizes ok\n"));            /* get code length code lengths (not a typo) */            state->have = 0;            while (state->have < state->ncode) {                NEEDBITS(3);                state->lens[order[state->have++]] = (unsigned short)BITS(3);                DROPBITS(3);            }            while (state->have < 19)                state->lens[order[state->have++]] = 0;            state->next = state->codes;            state->lencode = (code const FAR *)(state->next);            state->lenbits = 7;            ret = inflate_table(CODES, state->lens, 19, &(state->next),                                &(state->lenbits), state->work);            if (ret) {                strm->msg = (char *)"invalid code lengths set";                state->mode = BAD;                break;            }            Tracev((stderr, "inflate:       code lengths ok\n"));            /* get length and distance code code lengths */            state->have = 0;            while (state->have < state->nlen + state->ndist) {                for (;;) {                    this = state->lencode[BITS(state->lenbits)];                    if ((unsigned)(this.bits) <= bits) break;                    PULLBYTE();                }                if (this.val < 16) {                    NEEDBITS(this.bits);                    DROPBITS(this.bits);                    state->lens[state->have++] = this.val;                }                else {                    if (this.val == 16) {                        NEEDBITS(this.bits + 2);                        DROPBITS(this.bits);                        if (state->have == 0) {                            strm->msg = (char *)"invalid bit length repeat";                            state->mode = BAD;                            break;                        }                        len = (unsigned)(state->lens[state->have - 1]);                        copy = 3 + BITS(2);                        DROPBITS(2);                    }                    else if (this.val == 17) {                        NEEDBITS(this.bits + 3);                        DROPBITS(this.bits);                        len = 0;                        copy = 3 + BITS(3);                        DROPBITS(3);                    }                    else {                        NEEDBITS(this.bits + 7);                        DROPBITS(this.bits);                        len = 0;                        copy = 11 + BITS(7);                        DROPBITS(7);                    }                    if (state->have + copy > state->nlen + state->ndist) {                        strm->msg = (char *)"invalid bit length repeat";                        state->mode = BAD;                        break;                    }                    while (copy--)                        state->lens[state->have++] = (unsigned short)len;                }            }            /* build code tables */            state->next = state->codes;            state->lencode = (code const FAR *)(state->next);            state->lenbits = 9;            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),                                &(state->lenbits), state->work);            if (ret) {                strm->msg = (char *)"invalid literal/lengths set";                state->mode = BAD;                break;            }            state->distcode = (code const FAR *)(state->next);            state->distbits = 6;            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,                            &(state->next), &(state->distbits), state->work);            if (ret) {                strm->msg = (char *)"invalid distances set";                state->mode = BAD;                break;            }            Tracev((stderr, "inflate:       codes ok\n"));            state->mode = LEN;        case LEN:            /* use inflate_fast() if we have enough input and output */            if (have >= 6 && left >= 258) {                RESTORE();                if (state->whave < state->wsize)                    state->whave = state->wsize - left;                inflate_fast(strm, state->wsize);                LOAD();                break;            }            /* get a literal, length, or end-of-block code */            for (;;) {                this = state->lencode[BITS(state->lenbits)];                if ((unsigned)(this.bits) <= bits) break;                PULLBYTE();            }            if (this.op && (this.op & 0xf0) == 0) {                last = this;                for (;;) {                    this = state->lencode[last.val +                            (BITS(last.bits + last.op) >> last.bits)];                    if ((unsigned)(last.bits + this.bits) <= bits) break;                    PULLBYTE();                }                DROPBITS(last.bits);            }            DROPBITS(this.bits);            state->length = (unsigned)this.val;            /* process literal */            if (this.op == 0) {                Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?                        "inflate:         literal '%c'\n" :                        "inflate:         literal 0x%02x\n", this.val));                ROOM();                *put++ = (unsigned char)(state->length);                left--;                state->mode = LEN;                break;            }            /* process end of block */            if (this.op & 32) {                Tracevv((stderr, "inflate:         end of block\n"));                state->mode = TYPE;                break;            }            /* invalid code */            if (this.op & 64) {                strm->msg = (char *)"invalid literal/length code";                state->mode = BAD;                break;            }            /* length code -- get extra bits, if any */            state->extra = (unsigned)(this.op) & 15;            if (state->extra != 0) {                NEEDBITS(state->extra);                state->length += BITS(state->extra);                DROPBITS(state->extra);            }            Tracevv((stderr, "inflate:         length %u\n", state->length));            /* get distance code */            for (;;) {                this = state->distcode[BITS(state->distbits)];                if ((unsigned)(this.bits) <= bits) break;                PULLBYTE();            }            if ((this.op & 0xf0) == 0) {                last = this;                for (;;) {                    this = state->distcode[last.val +                            (BITS(last.bits + last.op) >> last.bits)];                    if ((unsigned)(last.bits + this.bits) <= bits) break;                    PULLBYTE();                }                DROPBITS(last.bits);            }            DROPBITS(this.bits);            if (this.op & 64) {                strm->msg = (char *)"invalid distance code";                state->mode = BAD;                break;            }            state->offset = (unsigned)this.val;            /* get distance extra bits, if any */            state->extra = (unsigned)(this.op) & 15;            if (state->extra != 0) {                NEEDBITS(state->extra);                state->offset += BITS(state->extra);                DROPBITS(state->extra);            }            if (state->offset > state->wsize - (state->whave < state->wsize ?                                                left : 0)) {                strm->msg = (char *)"invalid distance too far back";                state->mode = BAD;                break;            }            Tracevv((stderr, "inflate:         distance %u\n", state->offset));            /* copy match from window to output */            do {                ROOM();                copy = state->wsize - state->offset;                if (copy < left) {                    from = put + copy;                    copy = left - copy;                }                else {                    from = put - state->offset;                    copy = left;                }                if (copy > state->length) copy = state->length;                state->length -= copy;                left -= copy;                do {                    *put++ = *from++;                } while (--copy);            } while (state->length != 0);            break;        case DONE:            /* inflate stream terminated properly -- write leftover output */            ret = Z_STREAM_END;            if (left < state->wsize) {                if (out(out_desc, state->window, state->wsize - left))                    ret = Z_BUF_ERROR;            }            goto inf_leave;        case BAD:            ret = Z_DATA_ERROR;            goto inf_leave;        default:                /* can't happen, but makes compilers happy */            ret = Z_STREAM_ERROR;            goto inf_leave;        }    /* Return unused input */  inf_leave:    strm->next_in = next;    strm->avail_in = have;    return ret;}int ZEXPORT inflateBackEnd(strm)z_stream FAR *strm;{    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)        return Z_STREAM_ERROR;    ZFREE(strm, strm->state);    strm->state = Z_NULL;    Tracev((stderr, "inflate: end\n"));    return Z_OK;}