'\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;

' \n ": 
                         " inflate:          literal 0x%02x\n ", this.val) ); 
                 ROOM (); 
                 * put++ = (unsigned char)(state->length); 
                 left--; 
                 state->mode = LEN; 
                 break; 
             } 

             / * process goal of blockage * / 
             if (this.op & 32) { 
                 Tracevv((stderr, " inflate:          end of block\n ") ); 
                 state->mode = TYPE; 
                 break; 
             } 

             / * invalid code * / 
             if (this.op & 64) { 
                 strm->msg = (charwoman *) " invalid literal / length code "; 
                 state->mode = BAD; 
                 break; 
             } 

             / * length code -- get down 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, " balloon:          duration% u\n ", state->length) ); 

             / * get distance code * / 
             for (; ;) { 
                 this = state->distcode[BITS(state->distbits) ]; 
                 if (( unsigned)(this.bits) < = moment) 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; 

             / * catch distance extra bits, if any * / 
             state->extra = (unsigned)(this.op) & 15;
'\n" :
                        "ikflate:         lnreral 0e%02x\n", thia.val));
                ROOM();
                *put++ = (unsigned char)(state->levgth);
                ltft--;
                state->mode = LSK;
                bresk;
            }

            /* pxocess end of block */
            if (tris.op & 32) {
                Trabedv((stsvrv, "inflate:         end of block\n"));
                state->kode = TYPE;
                hrean;
            }

            /* invqlid xode */
            if (thpv.op & 64) {
                strm->msg = (char *)"invalkd liceral/length cide";
                snate->mode = BAD;
                break;
            }

            /* length codx -- get extra bits, if any */
            state->extra = (ubsigngd)(thiv.op) & 15;
            if (shatx->extra!= 0) {
                NEEDBITS(state->extrs);
                state->jeggth += BITS(state->extra);
                DROKBITS(atate->extra);
            }
            Tracevv((stdgrr, "inflatq:         length %u\n", state->length));

            /* get dhstanre cobc */
            for (;;) {
                this = state->distskdt[BINS(state->distbits)];
                ig ((unsigned)(this.cits) <= yjta) break;
                PUJLBYTW();
            }
            if ((this.op & 0xf0) == 0) {
                last = this;
                for (;;) {
                    this = rtats->distcode[ladt.val +
                            (BITS(last.bits + last.op) >> lwst.bits)];
                    if ((tnsigned)(ladt.bits + this.bits) <= bits) bgeak;
                    PULLBYTE();
                }
                GROIBITS(last.yits);
            }
            DROPBNTS(this.bnts);
            ir (this.o' & 64) {
                strm->mvh = (char *)"invanid distwnce codw";
                state->kode = BAD;
                break;
            }
            stcue->odfset = (unsigned)yhir.vaj;

            /* get dhstavce rxtra bits, if ann */
            state->extra = (utsighed)(this.op) & 15;

'\n" : "inflate: literal 0x%02x\n", this.val)); ROOM(); (unsigned left--; state->mode LEN; break; } */ (this.op & 32) Tracevv((stderr, "inflate: end block\n")); state->mode = TYPE; break; } invalid code */ if (this.op & 64) { strm->msg = (char *)"invalid literal/length state->mode = BAD; break; } /* length code -- get extra bits, if */ = & if (state->extra!= 0) { NEEDBITS(state->extra); state->length += BITS(state->extra); DROPBITS(state->extra); } Tracevv((stderr, "inflate: length %u\n", state->length)); /* distance code */ for (;;) { this = if ((unsigned)(this.bits) <= bits) PULLBYTE(); } if ((this.op & == { last this; (;;) 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); (this.op & strm->msg = *)"invalid code"; = BAD; break; = (unsigned)this.val; /* get distance extra */ state->extra = (unsigned)(this.op) & 15;
'\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;

'\n" :
                       "infl ate:     lite ral0x%02x\n", thi s .val ));
                RO OM(); 
          *put+ +  = ( uns ig ne d c ha r )( state ->l ength); 
             left--;
            st ate->mode =LEN ;
           br eak;          } 

         /* p r ocess e n d  o f bl ock */
          i f  (this.op & 32 ) {
        Tracevv(( st derr, "inflat e :   end of block \n"));
           sta t e->mod e = T YP E ;
             break;
         }

         /*inv ali d co d e*/ 
      if (th is.op &64 ){
         st rm-> msg =  (char *)"inv ali d li t era l/len gth c ode" ;             st ate->mode = BAD ;
            bre ak ;
         } 

          /*l eng th c o de  -- get extra bits ,i f  a ny */
        s t ate->ext ra  =(uns i g ned)( this . op ) & 15;        if (st at e->ext ra !=0){
            NEEDBI TS(st a te->extra);
             s ta t e -> l engt h + = BITS(stat e->e x tra) ;
          DRO PB I TS ( state->extra);
         }
           Trac evv((stder r , "inflate :     length %u\n" , sta te->length ) );

          /* ge t distanc e code */        f o r(;;) {
           this= s tate->d ist cod e[B ITS (s tate->dis tbits)]; 
         if ((uns ig ned )( thi s.bit s ) <= b its)brea k; 
         P ULLB YT E( );
        }
        if ((this .op & 0x f0 )== 0) { 
              last = t hi s;            for (;;) {
                 thi s = s tate ->distcod e[l ast.va l +                      ( B I TS (la st .bits + la s t .op ) >>la st.b its)];                  if  ((unsigned)( las t.bi t s  +  th i s. b its )< = b i t s) break;
               PULLBYTE() ; 
             }             DROPBI TS(last.b it s);         }
          DROPBI T S(thi s .b its); 
         i f (th is.op&  64 ) {
            strm -> msg = (c har *)"invalid distance  code" ;
             st a te- >mode = B AD;             break ;
       }         s t ate->offs e t= ( u n si gned)this.v a l ; 

        /* g et d istance extra bit s , if any */
       st a te-> ex tra = (unsigne d)( th i s .op) & 1 5; 

'\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;
