?? trees.cod
字號:
0008b 83 c0 02 add eax, 2
0008e 83 f8 20 cmp eax, 32 ; 00000020H
00091 0f 94 c1 sete cl
00094 89 4a 2c mov DWORD PTR [edx+44], ecx
; 1139 : }
00097 c3 ret 0
$LN20@set_data_t:
; 1137 : break;
; 1138 : s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;
00098 8b 12 mov edx, DWORD PTR [edx]
0009a 33 c9 xor ecx, ecx
0009c 83 c0 03 add eax, 3
0009f 83 f8 20 cmp eax, 32 ; 00000020H
000a2 0f 94 c1 sete cl
000a5 89 4a 2c mov DWORD PTR [edx+44], ecx
; 1139 : }
000a8 c3 ret 0
$LN21@set_data_t:
; 1137 : break;
; 1138 : s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;
000a9 8b 12 mov edx, DWORD PTR [edx]
000ab 33 c9 xor ecx, ecx
000ad 83 c0 04 add eax, 4
000b0 83 f8 20 cmp eax, 32 ; 00000020H
000b3 0f 94 c1 sete cl
000b6 89 4a 2c mov DWORD PTR [edx+44], ecx
; 1139 : }
000b9 c3 ret 0
$LN22@set_data_t:
; 1136 : if (s->dyn_ltree[n].Freq != 0)
000ba 83 c0 05 add eax, 5
$LN15@set_data_t:
; 1137 : break;
; 1138 : s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;
000bd 8b 12 mov edx, DWORD PTR [edx]
000bf 33 c9 xor ecx, ecx
000c1 83 f8 20 cmp eax, 32 ; 00000020H
000c4 0f 94 c1 sete cl
000c7 89 4a 2c mov DWORD PTR [edx+44], ecx
; 1139 : }
000ca c3 ret 0
_set_data_type ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _compress_block
_TEXT SEGMENT
tv870 = -12 ; size = 4
_len$79029 = -12 ; size = 4
tv869 = -8 ; size = 4
_len$79054 = -8 ; size = 4
_code$ = -8 ; size = 4
_lx$ = -4 ; size = 4
tv868 = 8 ; size = 4
_ltree$ = 8 ; size = 4
_dtree$ = 12 ; size = 4
_compress_block PROC ; COMDAT
; _s$ = eax
; 1076 : {
00000 83 ec 0c sub esp, 12 ; 0000000cH
00003 53 push ebx
00004 8b 5c 24 14 mov ebx, DWORD PTR _ltree$[esp+12]
00008 55 push ebp
; 1077 : unsigned dist; /* distance of matched string */
; 1078 : int lc; /* match length or unmatched char (if dist == 0) */
; 1079 : unsigned lx = 0; /* running index in l_buf */
00009 33 c9 xor ecx, ecx
; 1080 : unsigned code; /* the code to send */
; 1081 : int extra; /* number of extra bits to send */
; 1082 :
; 1083 : if (s->last_lit != 0) do {
0000b 39 88 a0 16 00
00 cmp DWORD PTR [eax+5792], ecx
00011 56 push esi
00012 57 push edi
00013 0f 84 39 03 00
00 je $LN17@compress_b
00019 8d a4 24 00 00
00 00 npad 7
$LL19@compress_b:
; 1084 : dist = s->d_buf[lx];
00020 8b 90 a4 16 00
00 mov edx, DWORD PTR [eax+5796]
00026 0f b7 2c 4a movzx ebp, WORD PTR [edx+ecx*2]
; 1085 : lc = s->l_buf[lx++];
0002a 8b 90 98 16 00
00 mov edx, DWORD PTR [eax+5784]
00030 0f b6 34 11 movzx esi, BYTE PTR [ecx+edx]
00034 83 c1 01 add ecx, 1
; 1086 : if (dist == 0) {
00037 85 ed test ebp, ebp
00039 89 4c 24 18 mov DWORD PTR _lx$[esp+28], ecx
; 1087 : send_code(s, lc, ltree); /* send a literal byte */
0003d 8b 88 bc 16 00
00 mov ecx, DWORD PTR [eax+5820]
00043 0f 85 81 00 00
00 jne $LN16@compress_b
00049 0f b7 7c b3 02 movzx edi, WORD PTR [ebx+esi*4+2]
0004e ba 10 00 00 00 mov edx, 16 ; 00000010H
00053 2b d7 sub edx, edi
00055 3b ca cmp ecx, edx
00057 7e 5c jle SHORT $LN15@compress_b
00059 0f b7 34 b3 movzx esi, WORD PTR [ebx+esi*4]
0005d 8b d6 mov edx, esi
0005f d3 e2 shl edx, cl
00061 8b 48 08 mov ecx, DWORD PTR [eax+8]
00064 89 5c 24 10 mov DWORD PTR tv870[esp+28], ebx
00068 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
0006f 0f b6 98 b8 16
00 00 movzx ebx, BYTE PTR [eax+5816]
00076 8b 50 14 mov edx, DWORD PTR [eax+20]
00079 88 1c 11 mov BYTE PTR [ecx+edx], bl
0007c 83 40 14 01 add DWORD PTR [eax+20], 1
00080 0f b6 98 b9 16
00 00 movzx ebx, BYTE PTR [eax+5817]
00087 8b 48 14 mov ecx, DWORD PTR [eax+20]
0008a 8b 50 08 mov edx, DWORD PTR [eax+8]
0008d 88 1c 11 mov BYTE PTR [ecx+edx], bl
00090 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
00096 83 40 14 01 add DWORD PTR [eax+20], 1
0009a 8b 5c 24 10 mov ebx, DWORD PTR tv870[esp+28]
0009e b1 10 mov cl, 16 ; 00000010H
000a0 2a ca sub cl, dl
000a2 66 d3 ee shr si, cl
000a5 8d 4c 3a f0 lea ecx, DWORD PTR [edx+edi-16]
000a9 66 89 b0 b8 16
00 00 mov WORD PTR [eax+5816], si
000b0 e9 87 02 00 00 jmp $LN29@compress_b
$LN15@compress_b:
000b5 66 8b 14 b3 mov dx, WORD PTR [ebx+esi*4]
000b9 66 d3 e2 shl dx, cl
000bc 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
000c3 03 cf add ecx, edi
; 1088 : Tracecv(isgraph(lc), (stderr," '%c' ", lc));
; 1089 : } else {
000c5 e9 72 02 00 00 jmp $LN29@compress_b
$LN16@compress_b:
; 1090 : /* Here, lc is the match length - MIN_MATCH */
; 1091 : code = _length_code[lc];
000ca 0f b6 96 00 00
00 00 movzx edx, BYTE PTR __length_code[esi]
; 1092 : send_code(s, code+LITERALS+1, ltree); /* send the length code */
000d1 0f b7 bc 93 06
04 00 00 movzx edi, WORD PTR [ebx+edx*4+1030]
000d9 bb 10 00 00 00 mov ebx, 16 ; 00000010H
000de 2b df sub ebx, edi
000e0 3b cb cmp ecx, ebx
000e2 89 7c 24 10 mov DWORD PTR _len$79029[esp+28], edi
000e6 8b 7c 24 20 mov edi, DWORD PTR _ltree$[esp+24]
000ea 89 54 24 14 mov DWORD PTR _code$[esp+28], edx
000ee 7e 63 jle SHORT $LN12@compress_b
000f0 0f b7 bc 97 04
04 00 00 movzx edi, WORD PTR [edi+edx*4+1028]
000f8 8b d7 mov edx, edi
000fa d3 e2 shl edx, cl
000fc 8b 48 08 mov ecx, DWORD PTR [eax+8]
000ff 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
00106 0f b6 98 b8 16
00 00 movzx ebx, BYTE PTR [eax+5816]
0010d 8b 50 14 mov edx, DWORD PTR [eax+20]
00110 88 1c 11 mov BYTE PTR [ecx+edx], bl
00113 83 40 14 01 add DWORD PTR [eax+20], 1
00117 8b 48 14 mov ecx, DWORD PTR [eax+20]
0011a 0f b6 98 b9 16
00 00 movzx ebx, BYTE PTR [eax+5817]
00121 8b 50 08 mov edx, DWORD PTR [eax+8]
00124 88 1c 11 mov BYTE PTR [ecx+edx], bl
00127 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
0012d 83 40 14 01 add DWORD PTR [eax+20], 1
00131 b1 10 mov cl, 16 ; 00000010H
00133 2a ca sub cl, dl
00135 66 d3 ef shr di, cl
00138 8b 4c 24 10 mov ecx, DWORD PTR _len$79029[esp+28]
0013c 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
00140 89 90 bc 16 00
00 mov DWORD PTR [eax+5820], edx
00146 8b 54 24 14 mov edx, DWORD PTR _code$[esp+28]
0014a 66 89 b8 b8 16
00 00 mov WORD PTR [eax+5816], di
00151 eb 1e jmp SHORT $LN30@compress_b
$LN12@compress_b:
00153 66 8b bc 97 04
04 00 00 mov di, WORD PTR [edi+edx*4+1028]
0015b 66 d3 e7 shl di, cl
0015e 66 09 b8 b8 16
00 00 or WORD PTR [eax+5816], di
00165 8b 7c 24 10 mov edi, DWORD PTR _len$79029[esp+28]
00169 03 cf add ecx, edi
0016b 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
$LN30@compress_b:
; 1093 : extra = extra_lbits[code];
00171 8b 3c 95 00 00
00 00 mov edi, DWORD PTR _extra_lbits[edx*4]
; 1094 : if (extra != 0) {
00178 85 ff test edi, edi
0017a 8b 5c 24 20 mov ebx, DWORD PTR _ltree$[esp+24]
0017e 74 7a je SHORT $LN8@compress_b
; 1095 : lc -= base_length[code];
00180 2b 34 95 00 00
00 00 sub esi, DWORD PTR _base_length[edx*4]
; 1096 : send_bits(s, lc, extra); /* send the extra length bits */
00187 8b 88 bc 16 00
00 mov ecx, DWORD PTR [eax+5820]
0018d ba 10 00 00 00 mov edx, 16 ; 00000010H
00192 2b d7 sub edx, edi
00194 3b ca cmp ecx, edx
00196 7e 51 jle SHORT $LN9@compress_b
00198 8b d6 mov edx, esi
0019a d3 e2 shl edx, cl
0019c 8b 48 08 mov ecx, DWORD PTR [eax+8]
0019f 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
001a6 0f b6 98 b8 16
00 00 movzx ebx, BYTE PTR [eax+5816]
001ad 8b 50 14 mov edx, DWORD PTR [eax+20]
001b0 88 1c 11 mov BYTE PTR [ecx+edx], bl
001b3 83 40 14 01 add DWORD PTR [eax+20], 1
001b7 0f b6 98 b9 16
00 00 movzx ebx, BYTE PTR [eax+5817]
001be 8b 48 14 mov ecx, DWORD PTR [eax+20]
001c1 8b 50 08 mov edx, DWORD PTR [eax+8]
001c4 88 1c 11 mov BYTE PTR [ecx+edx], bl
001c7 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
001cd 83 40 14 01 add DWORD PTR [eax+20], 1
001d1 8b 5c 24 20 mov ebx, DWORD PTR _ltree$[esp+24]
001d5 b1 10 mov cl, 16 ; 00000010H
001d7 2a ca sub cl, dl
001d9 66 d3 ee shr si, cl
001dc 8d 4c 3a f0 lea ecx, DWORD PTR [edx+edi-16]
001e0 66 89 b0 b8 16
00 00 mov WORD PTR [eax+5816], si
001e7 eb 0b jmp SHORT $LN31@compress_b
$LN9@compress_b:
001e9 d3 e6 shl esi, cl
001eb 66 09 b0 b8 16
00 00 or WORD PTR [eax+5816], si
001f2 03 cf add ecx, edi
$LN31@compress_b:
001f4 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
$LN8@compress_b:
; 1097 : }
; 1098 : dist--; /* dist is now the match distance - 1 */
001fa 83 ed 01 sub ebp, 1
; 1099 : code = d_code(dist);
001fd 81 fd 00 01 00
00 cmp ebp, 256 ; 00000100H
00203 73 09 jae SHORT $LN23@compress_b
00205 0f b6 bd 00 00
00 00 movzx edi, BYTE PTR __dist_code[ebp]
0020c eb 0c jmp SHORT $LN24@compress_b
$LN23@compress_b:
0020e 8b d5 mov edx, ebp
00210 c1 ea 07 shr edx, 7
00213 0f b6 ba 00 01
00 00 movzx edi, BYTE PTR __dist_code[edx+256]
$LN24@compress_b:
; 1100 : Assert (code < D_CODES, "bad d_code");
; 1101 :
; 1102 : send_code(s, code, dtree); /* send the distance code */
0021a 8b 4c 24 24 mov ecx, DWORD PTR _dtree$[esp+24]
0021e 0f b7 54 b9 02 movzx edx, WORD PTR [ecx+edi*4+2]
00223 8b 88 bc 16 00
00 mov ecx, DWORD PTR [eax+5820]
00229 be 10 00 00 00 mov esi, 16 ; 00000010H
0022e 2b f2 sub esi, edx
00230 3b ce cmp ecx, esi
00232 89 54 24 14 mov DWORD PTR _len$79054[esp+28], edx
00236 7e 63 jle SHORT $LN7@compress_b
00238 8b 54 24 24 mov edx, DWORD PTR _dtree$[esp+24]
0023c 0f b7 34 ba movzx esi, WORD PTR [edx+edi*4]
00240 8b d6 mov edx, esi
00242 d3 e2 shl edx, cl
00244 8b 48 08 mov ecx, DWORD PTR [eax+8]
00247 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
0024e 0f b6 98 b8 16
00 00 movzx ebx, BYTE PTR [eax+5816]
00255 8b 50 14 mov edx, DWORD PTR [eax+20]
00258 88 1c 11 mov BYTE PTR [ecx+edx], bl
0025b 83 40 14 01 add DWORD PTR [eax+20], 1
0025f 0f b6 98 b9 16
00 00 movzx ebx, BYTE PTR [eax+5817]
00266 8b 48 14 mov ecx, DWORD PTR [eax+20]
00269 8b 50 08 mov edx, DWORD PTR [eax+8]
0026c 88 1c 11 mov BYTE PTR [ecx+edx], bl
0026f 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
00275 83 40 14 01 add DWORD PTR [eax+20], 1
00279 8b 5c 24 20 mov ebx, DWORD PTR _ltree$[esp+24]
0027d b1 10 mov cl, 16 ; 00000010H
0027f 2a ca sub cl, dl
00281 66 d3 ee shr si, cl
00284 8b 4c 24 14 mov ecx, DWORD PTR _len$79054[esp+28]
00288 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
0028c 89 90 bc 16 00
00 mov DWORD PTR [eax+5820], edx
00292 66 89 b0 b8 16
00 00 mov WORD PTR [eax+5816], si
00299 eb 1a jmp SHORT $LN6@compress_b
$LN7@compress_b:
0029b 8b 74 24 24 mov esi, DWORD PTR _dtree$[esp+24]
0029f 66 8b 34 be mov si, WORD PTR [esi+edi*4]
002a3 66 d3 e6 shl si, cl
002a6 66 09 b0 b8 16
00 00 or WORD PTR [eax+5816], si
002ad 03 ca add ecx, edx
002af 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
$LN6@compress_b:
; 1103 : extra = extra_dbits[code];
002b5 8b 34 bd 00 00
00 00 mov esi, DWORD PTR _extra_dbits[edi*4]
; 1104 : if (extra != 0) {
002bc 85 f6 test esi, esi
002be 0f 84 7e 00 00
00 je $LN18@compress_b
; 1105 : dist -= base_dist[code];
; 1106 : send_bits(s, dist, extra); /* send the extra distance bits */
002c4 8b 88 bc 16 00
00 mov ecx, DWORD PTR [eax+5820]
002ca 2b 2c bd 00 00
00 00 sub ebp, DWORD PTR _base_dist[edi*4]
002d1 ba 10 00 00 00 mov edx, 16 ; 00000010H
002d6 2b d6 sub edx, esi
002d8 3b ca cmp ecx, edx
002da 7e 55 jle SHORT $LN4@compress_b
002dc 8b d5 mov edx, ebp
002de d3 e2 shl edx, cl
002e0 8b 48 08 mov ecx, DWORD PTR [eax+8]
002e3 89 5c 24 14 mov DWORD PTR tv869[esp+28], ebx
002e7 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
002ee 0f b6 98 b8 16
00 00 movzx ebx, BYTE PTR [eax+5816]
002f5 8b 50 14 mov edx, DWORD PTR [eax+20]
002f8 88 1c 11 mov BYTE PTR [ecx+edx], bl
002fb 83 40 14 01 add DWORD PTR [eax+20], 1
002ff 0f b6 98 b9 16
00 00 movzx ebx, BYTE PTR [eax+5817]
00306 8b 48 14 mov ecx, DWORD PTR [eax+20]
00309 8b 50 08 mov edx, DWORD PTR [eax+8]
0030c 88 1c 11 mov BYTE PTR [ecx+edx], bl
0030f 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
00315 83 40 14 01 add DWORD PTR [eax+20], 1
00319 8b 5c 24 14 mov ebx, DWORD PTR tv869[esp+28]
0031d b1 10 mov cl, 16 ; 00000010H
0031f 2a ca sub cl, dl
00321 66 d3 ed shr bp, cl
00324 8d 4c 32 f0 lea ecx, DWORD PTR [edx+esi-16]
00328 66 89 a8 b8 16
00 00 mov WORD PTR [eax+5816], bp
0032f eb 0b jmp SHORT $LN29@compress_b
$LN4@compress_b:
00331 d3 e5 shl ebp, cl
00333 66 09 a8 b8 16
00 00 or WORD PTR [eax+5816], bp
0033a 03 ce add ecx, esi
$LN29@compress_b:
0033c 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
$LN18@compress_b:
; 1107 : }
; 1108 : } /* literal or match pair ? */
; 1109 :
; 1110 : /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
; 1111 : Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
; 1112 : "pendingBuf overflow");
; 1113 :
; 1114 : } while (lx < s->last_lit);
00342 8b 4c 24 18 mov ecx, DWORD PTR _lx$[esp+28]
00346 3b 88 a0 16 00
00 cmp ecx, DWORD PTR [eax+5792]
0034c 0f 82 ce fc ff
ff jb $LL19@compress_b
$LN17@compress_b:
; 1115 :
; 1116 : send_code(s, END_BLOCK, ltree);
00352 0f b7 bb 02 04
00 00 movzx edi, WORD PTR [ebx+1026]
00359 8b 88 bc 16 00
00 mov ecx, DWORD PTR [eax+5820]
0035f ba 10 00 00 00 mov edx, 16 ; 00000010H
00364 2b d7 sub edx, edi
00366 3b ca cmp ecx, edx
00368 7e 73 jle SHORT $LN2@compress_b
0036a 0f b7 b3 00 04
00 00 movzx esi, WORD PTR [ebx+1024]
00371 8b d6 mov edx, esi
00373 d3 e2 shl edx, cl
00375 8b 48 08 mov ecx, DWORD PTR [eax+8]
00378 89 5c 24 20 mov DWORD PTR tv868[esp+24], ebx
0037c 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
00383 8b 50 14 mov edx, DWORD PTR [eax+20]
00386 8a 98 b8 16 00
00 mov bl, BYTE PTR [eax+5816]
0038c 88 1c 11 mov BYTE PTR [ecx+edx], bl
0038f 83 40 14 01 add DWORD PTR [eax+20], 1
00393 8b 68 14 mov ebp, DWORD PTR [eax+20]
00396 8b 48 08 mov ecx, DWORD PTR [eax+8]
00399 8a 90 b9 16 00
00 mov dl, BYTE PTR [eax+5817]
0039f 8b 5c 24 20 mov ebx, DWORD PTR tv868[esp+24]
003a3 88 14 29 mov BYTE PTR [ecx+ebp], dl
003a6 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
003ac 83 40 14 01 add DWORD PTR [eax+20], 1
003b0 b1 10 mov cl, 16 ; 00000010H
003b2 2a ca sub cl, dl
003b4 66 d3 ee shr si, cl
003b7 8d 4c 3a f0 lea ecx, DWORD PTR [edx+edi-16]
003bb 5f pop edi
003bc 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
003c2 66 89 b0 b8 16
00 00 mov WORD PTR [eax+5816], si
; 1117 : s->last_eob_len = ltree[END_BLOCK].Len;
003c9 0f b7 93 02 04
00 00 movzx edx, WORD PTR [ebx+1026]
003d0 5e pop esi
003d1 5d pop ebp
003d2 89 90 b4 16 00
00 mov DWORD PTR [eax+5812], edx
003d8 5b pop ebx
; 1118 : }
003d9 83 c4 0c add esp, 12 ; 0000000cH
003dc c3 ret 0
$LN2@compress_b:
; 1115 :
; 1116 : send_code(s, END_BLOCK, ltree);
003dd 66 8b 93 00 04
00 00 mov dx, WORD PTR [ebx+1024]
003e4 66 d3 e2 shl dx, cl
003e7 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
003ee 03 cf add ecx, edi
003f0 5f pop edi
003f1 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
; 1117 : s->last_eob_len = ltree[END_BLOCK].Len;
003f7 0f b7 8b 02 04
00 00 movzx ecx, WORD PTR [ebx+1026]
003fe 5e pop esi
003ff 5d pop ebp
00400 89 88 b4 16 00
00 mov DWORD PTR [eax+5812], ecx
00406 5b pop ebx
; 1118 : }
00407 83 c4 0c add esp, 12 ; 0000000cH
0040a c3 ret 0
_compress_block ENDP
_TEXT ENDS
PUBLIC __tr_align
; Function compile flags: /Ogtpy
; COMDAT __tr_align
_TEXT SEGMENT
__tr_align PROC ; COMDAT
; _s$ = eax
; 895 : send_bits(s, STATIC_TREES<<1, 3);
00000 8b 88 bc 16 00
00 mov ecx, DWORD PTR [eax+5820]
00006 ba 02 00 00 00 mov edx, 2
0000b d3 e2 shl edx, cl
0000d 53 push ebx
0000e 56 push esi
0000f 57 push edi
00010 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
00017 83 f9 0d cmp ecx, 13 ; 0000000dH
0001a be 01 00 00 00 mov esi, 1
0001f 7e 4a jle SHORT $LN9@tr_align
00021 0f b6 98 b8 16
00 00 movzx ebx, BYTE PTR [eax+5816]
00028 8b 50 14 mov edx, DWORD PTR [eax+20]
0002b 8b 48 08 mov ecx, DWORD PTR [eax+8]
0002e 88 1c 11 mov BYTE PTR [ecx+edx], bl
00031 01 70 14 add DWORD PTR [eax+20], esi
00034 0f b6 98 b9 16
00 00 movzx ebx, BYTE PTR [eax+5817]
0003b 8b 48 14 mov ecx, DWORD PTR [eax+20]
0003e 8b 50 08 mov edx, DWORD PTR [eax+8]
00041 88 1c 11 mov BYTE PTR [ecx+edx], bl
00044 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
0004a 01 70 14 add DWORD PTR [eax+20], esi
0004d b1 10 mov cl, 16 ; 00000010H
0004f 2a ca sub cl, dl
00051 bf 02 00 00 00 mov edi, 2
00056 66 d3 ef shr di, cl
00059 83 c2 f3 add edx, -13 ; fffffff3H
0005c 89 90 bc 16 00
00 mov DWORD PTR [eax+5820], edx
00062 66 89 b8 b8 16
00 00 mov WORD PTR [eax+5816], di
00069 eb 09 jmp SHORT $LN8@tr_align
$LN9@tr_align:
0006b 83 c1 03 add ecx, 3
0006e 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
$LN8@tr_align:
; 896 : send_code(s, END_BLOCK, static_ltree);
00074 8b 88 bc 16 00
00 mov ecx, DWORD PTR [eax+5820]
0007a 33 d2 xor edx, edx
0007c d3 e2 shl edx, cl
0007e 66 09 90 b8 16
00 00 or WORD PTR [eax+5816], dx
00085 83 f9 09 cmp ecx, 9
00088 7e 47 jle SHORT $LN7@tr_align
0008a 0f b6 98 b8 16
00 00 movzx ebx, BYTE PTR [eax+5816]
00091 8b 50 14 mov edx, DWORD PTR [eax+20]
00094 8b 48 08 mov ecx, DWORD PTR [eax+8]
00097 88 1c 11 mov BYTE PTR [ecx+edx], bl
0009a 01 70 14 add DWORD PTR [eax+20], esi
0009d 0f b6 98 b9 16
00 00 movzx ebx, BYTE PTR [eax+5817]
000a4 8b 48 14 mov ecx, DWORD PTR [eax+20]
000a7 8b 50 08 mov edx, DWORD PTR [eax+8]
000aa 88 1c 11 mov BYTE PTR [ecx+edx], bl
000ad 8b 90 bc 16 00
00 mov edx, DWORD PTR [eax+5820]
000b3 01 70 14 add DWORD PTR [eax+20], esi
000b6 b1 10 mov cl, 16 ; 00000010H
000b8 2a ca sub cl, dl
000ba 33 ff xor edi, edi
000bc 66 d3 ef shr di, cl
000bf 83 c2 f7 add edx, -9 ; fffffff7H
000c2 89 90 bc 16 00
00 mov DWORD PTR [eax+5820], edx
000c8 66 89 b8 b8 16
00 00 mov WORD PTR [eax+5816], di
000cf eb 09 jmp SHORT $LN6@tr_align
$LN7@tr_align:
000d1 83 c1 07 add ecx, 7
000d4 89 88 bc 16 00
00 mov DWORD PTR [eax+5820], ecx
$LN6@tr_align:
; 897 : #ifdef DEBUG
; 898 : s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
; 899 : #endif
; 900 : bi_flush(s);
000da e8 00 00 00 00 call _bi_flush
; 901 : /* Of the 10 bits for the empty block, we have already sent
; 902 : * (10 - bi_valid) bits. The lookahead for the last real code (before
; 903 : * the EOB of the previous block) was thus at least one plus the length
; 904 : * of the EOB plus what we have just sent of the empty static block.
; 905 : */
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -