gerrit.simantics Code Review - simantics/sysdyn.git/blob

   1 ; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01 \r
   2 \r
   3         TITLE   C:\Workspaces\Sysdyn\org.simantics.fmu\FMUSolution\zlib-1.2.6\inffast.c\r
   4         .686P\r
   5         .XMM\r
   6         include listing.inc\r
   7         .model  flat\r
   8 \r
   9 INCLUDELIB OLDNAMES\r
  10 \r
  11 PUBLIC  _inflate_fast\r
  12 ; Function compile flags: /Ogtp\r
  13 ; File c:\workspaces\sysdyn\org.simantics.fmu\fmusolution\zlib-1.2.6\inffast.c\r
  14 ;       COMDAT _inflate_fast\r
  15 _TEXT   SEGMENT\r
  16 _lmask$ = -60                                           ; size = 4\r
  17 _whave$ = -56                                           ; size = 4\r
  18 _beg$ = -52                                             ; size = 4\r
  19 _dmask$ = -48                                           ; size = 4\r
  20 _end$ = -44                                             ; size = 4\r
  21 _window$ = -40                                          ; size = 4\r
  22 _wsize$ = -36                                           ; size = 4\r
  23 _dcode$ = -32                                           ; size = 4\r
  24 _lcode$ = -28                                           ; size = 4\r
  25 tv565 = -24                                             ; size = 4\r
  26 tv563 = -24                                             ; size = 4\r
  27 _op$ = -24                                              ; size = 4\r
  28 _here$ = -24                                            ; size = 4\r
  29 _wnext$ = -20                                           ; size = 4\r
  30 _state$ = -16                                           ; size = 4\r
  31 _last$ = -12                                            ; size = 4\r
  32 _dist$ = -8                                             ; size = 4\r
  33 _in$ = -4                                               ; size = 4\r
  34 _strm$ = 8                                              ; size = 4\r
  35 tv870 = 12                                              ; size = 4\r
  36 tv567 = 12                                              ; size = 4\r
  37 _len$ = 12                                              ; size = 4\r
  38 _start$ = 12                                            ; size = 4\r
  39 _inflate_fast PROC                                      ; COMDAT\r
  40 \r
  41 ; 70   : {\r
  42 \r
  43   00000 55               push    ebp\r
  44   00001 8b ec            mov     ebp, esp\r
  45   00003 83 ec 3c         sub     esp, 60                        ; 0000003cH\r
  46 \r
  47 ; 99   :     in = strm->next_in - OFF;\r
  48 \r
  49   00006 53               push    ebx\r
  50 \r
  51 ; 100  :     last = in + (strm->avail_in - 5);\r
  52 ; 101  :     out = strm->next_out - OFF;\r
  53 ; 102  :     beg = out - (start - strm->avail_out);\r
  54 ; 103  :     end = out + (strm->avail_out - 257);\r
  55 ; 104  : #ifdef INFLATE_STRICT\r
  56 ; 105  :     dmax = state->dmax;\r
  57 ; 106  : #endif\r
  58 ; 107  :     wsize = state->wsize;\r
  59 ; 108  :     whave = state->whave;\r
  60 ; 109  :     wnext = state->wnext;\r
  61 ; 110  :     window = state->window;\r
  62 ; 111  :     hold = state->hold;\r
  63 \r
  64   00007 56               push    esi\r
  65 \r
  66 ; 116  :     dmask = (1U << state->distbits) - 1;\r
  67 \r
  68   00008 57               push    edi\r
  69 \r
  70 ; 71   :     struct inflate_state FAR *state;\r
  71 ; 72   :     unsigned char FAR *in;      /* local strm->next_in */\r
  72 ; 73   :     unsigned char FAR *last;    /* while in < last, enough input available */\r
  73 ; 74   :     unsigned char FAR *out;     /* local strm->next_out */\r
  74 ; 75   :     unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */\r
  75 ; 76   :     unsigned char FAR *end;     /* while out < end, enough space available */\r
  76 ; 77   : #ifdef INFLATE_STRICT\r
  77 ; 78   :     unsigned dmax;              /* maximum distance from zlib header */\r
  78 ; 79   : #endif\r
  79 ; 80   :     unsigned wsize;             /* window size or zero if not using window */\r
  80 ; 81   :     unsigned whave;             /* valid bytes in the window */\r
  81 ; 82   :     unsigned wnext;             /* window write index */\r
  82 ; 83   :     unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */\r
  83 ; 84   :     unsigned long hold;         /* local strm->hold */\r
  84 ; 85   :     unsigned bits;              /* local strm->bits */\r
  85 ; 86   :     code const FAR *lcode;      /* local strm->lencode */\r
  86 ; 87   :     code const FAR *dcode;      /* local strm->distcode */\r
  87 ; 88   :     unsigned lmask;             /* mask for first level of length codes */\r
  88 ; 89   :     unsigned dmask;             /* mask for first level of distance codes */\r
  89 ; 90   :     code here;                  /* retrieved table entry */\r
  90 ; 91   :     unsigned op;                /* code bits, operation, extra bits, or */\r
  91 ; 92   :                                 /*  window position, window bytes to copy */\r
  92 ; 93   :     unsigned len;               /* match length, unused bytes */\r
  93 ; 94   :     unsigned dist;              /* match distance */\r
  94 ; 95   :     unsigned char FAR *from;    /* where to copy match from */\r
  95 ; 96   : \r
  96 ; 97   :     /* copy state to local variables */\r
  97 ; 98   :     state = (struct inflate_state FAR *)strm->state;\r
  98 \r
  99   00009 8b 4d 08         mov     ecx, DWORD PTR _strm$[ebp]\r
 100   0000c 8b 41 1c         mov     eax, DWORD PTR [ecx+28]\r
 101 \r
 102 ; 99   :     in = strm->next_in - OFF;\r
 103 \r
 104   0000f 8b 11            mov     edx, DWORD PTR [ecx]\r
 105   00011 4a               dec     edx\r
 106   00012 89 55 fc         mov     DWORD PTR _in$[ebp], edx\r
 107 \r
 108 ; 100  :     last = in + (strm->avail_in - 5);\r
 109 ; 101  :     out = strm->next_out - OFF;\r
 110 ; 102  :     beg = out - (start - strm->avail_out);\r
 111 ; 103  :     end = out + (strm->avail_out - 257);\r
 112 ; 104  : #ifdef INFLATE_STRICT\r
 113 ; 105  :     dmax = state->dmax;\r
 114 ; 106  : #endif\r
 115 ; 107  :     wsize = state->wsize;\r
 116 ; 108  :     whave = state->whave;\r
 117 ; 109  :     wnext = state->wnext;\r
 118 ; 110  :     window = state->window;\r
 119 ; 111  :     hold = state->hold;\r
 120 \r
 121   00015 8b 58 38         mov     ebx, DWORD PTR [eax+56]\r
 122   00018 8b 71 04         mov     esi, DWORD PTR [ecx+4]\r
 123   0001b 8d 54 16 fb      lea     edx, DWORD PTR [esi+edx-5]\r
 124   0001f 8b 71 0c         mov     esi, DWORD PTR [ecx+12]\r
 125   00022 8b 49 10         mov     ecx, DWORD PTR [ecx+16]\r
 126   00025 89 55 f4         mov     DWORD PTR _last$[ebp], edx\r
 127   00028 8b d1            mov     edx, ecx\r
 128   0002a 2b 55 0c         sub     edx, DWORD PTR _start$[ebp]\r
 129   0002d 4e               dec     esi\r
 130   0002e 03 d6            add     edx, esi\r
 131   00030 8d 8c 31 ff fe\r
 132         ff ff            lea     ecx, DWORD PTR [ecx+esi-257]\r
 133   00037 89 55 cc         mov     DWORD PTR _beg$[ebp], edx\r
 134   0003a 8b 50 28         mov     edx, DWORD PTR [eax+40]\r
 135   0003d 89 4d d4         mov     DWORD PTR _end$[ebp], ecx\r
 136   00040 8b 48 2c         mov     ecx, DWORD PTR [eax+44]\r
 137   00043 89 55 dc         mov     DWORD PTR _wsize$[ebp], edx\r
 138   00046 8b 50 30         mov     edx, DWORD PTR [eax+48]\r
 139   00049 89 4d c8         mov     DWORD PTR _whave$[ebp], ecx\r
 140   0004c 8b 48 34         mov     ecx, DWORD PTR [eax+52]\r
 141   0004f 89 55 ec         mov     DWORD PTR _wnext$[ebp], edx\r
 142 \r
 143 ; 112  :     bits = state->bits;\r
 144 ; 113  :     lcode = state->lencode;\r
 145 \r
 146   00052 8b 50 4c         mov     edx, DWORD PTR [eax+76]\r
 147   00055 89 4d d8         mov     DWORD PTR _window$[ebp], ecx\r
 148 \r
 149 ; 114  :     dcode = state->distcode;\r
 150 \r
 151   00058 8b 48 50         mov     ecx, DWORD PTR [eax+80]\r
 152   0005b 89 55 e4         mov     DWORD PTR _lcode$[ebp], edx\r
 153   0005e 89 4d e0         mov     DWORD PTR _dcode$[ebp], ecx\r
 154 \r
 155 ; 115  :     lmask = (1U << state->lenbits) - 1;\r
 156 \r
 157   00061 8b 48 54         mov     ecx, DWORD PTR [eax+84]\r
 158   00064 ba 01 00 00 00   mov     edx, 1\r
 159   00069 d3 e2            shl     edx, cl\r
 160 \r
 161 ; 116  :     dmask = (1U << state->distbits) - 1;\r
 162 \r
 163   0006b 8b 48 58         mov     ecx, DWORD PTR [eax+88]\r
 164   0006e 89 45 f0         mov     DWORD PTR _state$[ebp], eax\r
 165   00071 8b 78 3c         mov     edi, DWORD PTR [eax+60]\r
 166   00074 c7 45 0c 01 00\r
 167         00 00            mov     DWORD PTR tv870[ebp], 1\r
 168   0007b 8b 45 0c         mov     eax, DWORD PTR tv870[ebp]\r
 169   0007e d3 e0            shl     eax, cl\r
 170   00080 4a               dec     edx\r
 171   00081 89 55 c4         mov     DWORD PTR _lmask$[ebp], edx\r
 172   00084 48               dec     eax\r
 173   00085 89 45 d0         mov     DWORD PTR _dmask$[ebp], eax\r
 174 $LL55@inflate_fa:\r
 175 \r
 176 ; 117  : \r
 177 ; 118  :     /* decode literals and length/distances until end-of-block or not enough\r
 178 ; 119  :        input data or output space */\r
 179 ; 120  :     do {\r
 180 ; 121  :         if (bits < 15) {\r
 181 \r
 182   00088 83 ff 0f         cmp     edi, 15                        ; 0000000fH\r
 183   0008b 73 24            jae     SHORT $LN52@inflate_fa\r
 184 \r
 185 ; 122  :             hold += (unsigned long)(PUP(in)) << bits;\r
 186 \r
 187   0008d 8b 45 fc         mov     eax, DWORD PTR _in$[ebp]\r
 188   00090 40               inc     eax\r
 189   00091 89 45 fc         mov     DWORD PTR _in$[ebp], eax\r
 190   00094 0f b6 00         movzx   eax, BYTE PTR [eax]\r
 191   00097 8b cf            mov     ecx, edi\r
 192   00099 d3 e0            shl     eax, cl\r
 193 \r
 194 ; 123  :             bits += 8;\r
 195 ; 124  :             hold += (unsigned long)(PUP(in)) << bits;\r
 196 \r
 197   0009b 8d 4f 08         lea     ecx, DWORD PTR [edi+8]\r
 198   0009e 03 d8            add     ebx, eax\r
 199   000a0 8b 45 fc         mov     eax, DWORD PTR _in$[ebp]\r
 200   000a3 40               inc     eax\r
 201   000a4 89 45 fc         mov     DWORD PTR _in$[ebp], eax\r
 202   000a7 0f b6 00         movzx   eax, BYTE PTR [eax]\r
 203   000aa d3 e0            shl     eax, cl\r
 204   000ac 03 d8            add     ebx, eax\r
 205 \r
 206 ; 125  :             bits += 8;\r
 207 \r
 208   000ae 83 c7 10         add     edi, 16                        ; 00000010H\r
 209 $LN52@inflate_fa:\r
 210 \r
 211 ; 126  :         }\r
 212 ; 127  :         here = lcode[hold & lmask];\r
 213 \r
 214   000b1 8b 4d e4         mov     ecx, DWORD PTR _lcode$[ebp]\r
 215   000b4 23 d3            and     edx, ebx\r
 216   000b6 8b 04 91         mov     eax, DWORD PTR [ecx+edx*4]\r
 217 \r
 218 ; 128  :       dolen:\r
 219 ; 129  :         op = (unsigned)(here.bits);\r
 220 \r
 221   000b9 8b d0            mov     edx, eax\r
 222   000bb c1 ea 08         shr     edx, 8\r
 223   000be 0f b6 ca         movzx   ecx, dl\r
 224 \r
 225 ; 130  :         hold >>= op;\r
 226 \r
 227   000c1 d3 eb            shr     ebx, cl\r
 228 \r
 229 ; 131  :         bits -= op;\r
 230 \r
 231   000c3 2b f9            sub     edi, ecx\r
 232 \r
 233 ; 132  :         op = (unsigned)(here.op);\r
 234 \r
 235   000c5 0f b6 d0         movzx   edx, al\r
 236 \r
 237 ; 133  :         if (op == 0) {                          /* literal */\r
 238 \r
 239   000c8 84 c0            test    al, al\r
 240   000ca 74 3c            je      SHORT $LN72@inflate_fa\r
 241   000cc 8d 64 24 00      npad    4\r
 242 $dolen$80287:\r
 243 \r
 244 ; 138  :         }\r
 245 ; 139  :         else if (op & 16) {                     /* length base */\r
 246 \r
 247   000d0 f6 c2 10         test    dl, 16                 ; 00000010H\r
 248   000d3 75 3c            jne     SHORT $LN73@inflate_fa\r
 249 \r
 250 ; 291  :             }\r
 251 ; 292  :         }\r
 252 ; 293  :         else if ((op & 64) == 0) {              /* 2nd level length code */\r
 253 \r
 254   000d5 f6 c2 40         test    dl, 64                 ; 00000040H\r
 255   000d8 0f 85 ab 02 00\r
 256         00               jne     $LN5@inflate_fa\r
 257 \r
 258 ; 294  :             here = lcode[here.val + (hold & ((1U << op) - 1))];\r
 259 \r
 260   000de 8b ca            mov     ecx, edx\r
 261   000e0 ba 01 00 00 00   mov     edx, 1\r
 262   000e5 d3 e2            shl     edx, cl\r
 263   000e7 c1 e8 10         shr     eax, 16                        ; 00000010H\r
 264   000ea 4a               dec     edx\r
 265   000eb 23 d3            and     edx, ebx\r
 266   000ed 03 d0            add     edx, eax\r
 267   000ef 8b 45 e4         mov     eax, DWORD PTR _lcode$[ebp]\r
 268   000f2 8b 04 90         mov     eax, DWORD PTR [eax+edx*4]\r
 269   000f5 8b c8            mov     ecx, eax\r
 270   000f7 c1 e9 08         shr     ecx, 8\r
 271   000fa 0f b6 c9         movzx   ecx, cl\r
 272   000fd d3 eb            shr     ebx, cl\r
 273   000ff 2b f9            sub     edi, ecx\r
 274   00101 0f b6 d0         movzx   edx, al\r
 275   00104 84 c0            test    al, al\r
 276   00106 75 c8            jne     SHORT $dolen$80287\r
 277 $LN72@inflate_fa:\r
 278 \r
 279 ; 134  :             Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\r
 280 ; 135  :                     "inflate:         literal '%c'\n" :\r
 281 ; 136  :                     "inflate:         literal 0x%02x\n", here.val));\r
 282 ; 137  :             PUP(out) = (unsigned char)(here.val);\r
 283 \r
 284   00108 46               inc     esi\r
 285   00109 c1 e8 10         shr     eax, 16                        ; 00000010H\r
 286   0010c e9 49 02 00 00   jmp     $LN84@inflate_fa\r
 287 $LN73@inflate_fa:\r
 288 \r
 289 ; 140  :             len = (unsigned)(here.val);\r
 290 \r
 291   00111 c1 e8 10         shr     eax, 16                        ; 00000010H\r
 292 \r
 293 ; 141  :             op &= 15;                           /* number of extra bits */\r
 294 \r
 295   00114 83 e2 0f         and     edx, 15                        ; 0000000fH\r
 296   00117 89 45 0c         mov     DWORD PTR _len$[ebp], eax\r
 297 \r
 298 ; 142  :             if (op) {\r
 299 \r
 300   0011a 74 2a            je      SHORT $LN48@inflate_fa\r
 301 \r
 302 ; 143  :                 if (bits < op) {\r
 303 \r
 304   0011c 3b fa            cmp     edi, edx\r
 305   0011e 73 13            jae     SHORT $LN47@inflate_fa\r
 306 \r
 307 ; 144  :                     hold += (unsigned long)(PUP(in)) << bits;\r
 308 \r
 309   00120 8b 45 fc         mov     eax, DWORD PTR _in$[ebp]\r
 310   00123 40               inc     eax\r
 311   00124 89 45 fc         mov     DWORD PTR _in$[ebp], eax\r
 312   00127 0f b6 00         movzx   eax, BYTE PTR [eax]\r
 313   0012a 8b cf            mov     ecx, edi\r
 314   0012c d3 e0            shl     eax, cl\r
 315   0012e 03 d8            add     ebx, eax\r
 316 \r
 317 ; 145  :                     bits += 8;\r
 318 \r
 319   00130 83 c7 08         add     edi, 8\r
 320 $LN47@inflate_fa:\r
 321 \r
 322 ; 146  :                 }\r
 323 ; 147  :                 len += (unsigned)hold & ((1U << op) - 1);\r
 324 \r
 325   00133 8b ca            mov     ecx, edx\r
 326   00135 b8 01 00 00 00   mov     eax, 1\r
 327   0013a d3 e0            shl     eax, cl\r
 328   0013c 48               dec     eax\r
 329   0013d 23 c3            and     eax, ebx\r
 330   0013f 01 45 0c         add     DWORD PTR _len$[ebp], eax\r
 331 \r
 332 ; 148  :                 hold >>= op;\r
 333 \r
 334   00142 d3 eb            shr     ebx, cl\r
 335 \r
 336 ; 149  :                 bits -= op;\r
 337 \r
 338   00144 2b fa            sub     edi, edx\r
 339 $LN48@inflate_fa:\r
 340 \r
 341 ; 150  :             }\r
 342 ; 151  :             Tracevv((stderr, "inflate:         length %u\n", len));\r
 343 ; 152  :             if (bits < 15) {\r
 344 \r
 345   00146 83 ff 0f         cmp     edi, 15                        ; 0000000fH\r
 346   00149 73 20            jae     SHORT $LN46@inflate_fa\r
 347 \r
 348 ; 153  :                 hold += (unsigned long)(PUP(in)) << bits;\r
 349 \r
 350   0014b 8b 45 fc         mov     eax, DWORD PTR _in$[ebp]\r
 351   0014e 0f b6 50 01      movzx   edx, BYTE PTR [eax+1]\r
 352 \r
 353 ; 154  :                 bits += 8;\r
 354 ; 155  :                 hold += (unsigned long)(PUP(in)) << bits;\r
 355 \r
 356   00152 83 c0 02         add     eax, 2\r
 357   00155 8b cf            mov     ecx, edi\r
 358   00157 89 45 fc         mov     DWORD PTR _in$[ebp], eax\r
 359   0015a 0f b6 00         movzx   eax, BYTE PTR [eax]\r
 360   0015d d3 e2            shl     edx, cl\r
 361   0015f 8d 4f 08         lea     ecx, DWORD PTR [edi+8]\r
 362   00162 d3 e0            shl     eax, cl\r
 363   00164 03 da            add     ebx, edx\r
 364   00166 03 d8            add     ebx, eax\r
 365 \r
 366 ; 156  :                 bits += 8;\r
 367 \r
 368   00168 83 c7 10         add     edi, 16                        ; 00000010H\r
 369 $LN46@inflate_fa:\r
 370 \r
 371 ; 157  :             }\r
 372 ; 158  :             here = dcode[hold & dmask];\r
 373 \r
 374   0016b 8b 4d d0         mov     ecx, DWORD PTR _dmask$[ebp]\r
 375   0016e 8b 55 e0         mov     edx, DWORD PTR _dcode$[ebp]\r
 376   00171 23 cb            and     ecx, ebx\r
 377   00173 8b 14 8a         mov     edx, DWORD PTR [edx+ecx*4]\r
 378 \r
 379 ; 159  :           dodist:\r
 380 ; 160  :             op = (unsigned)(here.bits);\r
 381 \r
 382   00176 8b c2            mov     eax, edx\r
 383   00178 c1 e8 08         shr     eax, 8\r
 384   0017b 0f b6 c8         movzx   ecx, al\r
 385 \r
 386 ; 161  :             hold >>= op;\r
 387 ; 162  :             bits -= op;\r
 388 ; 163  :             op = (unsigned)(here.op);\r
 389 \r
 390   0017e 0f b6 c2         movzx   eax, dl\r
 391   00181 d3 eb            shr     ebx, cl\r
 392   00183 2b f9            sub     edi, ecx\r
 393   00185 89 55 e8         mov     DWORD PTR _here$[ebp], edx\r
 394 \r
 395 ; 164  :             if (op & 16) {                      /* distance base */\r
 396 \r
 397   00188 a8 10            test    al, 16                 ; 00000010H\r
 398   0018a 75 3a            jne     SHORT $LN74@inflate_fa\r
 399   0018c 8d 64 24 00      npad    4\r
 400 $dodist$80302:\r
 401 \r
 402 ; 280  :                     }\r
 403 ; 281  :                 }\r
 404 ; 282  :             }\r
 405 ; 283  :             else if ((op & 64) == 0) {          /* 2nd level distance code */\r
 406 \r
 407   00190 a8 40            test    al, 64                 ; 00000040H\r
 408   00192 0f 85 e5 01 00\r
 409         00               jne     $LN8@inflate_fa\r
 410 \r
 411 ; 284  :                 here = dcode[here.val + (hold & ((1U << op) - 1))];\r
 412 \r
 413   00198 8b c8            mov     ecx, eax\r
 414   0019a 0f b7 45 ea      movzx   eax, WORD PTR _here$[ebp+2]\r
 415   0019e ba 01 00 00 00   mov     edx, 1\r
 416   001a3 d3 e2            shl     edx, cl\r
 417   001a5 8b 4d e0         mov     ecx, DWORD PTR _dcode$[ebp]\r
 418   001a8 4a               dec     edx\r
 419   001a9 23 d3            and     edx, ebx\r
 420   001ab 03 d0            add     edx, eax\r
 421   001ad 8b 14 91         mov     edx, DWORD PTR [ecx+edx*4]\r
 422   001b0 8b c2            mov     eax, edx\r
 423   001b2 c1 e8 08         shr     eax, 8\r
 424   001b5 0f b6 c8         movzx   ecx, al\r
 425   001b8 0f b6 c2         movzx   eax, dl\r
 426   001bb d3 eb            shr     ebx, cl\r
 427   001bd 2b f9            sub     edi, ecx\r
 428   001bf 89 55 e8         mov     DWORD PTR _here$[ebp], edx\r
 429   001c2 a8 10            test    al, 16                 ; 00000010H\r
 430   001c4 74 ca            je      SHORT $dodist$80302\r
 431 $LN74@inflate_fa:\r
 432 \r
 433 ; 165  :                 dist = (unsigned)(here.val);\r
 434 \r
 435   001c6 c1 ea 10         shr     edx, 16                        ; 00000010H\r
 436 \r
 437 ; 166  :                 op &= 15;                       /* number of extra bits */\r
 438 \r
 439   001c9 83 e0 0f         and     eax, 15                        ; 0000000fH\r
 440   001cc 89 55 f8         mov     DWORD PTR _dist$[ebp], edx\r
 441 \r
 442 ; 167  :                 if (bits < op) {\r
 443 \r
 444   001cf 3b f8            cmp     edi, eax\r
 445   001d1 73 2c            jae     SHORT $LN43@inflate_fa\r
 446 \r
 447 ; 168  :                     hold += (unsigned long)(PUP(in)) << bits;\r
 448 \r
 449   001d3 8b 4d fc         mov     ecx, DWORD PTR _in$[ebp]\r
 450   001d6 0f b6 51 01      movzx   edx, BYTE PTR [ecx+1]\r
 451   001da 41               inc     ecx\r
 452   001db 89 4d fc         mov     DWORD PTR _in$[ebp], ecx\r
 453   001de 8b cf            mov     ecx, edi\r
 454   001e0 d3 e2            shl     edx, cl\r
 455 \r
 456 ; 169  :                     bits += 8;\r
 457 \r
 458   001e2 83 c7 08         add     edi, 8\r
 459   001e5 03 da            add     ebx, edx\r
 460 \r
 461 ; 170  :                     if (bits < op) {\r
 462 \r
 463   001e7 3b f8            cmp     edi, eax\r
 464   001e9 73 14            jae     SHORT $LN43@inflate_fa\r
 465 \r
 466 ; 171  :                         hold += (unsigned long)(PUP(in)) << bits;\r
 467 \r
 468   001eb 8b 4d fc         mov     ecx, DWORD PTR _in$[ebp]\r
 469   001ee 0f b6 51 01      movzx   edx, BYTE PTR [ecx+1]\r
 470   001f2 41               inc     ecx\r
 471   001f3 89 4d fc         mov     DWORD PTR _in$[ebp], ecx\r
 472   001f6 8b cf            mov     ecx, edi\r
 473   001f8 d3 e2            shl     edx, cl\r
 474   001fa 03 da            add     ebx, edx\r
 475 \r
 476 ; 172  :                         bits += 8;\r
 477 \r
 478   001fc 83 c7 08         add     edi, 8\r
 479 $LN43@inflate_fa:\r
 480 \r
 481 ; 173  :                     }\r
 482 ; 174  :                 }\r
 483 ; 175  :                 dist += (unsigned)hold & ((1U << op) - 1);\r
 484 \r
 485   001ff ba 01 00 00 00   mov     edx, 1\r
 486   00204 8b c8            mov     ecx, eax\r
 487   00206 d3 e2            shl     edx, cl\r
 488 \r
 489 ; 176  : #ifdef INFLATE_STRICT\r
 490 ; 177  :                 if (dist > dmax) {\r
 491 ; 178  :                     strm->msg = (char *)"invalid distance too far back";\r
 492 ; 179  :                     state->mode = BAD;\r
 493 ; 180  :                     break;\r
 494 ; 181  :                 }\r
 495 ; 182  : #endif\r
 496 ; 183  :                 hold >>= op;\r
 497 ; 184  :                 bits -= op;\r
 498 \r
 499   00208 2b f8            sub     edi, eax\r
 500   0020a 4a               dec     edx\r
 501   0020b 23 d3            and     edx, ebx\r
 502   0020d d3 eb            shr     ebx, cl\r
 503   0020f 89 55 e8         mov     DWORD PTR tv563[ebp], edx\r
 504   00212 8b 55 f8         mov     edx, DWORD PTR _dist$[ebp]\r
 505   00215 03 55 e8         add     edx, DWORD PTR tv563[ebp]\r
 506 \r
 507 ; 185  :                 Tracevv((stderr, "inflate:         distance %u\n", dist));\r
 508 ; 186  :                 op = (unsigned)(out - beg);     /* max distance in output */\r
 509 \r
 510   00218 8b ce            mov     ecx, esi\r
 511   0021a 2b 4d cc         sub     ecx, DWORD PTR _beg$[ebp]\r
 512   0021d 89 55 f8         mov     DWORD PTR _dist$[ebp], edx\r
 513 \r
 514 ; 187  :                 if (dist > op) {                /* see if copy from window */\r
 515 \r
 516   00220 3b d1            cmp     edx, ecx\r
 517   00222 0f 86 f4 00 00\r
 518         00               jbe     $LN42@inflate_fa\r
 519 \r
 520 ; 188  :                     op = dist - op;             /* distance back in window */\r
 521 \r
 522   00228 8b c2            mov     eax, edx\r
 523   0022a 2b c1            sub     eax, ecx\r
 524   0022c 89 45 e8         mov     DWORD PTR _op$[ebp], eax\r
 525 \r
 526 ; 189  :                     if (op > whave) {\r
 527 \r
 528   0022f 3b 45 c8         cmp     eax, DWORD PTR _whave$[ebp]\r
 529   00232 76 10            jbe     SHORT $LN79@inflate_fa\r
 530 \r
 531 ; 190  :                         if (state->sane) {\r
 532 \r
 533   00234 8b 4d f0         mov     ecx, DWORD PTR _state$[ebp]\r
 534   00237 83 b9 c0 1b 00\r
 535         00 00            cmp     DWORD PTR [ecx+7104], 0\r
 536   0023e 0f 85 2d 01 00\r
 537         00               jne     $LN75@inflate_fa\r
 538 $LN79@inflate_fa:\r
 539 \r
 540 ; 195  :                         }\r
 541 ; 196  : #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\r
 542 ; 197  :                         if (len <= op - whave) {\r
 543 ; 198  :                             do {\r
 544 ; 199  :                                 PUP(out) = 0;\r
 545 ; 200  :                             } while (--len);\r
 546 ; 201  :                             continue;\r
 547 ; 202  :                         }\r
 548 ; 203  :                         len -= op - whave;\r
 549 ; 204  :                         do {\r
 550 ; 205  :                             PUP(out) = 0;\r
 551 ; 206  :                         } while (--op > whave);\r
 552 ; 207  :                         if (op == 0) {\r
 553 ; 208  :                             from = out - dist;\r
 554 ; 209  :                             do {\r
 555 ; 210  :                                 PUP(out) = PUP(from);\r
 556 ; 211  :                             } while (--len);\r
 557 ; 212  :                             continue;\r
 558 ; 213  :                         }\r
 559 ; 214  : #endif\r
 560 ; 215  :                     }\r
 561 ; 216  :                     from = window - OFF;\r
 562 \r
 563   00244 8b 4d d8         mov     ecx, DWORD PTR _window$[ebp]\r
 564 \r
 565 ; 217  :                     if (wnext == 0) {           /* very common case */\r
 566 \r
 567   00247 8b 55 ec         mov     edx, DWORD PTR _wnext$[ebp]\r
 568   0024a 49               dec     ecx\r
 569   0024b 85 d2            test    edx, edx\r
 570   0024d 75 1d            jne     SHORT $LN39@inflate_fa\r
 571 \r
 572 ; 218  :                         from += wsize - op;\r
 573 \r
 574   0024f 8b 55 dc         mov     edx, DWORD PTR _wsize$[ebp]\r
 575   00252 2b d0            sub     edx, eax\r
 576   00254 03 ca            add     ecx, edx\r
 577 \r
 578 ; 219  :                         if (op < len) {         /* some from window */\r
 579 \r
 580   00256 3b 45 0c         cmp     eax, DWORD PTR _len$[ebp]\r
 581   00259 73 74            jae     SHORT $LN80@inflate_fa\r
 582 \r
 583 ; 220  :                             len -= op;\r
 584 \r
 585   0025b 29 45 0c         sub     DWORD PTR _len$[ebp], eax\r
 586   0025e 8b ff            npad    2\r
 587 $LL37@inflate_fa:\r
 588 \r
 589 ; 221  :                             do {\r
 590 ; 222  :                                 PUP(out) = PUP(from);\r
 591 \r
 592   00260 8a 51 01         mov     dl, BYTE PTR [ecx+1]\r
 593   00263 41               inc     ecx\r
 594   00264 46               inc     esi\r
 595 \r
 596 ; 223  :                             } while (--op);\r
 597 \r
 598   00265 48               dec     eax\r
 599   00266 88 16            mov     BYTE PTR [esi], dl\r
 600   00268 75 f6            jne     SHORT $LL37@inflate_fa\r
 601 \r
 602 ; 224  :                             from = out - dist;  /* rest from output */\r
 603 ; 225  :                         }\r
 604 \r
 605   0026a eb 5e            jmp     SHORT $LN85@inflate_fa\r
 606 $LN39@inflate_fa:\r
 607 \r
 608 ; 226  :                     }\r
 609 ; 227  :                     else if (wnext < op) {      /* wrap around window */\r
 610 \r
 611   0026c 3b d0            cmp     edx, eax\r
 612   0026e 73 3f            jae     SHORT $LN33@inflate_fa\r
 613 \r
 614 ; 228  :                         from += wsize + wnext - op;\r
 615 \r
 616   00270 2b d0            sub     edx, eax\r
 617   00272 03 55 dc         add     edx, DWORD PTR _wsize$[ebp]\r
 618 \r
 619 ; 229  :                         op -= wnext;\r
 620 \r
 621   00275 8b 45 e8         mov     eax, DWORD PTR _op$[ebp]\r
 622   00278 2b 45 ec         sub     eax, DWORD PTR _wnext$[ebp]\r
 623   0027b 03 ca            add     ecx, edx\r
 624 \r
 625 ; 230  :                         if (op < len) {         /* some from end of window */\r
 626 \r
 627   0027d 3b 45 0c         cmp     eax, DWORD PTR _len$[ebp]\r
 628   00280 73 4d            jae     SHORT $LN80@inflate_fa\r
 629 \r
 630 ; 231  :                             len -= op;\r
 631 \r
 632   00282 29 45 0c         sub     DWORD PTR _len$[ebp], eax\r
 633 \r
 634 ; 234  :                             } while (--op);\r
 635 \r
 636   00285 2b ce            sub     ecx, esi\r
 637 $LL31@inflate_fa:\r
 638 \r
 639 ; 232  :                             do {\r
 640 ; 233  :                                 PUP(out) = PUP(from);\r
 641 \r
 642   00287 8a 54 31 01      mov     dl, BYTE PTR [ecx+esi+1]\r
 643   0028b 46               inc     esi\r
 644 \r
 645 ; 234  :                             } while (--op);\r
 646 \r
 647   0028c 48               dec     eax\r
 648   0028d 88 16            mov     BYTE PTR [esi], dl\r
 649   0028f 75 f6            jne     SHORT $LL31@inflate_fa\r
 650 \r
 651 ; 235  :                             from = window - OFF;\r
 652 \r
 653   00291 8b 4d d8         mov     ecx, DWORD PTR _window$[ebp]\r
 654 \r
 655 ; 236  :                             if (wnext < len) {  /* some from start of window */\r
 656 \r
 657   00294 8b 45 ec         mov     eax, DWORD PTR _wnext$[ebp]\r
 658   00297 49               dec     ecx\r
 659   00298 3b 45 0c         cmp     eax, DWORD PTR _len$[ebp]\r
 660   0029b 73 32            jae     SHORT $LN80@inflate_fa\r
 661 \r
 662 ; 237  :                                 op = wnext;\r
 663 ; 238  :                                 len -= op;\r
 664 \r
 665   0029d 29 45 0c         sub     DWORD PTR _len$[ebp], eax\r
 666   002a0 89 45 e8         mov     DWORD PTR _op$[ebp], eax\r
 667 $LL27@inflate_fa:\r
 668 \r
 669 ; 239  :                                 do {\r
 670 ; 240  :                                     PUP(out) = PUP(from);\r
 671 \r
 672   002a3 8a 51 01         mov     dl, BYTE PTR [ecx+1]\r
 673   002a6 41               inc     ecx\r
 674   002a7 46               inc     esi\r
 675 \r
 676 ; 241  :                                 } while (--op);\r
 677 \r
 678   002a8 48               dec     eax\r
 679   002a9 88 16            mov     BYTE PTR [esi], dl\r
 680   002ab 75 f6            jne     SHORT $LL27@inflate_fa\r
 681 \r
 682 ; 242  :                                 from = out - dist;      /* rest from output */\r
 683 ; 243  :                             }\r
 684 ; 244  :                         }\r
 685 ; 245  :                     }\r
 686 ; 246  :                     else {                      /* contiguous in window */\r
 687 \r
 688   002ad eb 1b            jmp     SHORT $LN85@inflate_fa\r
 689 $LN33@inflate_fa:\r
 690 \r
 691 ; 247  :                         from += wnext - op;\r
 692 \r
 693   002af 2b d0            sub     edx, eax\r
 694   002b1 03 ca            add     ecx, edx\r
 695 \r
 696 ; 248  :                         if (op < len) {         /* some from window */\r
 697 \r
 698   002b3 3b 45 0c         cmp     eax, DWORD PTR _len$[ebp]\r
 699   002b6 73 17            jae     SHORT $LN80@inflate_fa\r
 700 \r
 701 ; 249  :                             len -= op;\r
 702 \r
 703   002b8 29 45 0c         sub     DWORD PTR _len$[ebp], eax\r
 704   002bb eb 03 8d 49 00   npad    5\r
 705 $LL22@inflate_fa:\r
 706 \r
 707 ; 250  :                             do {\r
 708 ; 251  :                                 PUP(out) = PUP(from);\r
 709 \r
 710   002c0 8a 51 01         mov     dl, BYTE PTR [ecx+1]\r
 711   002c3 41               inc     ecx\r
 712   002c4 46               inc     esi\r
 713 \r
 714 ; 252  :                             } while (--op);\r
 715 \r
 716   002c5 48               dec     eax\r
 717   002c6 88 16            mov     BYTE PTR [esi], dl\r
 718   002c8 75 f6            jne     SHORT $LL22@inflate_fa\r
 719 $LN85@inflate_fa:\r
 720 \r
 721 ; 253  :                             from = out - dist;  /* rest from output */\r
 722 \r
 723   002ca 8b ce            mov     ecx, esi\r
 724   002cc 2b 4d f8         sub     ecx, DWORD PTR _dist$[ebp]\r
 725 $LN80@inflate_fa:\r
 726 \r
 727 ; 254  :                         }\r
 728 ; 255  :                     }\r
 729 ; 256  :                     while (len > 2) {\r
 730 \r
 731   002cf 8b 45 0c         mov     eax, DWORD PTR _len$[ebp]\r
 732   002d2 83 f8 02         cmp     eax, 2\r
 733   002d5 76 2e            jbe     SHORT $LN18@inflate_fa\r
 734   002d7 8d 50 fd         lea     edx, DWORD PTR [eax-3]\r
 735   002da b8 ab aa aa aa   mov     eax, -1431655765       ; aaaaaaabH\r
 736   002df f7 e2            mul     edx\r
 737   002e1 d1 ea            shr     edx, 1\r
 738   002e3 42               inc     edx\r
 739 $LL19@inflate_fa:\r
 740 \r
 741 ; 257  :                         PUP(out) = PUP(from);\r
 742 \r
 743   002e4 0f b6 41 01      movzx   eax, BYTE PTR [ecx+1]\r
 744 \r
 745 ; 258  :                         PUP(out) = PUP(from);\r
 746 ; 259  :                         PUP(out) = PUP(from);\r
 747 ; 260  :                         len -= 3;\r
 748 \r
 749   002e8 83 6d 0c 03      sub     DWORD PTR _len$[ebp], 3\r
 750   002ec 88 46 01         mov     BYTE PTR [esi+1], al\r
 751   002ef 0f b6 41 02      movzx   eax, BYTE PTR [ecx+2]\r
 752   002f3 88 46 02         mov     BYTE PTR [esi+2], al\r
 753   002f6 0f b6 41 03      movzx   eax, BYTE PTR [ecx+3]\r
 754   002fa 83 c1 03         add     ecx, 3\r
 755   002fd 83 c6 03         add     esi, 3\r
 756   00300 4a               dec     edx\r
 757   00301 88 06            mov     BYTE PTR [esi], al\r
 758   00303 75 df            jne     SHORT $LL19@inflate_fa\r
 759 $LN18@inflate_fa:\r
 760 \r
 761 ; 261  :                     }\r
 762 ; 262  :                     if (len) {\r
 763 \r
 764   00305 8b 45 0c         mov     eax, DWORD PTR _len$[ebp]\r
 765   00308 85 c0            test    eax, eax\r
 766   0030a 74 50            je      SHORT $LN54@inflate_fa\r
 767 \r
 768 ; 263  :                         PUP(out) = PUP(from);\r
 769 \r
 770   0030c 8a 51 01         mov     dl, BYTE PTR [ecx+1]\r
 771   0030f 46               inc     esi\r
 772   00310 88 16            mov     BYTE PTR [esi], dl\r
 773 \r
 774 ; 264  :                         if (len > 1)\r
 775 \r
 776   00312 83 f8 01         cmp     eax, 1\r
 777   00315 76 45            jbe     SHORT $LN54@inflate_fa\r
 778 \r
 779 ; 265  :                             PUP(out) = PUP(from);\r
 780 \r
 781   00317 8a 41 02         mov     al, BYTE PTR [ecx+2]\r
 782 \r
 783 ; 266  :                     }\r
 784 ; 267  :                 }\r
 785 ; 268  :                 else {\r
 786 \r
 787   0031a eb 3d            jmp     SHORT $LN86@inflate_fa\r
 788 $LN42@inflate_fa:\r
 789 \r
 790 ; 269  :                     from = out - dist;          /* copy direct from output */\r
 791 \r
 792   0031c 8b c6            mov     eax, esi\r
 793   0031e 2b c2            sub     eax, edx\r
 794 $LL14@inflate_fa:\r
 795 \r
 796 ; 270  :                     do {                        /* minimum length is three */\r
 797 ; 271  :                         PUP(out) = PUP(from);\r
 798 \r
 799   00320 0f b6 48 01      movzx   ecx, BYTE PTR [eax+1]\r
 800   00324 88 4e 01         mov     BYTE PTR [esi+1], cl\r
 801 \r
 802 ; 272  :                         PUP(out) = PUP(from);\r
 803 \r
 804   00327 8a 50 02         mov     dl, BYTE PTR [eax+2]\r
 805   0032a 88 56 02         mov     BYTE PTR [esi+2], dl\r
 806 \r
 807 ; 273  :                         PUP(out) = PUP(from);\r
 808 \r
 809   0032d 0f b6 48 03      movzx   ecx, BYTE PTR [eax+3]\r
 810   00331 83 c0 03         add     eax, 3\r
 811   00334 83 c6 03         add     esi, 3\r
 812   00337 88 0e            mov     BYTE PTR [esi], cl\r
 813 \r
 814 ; 274  :                         len -= 3;\r
 815 \r
 816   00339 8b 4d 0c         mov     ecx, DWORD PTR _len$[ebp]\r
 817   0033c 83 e9 03         sub     ecx, 3\r
 818   0033f 89 4d 0c         mov     DWORD PTR _len$[ebp], ecx\r
 819 \r
 820 ; 275  :                     } while (len > 2);\r
 821 \r
 822   00342 83 f9 02         cmp     ecx, 2\r
 823   00345 77 d9            ja      SHORT $LL14@inflate_fa\r
 824 \r
 825 ; 276  :                     if (len) {\r
 826 \r
 827   00347 85 c9            test    ecx, ecx\r
 828   00349 74 11            je      SHORT $LN54@inflate_fa\r
 829 \r
 830 ; 277  :                         PUP(out) = PUP(from);\r
 831 \r
 832   0034b 8a 50 01         mov     dl, BYTE PTR [eax+1]\r
 833   0034e 46               inc     esi\r
 834   0034f 88 16            mov     BYTE PTR [esi], dl\r
 835 \r
 836 ; 278  :                         if (len > 1)\r
 837 \r
 838   00351 83 f9 01         cmp     ecx, 1\r
 839   00354 76 06            jbe     SHORT $LN54@inflate_fa\r
 840 \r
 841 ; 279  :                             PUP(out) = PUP(from);\r
 842 \r
 843   00356 8a 40 02         mov     al, BYTE PTR [eax+2]\r
 844 $LN86@inflate_fa:\r
 845   00359 46               inc     esi\r
 846 $LN84@inflate_fa:\r
 847   0035a 88 06            mov     BYTE PTR [esi], al\r
 848 $LN54@inflate_fa:\r
 849 \r
 850 ; 305  :             break;\r
 851 ; 306  :         }\r
 852 ; 307  :     } while (in < last && out < end);\r
 853 \r
 854   0035c 8b 55 f4         mov     edx, DWORD PTR _last$[ebp]\r
 855   0035f 39 55 fc         cmp     DWORD PTR _in$[ebp], edx\r
 856   00362 73 4b            jae     SHORT $LN53@inflate_fa\r
 857   00364 3b 75 d4         cmp     esi, DWORD PTR _end$[ebp]\r
 858   00367 73 46            jae     SHORT $LN53@inflate_fa\r
 859 \r
 860 ; 319  :     strm->avail_out = (unsigned)(out < end ?\r
 861 ; 320  :                                  257 + (end - out) : 257 - (out - end));\r
 862 \r
 863   00369 8b 55 c4         mov     edx, DWORD PTR _lmask$[ebp]\r
 864   0036c e9 17 fd ff ff   jmp     $LL55@inflate_fa\r
 865 $LN75@inflate_fa:\r
 866 \r
 867 ; 191  :                             strm->msg =\r
 868 ; 192  :                                 (char *)"invalid distance too far back";\r
 869 \r
 870   00371 8b 55 08         mov     edx, DWORD PTR _strm$[ebp]\r
 871   00374 c7 42 18 00 00\r
 872         00 00            mov     DWORD PTR [edx+24], OFFSET ??_C@_0BO@ECPMAOGG@invalid?5distance?5too?5far?5back?$AA@\r
 873 \r
 874 ; 193  :                             state->mode = BAD;\r
 875 ; 194  :                             break;\r
 876 \r
 877   0037b eb 29            jmp     SHORT $LN87@inflate_fa\r
 878 $LN8@inflate_fa:\r
 879 \r
 880 ; 285  :                 goto dodist;\r
 881 ; 286  :             }\r
 882 ; 287  :             else {\r
 883 ; 288  :                 strm->msg = (char *)"invalid distance code";\r
 884 \r
 885   0037d 8b 45 08         mov     eax, DWORD PTR _strm$[ebp]\r
 886   00380 c7 40 18 00 00\r
 887         00 00            mov     DWORD PTR [eax+24], OFFSET ??_C@_0BG@LBKINIKP@invalid?5distance?5code?$AA@\r
 888 \r
 889 ; 289  :                 state->mode = BAD;\r
 890 ; 290  :                 break;\r
 891 \r
 892   00387 eb 1a            jmp     SHORT $LN88@inflate_fa\r
 893 $LN5@inflate_fa:\r
 894 \r
 895 ; 295  :             goto dolen;\r
 896 ; 296  :         }\r
 897 ; 297  :         else if (op & 32) {                     /* end-of-block */\r
 898 \r
 899   00389 f6 c2 20         test    dl, 32                 ; 00000020H\r
 900   0038c 74 0b            je      SHORT $LN3@inflate_fa\r
 901 \r
 902 ; 298  :             Tracevv((stderr, "inflate:         end of block\n"));\r
 903 ; 299  :             state->mode = TYPE;\r
 904 \r
 905   0038e 8b 55 f0         mov     edx, DWORD PTR _state$[ebp]\r
 906   00391 c7 02 0b 00 00\r
 907         00               mov     DWORD PTR [edx], 11    ; 0000000bH\r
 908 \r
 909 ; 300  :             break;\r
 910 \r
 911   00397 eb 13            jmp     SHORT $LN89@inflate_fa\r
 912 $LN3@inflate_fa:\r
 913 \r
 914 ; 301  :         }\r
 915 ; 302  :         else {\r
 916 ; 303  :             strm->msg = (char *)"invalid literal/length code";\r
 917 \r
 918   00399 8b 45 08         mov     eax, DWORD PTR _strm$[ebp]\r
 919   0039c c7 40 18 00 00\r
 920         00 00            mov     DWORD PTR [eax+24], OFFSET ??_C@_0BM@FFFLPBBC@invalid?5literal?1length?5code?$AA@\r
 921 $LN88@inflate_fa:\r
 922 \r
 923 ; 304  :             state->mode = BAD;\r
 924 \r
 925   003a3 8b 4d f0         mov     ecx, DWORD PTR _state$[ebp]\r
 926 $LN87@inflate_fa:\r
 927   003a6 c7 01 1d 00 00\r
 928         00               mov     DWORD PTR [ecx], 29    ; 0000001dH\r
 929 $LN89@inflate_fa:\r
 930   003ac 8b 55 f4         mov     edx, DWORD PTR _last$[ebp]\r
 931 $LN53@inflate_fa:\r
 932 \r
 933 ; 308  : \r
 934 ; 309  :     /* return unused bytes (on entry, bits < 8, so in won't go too far back) */\r
 935 ; 310  :     len = bits >> 3;\r
 936 \r
 937   003af 8b c7            mov     eax, edi\r
 938   003b1 c1 e8 03         shr     eax, 3\r
 939 \r
 940 ; 311  :     in -= len;\r
 941 \r
 942   003b4 29 45 fc         sub     DWORD PTR _in$[ebp], eax\r
 943 \r
 944 ; 312  :     bits -= len << 3;\r
 945 \r
 946   003b7 03 c0            add     eax, eax\r
 947   003b9 03 c0            add     eax, eax\r
 948   003bb 03 c0            add     eax, eax\r
 949   003bd 2b f8            sub     edi, eax\r
 950 \r
 951 ; 313  :     hold &= (1U << bits) - 1;\r
 952 \r
 953   003bf 8b cf            mov     ecx, edi\r
 954   003c1 b8 01 00 00 00   mov     eax, 1\r
 955   003c6 d3 e0            shl     eax, cl\r
 956 \r
 957 ; 314  : \r
 958 ; 315  :     /* update state and return */\r
 959 ; 316  :     strm->next_in = in + OFF;\r
 960 \r
 961   003c8 8b 4d 08         mov     ecx, DWORD PTR _strm$[ebp]\r
 962   003cb 48               dec     eax\r
 963   003cc 23 d8            and     ebx, eax\r
 964   003ce 8b 45 fc         mov     eax, DWORD PTR _in$[ebp]\r
 965   003d1 40               inc     eax\r
 966   003d2 89 01            mov     DWORD PTR [ecx], eax\r
 967 \r
 968 ; 317  :     strm->next_out = out + OFF;\r
 969 \r
 970   003d4 8d 46 01         lea     eax, DWORD PTR [esi+1]\r
 971   003d7 89 41 0c         mov     DWORD PTR [ecx+12], eax\r
 972 \r
 973 ; 318  :     strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));\r
 974 \r
 975   003da 8b 45 fc         mov     eax, DWORD PTR _in$[ebp]\r
 976   003dd 2b d0            sub     edx, eax\r
 977 \r
 978 ; 319  :     strm->avail_out = (unsigned)(out < end ?\r
 979 ; 320  :                                  257 + (end - out) : 257 - (out - end));\r
 980 \r
 981   003df 8b 45 d4         mov     eax, DWORD PTR _end$[ebp]\r
 982   003e2 2b c6            sub     eax, esi\r
 983   003e4 83 c2 05         add     edx, 5\r
 984   003e7 05 01 01 00 00   add     eax, 257               ; 00000101H\r
 985   003ec 89 41 10         mov     DWORD PTR [ecx+16], eax\r
 986 \r
 987 ; 321  :     state->hold = hold;\r
 988 \r
 989   003ef 8b 45 f0         mov     eax, DWORD PTR _state$[ebp]\r
 990   003f2 89 51 04         mov     DWORD PTR [ecx+4], edx\r
 991 \r
 992 ; 322  :     state->bits = bits;\r
 993 \r
 994   003f5 89 78 3c         mov     DWORD PTR [eax+60], edi\r
 995   003f8 5f               pop     edi\r
 996   003f9 5e               pop     esi\r
 997   003fa 89 58 38         mov     DWORD PTR [eax+56], ebx\r
 998   003fd 5b               pop     ebx\r
 999 \r
1000 ; 323  :     return;\r
1001 ; 324  : }\r
1002 \r
1003   003fe 8b e5            mov     esp, ebp\r
1004   00400 5d               pop     ebp\r
1005   00401 c3               ret     0\r
1006 _inflate_fast ENDP\r
1007 END\r