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\gzlib.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  ??_C@_07EBNKNFJN@?$DMfd?3?$CFd?$DO?$AA@         ; `string'\r
  12 PUBLIC  ??_C@_00CNPNBAHC@?$AA@                          ; `string'\r
  13 PUBLIC  ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@          ; `string'\r
  14 PUBLIC  ??_C@_02LMMGGCAJ@?3?5?$AA@                      ; `string'\r
  15 EXTRN   __imp__sprintf:PROC\r
  16 EXTRN   _open:PROC\r
  17 EXTRN   __imp___lseeki64:PROC\r
  18 EXTRN   __imp__free:PROC\r
  19 EXTRN   __imp__malloc:PROC\r
  20 ;       COMDAT ??_C@_02LMMGGCAJ@?3?5?$AA@\r
  21 CONST   SEGMENT\r
  22 ??_C@_02LMMGGCAJ@?3?5?$AA@ DB ': ', 00H                 ; `string'\r
  23 CONST   ENDS\r
  24 ;       COMDAT ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
  25 CONST   SEGMENT\r
  26 ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@ DB 'out of memory', 00H ; `string'\r
  27 CONST   ENDS\r
  28 ;       COMDAT ??_C@_00CNPNBAHC@?$AA@\r
  29 CONST   SEGMENT\r
  30 ??_C@_00CNPNBAHC@?$AA@ DB 00H                           ; `string'\r
  31 CONST   ENDS\r
  32 ;       COMDAT ??_C@_07EBNKNFJN@?$DMfd?3?$CFd?$DO?$AA@\r
  33 CONST   SEGMENT\r
  34 ??_C@_07EBNKNFJN@?$DMfd?3?$CFd?$DO?$AA@ DB '<fd:%d>', 00H ; `string'\r
  35 PUBLIC  _gz_error\r
  36 ; Function compile flags: /Ogtp\r
  37 ; File c:\workspaces\sysdyn\org.simantics.fmu\fmusolution\zlib-1.2.6\gzlib.c\r
  38 ;       COMDAT _gz_error\r
  39 _TEXT   SEGMENT\r
  40 _msg$ = 8                                               ; size = 4\r
  41 _gz_error PROC                                          ; COMDAT\r
  42 ; _state$ = ecx\r
  43 ; _err$ = eax\r
  44 \r
  45 ; 512  : {\r
  46 \r
  47   00000 55               push    ebp\r
  48   00001 8b ec            mov     ebp, esp\r
  49   00003 56               push    esi\r
  50   00004 57               push    edi\r
  51   00005 8b f9            mov     edi, ecx\r
  52   00007 8b f0            mov     esi, eax\r
  53 \r
  54 ; 513  :     /* free previously allocated message and clear */\r
  55 ; 514  :     if (state->msg != NULL) {\r
  56 \r
  57   00009 8b 47 60         mov     eax, DWORD PTR [edi+96]\r
  58   0000c 85 c0            test    eax, eax\r
  59   0000e 74 17            je      SHORT $LN16@gz_error\r
  60 \r
  61 ; 515  :         if (state->err != Z_MEM_ERROR)\r
  62 \r
  63   00010 83 7f 5c fc      cmp     DWORD PTR [edi+92], -4 ; fffffffcH\r
  64   00014 74 0a            je      SHORT $LN5@gz_error\r
  65 \r
  66 ; 516  :             free(state->msg);\r
  67 \r
  68   00016 50               push    eax\r
  69   00017 ff 15 00 00 00\r
  70         00               call    DWORD PTR __imp__free\r
  71   0001d 83 c4 04         add     esp, 4\r
  72 $LN5@gz_error:\r
  73 \r
  74 ; 517  :         state->msg = NULL;\r
  75 \r
  76   00020 c7 47 60 00 00\r
  77         00 00            mov     DWORD PTR [edi+96], 0\r
  78 $LN16@gz_error:\r
  79 \r
  80 ; 518  :     }\r
  81 ; 519  : \r
  82 ; 520  :     /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */\r
  83 ; 521  :     if (err != Z_OK && err != Z_BUF_ERROR)\r
  84 \r
  85   00027 85 f6            test    esi, esi\r
  86   00029 74 0b            je      SHORT $LN4@gz_error\r
  87   0002b 83 fe fb         cmp     esi, -5                        ; fffffffbH\r
  88   0002e 74 06            je      SHORT $LN4@gz_error\r
  89 \r
  90 ; 522  :         state->x.have = 0;\r
  91 \r
  92   00030 c7 07 00 00 00\r
  93         00               mov     DWORD PTR [edi], 0\r
  94 $LN4@gz_error:\r
  95 \r
  96 ; 523  : \r
  97 ; 524  :     /* set error code, and if no message, then done */\r
  98 ; 525  :     state->err = err;\r
  99 ; 526  :     if (msg == NULL)\r
 100 \r
 101   00036 8b 45 08         mov     eax, DWORD PTR _msg$[ebp]\r
 102   00039 89 77 5c         mov     DWORD PTR [edi+92], esi\r
 103   0003c 85 c0            test    eax, eax\r
 104   0003e 0f 84 b6 00 00\r
 105         00               je      $LN7@gz_error\r
 106 \r
 107 ; 527  :         return;\r
 108 ; 528  : \r
 109 ; 529  :     /* for an out of memory error, save as static string */\r
 110 ; 530  :     if (err == Z_MEM_ERROR) {\r
 111 \r
 112   00044 83 fe fc         cmp     esi, -4                        ; fffffffcH\r
 113   00047 75 07            jne     SHORT $LN2@gz_error\r
 114 \r
 115 ; 531  :         state->msg = (char *)msg;\r
 116 \r
 117   00049 89 47 60         mov     DWORD PTR [edi+96], eax\r
 118   0004c 5f               pop     edi\r
 119   0004d 5e               pop     esi\r
 120 \r
 121 ; 544  :     return;\r
 122 ; 545  : }\r
 123 \r
 124   0004e 5d               pop     ebp\r
 125   0004f c3               ret     0\r
 126 $LN2@gz_error:\r
 127   00050 53               push    ebx\r
 128 \r
 129 ; 532  :         return;\r
 130 ; 533  :     }\r
 131 ; 534  : \r
 132 ; 535  :     /* construct error message with path */\r
 133 ; 536  :     if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) {\r
 134 \r
 135   00051 8b 5f 18         mov     ebx, DWORD PTR [edi+24]\r
 136   00054 8b c3            mov     eax, ebx\r
 137   00056 8d 50 01         lea     edx, DWORD PTR [eax+1]\r
 138   00059 8d a4 24 00 00\r
 139         00 00            npad    7\r
 140 $LL11@gz_error:\r
 141   00060 8a 08            mov     cl, BYTE PTR [eax]\r
 142   00062 40               inc     eax\r
 143   00063 84 c9            test    cl, cl\r
 144   00065 75 f9            jne     SHORT $LL11@gz_error\r
 145   00067 2b c2            sub     eax, edx\r
 146   00069 8b d0            mov     edx, eax\r
 147   0006b 8b 45 08         mov     eax, DWORD PTR _msg$[ebp]\r
 148   0006e 8d 70 01         lea     esi, DWORD PTR [eax+1]\r
 149 $LL12@gz_error:\r
 150   00071 8a 08            mov     cl, BYTE PTR [eax]\r
 151   00073 40               inc     eax\r
 152   00074 84 c9            test    cl, cl\r
 153   00076 75 f9            jne     SHORT $LL12@gz_error\r
 154   00078 2b c6            sub     eax, esi\r
 155   0007a 8d 44 10 03      lea     eax, DWORD PTR [eax+edx+3]\r
 156   0007e 50               push    eax\r
 157   0007f ff 15 00 00 00\r
 158         00               call    DWORD PTR __imp__malloc\r
 159   00085 83 c4 04         add     esp, 4\r
 160   00088 89 47 60         mov     DWORD PTR [edi+96], eax\r
 161   0008b 85 c0            test    eax, eax\r
 162   0008d 75 13            jne     SHORT $LN1@gz_error\r
 163 \r
 164 ; 537  :         state->err = Z_MEM_ERROR;\r
 165 \r
 166   0008f 5b               pop     ebx\r
 167   00090 c7 47 5c fc ff\r
 168         ff ff            mov     DWORD PTR [edi+92], -4 ; fffffffcH\r
 169 \r
 170 ; 538  :         state->msg = (char *)"out of memory";\r
 171 \r
 172   00097 c7 47 60 00 00\r
 173         00 00            mov     DWORD PTR [edi+96], OFFSET ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
 174   0009e 5f               pop     edi\r
 175   0009f 5e               pop     esi\r
 176 \r
 177 ; 544  :     return;\r
 178 ; 545  : }\r
 179 \r
 180   000a0 5d               pop     ebp\r
 181   000a1 c3               ret     0\r
 182 $LN1@gz_error:\r
 183 \r
 184 ; 539  :         return;\r
 185 ; 540  :     }\r
 186 ; 541  :     strcpy(state->msg, state->path);\r
 187 \r
 188   000a2 8b cb            mov     ecx, ebx\r
 189   000a4 8b d0            mov     edx, eax\r
 190 $LL9@gz_error:\r
 191   000a6 8a 01            mov     al, BYTE PTR [ecx]\r
 192   000a8 88 02            mov     BYTE PTR [edx], al\r
 193   000aa 41               inc     ecx\r
 194   000ab 42               inc     edx\r
 195   000ac 84 c0            test    al, al\r
 196   000ae 75 f6            jne     SHORT $LL9@gz_error\r
 197 \r
 198 ; 542  :     strcat(state->msg, ": ");\r
 199 \r
 200   000b0 8b 47 60         mov     eax, DWORD PTR [edi+96]\r
 201   000b3 48               dec     eax\r
 202 $LL13@gz_error:\r
 203   000b4 8a 48 01         mov     cl, BYTE PTR [eax+1]\r
 204   000b7 40               inc     eax\r
 205   000b8 84 c9            test    cl, cl\r
 206   000ba 75 f8            jne     SHORT $LL13@gz_error\r
 207   000bc 66 8b 0d 00 00\r
 208         00 00            mov     cx, WORD PTR ??_C@_02LMMGGCAJ@?3?5?$AA@\r
 209   000c3 66 89 08         mov     WORD PTR [eax], cx\r
 210   000c6 8a 15 02 00 00\r
 211         00               mov     dl, BYTE PTR ??_C@_02LMMGGCAJ@?3?5?$AA@+2\r
 212   000cc 88 50 02         mov     BYTE PTR [eax+2], dl\r
 213 \r
 214 ; 543  :     strcat(state->msg, msg);\r
 215 \r
 216   000cf 8b 45 08         mov     eax, DWORD PTR _msg$[ebp]\r
 217   000d2 8b c8            mov     ecx, eax\r
 218 $LL14@gz_error:\r
 219   000d4 8a 10            mov     dl, BYTE PTR [eax]\r
 220   000d6 40               inc     eax\r
 221   000d7 84 d2            test    dl, dl\r
 222   000d9 75 f9            jne     SHORT $LL14@gz_error\r
 223   000db 8b 7f 60         mov     edi, DWORD PTR [edi+96]\r
 224   000de 2b c1            sub     eax, ecx\r
 225   000e0 8b f1            mov     esi, ecx\r
 226   000e2 4f               dec     edi\r
 227 $LL15@gz_error:\r
 228   000e3 8a 4f 01         mov     cl, BYTE PTR [edi+1]\r
 229   000e6 47               inc     edi\r
 230   000e7 84 c9            test    cl, cl\r
 231   000e9 75 f8            jne     SHORT $LL15@gz_error\r
 232   000eb 8b c8            mov     ecx, eax\r
 233   000ed c1 e9 02         shr     ecx, 2\r
 234   000f0 f3 a5            rep movsd\r
 235   000f2 8b c8            mov     ecx, eax\r
 236   000f4 83 e1 03         and     ecx, 3\r
 237   000f7 f3 a4            rep movsb\r
 238   000f9 5b               pop     ebx\r
 239 $LN7@gz_error:\r
 240   000fa 5f               pop     edi\r
 241   000fb 5e               pop     esi\r
 242 \r
 243 ; 544  :     return;\r
 244 ; 545  : }\r
 245 \r
 246   000fc 5d               pop     ebp\r
 247   000fd c3               ret     0\r
 248 _gz_error ENDP\r
 249 _TEXT   ENDS\r
 250 PUBLIC  _gzclearerr@4\r
 251 ; Function compile flags: /Ogtp\r
 252 ;       COMDAT _gzclearerr@4\r
 253 _TEXT   SEGMENT\r
 254 _file$ = 8                                              ; size = 4\r
 255 _gzclearerr@4 PROC                                      ; COMDAT\r
 256 \r
 257 ; 484  : {\r
 258 \r
 259   00000 55               push    ebp\r
 260   00001 8b ec            mov     ebp, esp\r
 261 \r
 262 ; 485  :     gz_statep state;\r
 263 ; 486  : \r
 264 ; 487  :     /* get internal structure and check integrity */\r
 265 ; 488  :     if (file == NULL)\r
 266 \r
 267   00003 8b 4d 08         mov     ecx, DWORD PTR _file$[ebp]\r
 268   00006 33 d2            xor     edx, edx\r
 269   00008 3b ca            cmp     ecx, edx\r
 270   0000a 74 29            je      SHORT $LN4@gzclearerr\r
 271 \r
 272 ; 489  :         return;\r
 273 ; 490  :     state = (gz_statep)file;\r
 274 ; 491  :     if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
 275 \r
 276   0000c 8b 41 10         mov     eax, DWORD PTR [ecx+16]\r
 277   0000f 3d 4f 1c 00 00   cmp     eax, 7247              ; 00001c4fH\r
 278   00014 74 0e            je      SHORT $LN7@gzclearerr\r
 279   00016 3d b1 79 00 00   cmp     eax, 31153             ; 000079b1H\r
 280   0001b 75 18            jne     SHORT $LN4@gzclearerr\r
 281 \r
 282 ; 492  :         return;\r
 283 ; 493  : \r
 284 ; 494  :     /* clear error and end-of-file */\r
 285 ; 495  :     if (state->mode == GZ_READ) {\r
 286 \r
 287   0001d 3d 4f 1c 00 00   cmp     eax, 7247              ; 00001c4fH\r
 288   00022 75 06            jne     SHORT $LN1@gzclearerr\r
 289 $LN7@gzclearerr:\r
 290 \r
 291 ; 496  :         state->eof = 0;\r
 292 \r
 293   00024 89 51 40         mov     DWORD PTR [ecx+64], edx\r
 294 \r
 295 ; 497  :         state->past = 0;\r
 296 \r
 297   00027 89 51 44         mov     DWORD PTR [ecx+68], edx\r
 298 $LN1@gzclearerr:\r
 299 \r
 300 ; 498  :     }\r
 301 ; 499  :     gz_error(state, Z_OK, NULL);\r
 302 \r
 303   0002a 52               push    edx\r
 304   0002b 33 c0            xor     eax, eax\r
 305   0002d e8 00 00 00 00   call    _gz_error\r
 306   00032 83 c4 04         add     esp, 4\r
 307 $LN4@gzclearerr:\r
 308 \r
 309 ; 500  : }\r
 310 \r
 311   00035 5d               pop     ebp\r
 312   00036 c2 04 00         ret     4\r
 313 _gzclearerr@4 ENDP\r
 314 _TEXT   ENDS\r
 315 PUBLIC  _gzerror@8\r
 316 ; Function compile flags: /Ogtp\r
 317 ;       COMDAT _gzerror@8\r
 318 _TEXT   SEGMENT\r
 319 _file$ = 8                                              ; size = 4\r
 320 _errnum$ = 12                                           ; size = 4\r
 321 _gzerror@8 PROC                                         ; COMDAT\r
 322 \r
 323 ; 465  : {\r
 324 \r
 325   00000 55               push    ebp\r
 326   00001 8b ec            mov     ebp, esp\r
 327 \r
 328 ; 466  :     gz_statep state;\r
 329 ; 467  : \r
 330 ; 468  :     /* get internal structure and check integrity */\r
 331 ; 469  :     if (file == NULL)\r
 332 \r
 333   00003 8b 45 08         mov     eax, DWORD PTR _file$[ebp]\r
 334   00006 85 c0            test    eax, eax\r
 335   00008 75 06            jne     SHORT $LN3@gzerror\r
 336 $LN8@gzerror:\r
 337 \r
 338 ; 470  :         return NULL;\r
 339 \r
 340   0000a 33 c0            xor     eax, eax\r
 341 \r
 342 ; 479  : }\r
 343 \r
 344   0000c 5d               pop     ebp\r
 345   0000d c2 08 00         ret     8\r
 346 $LN3@gzerror:\r
 347 \r
 348 ; 471  :     state = (gz_statep)file;\r
 349 ; 472  :     if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
 350 \r
 351   00010 8b 48 10         mov     ecx, DWORD PTR [eax+16]\r
 352   00013 81 f9 4f 1c 00\r
 353         00               cmp     ecx, 7247              ; 00001c4fH\r
 354   00019 74 08            je      SHORT $LN2@gzerror\r
 355   0001b 81 f9 b1 79 00\r
 356         00               cmp     ecx, 31153             ; 000079b1H\r
 357 \r
 358 ; 473  :         return NULL;\r
 359 \r
 360   00021 75 e7            jne     SHORT $LN8@gzerror\r
 361 $LN2@gzerror:\r
 362 \r
 363 ; 474  : \r
 364 ; 475  :     /* return error information */\r
 365 ; 476  :     if (errnum != NULL)\r
 366 \r
 367   00023 8b 4d 0c         mov     ecx, DWORD PTR _errnum$[ebp]\r
 368   00026 85 c9            test    ecx, ecx\r
 369   00028 74 05            je      SHORT $LN1@gzerror\r
 370 \r
 371 ; 477  :         *errnum = state->err;\r
 372 \r
 373   0002a 8b 50 5c         mov     edx, DWORD PTR [eax+92]\r
 374   0002d 89 11            mov     DWORD PTR [ecx], edx\r
 375 $LN1@gzerror:\r
 376 \r
 377 ; 478  :     return state->msg == NULL ? "" : state->msg;\r
 378 \r
 379   0002f 8b 40 60         mov     eax, DWORD PTR [eax+96]\r
 380   00032 85 c0            test    eax, eax\r
 381   00034 75 05            jne     SHORT $LN4@gzerror\r
 382   00036 b8 00 00 00 00   mov     eax, OFFSET ??_C@_00CNPNBAHC@?$AA@\r
 383 $LN4@gzerror:\r
 384 \r
 385 ; 479  : }\r
 386 \r
 387   0003b 5d               pop     ebp\r
 388   0003c c2 08 00         ret     8\r
 389 _gzerror@8 ENDP\r
 390 _TEXT   ENDS\r
 391 PUBLIC  _gzeof@4\r
 392 ; Function compile flags: /Ogtp\r
 393 ;       COMDAT _gzeof@4\r
 394 _TEXT   SEGMENT\r
 395 _file$ = 8                                              ; size = 4\r
 396 _gzeof@4 PROC                                           ; COMDAT\r
 397 \r
 398 ; 447  : {\r
 399 \r
 400   00000 55               push    ebp\r
 401   00001 8b ec            mov     ebp, esp\r
 402 \r
 403 ; 448  :     gz_statep state;\r
 404 ; 449  : \r
 405 ; 450  :     /* get internal structure and check integrity */\r
 406 ; 451  :     if (file == NULL)\r
 407 \r
 408   00003 8b 4d 08         mov     ecx, DWORD PTR _file$[ebp]\r
 409   00006 85 c9            test    ecx, ecx\r
 410 \r
 411 ; 452  :         return 0;\r
 412 \r
 413   00008 74 1f            je      SHORT $LN5@gzeof\r
 414 \r
 415 ; 453  :     state = (gz_statep)file;\r
 416 ; 454  :     if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
 417 \r
 418   0000a 8b 41 10         mov     eax, DWORD PTR [ecx+16]\r
 419   0000d 3d 4f 1c 00 00   cmp     eax, 7247              ; 00001c4fH\r
 420   00012 74 0e            je      SHORT $LN8@gzeof\r
 421   00014 3d b1 79 00 00   cmp     eax, 31153             ; 000079b1H\r
 422 \r
 423 ; 455  :         return 0;\r
 424 \r
 425   00019 75 0e            jne     SHORT $LN5@gzeof\r
 426 \r
 427 ; 456  : \r
 428 ; 457  :     /* return end-of-file state */\r
 429 ; 458  :     return state->mode == GZ_READ ? state->past : 0;\r
 430 \r
 431   0001b 3d 4f 1c 00 00   cmp     eax, 7247              ; 00001c4fH\r
 432   00020 75 07            jne     SHORT $LN5@gzeof\r
 433 $LN8@gzeof:\r
 434   00022 8b 41 44         mov     eax, DWORD PTR [ecx+68]\r
 435 \r
 436 ; 459  : }\r
 437 \r
 438   00025 5d               pop     ebp\r
 439   00026 c2 04 00         ret     4\r
 440 $LN5@gzeof:\r
 441 \r
 442 ; 456  : \r
 443 ; 457  :     /* return end-of-file state */\r
 444 ; 458  :     return state->mode == GZ_READ ? state->past : 0;\r
 445 \r
 446   00029 33 c0            xor     eax, eax\r
 447 \r
 448 ; 459  : }\r
 449 \r
 450   0002b 5d               pop     ebp\r
 451   0002c c2 04 00         ret     4\r
 452 _gzeof@4 ENDP\r
 453 _TEXT   ENDS\r
 454 PUBLIC  _gzoffset64@4\r
 455 ; Function compile flags: /Ogtp\r
 456 ;       COMDAT _gzoffset64@4\r
 457 _TEXT   SEGMENT\r
 458 _gzoffset64@4 PROC                                      ; COMDAT\r
 459 ; _file$ = esi\r
 460 \r
 461 ; 415  :     z_off64_t offset;\r
 462 ; 416  :     gz_statep state;\r
 463 ; 417  : \r
 464 ; 418  :     /* get internal structure and check integrity */\r
 465 ; 419  :     if (file == NULL)\r
 466 \r
 467   00000 85 f6            test    esi, esi\r
 468   00002 75 06            jne     SHORT $LN4@gzoffset64\r
 469 $LN7@gzoffset64:\r
 470 \r
 471 ; 420  :         return -1;\r
 472 \r
 473   00004 83 c8 ff         or      eax, -1\r
 474   00007 0b d0            or      edx, eax\r
 475 \r
 476 ; 431  :     return offset;\r
 477 ; 432  : }\r
 478 \r
 479   00009 c3               ret     0\r
 480 $LN4@gzoffset64:\r
 481 \r
 482 ; 421  :     state = (gz_statep)file;\r
 483 ; 422  :     if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
 484 \r
 485   0000a 8b 46 10         mov     eax, DWORD PTR [esi+16]\r
 486   0000d 3d 4f 1c 00 00   cmp     eax, 7247              ; 00001c4fH\r
 487   00012 74 07            je      SHORT $LN3@gzoffset64\r
 488   00014 3d b1 79 00 00   cmp     eax, 31153             ; 000079b1H\r
 489 \r
 490 ; 423  :         return -1;\r
 491 \r
 492   00019 75 e9            jne     SHORT $LN7@gzoffset64\r
 493 $LN3@gzoffset64:\r
 494 \r
 495 ; 424  : \r
 496 ; 425  :     /* compute and return effective offset in file */\r
 497 ; 426  :     offset = LSEEK(state->fd, 0, SEEK_CUR);\r
 498 \r
 499   0001b 8b 46 14         mov     eax, DWORD PTR [esi+20]\r
 500   0001e 6a 01            push    1\r
 501   00020 6a 00            push    0\r
 502   00022 50               push    eax\r
 503   00023 ff 15 00 00 00\r
 504         00               call    DWORD PTR __imp___lseeki64\r
 505   00029 99               cdq\r
 506 \r
 507 ; 427  :     if (offset == -1)\r
 508 \r
 509   0002a 8b c8            mov     ecx, eax\r
 510   0002c 23 ca            and     ecx, edx\r
 511   0002e 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 512   00031 83 f9 ff         cmp     ecx, -1\r
 513 \r
 514 ; 428  :         return -1;\r
 515 \r
 516   00034 74 ce            je      SHORT $LN7@gzoffset64\r
 517 \r
 518 ; 429  :     if (state->mode == GZ_READ)             /* reading */\r
 519 \r
 520   00036 81 7e 10 4f 1c\r
 521         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
 522   0003d 75 06            jne     SHORT $LN5@gzoffset64\r
 523 \r
 524 ; 430  :         offset -= state->strm.avail_in;     /* don't count buffered input */\r
 525 \r
 526   0003f 2b 46 68         sub     eax, DWORD PTR [esi+104]\r
 527   00042 83 da 00         sbb     edx, 0\r
 528 $LN5@gzoffset64:\r
 529 \r
 530 ; 431  :     return offset;\r
 531 ; 432  : }\r
 532 \r
 533   00045 c3               ret     0\r
 534 _gzoffset64@4 ENDP\r
 535 _TEXT   ENDS\r
 536 PUBLIC  _gztell64@4\r
 537 ; Function compile flags: /Ogtp\r
 538 ;       COMDAT _gztell64@4\r
 539 _TEXT   SEGMENT\r
 540 _gztell64@4 PROC                                        ; COMDAT\r
 541 ; _file$ = ecx\r
 542 \r
 543 ; 388  :     gz_statep state;\r
 544 ; 389  : \r
 545 ; 390  :     /* get internal structure and check integrity */\r
 546 ; 391  :     if (file == NULL)\r
 547 \r
 548   00000 85 c9            test    ecx, ecx\r
 549   00002 75 06            jne     SHORT $LN2@gztell64\r
 550 $LN7@gztell64:\r
 551 \r
 552 ; 392  :         return -1;\r
 553 \r
 554   00004 83 c8 ff         or      eax, -1\r
 555   00007 0b d0            or      edx, eax\r
 556 \r
 557 ; 399  : }\r
 558 \r
 559   00009 c3               ret     0\r
 560 $LN2@gztell64:\r
 561 \r
 562 ; 393  :     state = (gz_statep)file;\r
 563 ; 394  :     if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
 564 \r
 565   0000a 8b 41 10         mov     eax, DWORD PTR [ecx+16]\r
 566   0000d 3d 4f 1c 00 00   cmp     eax, 7247              ; 00001c4fH\r
 567   00012 74 07            je      SHORT $LN1@gztell64\r
 568   00014 3d b1 79 00 00   cmp     eax, 31153             ; 000079b1H\r
 569 \r
 570 ; 395  :         return -1;\r
 571 \r
 572   00019 75 e9            jne     SHORT $LN7@gztell64\r
 573 $LN1@gztell64:\r
 574 \r
 575 ; 396  : \r
 576 ; 397  :     /* return position */\r
 577 ; 398  :     return state->x.pos + (state->seek ? state->skip : 0);\r
 578 \r
 579   0001b 83 79 58 00      cmp     DWORD PTR [ecx+88], 0\r
 580   0001f 56               push    esi\r
 581   00020 74 12            je      SHORT $LN5@gztell64\r
 582   00022 8b 51 50         mov     edx, DWORD PTR [ecx+80]\r
 583   00025 8b 41 08         mov     eax, DWORD PTR [ecx+8]\r
 584   00028 8b 71 54         mov     esi, DWORD PTR [ecx+84]\r
 585   0002b 03 c2            add     eax, edx\r
 586   0002d 8b 51 0c         mov     edx, DWORD PTR [ecx+12]\r
 587   00030 13 d6            adc     edx, esi\r
 588   00032 5e               pop     esi\r
 589 \r
 590 ; 399  : }\r
 591 \r
 592   00033 c3               ret     0\r
 593 $LN5@gztell64:\r
 594 \r
 595 ; 396  : \r
 596 ; 397  :     /* return position */\r
 597 ; 398  :     return state->x.pos + (state->seek ? state->skip : 0);\r
 598 \r
 599   00034 8b 41 08         mov     eax, DWORD PTR [ecx+8]\r
 600   00037 33 d2            xor     edx, edx\r
 601   00039 33 f6            xor     esi, esi\r
 602   0003b 03 c2            add     eax, edx\r
 603   0003d 8b 51 0c         mov     edx, DWORD PTR [ecx+12]\r
 604   00040 13 d6            adc     edx, esi\r
 605   00042 5e               pop     esi\r
 606 \r
 607 ; 399  : }\r
 608 \r
 609   00043 c3               ret     0\r
 610 _gztell64@4 ENDP\r
 611 _TEXT   ENDS\r
 612 PUBLIC  _gzbuffer@8\r
 613 ; Function compile flags: /Ogtp\r
 614 ;       COMDAT _gzbuffer@8\r
 615 _TEXT   SEGMENT\r
 616 _file$ = 8                                              ; size = 4\r
 617 _size$ = 12                                             ; size = 4\r
 618 _gzbuffer@8 PROC                                        ; COMDAT\r
 619 \r
 620 ; 251  : {\r
 621 \r
 622   00000 55               push    ebp\r
 623   00001 8b ec            mov     ebp, esp\r
 624 \r
 625 ; 252  :     gz_statep state;\r
 626 ; 253  : \r
 627 ; 254  :     /* get internal structure and check integrity */\r
 628 ; 255  :     if (file == NULL)\r
 629 \r
 630   00003 8b 4d 08         mov     ecx, DWORD PTR _file$[ebp]\r
 631   00006 85 c9            test    ecx, ecx\r
 632   00008 75 07            jne     SHORT $LN4@gzbuffer\r
 633 $LN7@gzbuffer:\r
 634 \r
 635 ; 256  :         return -1;\r
 636 \r
 637   0000a 83 c8 ff         or      eax, -1\r
 638 \r
 639 ; 270  : }\r
 640 \r
 641   0000d 5d               pop     ebp\r
 642   0000e c2 08 00         ret     8\r
 643 $LN4@gzbuffer:\r
 644 \r
 645 ; 257  :     state = (gz_statep)file;\r
 646 ; 258  :     if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
 647 \r
 648   00011 8b 41 10         mov     eax, DWORD PTR [ecx+16]\r
 649   00014 3d 4f 1c 00 00   cmp     eax, 7247              ; 00001c4fH\r
 650   00019 74 07            je      SHORT $LN3@gzbuffer\r
 651   0001b 3d b1 79 00 00   cmp     eax, 31153             ; 000079b1H\r
 652 \r
 653 ; 259  :         return -1;\r
 654 \r
 655   00020 75 e8            jne     SHORT $LN7@gzbuffer\r
 656 $LN3@gzbuffer:\r
 657 \r
 658 ; 260  : \r
 659 ; 261  :     /* make sure we haven't already allocated memory */\r
 660 ; 262  :     if (state->size != 0)\r
 661 \r
 662   00022 83 79 1c 00      cmp     DWORD PTR [ecx+28], 0\r
 663 \r
 664 ; 263  :         return -1;\r
 665 \r
 666   00026 75 e2            jne     SHORT $LN7@gzbuffer\r
 667 \r
 668 ; 264  : \r
 669 ; 265  :     /* check and set requested size */\r
 670 ; 266  :     if (size < 2)\r
 671 \r
 672   00028 8b 45 0c         mov     eax, DWORD PTR _size$[ebp]\r
 673   0002b 83 f8 02         cmp     eax, 2\r
 674   0002e 73 05            jae     SHORT $LN1@gzbuffer\r
 675 \r
 676 ; 267  :         size = 2;               /* need two bytes to check magic header */\r
 677 \r
 678   00030 b8 02 00 00 00   mov     eax, 2\r
 679 $LN1@gzbuffer:\r
 680 \r
 681 ; 268  :     state->want = size;\r
 682 \r
 683   00035 89 41 20         mov     DWORD PTR [ecx+32], eax\r
 684 \r
 685 ; 269  :     return 0;\r
 686 \r
 687   00038 33 c0            xor     eax, eax\r
 688 \r
 689 ; 270  : }\r
 690 \r
 691   0003a 5d               pop     ebp\r
 692   0003b c2 08 00         ret     8\r
 693 _gzbuffer@8 ENDP\r
 694 ; Function compile flags: /Ogtp\r
 695 _TEXT   ENDS\r
 696 ;       COMDAT _gz_reset\r
 697 _TEXT   SEGMENT\r
 698 _gz_reset PROC                                          ; COMDAT\r
 699 ; _state$ = esi\r
 700 \r
 701 ; 77   : {\r
 702 \r
 703   00000 57               push    edi\r
 704 \r
 705 ; 78   :     state->x.have = 0;              /* no output data available */\r
 706 \r
 707   00001 33 ff            xor     edi, edi\r
 708 \r
 709 ; 79   :     if (state->mode == GZ_READ) {   /* for reading ... */\r
 710 \r
 711   00003 81 7e 10 4f 1c\r
 712         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
 713   0000a 89 3e            mov     DWORD PTR [esi], edi\r
 714   0000c 75 09            jne     SHORT $LN1@gz_reset\r
 715 \r
 716 ; 80   :         state->eof = 0;             /* not at end of file */\r
 717 \r
 718   0000e 89 7e 40         mov     DWORD PTR [esi+64], edi\r
 719 \r
 720 ; 81   :         state->past = 0;            /* have not read past end yet */\r
 721 \r
 722   00011 89 7e 44         mov     DWORD PTR [esi+68], edi\r
 723 \r
 724 ; 82   :         state->how = LOOK;          /* look for gzip header */\r
 725 \r
 726   00014 89 7e 30         mov     DWORD PTR [esi+48], edi\r
 727 $LN1@gz_reset:\r
 728 \r
 729 ; 83   :     }\r
 730 ; 84   :     state->seek = 0;                /* no seek request pending */\r
 731 ; 85   :     gz_error(state, Z_OK, NULL);    /* clear error */\r
 732 \r
 733   00017 57               push    edi\r
 734   00018 33 c0            xor     eax, eax\r
 735   0001a 8b ce            mov     ecx, esi\r
 736   0001c 89 7e 58         mov     DWORD PTR [esi+88], edi\r
 737   0001f e8 00 00 00 00   call    _gz_error\r
 738   00024 83 c4 04         add     esp, 4\r
 739 \r
 740 ; 86   :     state->x.pos = 0;               /* no uncompressed data yet */\r
 741 \r
 742   00027 89 7e 08         mov     DWORD PTR [esi+8], edi\r
 743   0002a 89 7e 0c         mov     DWORD PTR [esi+12], edi\r
 744 \r
 745 ; 87   :     state->strm.avail_in = 0;       /* no input data yet */\r
 746 \r
 747   0002d 89 7e 68         mov     DWORD PTR [esi+104], edi\r
 748   00030 5f               pop     edi\r
 749 \r
 750 ; 88   : }\r
 751 \r
 752   00031 c3               ret     0\r
 753 _gz_reset ENDP\r
 754 PUBLIC  _gzoffset@4\r
 755 ; Function compile flags: /Ogtp\r
 756 ;       COMDAT _gzoffset@4\r
 757 _TEXT   SEGMENT\r
 758 _file$ = 8                                              ; size = 4\r
 759 _gzoffset@4 PROC                                        ; COMDAT\r
 760 \r
 761 ; 437  : {\r
 762 \r
 763   00000 55               push    ebp\r
 764   00001 8b ec            mov     ebp, esp\r
 765   00003 83 e4 f8         and     esp, -8                        ; fffffff8H\r
 766   00006 51               push    ecx\r
 767   00007 56               push    esi\r
 768 \r
 769 ; 438  :     z_off64_t ret;\r
 770 ; 439  : \r
 771 ; 440  :     ret = gzoffset64(file);\r
 772 \r
 773   00008 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
 774   0000b e8 00 00 00 00   call    _gzoffset64@4\r
 775   00010 8b c8            mov     ecx, eax\r
 776   00012 8b f2            mov     esi, edx\r
 777 \r
 778 ; 441  :     return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
 779 \r
 780   00014 99               cdq\r
 781   00015 3b c8            cmp     ecx, eax\r
 782   00017 75 0d            jne     SHORT $LN3@gzoffset\r
 783   00019 3b f2            cmp     esi, edx\r
 784   0001b 75 09            jne     SHORT $LN3@gzoffset\r
 785   0001d 8b c1            mov     eax, ecx\r
 786 \r
 787 ; 442  : }\r
 788 \r
 789   0001f 5e               pop     esi\r
 790   00020 8b e5            mov     esp, ebp\r
 791   00022 5d               pop     ebp\r
 792   00023 c2 04 00         ret     4\r
 793 $LN3@gzoffset:\r
 794 \r
 795 ; 441  :     return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
 796 \r
 797   00026 83 c8 ff         or      eax, -1\r
 798 \r
 799 ; 442  : }\r
 800 \r
 801   00029 5e               pop     esi\r
 802   0002a 8b e5            mov     esp, ebp\r
 803   0002c 5d               pop     ebp\r
 804   0002d c2 04 00         ret     4\r
 805 _gzoffset@4 ENDP\r
 806 _TEXT   ENDS\r
 807 PUBLIC  _gztell@4\r
 808 ; Function compile flags: /Ogtp\r
 809 ;       COMDAT _gztell@4\r
 810 _TEXT   SEGMENT\r
 811 _file$ = 8                                              ; size = 4\r
 812 _gztell@4 PROC                                          ; COMDAT\r
 813 \r
 814 ; 404  : {\r
 815 \r
 816   00000 55               push    ebp\r
 817   00001 8b ec            mov     ebp, esp\r
 818 \r
 819 ; 405  :     z_off64_t ret;\r
 820 ; 406  : \r
 821 ; 407  :     ret = gztell64(file);\r
 822 \r
 823   00003 8b 4d 08         mov     ecx, DWORD PTR _file$[ebp]\r
 824   00006 56               push    esi\r
 825   00007 e8 00 00 00 00   call    _gztell64@4\r
 826   0000c 8b c8            mov     ecx, eax\r
 827   0000e 8b f2            mov     esi, edx\r
 828 \r
 829 ; 408  :     return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
 830 \r
 831   00010 99               cdq\r
 832   00011 3b c8            cmp     ecx, eax\r
 833   00013 75 0b            jne     SHORT $LN3@gztell\r
 834   00015 3b f2            cmp     esi, edx\r
 835   00017 75 07            jne     SHORT $LN3@gztell\r
 836   00019 8b c1            mov     eax, ecx\r
 837   0001b 5e               pop     esi\r
 838 \r
 839 ; 409  : }\r
 840 \r
 841   0001c 5d               pop     ebp\r
 842   0001d c2 04 00         ret     4\r
 843 $LN3@gztell:\r
 844 \r
 845 ; 408  :     return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
 846 \r
 847   00020 83 c8 ff         or      eax, -1\r
 848   00023 5e               pop     esi\r
 849 \r
 850 ; 409  : }\r
 851 \r
 852   00024 5d               pop     ebp\r
 853   00025 c2 04 00         ret     4\r
 854 _gztell@4 ENDP\r
 855 _TEXT   ENDS\r
 856 PUBLIC  _gzrewind@4\r
 857 ; Function compile flags: /Ogtp\r
 858 ;       COMDAT _gzrewind@4\r
 859 _TEXT   SEGMENT\r
 860 _file$ = 8                                              ; size = 4\r
 861 _gzrewind@4 PROC                                        ; COMDAT\r
 862 \r
 863 ; 275  : {\r
 864 \r
 865   00000 55               push    ebp\r
 866   00001 8b ec            mov     ebp, esp\r
 867   00003 83 e4 f8         and     esp, -8                        ; fffffff8H\r
 868   00006 51               push    ecx\r
 869   00007 56               push    esi\r
 870 \r
 871 ; 276  :     gz_statep state;\r
 872 ; 277  : \r
 873 ; 278  :     /* get internal structure */\r
 874 ; 279  :     if (file == NULL)\r
 875 \r
 876   00008 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
 877   0000b 85 f6            test    esi, esi\r
 878 \r
 879 ; 280  :         return -1;\r
 880 \r
 881   0000d 74 3f            je      SHORT $LN2@gzrewind\r
 882 \r
 883 ; 281  :     state = (gz_statep)file;\r
 884 ; 282  : \r
 885 ; 283  :     /* check that we're reading and that there's no error */\r
 886 ; 284  :     if (state->mode != GZ_READ ||\r
 887 ; 285  :             (state->err != Z_OK && state->err != Z_BUF_ERROR))\r
 888 \r
 889   0000f 81 7e 10 4f 1c\r
 890         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
 891   00016 75 36            jne     SHORT $LN2@gzrewind\r
 892   00018 8b 46 5c         mov     eax, DWORD PTR [esi+92]\r
 893   0001b 85 c0            test    eax, eax\r
 894   0001d 74 05            je      SHORT $LN3@gzrewind\r
 895   0001f 83 f8 fb         cmp     eax, -5                        ; fffffffbH\r
 896   00022 75 2a            jne     SHORT $LN2@gzrewind\r
 897 $LN3@gzrewind:\r
 898 \r
 899 ; 287  : \r
 900 ; 288  :     /* back up and start over */\r
 901 ; 289  :     if (LSEEK(state->fd, state->start, SEEK_SET) == -1)\r
 902 \r
 903   00024 8b 46 3c         mov     eax, DWORD PTR [esi+60]\r
 904   00027 8b 4e 38         mov     ecx, DWORD PTR [esi+56]\r
 905   0002a 8b 56 14         mov     edx, DWORD PTR [esi+20]\r
 906   0002d 6a 00            push    0\r
 907   0002f 50               push    eax\r
 908   00030 51               push    ecx\r
 909   00031 52               push    edx\r
 910   00032 ff 15 00 00 00\r
 911         00               call    DWORD PTR __imp___lseeki64\r
 912   00038 83 c4 10         add     esp, 16                        ; 00000010H\r
 913   0003b 83 f8 ff         cmp     eax, -1\r
 914 \r
 915 ; 290  :         return -1;\r
 916 \r
 917   0003e 74 0e            je      SHORT $LN2@gzrewind\r
 918 \r
 919 ; 291  :     gz_reset(state);\r
 920 \r
 921   00040 e8 00 00 00 00   call    _gz_reset\r
 922 \r
 923 ; 292  :     return 0;\r
 924 \r
 925   00045 33 c0            xor     eax, eax\r
 926 \r
 927 ; 293  : }\r
 928 \r
 929   00047 5e               pop     esi\r
 930   00048 8b e5            mov     esp, ebp\r
 931   0004a 5d               pop     ebp\r
 932   0004b c2 04 00         ret     4\r
 933 $LN2@gzrewind:\r
 934 \r
 935 ; 286  :         return -1;\r
 936 \r
 937   0004e 83 c8 ff         or      eax, -1\r
 938 \r
 939 ; 293  : }\r
 940 \r
 941   00051 5e               pop     esi\r
 942   00052 8b e5            mov     esp, ebp\r
 943   00054 5d               pop     ebp\r
 944   00055 c2 04 00         ret     4\r
 945 _gzrewind@4 ENDP\r
 946 ; Function compile flags: /Ogtp\r
 947 _TEXT   ENDS\r
 948 ;       COMDAT _gz_open\r
 949 _TEXT   SEGMENT\r
 950 _path$ = 8                                              ; size = 4\r
 951 _fd$ = 12                                               ; size = 4\r
 952 _gz_open PROC                                           ; COMDAT\r
 953 ; _mode$ = eax\r
 954 \r
 955 ; 95   : {\r
 956 \r
 957   00000 55               push    ebp\r
 958   00001 8b ec            mov     ebp, esp\r
 959   00003 53               push    ebx\r
 960   00004 57               push    edi\r
 961 \r
 962 ; 96   :     gz_statep state;\r
 963 ; 97   : \r
 964 ; 98   :     /* check input */\r
 965 ; 99   :     if (path == NULL)\r
 966 \r
 967   00005 33 ff            xor     edi, edi\r
 968   00007 8b d8            mov     ebx, eax\r
 969   00009 39 7d 08         cmp     DWORD PTR _path$[ebp], edi\r
 970   0000c 75 06            jne     SHORT $LN27@gz_open\r
 971 \r
 972 ; 100  :         return NULL;\r
 973 \r
 974   0000e 5f               pop     edi\r
 975   0000f 33 c0            xor     eax, eax\r
 976   00011 5b               pop     ebx\r
 977 \r
 978 ; 213  : }\r
 979 \r
 980   00012 5d               pop     ebp\r
 981   00013 c3               ret     0\r
 982 $LN27@gz_open:\r
 983   00014 56               push    esi\r
 984 \r
 985 ; 101  : \r
 986 ; 102  :     /* allocate gzFile structure to return */\r
 987 ; 103  :     state = malloc(sizeof(gz_state));\r
 988 \r
 989   00015 68 a0 00 00 00   push    160                    ; 000000a0H\r
 990   0001a ff 15 00 00 00\r
 991         00               call    DWORD PTR __imp__malloc\r
 992   00020 8b f0            mov     esi, eax\r
 993   00022 83 c4 04         add     esp, 4\r
 994 \r
 995 ; 104  :     if (state == NULL)\r
 996 \r
 997   00025 3b f7            cmp     esi, edi\r
 998 \r
 999 ; 105  :         return NULL;\r
1000 \r
1001   00027 0f 84 5b 01 00\r
1002         00               je      $LN42@gz_open\r
1003 \r
1004 ; 106  :     state->size = 0;            /* no buffers allocated yet */\r
1005 ; 107  :     state->want = GZBUFSIZE;    /* requested buffer size */\r
1006 ; 108  :     state->msg = NULL;          /* no error message yet */\r
1007 ; 109  : \r
1008 ; 110  :     /* interpret mode */\r
1009 ; 111  :     state->mode = GZ_NONE;\r
1010 ; 112  :     state->level = Z_DEFAULT_COMPRESSION;\r
1011 ; 113  :     state->strategy = Z_DEFAULT_STRATEGY;\r
1012 ; 114  :     state->direct = 0;\r
1013 ; 115  :     while (*mode) {\r
1014 \r
1015   0002d 8a 03            mov     al, BYTE PTR [ebx]\r
1016   0002f 89 7e 1c         mov     DWORD PTR [esi+28], edi\r
1017   00032 c7 46 20 00 20\r
1018         00 00            mov     DWORD PTR [esi+32], 8192 ; 00002000H\r
1019   00039 89 7e 60         mov     DWORD PTR [esi+96], edi\r
1020   0003c 89 7e 10         mov     DWORD PTR [esi+16], edi\r
1021   0003f c7 46 48 ff ff\r
1022         ff ff            mov     DWORD PTR [esi+72], -1\r
1023   00046 89 7e 4c         mov     DWORD PTR [esi+76], edi\r
1024   00049 89 7e 2c         mov     DWORD PTR [esi+44], edi\r
1025   0004c 84 c0            test    al, al\r
1026   0004e 74 78            je      SHORT $LN24@gz_open\r
1027   00050 ba 03 00 00 00   mov     edx, 3\r
1028   00055 8d 4a 01         lea     ecx, DWORD PTR [edx+1]\r
1029 $LL25@gz_open:\r
1030 \r
1031 ; 116  :         if (*mode >= '0' && *mode <= '9')\r
1032 \r
1033   00058 3c 30            cmp     al, 48                 ; 00000030H\r
1034   0005a 7c 0f            jl      SHORT $LN23@gz_open\r
1035   0005c 3c 39            cmp     al, 57                 ; 00000039H\r
1036   0005e 7f 0b            jg      SHORT $LN23@gz_open\r
1037 \r
1038 ; 117  :             state->level = *mode - '0';\r
1039 \r
1040   00060 0f be c0         movsx   eax, al\r
1041   00063 83 e8 30         sub     eax, 48                        ; 00000030H\r
1042   00066 89 46 48         mov     DWORD PTR [esi+72], eax\r
1043 \r
1044 ; 118  :         else\r
1045 \r
1046   00069 eb 55            jmp     SHORT $LN40@gz_open\r
1047 $LN23@gz_open:\r
1048 \r
1049 ; 119  :             switch (*mode) {\r
1050 \r
1051   0006b 0f be c0         movsx   eax, al\r
1052   0006e 83 c0 d5         add     eax, -43               ; ffffffd5H\r
1053   00071 83 f8 4c         cmp     eax, 76                        ; 0000004cH\r
1054   00074 77 4a            ja      SHORT $LN40@gz_open\r
1055   00076 0f b6 80 00 00\r
1056         00 00            movzx   eax, BYTE PTR $LN38@gz_open[eax]\r
1057   0007d ff 24 85 00 00\r
1058         00 00            jmp     DWORD PTR $LN44@gz_open[eax*4]\r
1059 $LN19@gz_open:\r
1060 \r
1061 ; 120  :             case 'r':\r
1062 ; 121  :                 state->mode = GZ_READ;\r
1063 \r
1064   00084 c7 46 10 4f 1c\r
1065         00 00            mov     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
1066 \r
1067 ; 122  :                 break;\r
1068 \r
1069   0008b eb 33            jmp     SHORT $LN40@gz_open\r
1070 $LN18@gz_open:\r
1071 \r
1072 ; 123  : #ifndef NO_GZCOMPRESS\r
1073 ; 124  :             case 'w':\r
1074 ; 125  :                 state->mode = GZ_WRITE;\r
1075 \r
1076   0008d c7 46 10 b1 79\r
1077         00 00            mov     DWORD PTR [esi+16], 31153 ; 000079b1H\r
1078 \r
1079 ; 126  :                 break;\r
1080 \r
1081   00094 eb 2a            jmp     SHORT $LN40@gz_open\r
1082 $LN17@gz_open:\r
1083 \r
1084 ; 127  :             case 'a':\r
1085 ; 128  :                 state->mode = GZ_APPEND;\r
1086 \r
1087   00096 c7 46 10 01 00\r
1088         00 00            mov     DWORD PTR [esi+16], 1\r
1089 \r
1090 ; 129  :                 break;\r
1091 \r
1092   0009d eb 21            jmp     SHORT $LN40@gz_open\r
1093 $LN14@gz_open:\r
1094 \r
1095 ; 130  : #endif\r
1096 ; 131  :             case '+':       /* can't read and write at the same time */\r
1097 ; 132  :                 free(state);\r
1098 ; 133  :                 return NULL;\r
1099 ; 134  :             case 'b':       /* ignore -- will request binary anyway */\r
1100 ; 135  :                 break;\r
1101 ; 136  :             case 'f':\r
1102 ; 137  :                 state->strategy = Z_FILTERED;\r
1103 \r
1104   0009f c7 46 4c 01 00\r
1105         00 00            mov     DWORD PTR [esi+76], 1\r
1106 \r
1107 ; 138  :                 break;\r
1108 \r
1109   000a6 eb 18            jmp     SHORT $LN40@gz_open\r
1110 $LN13@gz_open:\r
1111 \r
1112 ; 139  :             case 'h':\r
1113 ; 140  :                 state->strategy = Z_HUFFMAN_ONLY;\r
1114 \r
1115   000a8 c7 46 4c 02 00\r
1116         00 00            mov     DWORD PTR [esi+76], 2\r
1117 \r
1118 ; 141  :                 break;\r
1119 \r
1120   000af eb 0f            jmp     SHORT $LN40@gz_open\r
1121 $LN12@gz_open:\r
1122 \r
1123 ; 142  :             case 'R':\r
1124 ; 143  :                 state->strategy = Z_RLE;\r
1125 \r
1126   000b1 89 56 4c         mov     DWORD PTR [esi+76], edx\r
1127 \r
1128 ; 144  :                 break;\r
1129 \r
1130   000b4 eb 0a            jmp     SHORT $LN40@gz_open\r
1131 $LN11@gz_open:\r
1132 \r
1133 ; 145  :             case 'F':\r
1134 ; 146  :                 state->strategy = Z_FIXED;\r
1135 \r
1136   000b6 89 4e 4c         mov     DWORD PTR [esi+76], ecx\r
1137 $LN10@gz_open:\r
1138 \r
1139 ; 147  :             case 'T':\r
1140 ; 148  :                 state->direct = 1;\r
1141 \r
1142   000b9 c7 46 2c 01 00\r
1143         00 00            mov     DWORD PTR [esi+44], 1\r
1144 $LN40@gz_open:\r
1145 \r
1146 ; 106  :     state->size = 0;            /* no buffers allocated yet */\r
1147 ; 107  :     state->want = GZBUFSIZE;    /* requested buffer size */\r
1148 ; 108  :     state->msg = NULL;          /* no error message yet */\r
1149 ; 109  : \r
1150 ; 110  :     /* interpret mode */\r
1151 ; 111  :     state->mode = GZ_NONE;\r
1152 ; 112  :     state->level = Z_DEFAULT_COMPRESSION;\r
1153 ; 113  :     state->strategy = Z_DEFAULT_STRATEGY;\r
1154 ; 114  :     state->direct = 0;\r
1155 ; 115  :     while (*mode) {\r
1156 \r
1157   000c0 8a 43 01         mov     al, BYTE PTR [ebx+1]\r
1158 \r
1159 ; 149  :             default:        /* could consider as an error, but just ignore */\r
1160 ; 150  :                 ;\r
1161 ; 151  :             }\r
1162 ; 152  :         mode++;\r
1163 \r
1164   000c3 43               inc     ebx\r
1165   000c4 84 c0            test    al, al\r
1166   000c6 75 90            jne     SHORT $LL25@gz_open\r
1167 $LN24@gz_open:\r
1168 \r
1169 ; 153  :     }\r
1170 ; 154  : \r
1171 ; 155  :     /* must provide an "r", "w", or "a" */\r
1172 ; 156  :     if (state->mode == GZ_NONE) {\r
1173 \r
1174   000c8 8b 5e 10         mov     ebx, DWORD PTR [esi+16]\r
1175   000cb 3b df            cmp     ebx, edi\r
1176 \r
1177 ; 157  :         free(state);\r
1178 ; 158  :         return NULL;\r
1179 \r
1180   000cd 74 3e            je      SHORT $LN43@gz_open\r
1181 \r
1182 ; 159  :     }\r
1183 ; 160  : \r
1184 ; 161  :     /* can't force transparent read */\r
1185 ; 162  :     if (state->mode == GZ_READ) {\r
1186 \r
1187   000cf 81 fb 4f 1c 00\r
1188         00               cmp     ebx, 7247              ; 00001c4fH\r
1189   000d5 75 0c            jne     SHORT $LN7@gz_open\r
1190 \r
1191 ; 163  :         if (state->direct) {\r
1192 \r
1193   000d7 39 7e 2c         cmp     DWORD PTR [esi+44], edi\r
1194 \r
1195 ; 164  :             free(state);\r
1196 ; 165  :             return NULL;\r
1197 \r
1198   000da 75 31            jne     SHORT $LN43@gz_open\r
1199 \r
1200 ; 166  :         }\r
1201 ; 167  :         state->direct = 1;      /* for empty file */\r
1202 \r
1203   000dc c7 46 2c 01 00\r
1204         00 00            mov     DWORD PTR [esi+44], 1\r
1205 $LN7@gz_open:\r
1206 \r
1207 ; 168  :     }\r
1208 ; 169  : \r
1209 ; 170  :     /* save the path name for error messages */\r
1210 ; 171  :     state->path = malloc(strlen(path) + 1);\r
1211 \r
1212   000e3 8b 45 08         mov     eax, DWORD PTR _path$[ebp]\r
1213   000e6 8d 50 01         lea     edx, DWORD PTR [eax+1]\r
1214   000e9 8d a4 24 00 00\r
1215         00 00            npad    7\r
1216 $LL39@gz_open:\r
1217   000f0 8a 08            mov     cl, BYTE PTR [eax]\r
1218   000f2 40               inc     eax\r
1219   000f3 84 c9            test    cl, cl\r
1220   000f5 75 f9            jne     SHORT $LL39@gz_open\r
1221   000f7 2b c2            sub     eax, edx\r
1222   000f9 40               inc     eax\r
1223   000fa 50               push    eax\r
1224   000fb ff 15 00 00 00\r
1225         00               call    DWORD PTR __imp__malloc\r
1226   00101 8b f8            mov     edi, eax\r
1227   00103 83 c4 04         add     esp, 4\r
1228   00106 89 7e 18         mov     DWORD PTR [esi+24], edi\r
1229 \r
1230 ; 172  :     if (state->path == NULL) {\r
1231 \r
1232   00109 85 ff            test    edi, edi\r
1233   0010b 75 11            jne     SHORT $LN5@gz_open\r
1234 $LN43@gz_open:\r
1235 \r
1236 ; 173  :         free(state);\r
1237 \r
1238   0010d 56               push    esi\r
1239   0010e ff 15 00 00 00\r
1240         00               call    DWORD PTR __imp__free\r
1241   00114 83 c4 04         add     esp, 4\r
1242   00117 5e               pop     esi\r
1243   00118 5f               pop     edi\r
1244 \r
1245 ; 174  :         return NULL;\r
1246 \r
1247   00119 33 c0            xor     eax, eax\r
1248   0011b 5b               pop     ebx\r
1249 \r
1250 ; 213  : }\r
1251 \r
1252   0011c 5d               pop     ebp\r
1253   0011d c3               ret     0\r
1254 $LN5@gz_open:\r
1255 \r
1256 ; 175  :     }\r
1257 ; 176  :     strcpy(state->path, path);\r
1258 \r
1259   0011e 8b 4d 08         mov     ecx, DWORD PTR _path$[ebp]\r
1260   00121 8b d7            mov     edx, edi\r
1261 $LL30@gz_open:\r
1262   00123 8a 01            mov     al, BYTE PTR [ecx]\r
1263   00125 88 02            mov     BYTE PTR [edx], al\r
1264   00127 41               inc     ecx\r
1265   00128 42               inc     edx\r
1266   00129 84 c0            test    al, al\r
1267   0012b 75 f6            jne     SHORT $LL30@gz_open\r
1268 \r
1269 ; 177  : \r
1270 ; 178  :     /* open the file with the appropriate mode (or just use fd) */\r
1271 ; 179  :     state->fd = fd != -1 ? fd :\r
1272 ; 180  :         open(path,\r
1273 ; 181  : #ifdef O_LARGEFILE\r
1274 ; 182  :             O_LARGEFILE |\r
1275 ; 183  : #endif\r
1276 ; 184  : #ifdef O_BINARY\r
1277 ; 185  :             O_BINARY |\r
1278 ; 186  : #endif\r
1279 ; 187  :             (state->mode == GZ_READ ?\r
1280 ; 188  :                 O_RDONLY :\r
1281 ; 189  :                 (O_WRONLY | O_CREAT | (\r
1282 ; 190  :                     state->mode == GZ_WRITE ?\r
1283 ; 191  :                         O_TRUNC :\r
1284 ; 192  :                         O_APPEND))),\r
1285 ; 193  :             0666);\r
1286 \r
1287   0012d 8b 45 0c         mov     eax, DWORD PTR _fd$[ebp]\r
1288   00130 83 f8 ff         cmp     eax, -1\r
1289   00133 75 3c            jne     SHORT $LN34@gz_open\r
1290   00135 81 fb 4f 1c 00\r
1291         00               cmp     ebx, 7247              ; 00001c4fH\r
1292   0013b 75 04            jne     SHORT $LN31@gz_open\r
1293   0013d 33 c0            xor     eax, eax\r
1294   0013f eb 19            jmp     SHORT $LN32@gz_open\r
1295 $LN31@gz_open:\r
1296   00141 8d 83 4f 86 ff\r
1297         ff               lea     eax, DWORD PTR [ebx-31153]\r
1298   00147 f7 d8            neg     eax\r
1299   00149 1b c0            sbb     eax, eax\r
1300   0014b 25 08 fe ff ff   and     eax, -504              ; fffffe08H\r
1301   00150 05 00 02 00 00   add     eax, 512               ; 00000200H\r
1302   00155 0d 01 01 00 00   or      eax, 257               ; 00000101H\r
1303 $LN32@gz_open:\r
1304   0015a 8b 4d 08         mov     ecx, DWORD PTR _path$[ebp]\r
1305   0015d 68 b6 01 00 00   push    438                    ; 000001b6H\r
1306   00162 0d 00 80 00 00   or      eax, 32768             ; 00008000H\r
1307   00167 50               push    eax\r
1308   00168 51               push    ecx\r
1309   00169 e8 00 00 00 00   call    _open\r
1310   0016e 83 c4 0c         add     esp, 12                        ; 0000000cH\r
1311 $LN34@gz_open:\r
1312   00171 89 46 14         mov     DWORD PTR [esi+20], eax\r
1313 \r
1314 ; 194  :     if (state->fd == -1) {\r
1315 \r
1316   00174 83 f8 ff         cmp     eax, -1\r
1317   00177 75 16            jne     SHORT $LN4@gz_open\r
1318 \r
1319 ; 195  :         free(state->path);\r
1320 \r
1321   00179 57               push    edi\r
1322   0017a 8b 3d 00 00 00\r
1323         00               mov     edi, DWORD PTR __imp__free\r
1324   00180 ff d7            call    edi\r
1325 \r
1326 ; 196  :         free(state);\r
1327 \r
1328   00182 56               push    esi\r
1329   00183 ff d7            call    edi\r
1330   00185 83 c4 08         add     esp, 8\r
1331 $LN42@gz_open:\r
1332 \r
1333 ; 197  :         return NULL;\r
1334 \r
1335   00188 5e               pop     esi\r
1336   00189 5f               pop     edi\r
1337   0018a 33 c0            xor     eax, eax\r
1338   0018c 5b               pop     ebx\r
1339 \r
1340 ; 213  : }\r
1341 \r
1342   0018d 5d               pop     ebp\r
1343   0018e c3               ret     0\r
1344 $LN4@gz_open:\r
1345 \r
1346 ; 198  :     }\r
1347 ; 199  :     if (state->mode == GZ_APPEND)\r
1348 \r
1349   0018f 83 fb 01         cmp     ebx, 1\r
1350   00192 75 07            jne     SHORT $LN3@gz_open\r
1351 \r
1352 ; 200  :         state->mode = GZ_WRITE;         /* simplify later checks */\r
1353 \r
1354   00194 c7 46 10 b1 79\r
1355         00 00            mov     DWORD PTR [esi+16], 31153 ; 000079b1H\r
1356 $LN3@gz_open:\r
1357 \r
1358 ; 201  : \r
1359 ; 202  :     /* save the current position for rewinding (only if reading) */\r
1360 ; 203  :     if (state->mode == GZ_READ) {\r
1361 \r
1362   0019b 81 7e 10 4f 1c\r
1363         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
1364   001a2 75 26            jne     SHORT $LN1@gz_open\r
1365 \r
1366 ; 204  :         state->start = LSEEK(state->fd, 0, SEEK_CUR);\r
1367 \r
1368   001a4 6a 01            push    1\r
1369   001a6 33 ff            xor     edi, edi\r
1370   001a8 57               push    edi\r
1371   001a9 50               push    eax\r
1372   001aa ff 15 00 00 00\r
1373         00               call    DWORD PTR __imp___lseeki64\r
1374   001b0 99               cdq\r
1375   001b1 89 56 3c         mov     DWORD PTR [esi+60], edx\r
1376 \r
1377 ; 205  :         if (state->start == -1) state->start = 0;\r
1378 \r
1379   001b4 8b d0            mov     edx, eax\r
1380   001b6 23 56 3c         and     edx, DWORD PTR [esi+60]\r
1381   001b9 83 c4 0c         add     esp, 12                        ; 0000000cH\r
1382   001bc 89 46 38         mov     DWORD PTR [esi+56], eax\r
1383   001bf 83 fa ff         cmp     edx, -1\r
1384   001c2 75 06            jne     SHORT $LN1@gz_open\r
1385   001c4 89 7e 38         mov     DWORD PTR [esi+56], edi\r
1386   001c7 89 7e 3c         mov     DWORD PTR [esi+60], edi\r
1387 $LN1@gz_open:\r
1388 \r
1389 ; 206  :     }\r
1390 ; 207  : \r
1391 ; 208  :     /* initialize stream */\r
1392 ; 209  :     gz_reset(state);\r
1393 \r
1394   001ca e8 00 00 00 00   call    _gz_reset\r
1395 \r
1396 ; 210  : \r
1397 ; 211  :     /* return stream */\r
1398 ; 212  :     return (gzFile)state;\r
1399 \r
1400   001cf 8b c6            mov     eax, esi\r
1401   001d1 5e               pop     esi\r
1402   001d2 5f               pop     edi\r
1403   001d3 5b               pop     ebx\r
1404 \r
1405 ; 213  : }\r
1406 \r
1407   001d4 5d               pop     ebp\r
1408   001d5 c3               ret     0\r
1409   001d6 8b ff            npad    2\r
1410 $LN44@gz_open:\r
1411   001d8 00 00 00 00      DD      $LN43@gz_open\r
1412   001dc 00 00 00 00      DD      $LN11@gz_open\r
1413   001e0 00 00 00 00      DD      $LN12@gz_open\r
1414   001e4 00 00 00 00      DD      $LN10@gz_open\r
1415   001e8 00 00 00 00      DD      $LN17@gz_open\r
1416   001ec 00 00 00 00      DD      $LN14@gz_open\r
1417   001f0 00 00 00 00      DD      $LN13@gz_open\r
1418   001f4 00 00 00 00      DD      $LN19@gz_open\r
1419   001f8 00 00 00 00      DD      $LN18@gz_open\r
1420   001fc 00 00 00 00      DD      $LN40@gz_open\r
1421 $LN38@gz_open:\r
1422   00200 00               DB      0\r
1423   00201 09               DB      9\r
1424   00202 09               DB      9\r
1425   00203 09               DB      9\r
1426   00204 09               DB      9\r
1427   00205 09               DB      9\r
1428   00206 09               DB      9\r
1429   00207 09               DB      9\r
1430   00208 09               DB      9\r
1431   00209 09               DB      9\r
1432   0020a 09               DB      9\r
1433   0020b 09               DB      9\r
1434   0020c 09               DB      9\r
1435   0020d 09               DB      9\r
1436   0020e 09               DB      9\r
1437   0020f 09               DB      9\r
1438   00210 09               DB      9\r
1439   00211 09               DB      9\r
1440   00212 09               DB      9\r
1441   00213 09               DB      9\r
1442   00214 09               DB      9\r
1443   00215 09               DB      9\r
1444   00216 09               DB      9\r
1445   00217 09               DB      9\r
1446   00218 09               DB      9\r
1447   00219 09               DB      9\r
1448   0021a 09               DB      9\r
1449   0021b 01               DB      1\r
1450   0021c 09               DB      9\r
1451   0021d 09               DB      9\r
1452   0021e 09               DB      9\r
1453   0021f 09               DB      9\r
1454   00220 09               DB      9\r
1455   00221 09               DB      9\r
1456   00222 09               DB      9\r
1457   00223 09               DB      9\r
1458   00224 09               DB      9\r
1459   00225 09               DB      9\r
1460   00226 09               DB      9\r
1461   00227 02               DB      2\r
1462   00228 09               DB      9\r
1463   00229 03               DB      3\r
1464   0022a 09               DB      9\r
1465   0022b 09               DB      9\r
1466   0022c 09               DB      9\r
1467   0022d 09               DB      9\r
1468   0022e 09               DB      9\r
1469   0022f 09               DB      9\r
1470   00230 09               DB      9\r
1471   00231 09               DB      9\r
1472   00232 09               DB      9\r
1473   00233 09               DB      9\r
1474   00234 09               DB      9\r
1475   00235 09               DB      9\r
1476   00236 04               DB      4\r
1477   00237 09               DB      9\r
1478   00238 09               DB      9\r
1479   00239 09               DB      9\r
1480   0023a 09               DB      9\r
1481   0023b 05               DB      5\r
1482   0023c 09               DB      9\r
1483   0023d 06               DB      6\r
1484   0023e 09               DB      9\r
1485   0023f 09               DB      9\r
1486   00240 09               DB      9\r
1487   00241 09               DB      9\r
1488   00242 09               DB      9\r
1489   00243 09               DB      9\r
1490   00244 09               DB      9\r
1491   00245 09               DB      9\r
1492   00246 09               DB      9\r
1493   00247 07               DB      7\r
1494   00248 09               DB      9\r
1495   00249 09               DB      9\r
1496   0024a 09               DB      9\r
1497   0024b 09               DB      9\r
1498   0024c 08               DB      8\r
1499 _gz_open ENDP\r
1500 PUBLIC  _gzseek64@16\r
1501 ; Function compile flags: /Ogtp\r
1502 ;       COMDAT _gzseek64@16\r
1503 _TEXT   SEGMENT\r
1504 tv405 = 8                                               ; size = 8\r
1505 _offset$ = 8                                            ; size = 8\r
1506 _gzseek64@16 PROC                                       ; COMDAT\r
1507 ; _file$ = esi\r
1508 ; _whence$ = ecx\r
1509 \r
1510 ; 300  : {\r
1511 \r
1512   00000 55               push    ebp\r
1513   00001 8b ec            mov     ebp, esp\r
1514   00003 53               push    ebx\r
1515   00004 57               push    edi\r
1516 \r
1517 ; 301  :     unsigned n;\r
1518 ; 302  :     z_off64_t ret;\r
1519 ; 303  :     gz_statep state;\r
1520 ; 304  : \r
1521 ; 305  :     /* get internal structure and check integrity */\r
1522 ; 306  :     if (file == NULL)\r
1523 \r
1524   00005 85 f6            test    esi, esi\r
1525 \r
1526 ; 307  :         return -1;\r
1527 \r
1528   00007 74 28            je      SHORT $LN28@gzseek64\r
1529 \r
1530 ; 308  :     state = (gz_statep)file;\r
1531 ; 309  :     if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
1532 \r
1533   00009 8b 56 10         mov     edx, DWORD PTR [esi+16]\r
1534   0000c 81 fa 4f 1c 00\r
1535         00               cmp     edx, 7247              ; 00001c4fH\r
1536   00012 74 08            je      SHORT $LN14@gzseek64\r
1537   00014 81 fa b1 79 00\r
1538         00               cmp     edx, 31153             ; 000079b1H\r
1539 \r
1540 ; 310  :         return -1;\r
1541 \r
1542   0001a 75 15            jne     SHORT $LN28@gzseek64\r
1543 $LN14@gzseek64:\r
1544 \r
1545 ; 311  : \r
1546 ; 312  :     /* check that there's no error */\r
1547 ; 313  :     if (state->err != Z_OK && state->err != Z_BUF_ERROR)\r
1548 \r
1549   0001c 8b 46 5c         mov     eax, DWORD PTR [esi+92]\r
1550   0001f 85 c0            test    eax, eax\r
1551   00021 74 05            je      SHORT $LN13@gzseek64\r
1552   00023 83 f8 fb         cmp     eax, -5                        ; fffffffbH\r
1553 \r
1554 ; 314  :         return -1;\r
1555 \r
1556   00026 75 09            jne     SHORT $LN28@gzseek64\r
1557 $LN13@gzseek64:\r
1558 \r
1559 ; 315  : \r
1560 ; 316  :     /* can only seek from start or relative to current position */\r
1561 ; 317  :     if (whence != SEEK_SET && whence != SEEK_CUR)\r
1562 \r
1563   00028 85 c9            test    ecx, ecx\r
1564   0002a 74 10            je      SHORT $LN20@gzseek64\r
1565   0002c 83 f9 01         cmp     ecx, 1\r
1566   0002f 74 19            je      SHORT $LN11@gzseek64\r
1567 $LN28@gzseek64:\r
1568 \r
1569 ; 318  :         return -1;\r
1570 \r
1571   00031 83 c8 ff         or      eax, -1\r
1572   00034 0b d0            or      edx, eax\r
1573 \r
1574 ; 370  : }\r
1575 \r
1576   00036 5f               pop     edi\r
1577   00037 5b               pop     ebx\r
1578   00038 5d               pop     ebp\r
1579   00039 c2 08 00         ret     8\r
1580 $LN20@gzseek64:\r
1581 \r
1582 ; 319  : \r
1583 ; 320  :     /* normalize offset to a SEEK_CUR specification */\r
1584 ; 321  :     if (whence == SEEK_SET)\r
1585 ; 322  :         offset -= state->x.pos;\r
1586 \r
1587   0003c 8b 5d 08         mov     ebx, DWORD PTR _offset$[ebp]\r
1588   0003f 2b 5e 08         sub     ebx, DWORD PTR [esi+8]\r
1589   00042 8b 7d 0c         mov     edi, DWORD PTR _offset$[ebp+4]\r
1590   00045 1b 7e 0c         sbb     edi, DWORD PTR [esi+12]\r
1591   00048 eb 12            jmp     SHORT $LN9@gzseek64\r
1592 $LN11@gzseek64:\r
1593 \r
1594 ; 323  :     else if (state->seek)\r
1595 \r
1596   0004a 83 7e 58 00      cmp     DWORD PTR [esi+88], 0\r
1597 \r
1598 ; 324  :         offset += state->skip;\r
1599 \r
1600   0004e 8b 5d 08         mov     ebx, DWORD PTR _offset$[ebp]\r
1601   00051 8b 7d 0c         mov     edi, DWORD PTR _offset$[ebp+4]\r
1602   00054 74 06            je      SHORT $LN9@gzseek64\r
1603   00056 03 5e 50         add     ebx, DWORD PTR [esi+80]\r
1604   00059 13 7e 54         adc     edi, DWORD PTR [esi+84]\r
1605 $LN9@gzseek64:\r
1606 \r
1607 ; 325  :     state->seek = 0;\r
1608 \r
1609   0005c c7 46 58 00 00\r
1610         00 00            mov     DWORD PTR [esi+88], 0\r
1611 \r
1612 ; 326  : \r
1613 ; 327  :     /* if within raw area while reading, just go there */\r
1614 ; 328  :     if (state->mode == GZ_READ && state->how == COPY &&\r
1615 ; 329  :             state->x.pos + offset >= 0) {\r
1616 \r
1617   00063 81 fa 4f 1c 00\r
1618         00               cmp     edx, 7247              ; 00001c4fH\r
1619   00069 75 6c            jne     SHORT $LN8@gzseek64\r
1620   0006b 83 7e 30 01      cmp     DWORD PTR [esi+48], 1\r
1621   0006f 75 66            jne     SHORT $LN8@gzseek64\r
1622   00071 8b c3            mov     eax, ebx\r
1623   00073 03 46 08         add     eax, DWORD PTR [esi+8]\r
1624   00076 8b cf            mov     ecx, edi\r
1625   00078 13 4e 0c         adc     ecx, DWORD PTR [esi+12]\r
1626   0007b 89 4d 0c         mov     DWORD PTR tv405[ebp+4], ecx\r
1627   0007e 78 57            js      SHORT $LN8@gzseek64\r
1628   00080 7f 04            jg      SHORT $LN21@gzseek64\r
1629   00082 85 c0            test    eax, eax\r
1630   00084 72 51            jb      SHORT $LN8@gzseek64\r
1631 $LN21@gzseek64:\r
1632 \r
1633 ; 330  :         ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);\r
1634 ; 331  :         if (ret == -1)\r
1635 \r
1636   00086 33 c0            xor     eax, eax\r
1637   00088 8b cb            mov     ecx, ebx\r
1638   0008a 2b 0e            sub     ecx, DWORD PTR [esi]\r
1639   0008c 6a 01            push    1\r
1640   0008e 8b d7            mov     edx, edi\r
1641   00090 1b d0            sbb     edx, eax\r
1642   00092 8b 46 14         mov     eax, DWORD PTR [esi+20]\r
1643   00095 52               push    edx\r
1644   00096 51               push    ecx\r
1645   00097 50               push    eax\r
1646   00098 ff 15 00 00 00\r
1647         00               call    DWORD PTR __imp___lseeki64\r
1648   0009e 83 c4 10         add     esp, 16                        ; 00000010H\r
1649   000a1 83 f8 ff         cmp     eax, -1\r
1650 \r
1651 ; 332  :             return -1;\r
1652 \r
1653   000a4 74 8b            je      SHORT $LN28@gzseek64\r
1654 \r
1655 ; 333  :         state->x.have = 0;\r
1656 \r
1657   000a6 33 c0            xor     eax, eax\r
1658 \r
1659 ; 334  :         state->eof = 0;\r
1660 ; 335  :         state->past = 0;\r
1661 ; 336  :         state->seek = 0;\r
1662 ; 337  :         gz_error(state, Z_OK, NULL);\r
1663 \r
1664   000a8 50               push    eax\r
1665   000a9 8b ce            mov     ecx, esi\r
1666   000ab 89 06            mov     DWORD PTR [esi], eax\r
1667   000ad 89 46 40         mov     DWORD PTR [esi+64], eax\r
1668   000b0 89 46 44         mov     DWORD PTR [esi+68], eax\r
1669   000b3 89 46 58         mov     DWORD PTR [esi+88], eax\r
1670   000b6 e8 00 00 00 00   call    _gz_error\r
1671   000bb 83 c4 04         add     esp, 4\r
1672 \r
1673 ; 338  :         state->strm.avail_in = 0;\r
1674 ; 339  :         state->x.pos += offset;\r
1675 \r
1676   000be 01 5e 08         add     DWORD PTR [esi+8], ebx\r
1677 \r
1678 ; 340  :         return state->x.pos;\r
1679 \r
1680   000c1 8b 46 08         mov     eax, DWORD PTR [esi+8]\r
1681   000c4 c7 46 68 00 00\r
1682         00 00            mov     DWORD PTR [esi+104], 0\r
1683   000cb 11 7e 0c         adc     DWORD PTR [esi+12], edi\r
1684   000ce 8b 56 0c         mov     edx, DWORD PTR [esi+12]\r
1685 \r
1686 ; 370  : }\r
1687 \r
1688   000d1 5f               pop     edi\r
1689   000d2 5b               pop     ebx\r
1690   000d3 5d               pop     ebp\r
1691   000d4 c2 08 00         ret     8\r
1692 $LN8@gzseek64:\r
1693 \r
1694 ; 341  :     }\r
1695 ; 342  : \r
1696 ; 343  :     /* calculate skip amount, rewinding if needed for back seek when reading */\r
1697 ; 344  :     if (offset < 0) {\r
1698 \r
1699   000d7 85 ff            test    edi, edi\r
1700   000d9 7f 39            jg      SHORT $LN3@gzseek64\r
1701   000db 7c 04            jl      SHORT $LN22@gzseek64\r
1702   000dd 85 db            test    ebx, ebx\r
1703   000df 73 33            jae     SHORT $LN3@gzseek64\r
1704 $LN22@gzseek64:\r
1705 \r
1706 ; 345  :         if (state->mode != GZ_READ)         /* writing -- can't go backwards */\r
1707 \r
1708   000e1 81 fa 4f 1c 00\r
1709         00               cmp     edx, 7247              ; 00001c4fH\r
1710 \r
1711 ; 346  :             return -1;\r
1712 \r
1713   000e7 0f 85 44 ff ff\r
1714         ff               jne     $LN28@gzseek64\r
1715 \r
1716 ; 347  :         offset += state->x.pos;\r
1717 \r
1718   000ed 03 5e 08         add     ebx, DWORD PTR [esi+8]\r
1719   000f0 13 7e 0c         adc     edi, DWORD PTR [esi+12]\r
1720 \r
1721 ; 348  :         if (offset < 0)                     /* before start of file! */\r
1722 \r
1723   000f3 85 ff            test    edi, edi\r
1724   000f5 7f 0e            jg      SHORT $LN4@gzseek64\r
1725   000f7 0f 8c 34 ff ff\r
1726         ff               jl      $LN28@gzseek64\r
1727   000fd 85 db            test    ebx, ebx\r
1728 \r
1729 ; 349  :             return -1;\r
1730 \r
1731   000ff 0f 82 2c ff ff\r
1732         ff               jb      $LN28@gzseek64\r
1733 $LN4@gzseek64:\r
1734 \r
1735 ; 350  :         if (gzrewind(file) == -1)           /* rewind, then skip to offset */\r
1736 \r
1737   00105 56               push    esi\r
1738   00106 e8 00 00 00 00   call    _gzrewind@4\r
1739   0010b 83 f8 ff         cmp     eax, -1\r
1740 \r
1741 ; 351  :             return -1;\r
1742 \r
1743   0010e 0f 84 1d ff ff\r
1744         ff               je      $LN28@gzseek64\r
1745 $LN3@gzseek64:\r
1746 \r
1747 ; 352  :     }\r
1748 ; 353  : \r
1749 ; 354  :     /* if reading, skip what's in output buffer (one less gzgetc() check) */\r
1750 ; 355  :     if (state->mode == GZ_READ) {\r
1751 \r
1752   00114 81 7e 10 4f 1c\r
1753         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
1754   0011b 75 27            jne     SHORT $LN2@gzseek64\r
1755 \r
1756 ; 356  :         n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?\r
1757 ; 357  :             (unsigned)offset : state->x.have;\r
1758 \r
1759   0011d 8b 0e            mov     ecx, DWORD PTR [esi]\r
1760   0011f 33 c0            xor     eax, eax\r
1761   00121 3b c7            cmp     eax, edi\r
1762   00123 7f 0a            jg      SHORT $LN18@gzseek64\r
1763   00125 7c 04            jl      SHORT $LN24@gzseek64\r
1764   00127 3b cb            cmp     ecx, ebx\r
1765   00129 77 04            ja      SHORT $LN18@gzseek64\r
1766 $LN24@gzseek64:\r
1767   0012b 8b c1            mov     eax, ecx\r
1768   0012d eb 02            jmp     SHORT $LN19@gzseek64\r
1769 $LN18@gzseek64:\r
1770   0012f 8b c3            mov     eax, ebx\r
1771 $LN19@gzseek64:\r
1772 \r
1773 ; 358  :         state->x.have -= n;\r
1774 ; 359  :         state->x.next += n;\r
1775 \r
1776   00131 01 46 04         add     DWORD PTR [esi+4], eax\r
1777   00134 2b c8            sub     ecx, eax\r
1778   00136 89 0e            mov     DWORD PTR [esi], ecx\r
1779 \r
1780 ; 360  :         state->x.pos += n;\r
1781 \r
1782   00138 33 c9            xor     ecx, ecx\r
1783   0013a 01 46 08         add     DWORD PTR [esi+8], eax\r
1784   0013d 11 4e 0c         adc     DWORD PTR [esi+12], ecx\r
1785 \r
1786 ; 361  :         offset -= n;\r
1787 \r
1788   00140 2b d8            sub     ebx, eax\r
1789   00142 1b f9            sbb     edi, ecx\r
1790 $LN2@gzseek64:\r
1791 \r
1792 ; 362  :     }\r
1793 ; 363  : \r
1794 ; 364  :     /* request skip (if not zero) */\r
1795 ; 365  :     if (offset) {\r
1796 \r
1797   00144 8b c3            mov     eax, ebx\r
1798   00146 0b c7            or      eax, edi\r
1799   00148 74 0d            je      SHORT $LN1@gzseek64\r
1800 \r
1801 ; 366  :         state->seek = 1;\r
1802 \r
1803   0014a c7 46 58 01 00\r
1804         00 00            mov     DWORD PTR [esi+88], 1\r
1805 \r
1806 ; 367  :         state->skip = offset;\r
1807 \r
1808   00151 89 5e 50         mov     DWORD PTR [esi+80], ebx\r
1809   00154 89 7e 54         mov     DWORD PTR [esi+84], edi\r
1810 $LN1@gzseek64:\r
1811 \r
1812 ; 368  :     }\r
1813 ; 369  :     return state->x.pos + offset;\r
1814 \r
1815   00157 8b 46 08         mov     eax, DWORD PTR [esi+8]\r
1816   0015a 8b 56 0c         mov     edx, DWORD PTR [esi+12]\r
1817   0015d 03 c3            add     eax, ebx\r
1818   0015f 13 d7            adc     edx, edi\r
1819 \r
1820 ; 370  : }\r
1821 \r
1822   00161 5f               pop     edi\r
1823   00162 5b               pop     ebx\r
1824   00163 5d               pop     ebp\r
1825   00164 c2 08 00         ret     8\r
1826 _gzseek64@16 ENDP\r
1827 _TEXT   ENDS\r
1828 PUBLIC  _gzdopen@8\r
1829 ; Function compile flags: /Ogtp\r
1830 ;       COMDAT _gzdopen@8\r
1831 _TEXT   SEGMENT\r
1832 _fd$ = 8                                                ; size = 4\r
1833 _mode$ = 12                                             ; size = 4\r
1834 _gzdopen@8 PROC                                         ; COMDAT\r
1835 \r
1836 ; 235  : {\r
1837 \r
1838   00000 55               push    ebp\r
1839   00001 8b ec            mov     ebp, esp\r
1840   00003 56               push    esi\r
1841   00004 57               push    edi\r
1842 \r
1843 ; 236  :     char *path;         /* identifier for error messages */\r
1844 ; 237  :     gzFile gz;\r
1845 ; 238  : \r
1846 ; 239  :     if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL)\r
1847 \r
1848   00005 8b 7d 08         mov     edi, DWORD PTR _fd$[ebp]\r
1849   00008 83 ff ff         cmp     edi, -1\r
1850   0000b 74 3c            je      SHORT $LN1@gzdopen\r
1851   0000d 6a 13            push    19                     ; 00000013H\r
1852   0000f ff 15 00 00 00\r
1853         00               call    DWORD PTR __imp__malloc\r
1854   00015 8b f0            mov     esi, eax\r
1855   00017 83 c4 04         add     esp, 4\r
1856   0001a 85 f6            test    esi, esi\r
1857   0001c 74 2b            je      SHORT $LN1@gzdopen\r
1858 \r
1859 ; 241  :     sprintf(path, "<fd:%d>", fd);   /* for debugging */\r
1860 \r
1861   0001e 57               push    edi\r
1862   0001f 68 00 00 00 00   push    OFFSET ??_C@_07EBNKNFJN@?$DMfd?3?$CFd?$DO?$AA@\r
1863   00024 56               push    esi\r
1864   00025 ff 15 00 00 00\r
1865         00               call    DWORD PTR __imp__sprintf\r
1866 \r
1867 ; 242  :     gz = gz_open(path, fd, mode);\r
1868 \r
1869   0002b 8b 45 0c         mov     eax, DWORD PTR _mode$[ebp]\r
1870   0002e 57               push    edi\r
1871   0002f 56               push    esi\r
1872   00030 e8 00 00 00 00   call    _gz_open\r
1873 \r
1874 ; 243  :     free(path);\r
1875 \r
1876   00035 56               push    esi\r
1877   00036 8b f8            mov     edi, eax\r
1878   00038 ff 15 00 00 00\r
1879         00               call    DWORD PTR __imp__free\r
1880   0003e 83 c4 18         add     esp, 24                        ; 00000018H\r
1881 \r
1882 ; 244  :     return gz;\r
1883 \r
1884   00041 8b c7            mov     eax, edi\r
1885   00043 5f               pop     edi\r
1886   00044 5e               pop     esi\r
1887 \r
1888 ; 245  : }\r
1889 \r
1890   00045 5d               pop     ebp\r
1891   00046 c2 08 00         ret     8\r
1892 $LN1@gzdopen:\r
1893   00049 5f               pop     edi\r
1894 \r
1895 ; 240  :         return NULL;\r
1896 \r
1897   0004a 33 c0            xor     eax, eax\r
1898   0004c 5e               pop     esi\r
1899 \r
1900 ; 245  : }\r
1901 \r
1902   0004d 5d               pop     ebp\r
1903   0004e c2 08 00         ret     8\r
1904 _gzdopen@8 ENDP\r
1905 _TEXT   ENDS\r
1906 PUBLIC  _gzopen@8\r
1907 ; Function compile flags: /Ogtp\r
1908 ;       COMDAT _gzopen@8\r
1909 _TEXT   SEGMENT\r
1910 _path$ = 8                                              ; size = 4\r
1911 _mode$ = 12                                             ; size = 4\r
1912 _gzopen@8 PROC                                          ; COMDAT\r
1913 \r
1914 ; 219  : {\r
1915 \r
1916   00000 55               push    ebp\r
1917   00001 8b ec            mov     ebp, esp\r
1918 \r
1919 ; 220  :     return gz_open(path, -1, mode);\r
1920 \r
1921   00003 8b 45 08         mov     eax, DWORD PTR _path$[ebp]\r
1922   00006 6a ff            push    -1\r
1923   00008 50               push    eax\r
1924   00009 8b 45 0c         mov     eax, DWORD PTR _mode$[ebp]\r
1925   0000c e8 00 00 00 00   call    _gz_open\r
1926   00011 83 c4 08         add     esp, 8\r
1927 \r
1928 ; 221  : }\r
1929 \r
1930   00014 5d               pop     ebp\r
1931   00015 c2 08 00         ret     8\r
1932 _gzopen@8 ENDP\r
1933 PUBLIC  _gzseek@12\r
1934 ; Function compile flags: /Ogtp\r
1935 ;       COMDAT _gzseek@12\r
1936 _TEXT   SEGMENT\r
1937 _file$ = 8                                              ; size = 4\r
1938 _offset$ = 12                                           ; size = 4\r
1939 _whence$ = 16                                           ; size = 4\r
1940 _gzseek@12 PROC                                         ; COMDAT\r
1941 \r
1942 ; 377  : {\r
1943 \r
1944   00000 55               push    ebp\r
1945   00001 8b ec            mov     ebp, esp\r
1946   00003 83 e4 f8         and     esp, -8                        ; fffffff8H\r
1947   00006 51               push    ecx\r
1948 \r
1949 ; 378  :     z_off64_t ret;\r
1950 ; 379  : \r
1951 ; 380  :     ret = gzseek64(file, (z_off64_t)offset, whence);\r
1952 \r
1953   00007 8b 45 0c         mov     eax, DWORD PTR _offset$[ebp]\r
1954   0000a 8b 4d 10         mov     ecx, DWORD PTR _whence$[ebp]\r
1955   0000d 56               push    esi\r
1956   0000e 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
1957   00011 99               cdq\r
1958   00012 52               push    edx\r
1959   00013 50               push    eax\r
1960   00014 e8 00 00 00 00   call    _gzseek64@16\r
1961   00019 8b c8            mov     ecx, eax\r
1962   0001b 8b f2            mov     esi, edx\r
1963 \r
1964 ; 381  :     return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
1965 \r
1966   0001d 99               cdq\r
1967   0001e 3b c8            cmp     ecx, eax\r
1968   00020 75 0d            jne     SHORT $LN3@gzseek\r
1969   00022 3b f2            cmp     esi, edx\r
1970   00024 75 09            jne     SHORT $LN3@gzseek\r
1971   00026 8b c1            mov     eax, ecx\r
1972 \r
1973 ; 382  : }\r
1974 \r
1975   00028 5e               pop     esi\r
1976   00029 8b e5            mov     esp, ebp\r
1977   0002b 5d               pop     ebp\r
1978   0002c c2 0c 00         ret     12                     ; 0000000cH\r
1979 $LN3@gzseek:\r
1980 \r
1981 ; 381  :     return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
1982 \r
1983   0002f 83 c8 ff         or      eax, -1\r
1984 \r
1985 ; 382  : }\r
1986 \r
1987   00032 5e               pop     esi\r
1988   00033 8b e5            mov     esp, ebp\r
1989   00035 5d               pop     ebp\r
1990   00036 c2 0c 00         ret     12                     ; 0000000cH\r
1991 _gzseek@12 ENDP\r
1992 END\r