📄 inflate.cod
字号:
000af 5e pop esi
000b0 5f pop edi
000b1 5d pop ebp
000b2 b8 fd ff ff ff mov eax, -3 ; fffffffdH
000b7 5b pop ebx
; 1303 : }
000b8 c2 04 00 ret 4
$LN1@inflateSyn@2:
; 1298 : in = strm->total_in; out = strm->total_out;
000bb 8b 7d 14 mov edi, DWORD PTR [ebp+20]
; 1299 : inflateReset(strm);
000be 55 push ebp
000bf e8 00 00 00 00 call _inflateReset@4
; 1300 : strm->total_in = in; strm->total_out = out;
000c4 89 75 08 mov DWORD PTR [ebp+8], esi
000c7 5e pop esi
000c8 89 7d 14 mov DWORD PTR [ebp+20], edi
000cb 5f pop edi
000cc 5d pop ebp
; 1301 : state->mode = TYPE;
000cd c7 03 0b 00 00
00 mov DWORD PTR [ebx], 11 ; 0000000bH
; 1302 : return Z_OK;
000d3 33 c0 xor eax, eax
000d5 5b pop ebx
; 1303 : }
000d6 c2 04 00 ret 4
$LN6@inflateSyn@2:
000d9 5d pop ebp
; 1265 : unsigned len; /* number of bytes to look at or looked at */
; 1266 : unsigned long in, out; /* temporary to save total_in and total_out */
; 1267 : unsigned char buf[4]; /* to restore bit buffer to byte string */
; 1268 : struct inflate_state FAR *state;
; 1269 :
; 1270 : /* check parameters */
; 1271 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
000da b8 fe ff ff ff mov eax, -2 ; fffffffeH
000df 5b pop ebx
; 1303 : }
000e0 c2 04 00 ret 4
_inflateSync@4 ENDP
_TEXT ENDS
PUBLIC _inflateSetDictionary@12
; Function compile flags: /Ogtpy
; COMDAT _inflateSetDictionary@12
_TEXT SEGMENT
_strm$ = 8 ; size = 4
_dictionary$ = 12 ; size = 4
_dictLength$ = 16 ; size = 4
_inflateSetDictionary@12 PROC ; COMDAT
; 1173 : {
00000 53 push ebx
; 1174 : struct inflate_state FAR *state;
; 1175 : unsigned long id;
; 1176 :
; 1177 : /* check state */
; 1178 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
00001 8b 5c 24 08 mov ebx, DWORD PTR _strm$[esp]
00005 85 db test ebx, ebx
00007 56 push esi
00008 0f 84 c7 00 00
00 je $LN7@inflateSet
0000e 8b 73 1c mov esi, DWORD PTR [ebx+28]
00011 85 f6 test esi, esi
00013 0f 84 bc 00 00
00 je $LN7@inflateSet
; 1179 : state = (struct inflate_state FAR *)strm->state;
; 1180 : if (state->wrap != 0 && state->mode != DICT)
00019 83 7e 08 00 cmp DWORD PTR [esi+8], 0
0001d 55 push ebp
0001e 8b 6c 24 14 mov ebp, DWORD PTR _dictionary$[esp+8]
00022 57 push edi
00023 8b 7c 24 1c mov edi, DWORD PTR _dictLength$[esp+12]
00027 74 11 je SHORT $LN6@inflateSet
00029 83 3e 0a cmp DWORD PTR [esi], 10 ; 0000000aH
0002c 74 11 je SHORT $LN11@inflateSet
0002e 5f pop edi
0002f 5d pop ebp
00030 5e pop esi
; 1181 : return Z_STREAM_ERROR;
00031 b8 fe ff ff ff mov eax, -2 ; fffffffeH
00036 5b pop ebx
; 1209 : }
00037 c2 0c 00 ret 12 ; 0000000cH
$LN6@inflateSet:
; 1182 :
; 1183 : /* check for correct dictionary id */
; 1184 : if (state->mode == DICT) {
0003a 83 3e 0a cmp DWORD PTR [esi], 10 ; 0000000aH
0003d 75 24 jne SHORT $LN4@inflateSet
$LN11@inflateSet:
; 1185 : id = adler32(0L, Z_NULL, 0);
; 1186 : id = adler32(id, dictionary, dictLength);
0003f 57 push edi
00040 55 push ebp
00041 6a 00 push 0
00043 6a 00 push 0
00045 6a 00 push 0
00047 e8 00 00 00 00 call _adler32@12
0004c 50 push eax
0004d e8 00 00 00 00 call _adler32@12
; 1187 : if (id != state->check)
00052 3b 46 18 cmp eax, DWORD PTR [esi+24]
00055 74 0c je SHORT $LN4@inflateSet
00057 5f pop edi
00058 5d pop ebp
00059 5e pop esi
; 1188 : return Z_DATA_ERROR;
0005a b8 fd ff ff ff mov eax, -3 ; fffffffdH
0005f 5b pop ebx
; 1209 : }
00060 c2 0c 00 ret 12 ; 0000000cH
$LN4@inflateSet:
; 1189 : }
; 1190 :
; 1191 : /* copy dictionary to window */
; 1192 : if (updatewindow(strm, strm->avail_out)) {
00063 8b 43 10 mov eax, DWORD PTR [ebx+16]
00066 e8 00 00 00 00 call _updatewindow
0006b 85 c0 test eax, eax
0006d 74 12 je SHORT $LN3@inflateSet
0006f 5f pop edi
00070 5d pop ebp
; 1193 : state->mode = MEM;
00071 c7 06 1c 00 00
00 mov DWORD PTR [esi], 28 ; 0000001cH
00077 5e pop esi
; 1194 : return Z_MEM_ERROR;
00078 b8 fc ff ff ff mov eax, -4 ; fffffffcH
0007d 5b pop ebx
; 1209 : }
0007e c2 0c 00 ret 12 ; 0000000cH
$LN3@inflateSet:
; 1195 : }
; 1196 : if (dictLength > state->wsize) {
00081 8b 46 28 mov eax, DWORD PTR [esi+40]
00084 3b f8 cmp edi, eax
00086 76 28 jbe SHORT $LN2@inflateSet
; 1197 : zmemcpy(state->window, dictionary + dictLength - state->wsize,
; 1198 : state->wsize);
00088 2b e8 sub ebp, eax
0008a 50 push eax
0008b 8b 46 34 mov eax, DWORD PTR [esi+52]
0008e 03 ef add ebp, edi
00090 55 push ebp
00091 50 push eax
00092 e8 00 00 00 00 call _memcpy
; 1199 : state->whave = state->wsize;
00097 8b 4e 28 mov ecx, DWORD PTR [esi+40]
; 1200 : }
; 1201 : else {
; 1202 : zmemcpy(state->window + state->wsize - dictLength, dictionary,
; 1203 : dictLength);
0009a 83 c4 0c add esp, 12 ; 0000000cH
0009d 5f pop edi
0009e 5d pop ebp
0009f 89 4e 2c mov DWORD PTR [esi+44], ecx
; 1205 : }
; 1206 : state->havedict = 1;
000a2 c7 46 0c 01 00
00 00 mov DWORD PTR [esi+12], 1
000a9 5e pop esi
; 1207 : Tracev((stderr, "inflate: dictionary set\n"));
; 1208 : return Z_OK;
000aa 33 c0 xor eax, eax
000ac 5b pop ebx
; 1209 : }
000ad c2 0c 00 ret 12 ; 0000000cH
$LN2@inflateSet:
; 1200 : }
; 1201 : else {
; 1202 : zmemcpy(state->window + state->wsize - dictLength, dictionary,
; 1203 : dictLength);
000b0 8b 56 34 mov edx, DWORD PTR [esi+52]
000b3 57 push edi
000b4 2b d7 sub edx, edi
000b6 03 d0 add edx, eax
000b8 55 push ebp
000b9 52 push edx
000ba e8 00 00 00 00 call _memcpy
000bf 83 c4 0c add esp, 12 ; 0000000cH
; 1204 : state->whave = dictLength;
000c2 89 7e 2c mov DWORD PTR [esi+44], edi
000c5 5f pop edi
000c6 5d pop ebp
; 1205 : }
; 1206 : state->havedict = 1;
000c7 c7 46 0c 01 00
00 00 mov DWORD PTR [esi+12], 1
000ce 5e pop esi
; 1207 : Tracev((stderr, "inflate: dictionary set\n"));
; 1208 : return Z_OK;
000cf 33 c0 xor eax, eax
000d1 5b pop ebx
; 1209 : }
000d2 c2 0c 00 ret 12 ; 0000000cH
$LN7@inflateSet:
000d5 5e pop esi
; 1174 : struct inflate_state FAR *state;
; 1175 : unsigned long id;
; 1176 :
; 1177 : /* check state */
; 1178 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
000d6 b8 fe ff ff ff mov eax, -2 ; fffffffeH
000db 5b pop ebx
; 1209 : }
000dc c2 0c 00 ret 12 ; 0000000cH
_inflateSetDictionary@12 ENDP
_TEXT ENDS
PUBLIC _inflate@8
; Function compile flags: /Ogtpy
; COMDAT _inflate@8
_TEXT SEGMENT
_have$ = -44 ; size = 4
_this$ = -40 ; size = 4
_copy$ = -40 ; size = 4
_last$ = -36 ; size = 4
_hold$ = -36 ; size = 4
_left$ = -32 ; size = 4
_hbuf$ = -28 ; size = 4
tv2314 = -24 ; size = 4
tv2240 = -24 ; size = 4
tv2228 = -24 ; size = 4
tv2224 = -24 ; size = 4
tv2223 = -24 ; size = 4
_from$ = -24 ; size = 4
_len$ = -24 ; size = 4
_put$ = -20 ; size = 4
_out$ = -16 ; size = 4
_ret$ = -12 ; size = 4
tv2230 = -8 ; size = 4
tv2226 = -8 ; size = 4
tv2222 = -8 ; size = 4
tv2108 = -8 ; size = 4
tv2092 = -8 ; size = 4
tv2069 = -8 ; size = 4
tv2066 = -8 ; size = 4
_in$ = -4 ; size = 4
_strm$ = 8 ; size = 4
_flush$ = 12 ; size = 4
_inflate@8 PROC ; COMDAT
; 558 : struct inflate_state FAR *state;
; 559 : unsigned char FAR *next; /* next input */
; 560 : unsigned char FAR *put; /* next output */
; 561 : unsigned have, left; /* available input and output */
; 562 : unsigned long hold; /* bit buffer */
; 563 : unsigned bits; /* bits in bit buffer */
; 564 : unsigned in, out; /* save starting available input and output */
; 565 : unsigned copy; /* number of stored or match bytes to copy */
; 566 : unsigned char FAR *from; /* where to copy match bytes from */
; 567 : code this; /* current decoding table entry */
; 568 : code last; /* parent table entry */
; 569 : unsigned len; /* length to copy for repeats, bits to drop */
; 570 : int ret; /* return code */
; 571 : #ifdef GUNZIP
; 572 : unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
; 573 : #endif
; 574 : static const unsigned short order[19] = /* permutation of code lengths */
; 575 : {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
; 576 :
; 577 : if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
; 578 : (strm->next_in == Z_NULL && strm->avail_in != 0))
00000 8b 44 24 04 mov eax, DWORD PTR _strm$[esp-4]
00004 83 ec 2c sub esp, 44 ; 0000002cH
00007 85 c0 test eax, eax
00009 57 push edi
0000a 0f 84 3f 15 00
00 je $LN492@inflate
00010 8b 78 1c mov edi, DWORD PTR [eax+28]
00013 85 ff test edi, edi
00015 0f 84 34 15 00
00 je $LN492@inflate
0001b 83 78 0c 00 cmp DWORD PTR [eax+12], 0
0001f 0f 84 2a 15 00
00 je $LN492@inflate
00025 83 38 00 cmp DWORD PTR [eax], 0
00028 75 0a jne SHORT $LN493@inflate
0002a 83 78 04 00 cmp DWORD PTR [eax+4], 0
0002e 0f 85 1b 15 00
00 jne $LN492@inflate
$LN493@inflate:
; 580 :
; 581 : state = (struct inflate_state FAR *)strm->state;
; 582 : if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
00034 83 3f 0b cmp DWORD PTR [edi], 11 ; 0000000bH
00037 75 06 jne SHORT $LN490@inflate
00039 c7 07 0c 00 00
00 mov DWORD PTR [edi], 12 ; 0000000cH
$LN490@inflate:
; 583 : LOAD();
0003f 8b 48 0c mov ecx, DWORD PTR [eax+12]
00042 8b 50 04 mov edx, DWORD PTR [eax+4]
00045 53 push ebx
00046 8b 5f 38 mov ebx, DWORD PTR [edi+56]
00049 55 push ebp
0004a 8b 28 mov ebp, DWORD PTR [eax]
0004c 89 4c 24 24 mov DWORD PTR _put$[esp+56], ecx
00050 8b 48 10 mov ecx, DWORD PTR [eax+16]
; 584 : in = have;
; 585 : out = left;
; 586 : ret = Z_OK;
; 587 : for (;;)
; 588 : switch (state->mode) {
00053 8b 07 mov eax, DWORD PTR [edi]
00055 83 f8 1c cmp eax, 28 ; 0000001cH
00058 56 push esi
00059 8b 77 3c mov esi, DWORD PTR [edi+60]
0005c 89 4c 24 1c mov DWORD PTR _left$[esp+60], ecx
00060 89 54 24 10 mov DWORD PTR _have$[esp+60], edx
00064 89 5c 24 18 mov DWORD PTR _hold$[esp+60], ebx
00068 89 54 24 38 mov DWORD PTR _in$[esp+60], edx
0006c 89 4c 24 2c mov DWORD PTR _out$[esp+60], ecx
00070 c7 44 24 30 00
00 00 00 mov DWORD PTR _ret$[esp+60], 0
00078 0f 87 77 13 00
00 ja $LN11@inflate
0007e 8b ff npad 2
$LL487@inflate:
00080 ff 24 85 00 00
00 00 jmp DWORD PTR $LN785@inflate[eax*4]
$LN483@inflate:
; 589 : case HEAD:
; 590 : if (state->wrap == 0) {
00087 83 7f 08 00 cmp DWORD PTR [edi+8], 0
0008b 75 0b jne SHORT $LN481@inflate
; 591 : state->mode = TYPEDO;
0008d c7 07 0c 00 00
00 mov DWORD PTR [edi], 12 ; 0000000cH
; 592 : break;
00093 e9 52 13 00 00 jmp $LN725@inflate
$LN481@inflate:
; 593 : }
; 594 : NEEDBITS(16);
00098 83 fe 10 cmp esi, 16 ; 00000010H
0009b 73 2b jae SHORT $LN480@inflate
0009d 8d 49 00 npad 3
$LL478@inflate:
000a0 85 d2 test edx, edx
000a2 0f 84 a4 13 00
00 je $inf_leave$78536
000a8 0f b6 45 00 movzx eax, BYTE PTR [ebp]
000ac 8b ce mov ecx, esi
000ae d3 e0 shl eax, cl
000b0 83 ea 01 sub edx, 1
000b3 83 c6 08 add esi, 8
000b6 83 c5 01 add ebp, 1
000b9 03 d8 add ebx, eax
000bb 83 fe 10 cmp esi, 16 ; 00000010H
000be 89 54 24 10 mov DWORD PTR _have$[esp+60], edx
000c2 89 5c 24 18 mov DWORD PTR _hold$[esp+60], ebx
000c6 72 d8 jb SHORT $LL478@inflate
$LN480@inflate:
; 595 : #ifdef GUNZIP
; 596 : if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
000c8 f6 47 08 02 test BYTE PTR [edi+8], 2
000cc 74 47 je SHORT $LN472@inflate
000ce 81 fb 1f 8b 00
00 cmp ebx, 35615 ; 00008b1fH
000d4 75 3f jne SHORT $LN472@inflate
; 597 : state->check = crc32(0L, Z_NULL, 0);
000d6 6a 00 push 0
000d8 6a 00 push 0
000da 6a 00 push 0
000dc e8 00 00 00 00 call _crc32@12
; 598 : CRC2(state->check, hold);
000e1 6a 02 push 2
000e3 8d 4c 24 24 lea ecx, DWORD PTR _hbuf$[esp+64]
000e7 51 push ecx
000e8 50 push eax
000e9 89 47 18 mov DWORD PTR [edi+24], eax
000ec c6 44 24 2c 1f mov BYTE PTR _hbuf$[esp+72], 31 ; 0000001fH
000f1 c6 44 24 2d 8b mov BYTE PTR _hbuf$[esp+73], 139 ; 0000008bH
000f6 e8 00 00 00 00 call _crc32@12
; 599 : INITBITS();
; 600 : state->mode = FLAGS;
; 601 : break;
000fb 8b 54 24 10 mov edx, DWORD PTR _have$[esp+60]
000ff 33 db xor ebx, ebx
00101 89 47 18 mov DWORD PTR [edi+24], eax
00104 89 5c 24 18 mov DWORD PTR _hold$[esp+60], ebx
00108 33 f6 xor esi, esi
0010a c7 07 01 00 00
00 mov DWORD PTR [edi], 1
00110 e9 d5 12 00 00 jmp $LN725@inflate
$LN472@inflate:
; 602 : }
; 603 : state->flags = 0; /* expect zlib header */
; 604 : if (state->head != Z_NULL)
00115 8b 47 20 mov eax, DWORD PTR [edi+32]
00118 85 c0 test eax, eax
0011a c7 47 10 00 00
00 00 mov DWORD PTR [edi+16], 0
00121 74 07 je SHORT $LN465@inflate
; 605 : state->head->done = -1;
00123 c7 40 30 ff ff
ff ff mov DWORD PTR [eax+48], -1
$LN465@inflate:
; 606 : if (!(state->wrap & 1) || /* check if zlib header allowed */
; 607 : #else
; 608 : if (
; 609 : #endif
; 610 : ((BITS(8) << 8) + (hold >> 8)) % 31) {
0012a f6 47 08 01 test BYTE PTR [edi+8], 1
0012e 0f 84 a4 00 00
00 je $LN463@inflate
00134 0f b6 c3 movzx eax, bl
00137 c1 e0 08 shl eax, 8
0013a 8b d3 mov edx, ebx
0013c c1 ea 08 shr edx, 8
0013f 03 c2 add eax, edx
00141 33 d2 xor edx, edx
00143 b9 1f 00 00 00 mov ecx, 31 ; 0000001fH
00148 f7 f1 div ecx
0014a 85 d2 test edx, edx
0014c 0f 85 86 00 00
00 jne $LN463@inflate
; 614 : }
; 615 : if (BITS(4) != Z_DEFLATED) {
00152 8b d3 mov edx, ebx
00154 80 e2 0f and dl, 15 ; 0000000fH
00157 80 fa 08 cmp dl, 8
0015a 74 14 je SHORT $LN461@inflate
; 616 : strm->msg = (char *)"unknown compression method";
0015c 8b 44 24 40 mov eax, DWORD PTR _strm$[esp+56]
; 617 : state->mode = BAD;
; 618 : break;
00160 8b 54 24 10 mov edx, DWORD PTR _have$[esp+60]
00164 c7 40 18 00 00
00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BL@IHKGDAEE@unknown?5compression?5method?$AA@
0016b e9 74 12 00 00 jmp $LN780@inflate
$LN461@inflate:
; 619 : }
; 620 : DROPBITS(4);
00170 c1 eb 04 shr ebx, 4
; 621 : len = BITS(4) + 8;
00173 8b cb mov ecx, ebx
00175 83 e1 0f and ecx, 15 ; 0000000fH
00178 83 c1 08 add ecx, 8
0017b 83 ee 04 sub esi, 4
; 622 : if (len > state->wbits) {
0017e 3b 4f 24 cmp ecx, DWORD PTR [edi+36]
00181 89 5c 24 18 mov DWORD PTR _hold$[esp+60], ebx
00185 76 14 jbe SHORT $LN458@inflate
; 623 : strm->msg = (char *)"invalid window size";
00187 8b 4c 24 40 mov ecx, DWORD PTR _strm$[esp+56]
; 624 : state->mode = BAD;
; 625 : break;
0018b 8b 54 24 10 mov edx, DWORD PTR _have$[esp+60]
0018f c7 41 18 00 00
00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BE@EMOGCLGO@invalid?5window?5size?$AA@
00196 e9 49 12 00 00 jmp $LN780@inflate
$LN458@inflate:
; 626 : }
; 627 : state->dmax = 1U << len;
0019b ba 01 00 00 00 mov edx, 1
; 628 : Tracev((stderr, "inflate: zlib header ok\n"));
; 629 : strm->adler = state->check = adler32(0L, Z_NULL, 0);
001a0 6a 00 push 0
001a2 d3 e2 shl edx, cl
001a4 6a 00 push 0
001a6 6a 00 push 0
001a8 89 57 14 mov DWORD PTR [edi+20], edx
001ab e8 00 00 00 00 call _adler32@12
001b0 8b 4c 24 40 mov ecx, DWORD PTR _strm$[esp+56]
; 630 : state->mode = hold & 0x200 ? DICTID : TYPE;
; 631 : INITBITS();
; 632 : break;
001b4 8b 54 24 10 mov edx, DWORD PTR _have$[esp+60]
001b8 c1 eb 08 shr ebx, 8
001bb f7 d3 not ebx
001bd 83 e3 02 and ebx, 2
001c0 83 cb 09 or ebx, 9
001c3 89 47 18 mov DWORD PTR [edi+24], eax
001c6 89 41 30 mov DWORD PTR [ecx+48], eax
001c9 89 1f mov DWORD PTR [edi], ebx
001cb 33 db xor ebx, ebx
001cd 89 5c 24 18 mov DWORD PTR _hold$[esp+60], ebx
001d1 33 f6 xor esi, esi
001d3 e9 12 12 00 00 jmp $LN725@inflate
$LN463@inflate:
; 611 : strm->msg = (char *)"incorrect header check";
001d8 8b 54 24 40 mov edx, DWORD PTR _strm$[esp+56]
001dc c7 42 18 00 00
00 00 mov DWORD PTR [edx+24], OFFSET ??_C@_0BH@LIBMMIGA@incorrect?5header?5check?$AA@
; 612 : state->mode = BAD;
; 613 : break;
001e3 8b 54 24 10 mov edx, DWORD PTR _have$[esp+60]
001e7 e9 f8 11 00 00 jmp $LN780@inflate
$LN453@inflate:
; 633 : #ifdef GUNZIP
; 634 : case FLAGS:
; 635 : NEEDBITS(16);
001ec 83 fe 10 cmp esi, 16 ; 00000010H
001ef 73 28 jae SHORT $LN452@inflate
$LL450@inflate:
001f1 85 d2 test edx, edx
001f3 0f 84 53 12 00
00 je $inf_leave$78536
001f9 0f b6 45 00 movzx eax, BYTE PTR [ebp]
001fd 8b ce mov ecx, esi
001ff d3 e0 shl eax, cl
00201 83 ea 01 sub edx, 1
00204 83 c6 08 add esi, 8
00207 83 c5 01 add ebp, 1
0020a 03 d8 add ebx, eax
0020c 83 fe 10 cmp esi, 16 ; 00000010H
0020f 89 54 24 10 mov DWORD PTR _have$[esp+60], edx
00213 89 5c 24 18 mov DWORD PTR _hold$[esp+60], ebx
00217 72 d8 jb SHORT $LL450@inflate
$LN452@inflate:
; 636 : state->flags = (int)(hold);
; 637 : if ((state->flags & 0xff) != Z_DEFLATED) {
00219 80 fb 08 cmp bl, 8
0021c 89 5f 10 mov DWORD PTR [edi+16], ebx
0021f 74 10 je SHORT $LN444@inflate
; 638 : strm->msg = (char *)"unknown compression method";
00221 8b 4c 24 40 mov ecx, DWORD PTR _strm$[esp+56]
00225 c7 41 18 00 00
00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BL@IHKGDAEE@unknown?5compression?5method?$AA@
; 639 : state->mode = BAD;
; 640 : break;
0022c e9 b3 11 00 00 jmp $LN780@inflate
$LN444@inflate:
; 641 : }
; 642 : if (state->flags & 0xe000) {
00231 f7 c3 00 e0 00
00 test ebx, 57344 ; 0000e000H
00237 74 10 je SHORT $LN443@inflate
; 643 : strm->msg = (char *)"unknown header flags set";
00239 8b⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -