break;            case 3:                strm->msg = (char *)"invalid block type";                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";                mode = BAD;                break;            }            length = (unsigned)hold & 0xffff;            Tracev((stderr, "inflate:       stored length %lu\n",                    length));            INITBITS();            /* copy stored block from input to output */            while (length != 0) {                copy = 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;                length -= copy;            }            Tracev((stderr, "inflate:       stored end\n"));            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);            if (state->nlen > 286) {                strm->msg = (char *)"too many length symbols";                mode = BAD;                break;            }            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;            lencode = (code const FAR *)(state->next);            lenbits = 7;            ret = inflate_table9(CODES, state->lens, 19, &(state->next),                                &(lenbits), state->work);            if (ret) {                strm->msg = (char *)"invalid code lengths set";                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 = lencode[BITS(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";                            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";                        mode = BAD;                        break;                    }                    while (copy--)                        state->lens[state->have++] = (unsigned short)len;                }            }            /* handle error breaks in while */            if (mode == BAD) break;            /* build code tables */            state->next = state->codes;            lencode = (code const FAR *)(state->next);            lenbits = 9;            ret = inflate_table9(LENS, state->lens, state->nlen,                            &(state->next), &(lenbits), state->work);            if (ret) {                strm->msg = (char *)"invalid literal/lengths set";                mode = BAD;                break;            }            distcode = (code const FAR *)(state->next);            distbits = 6;            ret = inflate_table9(DISTS, state->lens + state->nlen,                            state->ndist, &(state->next), &(distbits),                            state->work);            if (ret) {                strm->msg = (char *)"invalid distances set";                mode = BAD;                break;            }            Tracev((stderr, "inflate:       codes ok\n"));            mode = LEN;        case LEN:            /* get a literal, length, or end-of-block code */            for (;;) {                this = lencode[BITS(lenbits)];                if ((unsigned)(this.bits) <= bits) break;                PULLBYTE();            }            if (this.op && (this.op & 0xf0) == 0) {                last = this;                for (;;) {                    this = 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);            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)(length);                left--;                mode = LEN;                break;            }            /* process end of block */            if (this.op & 32) {                Tracevv((stderr, "inflate:         end of block\n"));                mode = TYPE;                break;            }            /* invalid code */            if (this.op & 64) {                strm->msg = (char *)"invalid literal/length code";                mode = BAD;                break;            }            /* length code -- get extra bits, if any */            extra = (unsigned)(this.op) & 31;            if (extra != 0) {                NEEDBITS(extra);                length += BITS(extra);                DROPBITS(extra);            }            Tracevv((stderr, "inflate:         length %lu\n", length));            /* get distance code */            for (;;) {                this = distcode[BITS(distbits)];                if ((unsigned)(this.bits) <= bits) break;                PULLBYTE();            }            if ((this.op & 0xf0) == 0) {                last = this;                for (;;) {                    this = 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";                mode = BAD;                break;            }            offset = (unsigned)this.val;            /* get distance extra bits, if any */            extra = (unsigned)(this.op) & 15;            if (extra != 0) {                NEEDBITS(extra);                offset += BITS(extra);                DROPBITS(extra);            }            if (offset > WSIZE - (wrap ? 0: left)) {                strm->msg = (char *)"invalid distance too far back";                mode = BAD;                break;            }            Tracevv((stderr, "inflate:         distance %lu\n", offset));            /* copy match from window to output */            do {                ROOM();                copy = WSIZE - offset;                if (copy < left) {                    from = put + copy;                    copy = left - copy;                }                else {                    from = put - offset;                    copy = left;                }                if (copy > length) copy = length;                length -= copy;                left -= copy;                do {                    *put++ = *from++;                } while (--copy);            } while (length != 0);            break;        case DONE:            /* inflate stream terminated properly -- write leftover output */            ret = Z_STREAM_END;            if (left < WSIZE) {                if (out(out_desc, window, (unsigned)(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 inflateBack9End(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;}