1 ; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01
\r
3 TITLE C:\Workspaces\Sysdyn\org.simantics.fmu\FMUSolution\zlib-1.2.6\deflate.c
\r
11 PUBLIC _deflate_copyright
\r
13 _deflate_copyright DB ' deflate 1.2.6 Copyright 1995-2012 Jean-loup Gaill'
\r
14 DB 'y and Mark Adler ', 00H
\r
16 _configuration_table DW 00H
\r
20 DD FLAT:_deflate_stored
\r
25 DD FLAT:_deflate_fast
\r
30 DD FLAT:_deflate_fast
\r
35 DD FLAT:_deflate_fast
\r
40 DD FLAT:_deflate_slow
\r
45 DD FLAT:_deflate_slow
\r
50 DD FLAT:_deflate_slow
\r
55 DD FLAT:_deflate_slow
\r
60 DD FLAT:_deflate_slow
\r
65 DD FLAT:_deflate_slow
\r
66 ?my_version@?1??deflateInit2_@@9@9 DB '1.2.6', 00H ; `deflateInit2_'::`2'::my_version
\r
67 ; Function compile flags: /Ogtp
\r
68 ; File c:\workspaces\sysdyn\org.simantics.fmu\fmusolution\zlib-1.2.6\deflate.c
\r
69 ; COMDAT _longest_match
\r
71 tv299 = -20 ; size = 4
\r
72 _limit$ = -16 ; size = 4
\r
73 _nice_match$ = -12 ; size = 4
\r
74 _chain_length$ = -8 ; size = 4
\r
75 _scan_end$ = -2 ; size = 1
\r
76 _scan_end1$ = -1 ; size = 1
\r
77 _cur_match$ = 8 ; size = 4
\r
78 _longest_match PROC ; COMDAT
\r
84 00001 8b ec mov ebp, esp
\r
85 00003 83 ec 14 sub esp, 20 ; 00000014H
\r
87 ; 1150 : unsigned chain_length = s->max_chain_length;/* max hash chain length */
\r
88 ; 1151 : register Bytef *scan = s->window + s->strstart; /* current string */
\r
90 00006 8b 57 6c mov edx, DWORD PTR [edi+108]
\r
91 00009 8b 47 7c mov eax, DWORD PTR [edi+124]
\r
92 0000c 8b 4f 38 mov ecx, DWORD PTR [edi+56]
\r
96 ; 1152 : register Bytef *match; /* matched string */
\r
97 ; 1153 : register int len; /* length of current match */
\r
98 ; 1154 : int best_len = s->prev_length; /* best match length so far */
\r
99 ; 1155 : int nice_match = s->nice_match; /* stop if match long enough */
\r
101 00011 8b b7 90 00 00
\r
102 00 mov esi, DWORD PTR [edi+144]
\r
103 00017 89 75 f4 mov DWORD PTR _nice_match$[ebp], esi
\r
105 ; 1156 : IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
\r
106 ; 1157 : s->strstart - (IPos)MAX_DIST(s) : NIL;
\r
108 0001a 8b 77 2c mov esi, DWORD PTR [edi+44]
\r
109 0001d 8d 9e fa fe ff
\r
110 ff lea ebx, DWORD PTR [esi-262]
\r
111 00023 03 ca add ecx, edx
\r
112 00025 89 45 f8 mov DWORD PTR _chain_length$[ebp], eax
\r
113 00028 8b 47 78 mov eax, DWORD PTR [edi+120]
\r
114 0002b 3b d3 cmp edx, ebx
\r
115 0002d 76 0d jbe SHORT $LN18@longest_ma
\r
116 0002f 2b d6 sub edx, esi
\r
117 00031 81 c2 06 01 00
\r
118 00 add edx, 262 ; 00000106H
\r
119 00037 89 55 f0 mov DWORD PTR _limit$[ebp], edx
\r
120 0003a eb 07 jmp SHORT $LN19@longest_ma
\r
122 0003c c7 45 f0 00 00
\r
123 00 00 mov DWORD PTR _limit$[ebp], 0
\r
126 ; 1158 : /* Stop when cur_match becomes <= limit. To simplify the code,
\r
127 ; 1159 : * we prevent matches with the string of window index 0.
\r
129 ; 1161 : Posf *prev = s->prev;
\r
130 ; 1162 : uInt wmask = s->w_mask;
\r
132 ; 1164 : #ifdef UNALIGNED_OK
\r
133 ; 1165 : /* Compare two bytes at a time. Note: this is not always beneficial.
\r
134 ; 1166 : * Try with and without -DUNALIGNED_OK to check.
\r
136 ; 1168 : register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
\r
137 ; 1169 : register ush scan_start = *(ushf*)scan;
\r
138 ; 1170 : register ush scan_end = *(ushf*)(scan+best_len-1);
\r
140 ; 1172 : register Bytef *strend = s->window + s->strstart + MAX_MATCH;
\r
141 ; 1173 : register Byte scan_end1 = scan[best_len-1];
\r
143 00043 0f b6 54 08 ff movzx edx, BYTE PTR [eax+ecx-1]
\r
144 00048 88 55 ff mov BYTE PTR _scan_end1$[ebp], dl
\r
146 ; 1174 : register Byte scan_end = scan[best_len];
\r
148 0004b 0f b6 14 08 movzx edx, BYTE PTR [eax+ecx]
\r
149 0004f 8d b1 02 01 00
\r
150 00 lea esi, DWORD PTR [ecx+258]
\r
151 00055 88 55 fe mov BYTE PTR _scan_end$[ebp], dl
\r
155 ; 1177 : /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
\r
156 ; 1178 : * It is easy to get rid of this optimization if necessary.
\r
158 ; 1180 : Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
\r
160 ; 1182 : /* Do not waste too much time if we already have a good match: */
\r
161 ; 1183 : if (s->prev_length >= s->good_match) {
\r
163 00058 3b 87 8c 00 00
\r
164 00 cmp eax, DWORD PTR [edi+140]
\r
165 0005e 72 04 jb SHORT $LN15@longest_ma
\r
167 ; 1184 : chain_length >>= 2;
\r
169 00060 c1 6d f8 02 shr DWORD PTR _chain_length$[ebp], 2
\r
173 ; 1186 : /* Do not look for matches beyond the end of the input. This is necessary
\r
174 ; 1187 : * to make deflate deterministic.
\r
176 ; 1189 : if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
\r
178 00064 8b 57 74 mov edx, DWORD PTR [edi+116]
\r
179 00067 39 55 f4 cmp DWORD PTR _nice_match$[ebp], edx
\r
180 0006a 76 03 jbe SHORT $LN25@longest_ma
\r
181 0006c 89 55 f4 mov DWORD PTR _nice_match$[ebp], edx
\r
183 0006f 8b 5d 08 mov ebx, DWORD PTR _cur_match$[ebp]
\r
187 ; 1191 : Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
\r
190 ; 1194 : Assert(cur_match < s->strstart, "no future");
\r
191 ; 1195 : match = s->window + cur_match;
\r
193 00072 8b 57 38 mov edx, DWORD PTR [edi+56]
\r
194 00075 03 d3 add edx, ebx
\r
197 ; 1197 : /* Skip to next match if the match length cannot increase
\r
198 ; 1198 : * or if the match length is less than 2. Note that the checks below
\r
199 ; 1199 : * for insufficient lookahead only occur occasionally for performance
\r
200 ; 1200 : * reasons. Therefore uninitialized memory will be accessed, and
\r
201 ; 1201 : * conditional jumps will be made that depend on those values.
\r
202 ; 1202 : * However the length of the match is limited to the lookahead, so
\r
203 ; 1203 : * the output of deflate is not affected by the uninitialized values.
\r
205 ; 1205 : #if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
\r
206 ; 1206 : /* This code assumes sizeof(unsigned short) == 2. Do not use
\r
207 ; 1207 : * UNALIGNED_OK if your compiler uses a different size.
\r
209 ; 1209 : if (*(ushf*)(match+best_len-1) != scan_end ||
\r
210 ; 1210 : *(ushf*)match != scan_start) continue;
\r
212 ; 1212 : /* It is not necessary to compare scan[2] and match[2] since they are
\r
213 ; 1213 : * always equal when the other bytes match, given that the hash keys
\r
214 ; 1214 : * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
\r
215 ; 1215 : * strstart+3, +5, ... up to strstart+257. We check for insufficient
\r
216 ; 1216 : * lookahead only every 4th comparison; the 128th check will be made
\r
217 ; 1217 : * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
\r
218 ; 1218 : * necessary to put more guard bytes at the end of the window, or
\r
219 ; 1219 : * to check more often for insufficient lookahead.
\r
221 ; 1221 : Assert(scan[2] == match[2], "scan[2]?");
\r
222 ; 1222 : scan++, match++;
\r
224 ; 1224 : } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
\r
225 ; 1225 : *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
\r
226 ; 1226 : *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
\r
227 ; 1227 : *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
\r
228 ; 1228 : scan < strend);
\r
229 ; 1229 : /* The funny "do {}" generates better code on most compilers */
\r
231 ; 1231 : /* Here, scan <= window+strstart+257 */
\r
232 ; 1232 : Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
\r
233 ; 1233 : if (*scan == *match) scan++;
\r
235 ; 1235 : len = (MAX_MATCH - 1) - (int)(strend-scan);
\r
236 ; 1236 : scan = strend - (MAX_MATCH-1);
\r
238 ; 1238 : #else /* UNALIGNED_OK */
\r
240 ; 1240 : if (match[best_len] != scan_end ||
\r
241 ; 1241 : match[best_len-1] != scan_end1 ||
\r
242 ; 1242 : *match != *scan ||
\r
243 ; 1243 : *++match != scan[1]) continue;
\r
245 00077 8a 5d fe mov bl, BYTE PTR _scan_end$[ebp]
\r
246 0007a 38 1c 02 cmp BYTE PTR [edx+eax], bl
\r
247 0007d 0f 85 a9 00 00
\r
248 00 jne $LN12@longest_ma
\r
249 00083 8a 5d ff mov bl, BYTE PTR _scan_end1$[ebp]
\r
250 00086 38 5c 02 ff cmp BYTE PTR [edx+eax-1], bl
\r
251 0008a 0f 85 9c 00 00
\r
252 00 jne $LN12@longest_ma
\r
253 00090 8a 1a mov bl, BYTE PTR [edx]
\r
254 00092 3a 19 cmp bl, BYTE PTR [ecx]
\r
255 00094 0f 85 92 00 00
\r
256 00 jne $LN12@longest_ma
\r
257 0009a 8a 5a 01 mov bl, BYTE PTR [edx+1]
\r
258 0009d 3a 59 01 cmp bl, BYTE PTR [ecx+1]
\r
259 000a0 0f 85 86 00 00
\r
260 00 jne $LN12@longest_ma
\r
263 ; 1245 : /* The check at best_len-1 can be removed because it will be made
\r
264 ; 1246 : * again later. (This heuristic is not always a win.)
\r
265 ; 1247 : * It is not necessary to compare scan[2] and match[2] since they
\r
266 ; 1248 : * are always equal when the other bytes match, given that
\r
267 ; 1249 : * the hash keys are equal and that HASH_BITS >= 8.
\r
269 ; 1251 : scan += 2, match++;
\r
271 000a6 83 c1 02 add ecx, 2
\r
272 000a9 83 c2 02 add edx, 2
\r
273 000ac 8d 64 24 00 npad 4
\r
276 ; 1252 : Assert(*scan == *match, "match[2]?");
\r
278 ; 1254 : /* We check for insufficient lookahead only every 8th comparison;
\r
279 ; 1255 : * the 256th check will be made at strstart+258.
\r
282 ; 1258 : } while (*++scan == *++match && *++scan == *++match &&
\r
283 ; 1259 : *++scan == *++match && *++scan == *++match &&
\r
284 ; 1260 : *++scan == *++match && *++scan == *++match &&
\r
285 ; 1261 : *++scan == *++match && *++scan == *++match &&
\r
286 ; 1262 : scan < strend);
\r
288 000b0 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
290 000b4 3a 5a 01 cmp bl, BYTE PTR [edx+1]
\r
291 000b7 75 45 jne SHORT $LN5@longest_ma
\r
292 000b9 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
294 000bd 3a 5a 02 cmp bl, BYTE PTR [edx+2]
\r
295 000c0 75 3c jne SHORT $LN5@longest_ma
\r
296 000c2 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
298 000c6 3a 5a 03 cmp bl, BYTE PTR [edx+3]
\r
299 000c9 75 33 jne SHORT $LN5@longest_ma
\r
300 000cb 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
302 000cf 3a 5a 04 cmp bl, BYTE PTR [edx+4]
\r
303 000d2 75 2a jne SHORT $LN5@longest_ma
\r
304 000d4 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
306 000d8 3a 5a 05 cmp bl, BYTE PTR [edx+5]
\r
307 000db 75 21 jne SHORT $LN5@longest_ma
\r
308 000dd 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
310 000e1 3a 5a 06 cmp bl, BYTE PTR [edx+6]
\r
311 000e4 75 18 jne SHORT $LN5@longest_ma
\r
312 000e6 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
314 000ea 3a 5a 07 cmp bl, BYTE PTR [edx+7]
\r
315 000ed 75 0f jne SHORT $LN5@longest_ma
\r
316 000ef 8a 59 01 mov bl, BYTE PTR [ecx+1]
\r
318 000f3 83 c2 08 add edx, 8
\r
319 000f6 3a 1a cmp bl, BYTE PTR [edx]
\r
320 000f8 75 04 jne SHORT $LN5@longest_ma
\r
321 000fa 3b ce cmp ecx, esi
\r
322 000fc 72 b2 jb SHORT $LL8@longest_ma
\r
326 ; 1264 : Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
\r
328 ; 1266 : len = MAX_MATCH - (int)(strend - scan);
\r
330 000fe 8b d1 mov edx, ecx
\r
331 00100 2b d6 sub edx, esi
\r
332 00102 81 c2 02 01 00
\r
333 00 add edx, 258 ; 00000102H
\r
335 ; 1267 : scan = strend - MAX_MATCH;
\r
337 00108 8d 8e fe fe ff
\r
338 ff lea ecx, DWORD PTR [esi-258]
\r
341 ; 1269 : #endif /* UNALIGNED_OK */
\r
343 ; 1271 : if (len > best_len) {
\r
345 0010e 3b d0 cmp edx, eax
\r
346 00110 7e 1a jle SHORT $LN12@longest_ma
\r
348 ; 1272 : s->match_start = cur_match;
\r
350 00112 8b 45 08 mov eax, DWORD PTR _cur_match$[ebp]
\r
351 00115 89 47 70 mov DWORD PTR [edi+112], eax
\r
353 ; 1273 : best_len = len;
\r
355 00118 8b c2 mov eax, edx
\r
357 ; 1274 : if (len >= nice_match) break;
\r
359 0011a 3b 55 f4 cmp edx, DWORD PTR _nice_match$[ebp]
\r
360 0011d 7d 2b jge SHORT $LN11@longest_ma
\r
362 ; 1275 : #ifdef UNALIGNED_OK
\r
363 ; 1276 : scan_end = *(ushf*)(scan+best_len-1);
\r
365 ; 1278 : scan_end1 = scan[best_len-1];
\r
367 0011f 8a 5c 0a ff mov bl, BYTE PTR [edx+ecx-1]
\r
369 ; 1279 : scan_end = scan[best_len];
\r
371 00123 8a 14 0a mov dl, BYTE PTR [edx+ecx]
\r
372 00126 88 5d ff mov BYTE PTR _scan_end1$[ebp], bl
\r
373 00129 88 55 fe mov BYTE PTR _scan_end$[ebp], dl
\r
378 ; 1282 : } while ((cur_match = prev[cur_match & wmask]) > limit
\r
379 ; 1283 : && --chain_length != 0);
\r
381 0012c 8b 5f 34 mov ebx, DWORD PTR [edi+52]
\r
382 0012f 23 5d 08 and ebx, DWORD PTR _cur_match$[ebp]
\r
383 00132 8b 57 40 mov edx, DWORD PTR [edi+64]
\r
384 00135 0f b7 1c 5a movzx ebx, WORD PTR [edx+ebx*2]
\r
385 00139 89 5d 08 mov DWORD PTR _cur_match$[ebp], ebx
\r
386 0013c 3b 5d f0 cmp ebx, DWORD PTR _limit$[ebp]
\r
387 0013f 76 09 jbe SHORT $LN11@longest_ma
\r
388 00141 ff 4d f8 dec DWORD PTR _chain_length$[ebp]
\r
389 00144 0f 85 28 ff ff
\r
390 ff jne $LL13@longest_ma
\r
394 ; 1285 : if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
\r
396 0014a 8b 4f 74 mov ecx, DWORD PTR [edi+116]
\r
399 0014f 3b c1 cmp eax, ecx
\r
400 00151 76 02 jbe SHORT $LN16@longest_ma
\r
402 ; 1286 : return s->lookahead;
\r
404 00153 8b c1 mov eax, ecx
\r
409 00155 8b e5 mov esp, ebp
\r
412 _longest_match ENDP
\r
413 ; Function compile flags: /Ogtp
\r
417 _lm_init PROC ; COMDAT
\r
420 ; 1107 : s->window_size = (ulg)2L*s->w_size;
\r
422 00000 8b 46 2c mov eax, DWORD PTR [esi+44]
\r
425 ; 1109 : CLEAR_HASH(s);
\r
427 00003 8b 4e 4c mov ecx, DWORD PTR [esi+76]
\r
428 00006 8b 56 44 mov edx, DWORD PTR [esi+68]
\r
429 00009 03 c0 add eax, eax
\r
430 0000b 89 46 3c mov DWORD PTR [esi+60], eax
\r
431 0000e 33 c0 xor eax, eax
\r
432 00010 66 89 44 4a fe mov WORD PTR [edx+ecx*2-2], ax
\r
433 00015 8b 4e 4c mov ecx, DWORD PTR [esi+76]
\r
434 00018 8b 46 44 mov eax, DWORD PTR [esi+68]
\r
436 0001c 8d 54 09 fe lea edx, DWORD PTR [ecx+ecx-2]
\r
438 00021 33 ff xor edi, edi
\r
441 00025 e8 00 00 00 00 call _memset
\r
444 ; 1111 : /* Set the default configuration parameters:
\r
446 ; 1113 : s->max_lazy_match = configuration_table[s->level].max_lazy;
\r
448 0002a 8b 86 84 00 00
\r
449 00 mov eax, DWORD PTR [esi+132]
\r
450 00030 8d 04 40 lea eax, DWORD PTR [eax+eax*2]
\r
451 00033 03 c0 add eax, eax
\r
452 00035 0f b7 8c 00 02
\r
453 00 00 00 movzx ecx, WORD PTR _configuration_table[eax+eax+2]
\r
454 0003d 03 c0 add eax, eax
\r
455 0003f 89 8e 80 00 00
\r
456 00 mov DWORD PTR [esi+128], ecx
\r
458 ; 1114 : s->good_match = configuration_table[s->level].good_length;
\r
460 00045 0f b7 90 00 00
\r
461 00 00 movzx edx, WORD PTR _configuration_table[eax]
\r
462 0004c 89 96 8c 00 00
\r
463 00 mov DWORD PTR [esi+140], edx
\r
465 ; 1115 : s->nice_match = configuration_table[s->level].nice_length;
\r
467 00052 0f b7 88 04 00
\r
468 00 00 movzx ecx, WORD PTR _configuration_table[eax+4]
\r
469 00059 89 8e 90 00 00
\r
470 00 mov DWORD PTR [esi+144], ecx
\r
472 ; 1116 : s->max_chain_length = configuration_table[s->level].max_chain;
\r
474 0005f 0f b7 90 06 00
\r
475 00 00 movzx edx, WORD PTR _configuration_table[eax+6]
\r
478 ; 1118 : s->strstart = 0;
\r
479 ; 1119 : s->block_start = 0L;
\r
480 ; 1120 : s->lookahead = 0;
\r
481 ; 1121 : s->insert = 0;
\r
482 ; 1122 : s->match_length = s->prev_length = MIN_MATCH-1;
\r
484 00066 b8 02 00 00 00 mov eax, 2
\r
485 0006b 83 c4 0c add esp, 12 ; 0000000cH
\r
486 0006e 89 7e 6c mov DWORD PTR [esi+108], edi
\r
487 00071 89 7e 5c mov DWORD PTR [esi+92], edi
\r
488 00074 89 7e 74 mov DWORD PTR [esi+116], edi
\r
489 00077 89 be b4 16 00
\r
490 00 mov DWORD PTR [esi+5812], edi
\r
492 ; 1123 : s->match_available = 0;
\r
494 0007d 89 7e 68 mov DWORD PTR [esi+104], edi
\r
496 ; 1124 : s->ins_h = 0;
\r
498 00080 89 7e 48 mov DWORD PTR [esi+72], edi
\r
499 00083 89 56 7c mov DWORD PTR [esi+124], edx
\r
500 00086 89 46 78 mov DWORD PTR [esi+120], eax
\r
501 00089 89 46 60 mov DWORD PTR [esi+96], eax
\r
504 ; 1125 : #ifndef FASTEST
\r
505 ; 1126 : #ifdef ASMV
\r
506 ; 1127 : match_init(); /* initialize the asm code */
\r
514 PUBLIC _deflateEnd@4
\r
515 ; Function compile flags: /Ogtp
\r
516 ; COMDAT _deflateEnd@4
\r
518 _strm$ = 8 ; size = 4
\r
519 _deflateEnd@4 PROC ; COMDAT
\r
524 00001 8b ec mov ebp, esp
\r
527 ; 980 : int status;
\r
529 ; 982 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
531 00004 8b 75 08 mov esi, DWORD PTR _strm$[ebp]
\r
532 00007 85 f6 test esi, esi
\r
533 00009 0f 84 c2 00 00
\r
534 00 je $LN6@deflateEnd
\r
535 0000f 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
536 00012 85 c0 test eax, eax
\r
537 00014 0f 84 b7 00 00
\r
538 00 je $LN6@deflateEnd
\r
541 ; 984 : status = strm->state->status;
\r
544 0001b 8b 78 04 mov edi, DWORD PTR [eax+4]
\r
546 ; 985 : if (status != INIT_STATE &&
\r
547 ; 986 : status != EXTRA_STATE &&
\r
548 ; 987 : status != NAME_STATE &&
\r
549 ; 988 : status != COMMENT_STATE &&
\r
550 ; 989 : status != HCRC_STATE &&
\r
551 ; 990 : status != BUSY_STATE &&
\r
552 ; 991 : status != FINISH_STATE) {
\r
554 0001e 83 ff 2a cmp edi, 42 ; 0000002aH
\r
555 00021 74 2c je SHORT $LN5@deflateEnd
\r
556 00023 83 ff 45 cmp edi, 69 ; 00000045H
\r
557 00026 74 27 je SHORT $LN5@deflateEnd
\r
558 00028 83 ff 49 cmp edi, 73 ; 00000049H
\r
559 0002b 74 22 je SHORT $LN5@deflateEnd
\r
560 0002d 83 ff 5b cmp edi, 91 ; 0000005bH
\r
561 00030 74 1d je SHORT $LN5@deflateEnd
\r
562 00032 83 ff 67 cmp edi, 103 ; 00000067H
\r
563 00035 74 18 je SHORT $LN5@deflateEnd
\r
564 00037 83 ff 71 cmp edi, 113 ; 00000071H
\r
565 0003a 74 13 je SHORT $LN5@deflateEnd
\r
566 0003c 81 ff 9a 02 00
\r
567 00 cmp edi, 666 ; 0000029aH
\r
568 00042 74 0b je SHORT $LN5@deflateEnd
\r
570 ; 992 : return Z_STREAM_ERROR;
\r
573 00045 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
579 0004c c2 04 00 ret 4
\r
584 ; 995 : /* Deallocate in reverse order of allocations: */
\r
585 ; 996 : TRY_FREE(strm, strm->state->pending_buf);
\r
587 0004f 8b 40 08 mov eax, DWORD PTR [eax+8]
\r
588 00052 85 c0 test eax, eax
\r
589 00054 74 0d je SHORT $LN4@deflateEnd
\r
590 00056 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
592 0005a 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
594 0005e ff d1 call ecx
\r
595 00060 83 c4 08 add esp, 8
\r
598 ; 997 : TRY_FREE(strm, strm->state->head);
\r
600 00063 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
601 00066 8b 42 44 mov eax, DWORD PTR [edx+68]
\r
602 00069 85 c0 test eax, eax
\r
603 0006b 74 0d je SHORT $LN3@deflateEnd
\r
604 0006d 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
606 00071 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
608 00075 ff d1 call ecx
\r
609 00077 83 c4 08 add esp, 8
\r
612 ; 998 : TRY_FREE(strm, strm->state->prev);
\r
614 0007a 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
615 0007d 8b 42 40 mov eax, DWORD PTR [edx+64]
\r
616 00080 85 c0 test eax, eax
\r
617 00082 74 0d je SHORT $LN2@deflateEnd
\r
618 00084 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
620 00088 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
622 0008c ff d1 call ecx
\r
623 0008e 83 c4 08 add esp, 8
\r
626 ; 999 : TRY_FREE(strm, strm->state->window);
\r
628 00091 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
629 00094 8b 42 38 mov eax, DWORD PTR [edx+56]
\r
630 00097 85 c0 test eax, eax
\r
631 00099 74 0d je SHORT $LN1@deflateEnd
\r
632 0009b 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
634 0009f 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
636 000a3 ff d1 call ecx
\r
637 000a5 83 c4 08 add esp, 8
\r
641 ; 1001 : ZFREE(strm, strm->state);
\r
643 000a8 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
644 000ab 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
645 000ae 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
648 000b3 ff d1 call ecx
\r
649 000b5 83 c4 08 add esp, 8
\r
651 ; 1002 : strm->state = Z_NULL;
\r
653 ; 1004 : return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
\r
655 000b8 33 c0 xor eax, eax
\r
656 000ba 83 ff 71 cmp edi, 113 ; 00000071H
\r
657 000bd 0f 95 c0 setne al
\r
659 000c1 c7 46 1c 00 00
\r
660 00 00 mov DWORD PTR [esi+28], 0
\r
663 000ca 83 e0 fd and eax, -3 ; fffffffdH
\r
668 000ce c2 04 00 ret 4
\r
671 ; 980 : int status;
\r
673 ; 982 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
675 000d1 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
681 000d8 c2 04 00 ret 4
\r
683 ; Function compile flags: /Ogtp
\r
685 ; COMDAT _flush_pending
\r
687 _flush_pending PROC ; COMDAT
\r
694 ; 643 : unsigned len;
\r
695 ; 644 : deflate_state *s = strm->state;
\r
697 00001 8b 5f 1c mov ebx, DWORD PTR [edi+28]
\r
701 ; 646 : _tr_flush_bits(s);
\r
703 00005 8b c3 mov eax, ebx
\r
704 00007 e8 00 00 00 00 call __tr_flush_bits
\r
706 ; 647 : len = s->pending;
\r
708 0000c 8b 73 14 mov esi, DWORD PTR [ebx+20]
\r
710 ; 648 : if (len > strm->avail_out) len = strm->avail_out;
\r
712 0000f 8b 47 10 mov eax, DWORD PTR [edi+16]
\r
713 00012 3b f0 cmp esi, eax
\r
714 00014 76 02 jbe SHORT $LN3@flush_pend
\r
715 00016 8b f0 mov esi, eax
\r
718 ; 649 : if (len == 0) return;
\r
720 00018 85 f6 test esi, esi
\r
721 0001a 74 28 je SHORT $LN1@flush_pend
\r
724 ; 651 : zmemcpy(strm->next_out, s->pending_out, len);
\r
726 0001c 8b 43 10 mov eax, DWORD PTR [ebx+16]
\r
727 0001f 8b 4f 0c mov ecx, DWORD PTR [edi+12]
\r
731 00025 e8 00 00 00 00 call _memcpy
\r
733 ; 652 : strm->next_out += len;
\r
735 0002a 01 77 0c add DWORD PTR [edi+12], esi
\r
737 ; 653 : s->pending_out += len;
\r
739 0002d 01 73 10 add DWORD PTR [ebx+16], esi
\r
741 ; 654 : strm->total_out += len;
\r
743 00030 01 77 14 add DWORD PTR [edi+20], esi
\r
745 ; 655 : strm->avail_out -= len;
\r
747 00033 29 77 10 sub DWORD PTR [edi+16], esi
\r
748 00036 83 c4 0c add esp, 12 ; 0000000cH
\r
750 ; 656 : s->pending -= len;
\r
752 00039 29 73 14 sub DWORD PTR [ebx+20], esi
\r
754 ; 657 : if (s->pending == 0) {
\r
756 0003c 75 06 jne SHORT $LN1@flush_pend
\r
758 ; 658 : s->pending_out = s->pending_buf;
\r
760 0003e 8b 53 08 mov edx, DWORD PTR [ebx+8]
\r
761 00041 89 53 10 mov DWORD PTR [ebx+16], edx
\r
770 _flush_pending ENDP
\r
771 ; Function compile flags: /Ogtp
\r
773 ; COMDAT _putShortMSB
\r
775 _putShortMSB PROC ; COMDAT
\r
783 ; 630 : put_byte(s, (Byte)(b >> 8));
\r
785 00001 8b 70 08 mov esi, DWORD PTR [eax+8]
\r
787 00005 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
788 00008 8b d1 mov edx, ecx
\r
789 0000a c1 ea 08 shr edx, 8
\r
790 0000d 88 14 3e mov BYTE PTR [esi+edi], dl
\r
792 ; 631 : put_byte(s, (Byte)(b & 0xff));
\r
794 00010 8b 78 08 mov edi, DWORD PTR [eax+8]
\r
795 00013 be 01 00 00 00 mov esi, 1
\r
796 00018 01 70 14 add DWORD PTR [eax+20], esi
\r
797 0001b 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
798 0001e 88 0c 3a mov BYTE PTR [edx+edi], cl
\r
799 00021 01 70 14 add DWORD PTR [eax+20], esi
\r
808 PUBLIC _deflateBound@8
\r
809 ; Function compile flags: /Ogtp
\r
810 ; COMDAT _deflateBound@8
\r
812 _strm$ = 8 ; size = 4
\r
813 _complen$ = 12 ; size = 4
\r
814 _sourceLen$ = 12 ; size = 4
\r
815 _deflateBound@8 PROC ; COMDAT
\r
820 00001 8b ec mov ebp, esp
\r
822 ; 568 : deflate_state *s;
\r
823 ; 569 : uLong complen, wraplen;
\r
824 ; 570 : Bytef *str;
\r
826 ; 572 : /* conservative upper bound for compressed data */
\r
827 ; 573 : complen = sourceLen +
\r
828 ; 574 : ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
\r
830 00003 8b 55 0c mov edx, DWORD PTR _sourceLen$[ebp]
\r
831 00006 8d 42 3f lea eax, DWORD PTR [edx+63]
\r
832 00009 c1 e8 06 shr eax, 6
\r
833 0000c 8d 4a 07 lea ecx, DWORD PTR [edx+7]
\r
834 0000f 03 c2 add eax, edx
\r
835 00011 c1 e9 03 shr ecx, 3
\r
836 00014 8d 4c 01 05 lea ecx, DWORD PTR [ecx+eax+5]
\r
839 ; 576 : /* if can't get parameters, return conservative bound plus zlib wrapper */
\r
840 ; 577 : if (strm == Z_NULL || strm->state == Z_NULL)
\r
842 00018 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
844 0001c 89 4d 0c mov DWORD PTR _complen$[ebp], ecx
\r
845 0001f 85 c0 test eax, eax
\r
846 00021 0f 84 ac 00 00
\r
847 00 je $LN20@deflateBou
\r
848 00027 8b 78 1c mov edi, DWORD PTR [eax+28]
\r
849 0002a 85 ff test edi, edi
\r
850 0002c 0f 84 a1 00 00
\r
851 00 je $LN20@deflateBou
\r
854 ; 580 : /* compute wrapper length */
\r
855 ; 581 : s = strm->state;
\r
856 ; 582 : switch (s->wrap) {
\r
858 00032 8b 47 18 mov eax, DWORD PTR [edi+24]
\r
859 00035 83 e8 00 sub eax, 0
\r
861 00039 74 5f je SHORT $LN17@deflateBou
\r
863 0003c 74 4d je SHORT $LN16@deflateBou
\r
865 0003f 74 07 je SHORT $LN15@deflateBou
\r
867 ; 608 : default: /* for compiler happiness */
\r
868 ; 609 : wraplen = 6;
\r
870 00041 b8 06 00 00 00 mov eax, 6
\r
871 00046 eb 54 jmp SHORT $LN28@deflateBou
\r
874 ; 589 : case 2: /* gzip wrapper */
\r
875 ; 590 : wraplen = 18;
\r
876 ; 591 : if (s->gzhead != Z_NULL) { /* user-supplied gzip header */
\r
878 00048 8b 77 1c mov esi, DWORD PTR [edi+28]
\r
879 0004b b8 12 00 00 00 mov eax, 18 ; 00000012H
\r
880 00050 85 f6 test esi, esi
\r
881 00052 74 48 je SHORT $LN28@deflateBou
\r
883 ; 592 : if (s->gzhead->extra != Z_NULL)
\r
885 00054 83 7e 10 00 cmp DWORD PTR [esi+16], 0
\r
886 00058 74 06 je SHORT $LN13@deflateBou
\r
888 ; 593 : wraplen += 2 + s->gzhead->extra_len;
\r
890 0005a 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
891 0005d 83 c0 14 add eax, 20 ; 00000014H
\r
894 ; 594 : str = s->gzhead->name;
\r
896 00060 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
899 ; 595 : if (str != Z_NULL)
\r
901 00064 85 c9 test ecx, ecx
\r
902 00066 74 08 je SHORT $LN9@deflateBou
\r
907 ; 598 : } while (*str++);
\r
909 00068 8a 19 mov bl, BYTE PTR [ecx]
\r
912 0006c 84 db test bl, bl
\r
913 0006e 75 f8 jne SHORT $LL11@deflateBou
\r
916 ; 599 : str = s->gzhead->comment;
\r
918 00070 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
920 ; 600 : if (str != Z_NULL)
\r
922 00073 85 c9 test ecx, ecx
\r
923 00075 74 08 je SHORT $LN5@deflateBou
\r
928 ; 603 : } while (*str++);
\r
930 00077 8a 19 mov bl, BYTE PTR [ecx]
\r
933 0007b 84 db test bl, bl
\r
934 0007d 75 f8 jne SHORT $LL7@deflateBou
\r
937 ; 604 : if (s->gzhead->hcrc)
\r
939 0007f 83 7e 2c 00 cmp DWORD PTR [esi+44], 0
\r
941 00084 74 16 je SHORT $LN28@deflateBou
\r
943 ; 605 : wraplen += 2;
\r
945 00086 83 c0 02 add eax, 2
\r
950 00089 eb 11 jmp SHORT $LN28@deflateBou
\r
954 ; 586 : case 1: /* zlib wrapper */
\r
955 ; 587 : wraplen = 6 + (s->strstart ? 4 : 0);
\r
957 0008b 8b 47 6c mov eax, DWORD PTR [edi+108]
\r
958 0008e f7 d8 neg eax
\r
959 00090 1b c0 sbb eax, eax
\r
960 00092 83 e0 04 and eax, 4
\r
961 00095 83 c0 06 add eax, 6
\r
965 00098 eb 02 jmp SHORT $LN28@deflateBou
\r
968 ; 583 : case 0: /* raw deflate */
\r
969 ; 584 : wraplen = 0;
\r
971 0009a 33 c0 xor eax, eax
\r
976 ; 612 : /* if not default parameters, return conservative bound */
\r
977 ; 613 : if (s->w_bits != 15 || s->hash_bits != 8 + 7)
\r
979 0009c b9 0f 00 00 00 mov ecx, 15 ; 0000000fH
\r
980 000a1 39 4f 30 cmp DWORD PTR [edi+48], ecx
\r
981 000a4 75 24 jne SHORT $LN1@deflateBou
\r
982 000a6 39 4f 50 cmp DWORD PTR [edi+80], ecx
\r
983 000a9 75 1f jne SHORT $LN1@deflateBou
\r
986 ; 616 : /* default settings: return tight bound for that case */
\r
987 ; 617 : return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
\r
988 ; 618 : (sourceLen >> 25) + 13 - 6 + wraplen;
\r
990 000ab 8b f2 mov esi, edx
\r
991 000ad c1 ee 0e shr esi, 14 ; 0000000eH
\r
992 000b0 03 f0 add esi, eax
\r
993 000b2 8b ca mov ecx, edx
\r
994 000b4 c1 e9 19 shr ecx, 25 ; 00000019H
\r
995 000b7 8b c2 mov eax, edx
\r
996 000b9 c1 e8 0c shr eax, 12 ; 0000000cH
\r
997 000bc 03 f1 add esi, ecx
\r
998 000be 03 c6 add eax, esi
\r
1000 000c1 8d 44 10 07 lea eax, DWORD PTR [eax+edx+7]
\r
1006 000c7 c2 08 00 ret 8
\r
1009 ; 614 : return complen + wraplen;
\r
1011 000ca 03 45 0c add eax, DWORD PTR _complen$[ebp]
\r
1018 000d0 c2 08 00 ret 8
\r
1021 ; 578 : return complen + 6;
\r
1023 000d3 8d 41 06 lea eax, DWORD PTR [ecx+6]
\r
1029 000d8 c2 08 00 ret 8
\r
1030 _deflateBound@8 ENDP
\r
1032 PUBLIC _deflateTune@20
\r
1033 ; Function compile flags: /Ogtp
\r
1034 ; COMDAT _deflateTune@20
\r
1036 _strm$ = 8 ; size = 4
\r
1037 _good_length$ = 12 ; size = 4
\r
1038 _max_lazy$ = 16 ; size = 4
\r
1039 _nice_length$ = 20 ; size = 4
\r
1040 _max_chain$ = 24 ; size = 4
\r
1041 _deflateTune@20 PROC ; COMDAT
\r
1046 00001 8b ec mov ebp, esp
\r
1048 ; 536 : deflate_state *s;
\r
1050 ; 538 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1052 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
1053 00006 85 c0 test eax, eax
\r
1054 00008 74 2e je SHORT $LN1@deflateTun
\r
1055 0000a 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
1056 0000d 85 c0 test eax, eax
\r
1057 0000f 74 27 je SHORT $LN1@deflateTun
\r
1059 ; 539 : s = strm->state;
\r
1060 ; 540 : s->good_match = good_length;
\r
1062 00011 8b 4d 0c mov ecx, DWORD PTR _good_length$[ebp]
\r
1064 ; 541 : s->max_lazy_match = max_lazy;
\r
1066 00014 8b 55 10 mov edx, DWORD PTR _max_lazy$[ebp]
\r
1067 00017 89 88 8c 00 00
\r
1068 00 mov DWORD PTR [eax+140], ecx
\r
1070 ; 542 : s->nice_match = nice_length;
\r
1072 0001d 8b 4d 14 mov ecx, DWORD PTR _nice_length$[ebp]
\r
1073 00020 89 90 80 00 00
\r
1074 00 mov DWORD PTR [eax+128], edx
\r
1076 ; 543 : s->max_chain_length = max_chain;
\r
1078 00026 8b 55 18 mov edx, DWORD PTR _max_chain$[ebp]
\r
1079 00029 89 88 90 00 00
\r
1080 00 mov DWORD PTR [eax+144], ecx
\r
1081 0002f 89 50 7c mov DWORD PTR [eax+124], edx
\r
1083 ; 544 : return Z_OK;
\r
1085 00032 33 c0 xor eax, eax
\r
1090 00035 c2 14 00 ret 20 ; 00000014H
\r
1093 ; 536 : deflate_state *s;
\r
1095 ; 538 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1097 00038 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
1102 0003e c2 14 00 ret 20 ; 00000014H
\r
1103 _deflateTune@20 ENDP
\r
1105 PUBLIC _deflatePrime@12
\r
1106 ; Function compile flags: /Ogtp
\r
1107 ; COMDAT _deflatePrime@12
\r
1109 _strm$ = 8 ; size = 4
\r
1110 _bits$ = 12 ; size = 4
\r
1111 _value$ = 16 ; size = 4
\r
1112 _deflatePrime@12 PROC ; COMDAT
\r
1117 00001 8b ec mov ebp, esp
\r
1119 ; 469 : deflate_state *s;
\r
1122 ; 472 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1124 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
1125 00006 85 c0 test eax, eax
\r
1126 00008 74 74 je SHORT $LN6@deflatePri
\r
1127 0000a 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
1128 0000d 85 c0 test eax, eax
\r
1129 0000f 74 6d je SHORT $LN6@deflatePri
\r
1131 ; 473 : s = strm->state;
\r
1132 ; 474 : if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
\r
1134 00011 8b 48 10 mov ecx, DWORD PTR [eax+16]
\r
1135 00014 83 c1 02 add ecx, 2
\r
1136 00017 39 88 a4 16 00
\r
1137 00 cmp DWORD PTR [eax+5796], ecx
\r
1138 0001d 73 09 jae SHORT $LN10@deflatePri
\r
1140 ; 475 : return Z_BUF_ERROR;
\r
1142 0001f b8 fb ff ff ff mov eax, -5 ; fffffffbH
\r
1147 00025 c2 0c 00 ret 12 ; 0000000cH
\r
1153 ; 475 : return Z_BUF_ERROR;
\r
1155 0002b 8b 7d 0c mov edi, DWORD PTR _bits$[ebp]
\r
1156 0002e 8b ff npad 2
\r
1160 ; 477 : put = Buf_size - s->bi_valid;
\r
1162 00030 8b 90 bc 16 00
\r
1163 00 mov edx, DWORD PTR [eax+5820]
\r
1164 00036 be 10 00 00 00 mov esi, 16 ; 00000010H
\r
1165 0003b 2b f2 sub esi, edx
\r
1167 ; 478 : if (put > bits)
\r
1169 0003d 3b f7 cmp esi, edi
\r
1170 0003f 7e 02 jle SHORT $LN1@deflatePri
\r
1172 ; 479 : put = bits;
\r
1174 00041 8b f7 mov esi, edi
\r
1177 ; 480 : s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
\r
1179 00043 8b ce mov ecx, esi
\r
1180 00045 bb 01 00 00 00 mov ebx, 1
\r
1181 0004a 66 d3 e3 shl bx, cl
\r
1182 0004d 8b ca mov ecx, edx
\r
1184 ; 481 : s->bi_valid += put;
\r
1186 0004f 03 d6 add edx, esi
\r
1187 00051 89 90 bc 16 00
\r
1188 00 mov DWORD PTR [eax+5820], edx
\r
1189 00057 66 4b dec bx
\r
1190 00059 66 23 5d 10 and bx, WORD PTR _value$[ebp]
\r
1191 0005d 66 d3 e3 shl bx, cl
\r
1192 00060 66 09 98 b8 16
\r
1193 00 00 or WORD PTR [eax+5816], bx
\r
1195 ; 482 : _tr_flush_bits(s);
\r
1197 00067 e8 00 00 00 00 call __tr_flush_bits
\r
1199 ; 483 : value >>= put;
\r
1201 0006c 8b ce mov ecx, esi
\r
1202 0006e d3 7d 10 sar DWORD PTR _value$[ebp], cl
\r
1204 ; 484 : bits -= put;
\r
1206 00071 2b fe sub edi, esi
\r
1208 ; 485 : } while (bits);
\r
1210 00073 75 bb jne SHORT $LL4@deflatePri
\r
1212 ; 486 : return Z_OK;
\r
1216 00077 33 c0 xor eax, eax
\r
1222 0007b c2 0c 00 ret 12 ; 0000000cH
\r
1225 ; 469 : deflate_state *s;
\r
1228 ; 472 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1230 0007e b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
1235 00084 c2 0c 00 ret 12 ; 0000000cH
\r
1236 _deflatePrime@12 ENDP
\r
1238 PUBLIC _deflatePending@12
\r
1239 ; Function compile flags: /Ogtp
\r
1240 ; COMDAT _deflatePending@12
\r
1242 _strm$ = 8 ; size = 4
\r
1243 _pending$ = 12 ; size = 4
\r
1244 _bits$ = 16 ; size = 4
\r
1245 _deflatePending@12 PROC ; COMDAT
\r
1250 00001 8b ec mov ebp, esp
\r
1252 ; 455 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1254 00003 8b 55 08 mov edx, DWORD PTR _strm$[ebp]
\r
1255 00006 85 d2 test edx, edx
\r
1256 00008 74 2b je SHORT $LN3@deflatePen
\r
1257 0000a 8b 42 1c mov eax, DWORD PTR [edx+28]
\r
1258 0000d 85 c0 test eax, eax
\r
1259 0000f 74 24 je SHORT $LN3@deflatePen
\r
1261 ; 456 : if (pending != Z_NULL)
\r
1263 00011 8b 4d 0c mov ecx, DWORD PTR _pending$[ebp]
\r
1264 00014 85 c9 test ecx, ecx
\r
1265 00016 74 05 je SHORT $LN2@deflatePen
\r
1267 ; 457 : *pending = strm->state->pending;
\r
1269 00018 8b 40 14 mov eax, DWORD PTR [eax+20]
\r
1270 0001b 89 01 mov DWORD PTR [ecx], eax
\r
1273 ; 458 : if (bits != Z_NULL)
\r
1275 0001d 8b 45 10 mov eax, DWORD PTR _bits$[ebp]
\r
1276 00020 85 c0 test eax, eax
\r
1277 00022 74 0b je SHORT $LN1@deflatePen
\r
1279 ; 459 : *bits = strm->state->bi_valid;
\r
1281 00024 8b 4a 1c mov ecx, DWORD PTR [edx+28]
\r
1282 00027 8b 91 bc 16 00
\r
1283 00 mov edx, DWORD PTR [ecx+5820]
\r
1284 0002d 89 10 mov DWORD PTR [eax], edx
\r
1287 ; 460 : return Z_OK;
\r
1289 0002f 33 c0 xor eax, eax
\r
1294 00032 c2 0c 00 ret 12 ; 0000000cH
\r
1297 ; 455 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1299 00035 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
1304 0003b c2 0c 00 ret 12 ; 0000000cH
\r
1305 _deflatePending@12 ENDP
\r
1307 PUBLIC _deflateSetHeader@8
\r
1308 ; Function compile flags: /Ogtp
\r
1309 ; COMDAT _deflateSetHeader@8
\r
1311 _strm$ = 8 ; size = 4
\r
1312 _head$ = 12 ; size = 4
\r
1313 _deflateSetHeader@8 PROC ; COMDAT
\r
1318 00001 8b ec mov ebp, esp
\r
1320 ; 443 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1322 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
1323 00006 85 c0 test eax, eax
\r
1324 00008 74 19 je SHORT $LN2@deflateSet
\r
1325 0000a 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
1326 0000d 85 c0 test eax, eax
\r
1327 0000f 74 12 je SHORT $LN2@deflateSet
\r
1329 ; 444 : if (strm->state->wrap != 2) return Z_STREAM_ERROR;
\r
1331 00011 83 78 18 02 cmp DWORD PTR [eax+24], 2
\r
1332 00015 75 0c jne SHORT $LN2@deflateSet
\r
1334 ; 445 : strm->state->gzhead = head;
\r
1336 00017 8b 4d 0c mov ecx, DWORD PTR _head$[ebp]
\r
1337 0001a 89 48 1c mov DWORD PTR [eax+28], ecx
\r
1339 ; 446 : return Z_OK;
\r
1341 0001d 33 c0 xor eax, eax
\r
1346 00020 c2 08 00 ret 8
\r
1349 ; 443 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1351 00023 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
1356 00029 c2 08 00 ret 8
\r
1357 _deflateSetHeader@8 ENDP
\r
1358 ; Function compile flags: /Ogtp
\r
1359 ; COMDAT _read_buf
\r
1361 _read_buf PROC ; COMDAT
\r
1366 ; 1079 : unsigned len = strm->avail_in;
\r
1368 00000 8b 46 04 mov eax, DWORD PTR [esi+4]
\r
1370 00004 8b f8 mov edi, eax
\r
1373 ; 1081 : if (len > size) len = size;
\r
1375 00006 3b f9 cmp edi, ecx
\r
1376 00008 76 02 jbe SHORT $LN5@read_buf
\r
1377 0000a 8b f9 mov edi, ecx
\r
1380 ; 1082 : if (len == 0) return 0;
\r
1382 0000c 85 ff test edi, edi
\r
1383 0000e 75 04 jne SHORT $LN4@read_buf
\r
1384 00010 33 c0 xor eax, eax
\r
1393 ; 1084 : strm->avail_in -= len;
\r
1395 00014 2b c7 sub eax, edi
\r
1396 00016 89 46 04 mov DWORD PTR [esi+4], eax
\r
1399 ; 1086 : zmemcpy(buf, strm->next_in, len);
\r
1401 00019 8b 06 mov eax, DWORD PTR [esi]
\r
1405 0001e e8 00 00 00 00 call _memcpy
\r
1407 ; 1087 : if (strm->state->wrap == 1) {
\r
1409 00023 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
1410 00026 8b 41 18 mov eax, DWORD PTR [ecx+24]
\r
1411 00029 83 c4 0c add esp, 12 ; 0000000cH
\r
1412 0002c 83 f8 01 cmp eax, 1
\r
1413 0002f 75 17 jne SHORT $LN3@read_buf
\r
1415 ; 1088 : strm->adler = adler32(strm->adler, buf, len);
\r
1417 00031 8b 56 30 mov edx, DWORD PTR [esi+48]
\r
1421 00037 e8 00 00 00 00 call _adler32@12
\r
1425 ; 1095 : strm->next_in += len;
\r
1427 0003c 01 3e add DWORD PTR [esi], edi
\r
1429 ; 1096 : strm->total_in += len;
\r
1431 0003e 01 7e 08 add DWORD PTR [esi+8], edi
\r
1432 00041 89 46 30 mov DWORD PTR [esi+48], eax
\r
1435 ; 1098 : return (int)len;
\r
1437 00044 8b c7 mov eax, edi
\r
1446 ; 1090 : #ifdef GZIP
\r
1447 ; 1091 : else if (strm->state->wrap == 2) {
\r
1449 00048 83 f8 02 cmp eax, 2
\r
1450 0004b 75 0e jne SHORT $LN1@read_buf
\r
1452 ; 1092 : strm->adler = crc32(strm->adler, buf, len);
\r
1454 0004d 8b 46 30 mov eax, DWORD PTR [esi+48]
\r
1458 00053 e8 00 00 00 00 call _crc32@12
\r
1459 00058 89 46 30 mov DWORD PTR [esi+48], eax
\r
1464 ; 1095 : strm->next_in += len;
\r
1466 0005b 01 3e add DWORD PTR [esi], edi
\r
1468 ; 1096 : strm->total_in += len;
\r
1470 0005d 01 7e 08 add DWORD PTR [esi+8], edi
\r
1473 ; 1098 : return (int)len;
\r
1475 00060 8b c7 mov eax, edi
\r
1483 PUBLIC _deflateCopy@8
\r
1484 ; Function compile flags: /Ogtp
\r
1485 ; COMDAT _deflateCopy@8
\r
1487 _dest$ = 8 ; size = 4
\r
1488 tv260 = 12 ; size = 4
\r
1489 _overlay$ = 12 ; size = 4
\r
1490 _source$ = 12 ; size = 4
\r
1491 _deflateCopy@8 PROC ; COMDAT
\r
1496 00001 8b ec mov ebp, esp
\r
1500 ; 1016 : #ifdef MAXSEG_64K
\r
1501 ; 1017 : return Z_STREAM_ERROR;
\r
1503 ; 1019 : deflate_state *ds;
\r
1504 ; 1020 : deflate_state *ss;
\r
1505 ; 1021 : ushf *overlay;
\r
1508 ; 1024 : if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
\r
1510 00005 8b 75 0c mov esi, DWORD PTR _source$[ebp]
\r
1511 00008 85 f6 test esi, esi
\r
1512 0000a 0f 84 84 01 00
\r
1513 00 je $LN4@deflateCop
\r
1514 00010 8b 5d 08 mov ebx, DWORD PTR _dest$[ebp]
\r
1515 00013 85 db test ebx, ebx
\r
1516 00015 0f 84 79 01 00
\r
1517 00 je $LN4@deflateCop
\r
1518 0001b 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
1519 0001e 89 45 0c mov DWORD PTR tv260[ebp], eax
\r
1520 00021 85 c0 test eax, eax
\r
1521 00023 0f 84 6b 01 00
\r
1522 00 je $LN4@deflateCop
\r
1526 ; 1028 : ss = source->state;
\r
1528 ; 1030 : zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
\r
1531 0002a b9 0e 00 00 00 mov ecx, 14 ; 0000000eH
\r
1532 0002f 8b fb mov edi, ebx
\r
1533 00031 f3 a5 rep movsd
\r
1536 ; 1032 : ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
\r
1538 00033 8b 43 28 mov eax, DWORD PTR [ebx+40]
\r
1539 00036 8b 4b 20 mov ecx, DWORD PTR [ebx+32]
\r
1540 00039 68 c4 16 00 00 push 5828 ; 000016c4H
\r
1541 0003e 6a 01 push 1
\r
1543 00041 ff d1 call ecx
\r
1544 00043 8b f0 mov esi, eax
\r
1545 00045 83 c4 0c add esp, 12 ; 0000000cH
\r
1547 ; 1033 : if (ds == Z_NULL) return Z_MEM_ERROR;
\r
1549 00048 85 f6 test esi, esi
\r
1550 0004a 0f 84 38 01 00
\r
1551 00 je $LN9@deflateCop
\r
1553 ; 1034 : dest->state = (struct internal_state FAR *) ds;
\r
1554 ; 1035 : zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
\r
1556 00050 8b 7d 0c mov edi, DWORD PTR tv260[ebp]
\r
1557 00053 68 c4 16 00 00 push 5828 ; 000016c4H
\r
1560 0005a 89 73 1c mov DWORD PTR [ebx+28], esi
\r
1561 0005d e8 00 00 00 00 call _memcpy
\r
1563 ; 1036 : ds->strm = dest;
\r
1565 ; 1038 : ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
\r
1567 00062 8b 56 2c mov edx, DWORD PTR [esi+44]
\r
1568 00065 89 1e mov DWORD PTR [esi], ebx
\r
1569 00067 8b 43 28 mov eax, DWORD PTR [ebx+40]
\r
1570 0006a 8b 4b 20 mov ecx, DWORD PTR [ebx+32]
\r
1571 0006d 6a 02 push 2
\r
1574 00071 ff d1 call ecx
\r
1576 ; 1039 : ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
\r
1578 00073 8b 56 2c mov edx, DWORD PTR [esi+44]
\r
1579 00076 89 46 38 mov DWORD PTR [esi+56], eax
\r
1580 00079 8b 43 28 mov eax, DWORD PTR [ebx+40]
\r
1581 0007c 8b 4b 20 mov ecx, DWORD PTR [ebx+32]
\r
1582 0007f 6a 02 push 2
\r
1585 00083 ff d1 call ecx
\r
1587 ; 1040 : ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
\r
1589 00085 8b 56 4c mov edx, DWORD PTR [esi+76]
\r
1590 00088 89 46 40 mov DWORD PTR [esi+64], eax
\r
1591 0008b 8b 43 28 mov eax, DWORD PTR [ebx+40]
\r
1592 0008e 8b 4b 20 mov ecx, DWORD PTR [ebx+32]
\r
1593 00091 6a 02 push 2
\r
1596 00095 ff d1 call ecx
\r
1598 ; 1041 : overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
\r
1600 00097 8b 96 9c 16 00
\r
1601 00 mov edx, DWORD PTR [esi+5788]
\r
1602 0009d 89 46 44 mov DWORD PTR [esi+68], eax
\r
1603 000a0 8b 43 28 mov eax, DWORD PTR [ebx+40]
\r
1604 000a3 8b 4b 20 mov ecx, DWORD PTR [ebx+32]
\r
1605 000a6 6a 04 push 4
\r
1608 000aa ff d1 call ecx
\r
1610 ; 1042 : ds->pending_buf = (uchf *) overlay;
\r
1612 ; 1044 : if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
\r
1613 ; 1045 : ds->pending_buf == Z_NULL) {
\r
1615 000ac 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
1616 000af 83 c4 3c add esp, 60 ; 0000003cH
\r
1617 000b2 89 45 0c mov DWORD PTR _overlay$[ebp], eax
\r
1618 000b5 89 46 08 mov DWORD PTR [esi+8], eax
\r
1619 000b8 85 c9 test ecx, ecx
\r
1620 000ba 0f 84 c2 00 00
\r
1621 00 je $LN1@deflateCop
\r
1622 000c0 83 7e 40 00 cmp DWORD PTR [esi+64], 0
\r
1623 000c4 0f 84 b8 00 00
\r
1624 00 je $LN1@deflateCop
\r
1625 000ca 83 7e 44 00 cmp DWORD PTR [esi+68], 0
\r
1626 000ce 0f 84 ae 00 00
\r
1627 00 je $LN1@deflateCop
\r
1628 000d4 85 c0 test eax, eax
\r
1629 000d6 0f 84 a6 00 00
\r
1630 00 je $LN1@deflateCop
\r
1633 ; 1049 : /* following zmemcpy do not work for 16-bit MSDOS */
\r
1634 ; 1050 : zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
\r
1636 000dc 8b 56 2c mov edx, DWORD PTR [esi+44]
\r
1637 000df 8b 47 38 mov eax, DWORD PTR [edi+56]
\r
1638 000e2 03 d2 add edx, edx
\r
1642 000e7 e8 00 00 00 00 call _memcpy
\r
1644 ; 1051 : zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
\r
1646 000ec 8b 4e 2c mov ecx, DWORD PTR [esi+44]
\r
1647 000ef 8b 57 40 mov edx, DWORD PTR [edi+64]
\r
1648 000f2 8b 46 40 mov eax, DWORD PTR [esi+64]
\r
1649 000f5 03 c9 add ecx, ecx
\r
1653 000fa e8 00 00 00 00 call _memcpy
\r
1655 ; 1052 : zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
\r
1657 000ff 8b 4e 4c mov ecx, DWORD PTR [esi+76]
\r
1658 00102 8b 57 44 mov edx, DWORD PTR [edi+68]
\r
1659 00105 8b 46 44 mov eax, DWORD PTR [esi+68]
\r
1660 00108 03 c9 add ecx, ecx
\r
1664 0010d e8 00 00 00 00 call _memcpy
\r
1666 ; 1053 : zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
\r
1668 00112 8b 4e 0c mov ecx, DWORD PTR [esi+12]
\r
1669 00115 8b 57 08 mov edx, DWORD PTR [edi+8]
\r
1670 00118 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
1674 0011e e8 00 00 00 00 call _memcpy
\r
1677 ; 1055 : ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
\r
1679 00123 8b 57 10 mov edx, DWORD PTR [edi+16]
\r
1680 00126 2b 57 08 sub edx, DWORD PTR [edi+8]
\r
1681 00129 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
1683 ; 1056 : ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
\r
1685 0012c 8b 86 9c 16 00
\r
1686 00 mov eax, DWORD PTR [esi+5788]
\r
1687 00132 8b 7d 0c mov edi, DWORD PTR _overlay$[ebp]
\r
1688 00135 03 d1 add edx, ecx
\r
1689 00137 89 56 10 mov DWORD PTR [esi+16], edx
\r
1690 0013a 8b d0 mov edx, eax
\r
1692 ; 1057 : ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
\r
1694 0013c 8d 0c 41 lea ecx, DWORD PTR [ecx+eax*2]
\r
1695 0013f d1 ea shr edx, 1
\r
1696 00141 03 c8 add ecx, eax
\r
1697 00143 8d 14 57 lea edx, DWORD PTR [edi+edx*2]
\r
1698 00146 83 c4 30 add esp, 48 ; 00000030H
\r
1699 00149 89 96 a4 16 00
\r
1700 00 mov DWORD PTR [esi+5796], edx
\r
1701 0014f 89 8e 98 16 00
\r
1702 00 mov DWORD PTR [esi+5784], ecx
\r
1705 ; 1059 : ds->l_desc.dyn_tree = ds->dyn_ltree;
\r
1706 ; 1060 : ds->d_desc.dyn_tree = ds->dyn_dtree;
\r
1708 00155 8d 86 88 09 00
\r
1709 00 lea eax, DWORD PTR [esi+2440]
\r
1710 0015b 8d 96 94 00 00
\r
1711 00 lea edx, DWORD PTR [esi+148]
\r
1713 ; 1061 : ds->bl_desc.dyn_tree = ds->bl_tree;
\r
1715 00161 8d 8e 7c 0a 00
\r
1716 00 lea ecx, DWORD PTR [esi+2684]
\r
1718 00168 89 86 24 0b 00
\r
1719 00 mov DWORD PTR [esi+2852], eax
\r
1720 0016e 89 96 18 0b 00
\r
1721 00 mov DWORD PTR [esi+2840], edx
\r
1722 00174 89 8e 30 0b 00
\r
1723 00 mov DWORD PTR [esi+2864], ecx
\r
1727 ; 1063 : return Z_OK;
\r
1729 0017b 33 c0 xor eax, eax
\r
1732 ; 1064 : #endif /* MAXSEG_64K */
\r
1736 0017f c2 08 00 ret 8
\r
1739 ; 1046 : deflateEnd (dest);
\r
1742 00183 e8 00 00 00 00 call _deflateEnd@4
\r
1745 ; 1047 : return Z_MEM_ERROR;
\r
1749 0018a b8 fc ff ff ff mov eax, -4 ; fffffffcH
\r
1752 ; 1064 : #endif /* MAXSEG_64K */
\r
1756 00191 c2 08 00 ret 8
\r
1760 ; 1025 : return Z_STREAM_ERROR;
\r
1762 00195 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
1765 ; 1064 : #endif /* MAXSEG_64K */
\r
1769 0019c c2 08 00 ret 8
\r
1770 _deflateCopy@8 ENDP
\r
1772 PUBLIC _deflateResetKeep@4
\r
1773 ; Function compile flags: /Ogtp
\r
1774 ; COMDAT _deflateResetKeep@4
\r
1776 _strm$ = 8 ; size = 4
\r
1777 _deflateResetKeep@4 PROC ; COMDAT
\r
1782 00001 8b ec mov ebp, esp
\r
1787 ; 395 : deflate_state *s;
\r
1789 ; 397 : if (strm == Z_NULL || strm->state == Z_NULL ||
\r
1790 ; 398 : strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
\r
1792 00006 8b 7d 08 mov edi, DWORD PTR _strm$[ebp]
\r
1793 00009 33 db xor ebx, ebx
\r
1794 0000b 3b fb cmp edi, ebx
\r
1795 0000d 0f 84 86 00 00
\r
1796 00 je $LN2@deflateRes
\r
1797 00013 8b 77 1c mov esi, DWORD PTR [edi+28]
\r
1798 00016 3b f3 cmp esi, ebx
\r
1799 00018 74 7f je SHORT $LN2@deflateRes
\r
1800 0001a 39 5f 20 cmp DWORD PTR [edi+32], ebx
\r
1801 0001d 74 7a je SHORT $LN2@deflateRes
\r
1802 0001f 39 5f 24 cmp DWORD PTR [edi+36], ebx
\r
1803 00022 74 75 je SHORT $LN2@deflateRes
\r
1807 ; 402 : strm->total_in = strm->total_out = 0;
\r
1809 00024 89 5f 14 mov DWORD PTR [edi+20], ebx
\r
1810 00027 89 5f 08 mov DWORD PTR [edi+8], ebx
\r
1812 ; 403 : strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
\r
1814 0002a 89 5f 18 mov DWORD PTR [edi+24], ebx
\r
1816 ; 404 : strm->data_type = Z_UNKNOWN;
\r
1818 0002d c7 47 2c 02 00
\r
1819 00 00 mov DWORD PTR [edi+44], 2
\r
1822 ; 406 : s = (deflate_state *)strm->state;
\r
1823 ; 407 : s->pending = 0;
\r
1824 ; 408 : s->pending_out = s->pending_buf;
\r
1826 00034 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
1827 00037 89 46 10 mov DWORD PTR [esi+16], eax
\r
1830 ; 410 : if (s->wrap < 0) {
\r
1832 0003a 8b 46 18 mov eax, DWORD PTR [esi+24]
\r
1833 0003d 89 5e 14 mov DWORD PTR [esi+20], ebx
\r
1834 00040 3b c3 cmp eax, ebx
\r
1835 00042 7d 05 jge SHORT $LN1@deflateRes
\r
1837 ; 411 : s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
\r
1839 00044 f7 d8 neg eax
\r
1840 00046 89 46 18 mov DWORD PTR [esi+24], eax
\r
1844 ; 413 : s->status = s->wrap ? INIT_STATE : BUSY_STATE;
\r
1846 00049 8b 46 18 mov eax, DWORD PTR [esi+24]
\r
1847 0004c 8b c8 mov ecx, eax
\r
1848 0004e f7 d9 neg ecx
\r
1849 00050 1b c9 sbb ecx, ecx
\r
1850 00052 83 e1 b9 and ecx, -71 ; ffffffb9H
\r
1852 ; 414 : strm->adler =
\r
1853 ; 415 : #ifdef GZIP
\r
1854 ; 416 : s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
\r
1856 ; 418 : adler32(0L, Z_NULL, 0);
\r
1859 00056 83 c1 71 add ecx, 113 ; 00000071H
\r
1861 0005a 89 4e 04 mov DWORD PTR [esi+4], ecx
\r
1863 0005e 83 f8 02 cmp eax, 2
\r
1864 00061 75 1b jne SHORT $LN6@deflateRes
\r
1865 00063 e8 00 00 00 00 call _crc32@12
\r
1866 00068 89 47 30 mov DWORD PTR [edi+48], eax
\r
1868 ; 419 : s->last_flush = Z_NO_FLUSH;
\r
1870 ; 421 : _tr_init(s);
\r
1872 0006b 8b d6 mov edx, esi
\r
1873 0006d 89 5e 28 mov DWORD PTR [esi+40], ebx
\r
1874 00070 e8 00 00 00 00 call __tr_init
\r
1879 ; 423 : return Z_OK;
\r
1881 00077 33 c0 xor eax, eax
\r
1887 0007b c2 04 00 ret 4
\r
1890 ; 414 : strm->adler =
\r
1891 ; 415 : #ifdef GZIP
\r
1892 ; 416 : s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
\r
1894 ; 418 : adler32(0L, Z_NULL, 0);
\r
1896 0007e e8 00 00 00 00 call _adler32@12
\r
1897 00083 89 47 30 mov DWORD PTR [edi+48], eax
\r
1899 ; 419 : s->last_flush = Z_NO_FLUSH;
\r
1901 ; 421 : _tr_init(s);
\r
1903 00086 8b d6 mov edx, esi
\r
1904 00088 89 5e 28 mov DWORD PTR [esi+40], ebx
\r
1905 0008b e8 00 00 00 00 call __tr_init
\r
1910 ; 423 : return Z_OK;
\r
1912 00092 33 c0 xor eax, eax
\r
1918 00096 c2 04 00 ret 4
\r
1923 ; 399 : return Z_STREAM_ERROR;
\r
1925 0009b b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
1931 000a2 c2 04 00 ret 4
\r
1932 _deflateResetKeep@4 ENDP
\r
1933 ; Function compile flags: /Ogtp
\r
1934 ; COMDAT _fill_window
\r
1936 _wsize$ = -4 ; size = 4
\r
1937 _fill_window PROC ; COMDAT
\r
1943 00001 8b ec mov ebp, esp
\r
1947 ; 1391 : register unsigned n, m;
\r
1948 ; 1392 : register Posf *p;
\r
1949 ; 1393 : unsigned more; /* Amount of free space at the end of the window. */
\r
1950 ; 1394 : uInt wsize = s->w_size;
\r
1952 00005 8b 5f 2c mov ebx, DWORD PTR [edi+44]
\r
1954 00009 89 5d fc mov DWORD PTR _wsize$[ebp], ebx
\r
1955 0000c eb 05 jmp SHORT $LN26@fill_windo
\r
1956 0000e 8b ff npad 2
\r
1958 00010 8b 5d fc mov ebx, DWORD PTR _wsize$[ebp]
\r
1962 ; 1396 : Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
\r
1965 ; 1399 : more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
\r
1967 00013 8b 77 3c mov esi, DWORD PTR [edi+60]
\r
1968 00016 2b 77 74 sub esi, DWORD PTR [edi+116]
\r
1969 00019 8b 47 6c mov eax, DWORD PTR [edi+108]
\r
1972 ; 1401 : /* Deal with !@#$% 64K limit: */
\r
1973 ; 1402 : if (sizeof(int) <= 2) {
\r
1974 ; 1403 : if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
\r
1975 ; 1404 : more = wsize;
\r
1977 ; 1406 : } else if (more == (unsigned)(-1)) {
\r
1978 ; 1407 : /* Very unlikely, but possible on 16 bit machine if
\r
1979 ; 1408 : * strstart == 0 && lookahead == 1 (input done a byte at time)
\r
1985 ; 1414 : /* If the window is almost full and there is insufficient lookahead,
\r
1986 ; 1415 : * move the upper half to the lower one to make room in the upper half.
\r
1988 ; 1417 : if (s->strstart >= wsize+MAX_DIST(s)) {
\r
1990 0001c 8b 4f 2c mov ecx, DWORD PTR [edi+44]
\r
1991 0001f 8d 94 0b fa fe
\r
1992 ff ff lea edx, DWORD PTR [ebx+ecx-262]
\r
1993 00026 2b f0 sub esi, eax
\r
1994 00028 3b c2 cmp eax, edx
\r
1995 0002a 72 5d jb SHORT $LN19@fill_windo
\r
1998 ; 1419 : zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
\r
2000 0002c 8b 47 38 mov eax, DWORD PTR [edi+56]
\r
2002 00030 8d 0c 18 lea ecx, DWORD PTR [eax+ebx]
\r
2005 00035 e8 00 00 00 00 call _memcpy
\r
2007 ; 1420 : s->match_start -= wsize;
\r
2008 ; 1421 : s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
\r
2009 ; 1422 : s->block_start -= (long) wsize;
\r
2011 ; 1424 : /* Slide the hash table (could be avoided with 32 bit values
\r
2012 ; 1425 : at the expense of memory usage). We slide even when level == 0
\r
2013 ; 1426 : to keep the hash table consistent if we switch back to level > 0
\r
2014 ; 1427 : later. (Using level 0 permanently is not an optimal usage of
\r
2015 ; 1428 : zlib, so we don't care about this pathological case.)
\r
2017 ; 1430 : n = s->hash_size;
\r
2019 0003a 8b 57 4c mov edx, DWORD PTR [edi+76]
\r
2021 ; 1431 : p = &s->head[n];
\r
2023 0003d 8b 47 44 mov eax, DWORD PTR [edi+68]
\r
2024 00040 29 5f 70 sub DWORD PTR [edi+112], ebx
\r
2025 00043 29 5f 6c sub DWORD PTR [edi+108], ebx
\r
2026 00046 83 c4 0c add esp, 12 ; 0000000cH
\r
2027 00049 29 5f 5c sub DWORD PTR [edi+92], ebx
\r
2028 0004c 8d 0c 50 lea ecx, DWORD PTR [eax+edx*2]
\r
2033 ; 1433 : m = *--p;
\r
2035 00050 0f b7 41 fe movzx eax, WORD PTR [ecx-2]
\r
2036 00054 83 e9 02 sub ecx, 2
\r
2038 ; 1434 : *p = (Pos)(m >= wsize ? m-wsize : NIL);
\r
2040 00057 3b c3 cmp eax, ebx
\r
2041 00059 72 04 jb SHORT $LN29@fill_windo
\r
2042 0005b 2b c3 sub eax, ebx
\r
2043 0005d eb 02 jmp SHORT $LN30@fill_windo
\r
2045 0005f 33 c0 xor eax, eax
\r
2048 ; 1435 : } while (--n);
\r
2051 00062 66 89 01 mov WORD PTR [ecx], ax
\r
2052 00065 75 e9 jne SHORT $LL18@fill_windo
\r
2055 ; 1437 : n = wsize;
\r
2056 ; 1438 : #ifndef FASTEST
\r
2057 ; 1439 : p = &s->prev[n];
\r
2059 00067 8b 4f 40 mov ecx, DWORD PTR [edi+64]
\r
2060 0006a 8b d3 mov edx, ebx
\r
2061 0006c 8d 0c 59 lea ecx, DWORD PTR [ecx+ebx*2]
\r
2066 ; 1441 : m = *--p;
\r
2068 00070 0f b7 41 fe movzx eax, WORD PTR [ecx-2]
\r
2069 00074 83 e9 02 sub ecx, 2
\r
2071 ; 1442 : *p = (Pos)(m >= wsize ? m-wsize : NIL);
\r
2073 00077 3b c3 cmp eax, ebx
\r
2074 00079 72 04 jb SHORT $LN31@fill_windo
\r
2075 0007b 2b c3 sub eax, ebx
\r
2076 0007d eb 02 jmp SHORT $LN32@fill_windo
\r
2078 0007f 33 c0 xor eax, eax
\r
2081 ; 1443 : /* If n is not on any hash chain, prev[n] is garbage but
\r
2082 ; 1444 : * its value will never be used.
\r
2084 ; 1446 : } while (--n);
\r
2087 00082 66 89 01 mov WORD PTR [ecx], ax
\r
2088 00085 75 e9 jne SHORT $LL15@fill_windo
\r
2091 ; 1448 : more += wsize;
\r
2093 00087 03 f3 add esi, ebx
\r
2097 ; 1450 : if (s->strm->avail_in == 0) break;
\r
2099 00089 8b 07 mov eax, DWORD PTR [edi]
\r
2100 0008b 83 78 04 00 cmp DWORD PTR [eax+4], 0
\r
2101 0008f 0f 84 b0 00 00
\r
2102 00 je $LN24@fill_windo
\r
2105 ; 1452 : /* If there was no sliding:
\r
2106 ; 1453 : * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
\r
2107 ; 1454 : * more == window_size - lookahead - strstart
\r
2108 ; 1455 : * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
\r
2109 ; 1456 : * => more >= window_size - 2*WSIZE + 2
\r
2110 ; 1457 : * In the BIG_MEM or MMAP case (not yet supported),
\r
2111 ; 1458 : * window_size == input_size + MIN_LOOKAHEAD &&
\r
2112 ; 1459 : * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
\r
2113 ; 1460 : * Otherwise, window_size == 2*WSIZE so more >= 2.
\r
2114 ; 1461 : * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
\r
2116 ; 1463 : Assert(more >= 2, "more < 2");
\r
2118 ; 1465 : n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
\r
2120 00095 8b 5f 74 mov ebx, DWORD PTR [edi+116]
\r
2121 00098 03 5f 6c add ebx, DWORD PTR [edi+108]
\r
2122 0009b 8b ce mov ecx, esi
\r
2123 0009d 03 5f 38 add ebx, DWORD PTR [edi+56]
\r
2124 000a0 8b f0 mov esi, eax
\r
2125 000a2 e8 00 00 00 00 call _read_buf
\r
2127 ; 1466 : s->lookahead += n;
\r
2129 000a7 01 47 74 add DWORD PTR [edi+116], eax
\r
2130 000aa 8b 47 74 mov eax, DWORD PTR [edi+116]
\r
2133 ; 1468 : /* Initialize the hash value now that we have some input: */
\r
2134 ; 1469 : if (s->lookahead + s->insert >= MIN_MATCH) {
\r
2136 000ad 8b b7 b4 16 00
\r
2137 00 mov esi, DWORD PTR [edi+5812]
\r
2138 000b3 8d 14 06 lea edx, DWORD PTR [esi+eax]
\r
2139 000b6 83 fa 03 cmp edx, 3
\r
2140 000b9 72 75 jb SHORT $LN25@fill_windo
\r
2142 ; 1470 : uInt str = s->strstart - s->insert;
\r
2144 000bb 8b 57 6c mov edx, DWORD PTR [edi+108]
\r
2146 ; 1471 : s->ins_h = s->window[str];
\r
2148 000be 8b 5f 38 mov ebx, DWORD PTR [edi+56]
\r
2150 ; 1472 : UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
\r
2152 000c1 8b 4f 58 mov ecx, DWORD PTR [edi+88]
\r
2153 000c4 2b d6 sub edx, esi
\r
2154 000c6 0f b6 04 13 movzx eax, BYTE PTR [ebx+edx]
\r
2155 000ca 89 47 48 mov DWORD PTR [edi+72], eax
\r
2156 000cd d3 e0 shl eax, cl
\r
2157 000cf 0f b6 4c 13 01 movzx ecx, BYTE PTR [ebx+edx+1]
\r
2158 000d4 33 c1 xor eax, ecx
\r
2159 000d6 23 47 54 and eax, DWORD PTR [edi+84]
\r
2160 000d9 89 47 48 mov DWORD PTR [edi+72], eax
\r
2162 ; 1473 : #if MIN_MATCH != 3
\r
2163 ; 1474 : Call UPDATE_HASH() MIN_MATCH-3 more times
\r
2165 ; 1476 : while (s->insert) {
\r
2167 000dc 85 f6 test esi, esi
\r
2168 000de 74 50 je SHORT $LN25@fill_windo
\r
2171 ; 1477 : UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
\r
2173 000e0 8b 77 48 mov esi, DWORD PTR [edi+72]
\r
2174 000e3 8b 4f 58 mov ecx, DWORD PTR [edi+88]
\r
2175 000e6 8b 47 38 mov eax, DWORD PTR [edi+56]
\r
2176 000e9 0f b6 44 10 02 movzx eax, BYTE PTR [eax+edx+2]
\r
2178 ; 1478 : #ifndef FASTEST
\r
2179 ; 1479 : s->prev[str & s->w_mask] = s->head[s->ins_h];
\r
2181 000ee 8b 5f 40 mov ebx, DWORD PTR [edi+64]
\r
2182 000f1 d3 e6 shl esi, cl
\r
2183 000f3 8b 4f 44 mov ecx, DWORD PTR [edi+68]
\r
2184 000f6 33 c6 xor eax, esi
\r
2185 000f8 23 47 54 and eax, DWORD PTR [edi+84]
\r
2186 000fb 8b 77 34 mov esi, DWORD PTR [edi+52]
\r
2187 000fe 89 47 48 mov DWORD PTR [edi+72], eax
\r
2188 00101 66 8b 04 41 mov ax, WORD PTR [ecx+eax*2]
\r
2189 00105 23 f2 and esi, edx
\r
2190 00107 66 89 04 73 mov WORD PTR [ebx+esi*2], ax
\r
2193 ; 1481 : s->head[s->ins_h] = (Pos)str;
\r
2195 0010b 8b 4f 48 mov ecx, DWORD PTR [edi+72]
\r
2196 0010e 8b 47 44 mov eax, DWORD PTR [edi+68]
\r
2197 00111 66 89 14 48 mov WORD PTR [eax+ecx*2], dx
\r
2200 ; 1483 : s->insert--;
\r
2202 00115 ff 8f b4 16 00
\r
2203 00 dec DWORD PTR [edi+5812]
\r
2204 0011b 8b 87 b4 16 00
\r
2205 00 mov eax, DWORD PTR [edi+5812]
\r
2207 ; 1484 : if (s->lookahead + s->insert < MIN_MATCH)
\r
2209 00121 8b 4f 74 mov ecx, DWORD PTR [edi+116]
\r
2210 00124 03 c8 add ecx, eax
\r
2212 00127 83 f9 03 cmp ecx, 3
\r
2213 0012a 72 04 jb SHORT $LN25@fill_windo
\r
2215 ; 1473 : #if MIN_MATCH != 3
\r
2216 ; 1474 : Call UPDATE_HASH() MIN_MATCH-3 more times
\r
2218 ; 1476 : while (s->insert) {
\r
2220 0012c 85 c0 test eax, eax
\r
2221 0012e 75 b0 jne SHORT $LL10@fill_windo
\r
2227 ; 1488 : /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
\r
2228 ; 1489 : * but this is not important since only literal bytes will be emitted.
\r
2231 ; 1492 : } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
\r
2233 00130 81 7f 74 06 01
\r
2234 00 00 cmp DWORD PTR [edi+116], 262 ; 00000106H
\r
2235 00137 73 0c jae SHORT $LN24@fill_windo
\r
2236 00139 8b 17 mov edx, DWORD PTR [edi]
\r
2237 0013b 83 7a 04 00 cmp DWORD PTR [edx+4], 0
\r
2238 0013f 0f 85 cb fe ff
\r
2239 ff jne $LL39@fill_windo
\r
2243 ; 1494 : /* If the WIN_INIT bytes after the end of the current data have never been
\r
2244 ; 1495 : * written, then zero those bytes in order to avoid memory check reports of
\r
2245 ; 1496 : * the use of uninitialized (or uninitialised as Julian writes) bytes by
\r
2246 ; 1497 : * the longest match routines. Update the high water mark for the next
\r
2247 ; 1498 : * time through here. WIN_INIT is set to MAX_MATCH since the longest match
\r
2248 ; 1499 : * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
\r
2250 ; 1501 : if (s->high_water < s->window_size) {
\r
2252 00145 8b 87 c0 16 00
\r
2253 00 mov eax, DWORD PTR [edi+5824]
\r
2254 0014b 8b 4f 3c mov ecx, DWORD PTR [edi+60]
\r
2255 0014e 3b c1 cmp eax, ecx
\r
2256 00150 73 6b jae SHORT $LN2@fill_windo
\r
2258 ; 1502 : ulg curr = s->strstart + (ulg)(s->lookahead);
\r
2260 00152 8b 77 74 mov esi, DWORD PTR [edi+116]
\r
2261 00155 03 77 6c add esi, DWORD PTR [edi+108]
\r
2263 ; 1503 : ulg init;
\r
2265 ; 1505 : if (s->high_water < curr) {
\r
2267 00158 3b c6 cmp eax, esi
\r
2268 0015a 73 30 jae SHORT $LN5@fill_windo
\r
2270 ; 1506 : /* Previous high water mark below current data -- zero WIN_INIT
\r
2271 ; 1507 : * bytes or up to end of window, whichever is less.
\r
2273 ; 1509 : init = s->window_size - curr;
\r
2275 0015c 2b ce sub ecx, esi
\r
2276 0015e 8b d9 mov ebx, ecx
\r
2278 ; 1510 : if (init > WIN_INIT)
\r
2280 00160 81 fb 02 01 00
\r
2281 00 cmp ebx, 258 ; 00000102H
\r
2282 00166 76 05 jbe SHORT $LN4@fill_windo
\r
2284 ; 1511 : init = WIN_INIT;
\r
2286 00168 bb 02 01 00 00 mov ebx, 258 ; 00000102H
\r
2289 ; 1512 : zmemzero(s->window + curr, (unsigned)init);
\r
2291 0016d 8b 47 38 mov eax, DWORD PTR [edi+56]
\r
2293 00171 03 c6 add eax, esi
\r
2294 00173 6a 00 push 0
\r
2296 00176 e8 00 00 00 00 call _memset
\r
2297 0017b 83 c4 0c add esp, 12 ; 0000000cH
\r
2299 ; 1513 : s->high_water = curr + init;
\r
2301 0017e 03 de add ebx, esi
\r
2303 00181 89 9f c0 16 00
\r
2304 00 mov DWORD PTR [edi+5824], ebx
\r
2310 ; 1528 : Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
\r
2311 ; 1529 : "not enough room for search");
\r
2314 00188 8b e5 mov esp, ebp
\r
2320 ; 1515 : else if (s->high_water < (ulg)curr + WIN_INIT) {
\r
2322 0018c 8d 96 02 01 00
\r
2323 00 lea edx, DWORD PTR [esi+258]
\r
2324 00192 3b c2 cmp eax, edx
\r
2325 00194 73 27 jae SHORT $LN2@fill_windo
\r
2327 ; 1516 : /* High water mark at or above current data, but below current data
\r
2328 ; 1517 : * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
\r
2329 ; 1518 : * to end of window, whichever is less.
\r
2331 ; 1520 : init = (ulg)curr + WIN_INIT - s->high_water;
\r
2333 00196 2b f0 sub esi, eax
\r
2334 00198 81 c6 02 01 00
\r
2335 00 add esi, 258 ; 00000102H
\r
2337 ; 1521 : if (init > s->window_size - s->high_water)
\r
2339 0019e 2b c8 sub ecx, eax
\r
2340 001a0 3b f1 cmp esi, ecx
\r
2341 001a2 76 02 jbe SHORT $LN1@fill_windo
\r
2343 ; 1522 : init = s->window_size - s->high_water;
\r
2345 001a4 8b f1 mov esi, ecx
\r
2348 ; 1523 : zmemzero(s->window + s->high_water, (unsigned)init);
\r
2350 001a6 8b 4f 38 mov ecx, DWORD PTR [edi+56]
\r
2352 001aa 03 c8 add ecx, eax
\r
2353 001ac 6a 00 push 0
\r
2355 001af e8 00 00 00 00 call _memset
\r
2356 001b4 83 c4 0c add esp, 12 ; 0000000cH
\r
2358 ; 1524 : s->high_water += init;
\r
2360 001b7 01 b7 c0 16 00
\r
2361 00 add DWORD PTR [edi+5824], esi
\r
2369 ; 1528 : Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
\r
2370 ; 1529 : "not enough room for search");
\r
2373 001bf 8b e5 mov esp, ebp
\r
2378 PUBLIC _deflateReset@4
\r
2379 ; Function compile flags: /Ogtp
\r
2380 ; COMDAT _deflateReset@4
\r
2382 _strm$ = 8 ; size = 4
\r
2383 _deflateReset@4 PROC ; COMDAT
\r
2388 00001 8b ec mov ebp, esp
\r
2393 ; 432 : ret = deflateResetKeep(strm);
\r
2395 00004 8b 75 08 mov esi, DWORD PTR _strm$[ebp]
\r
2398 00009 e8 00 00 00 00 call _deflateResetKeep@4
\r
2399 0000e 8b f8 mov edi, eax
\r
2401 ; 433 : if (ret == Z_OK)
\r
2403 00010 85 ff test edi, edi
\r
2404 00012 75 0a jne SHORT $LN1@deflateRes@2
\r
2406 ; 434 : lm_init(strm->state);
\r
2408 00014 8b 76 1c mov esi, DWORD PTR [esi+28]
\r
2409 00017 e8 00 00 00 00 call _lm_init
\r
2411 ; 435 : return ret;
\r
2413 0001c 8b c7 mov eax, edi
\r
2414 $LN1@deflateRes@2:
\r
2421 00021 c2 04 00 ret 4
\r
2422 _deflateReset@4 ENDP
\r
2424 PUBLIC _deflateSetDictionary@12
\r
2425 ; Function compile flags: /Ogtp
\r
2426 ; COMDAT _deflateSetDictionary@12
\r
2428 _avail$ = -8 ; size = 4
\r
2429 _wrap$ = -4 ; size = 4
\r
2430 _strm$ = 8 ; size = 4
\r
2431 _n$ = 12 ; size = 4
\r
2432 _dictionary$ = 12 ; size = 4
\r
2433 _next$ = 16 ; size = 4
\r
2434 _dictLength$ = 16 ; size = 4
\r
2435 _deflateSetDictionary@12 PROC ; COMDAT
\r
2440 00001 8b ec mov ebp, esp
\r
2441 00003 83 ec 08 sub esp, 8
\r
2444 ; 328 : deflate_state *s;
\r
2445 ; 329 : uInt str, n;
\r
2447 ; 331 : unsigned avail;
\r
2448 ; 332 : unsigned char *next;
\r
2450 ; 334 : if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
\r
2452 00007 8b 75 08 mov esi, DWORD PTR _strm$[ebp]
\r
2454 0000b 85 f6 test esi, esi
\r
2455 0000d 0f 84 61 01 00
\r
2456 00 je $LN12@deflateSet@2
\r
2457 00013 8b 7e 1c mov edi, DWORD PTR [esi+28]
\r
2458 00016 85 ff test edi, edi
\r
2459 00018 0f 84 56 01 00
\r
2460 00 je $LN12@deflateSet@2
\r
2461 0001e 8b 4d 0c mov ecx, DWORD PTR _dictionary$[ebp]
\r
2462 00021 85 c9 test ecx, ecx
\r
2463 00023 0f 84 4b 01 00
\r
2464 00 je $LN12@deflateSet@2
\r
2466 ; 336 : s = strm->state;
\r
2467 ; 337 : wrap = s->wrap;
\r
2469 00029 8b 47 18 mov eax, DWORD PTR [edi+24]
\r
2470 0002c 89 45 fc mov DWORD PTR _wrap$[ebp], eax
\r
2472 ; 338 : if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
\r
2474 0002f 83 f8 02 cmp eax, 2
\r
2475 00032 0f 84 3c 01 00
\r
2476 00 je $LN12@deflateSet@2
\r
2477 00038 83 f8 01 cmp eax, 1
\r
2478 0003b 75 0a jne SHORT $LN9@deflateSet@2
\r
2479 0003d 83 7f 04 2a cmp DWORD PTR [edi+4], 42 ; 0000002aH
\r
2480 00041 0f 85 2d 01 00
\r
2481 00 jne $LN12@deflateSet@2
\r
2482 $LN9@deflateSet@2:
\r
2483 00047 83 7f 74 00 cmp DWORD PTR [edi+116], 0
\r
2484 0004b 0f 85 23 01 00
\r
2485 00 jne $LN12@deflateSet@2
\r
2487 ; 339 : return Z_STREAM_ERROR;
\r
2489 ; 341 : /* when using zlib wrappers, compute Adler-32 for provided dictionary */
\r
2490 ; 342 : if (wrap == 1)
\r
2493 00052 8b 5d 10 mov ebx, DWORD PTR _dictLength$[ebp]
\r
2494 00055 83 f8 01 cmp eax, 1
\r
2495 00058 75 14 jne SHORT $LN8@deflateSet@2
\r
2497 ; 343 : strm->adler = adler32(strm->adler, dictionary, dictLength);
\r
2499 0005a 8b 46 30 mov eax, DWORD PTR [esi+48]
\r
2503 00060 e8 00 00 00 00 call _adler32@12
\r
2504 00065 8b 4d 0c mov ecx, DWORD PTR _dictionary$[ebp]
\r
2505 00068 89 46 30 mov DWORD PTR [esi+48], eax
\r
2506 0006b 8b 45 fc mov eax, DWORD PTR _wrap$[ebp]
\r
2507 $LN8@deflateSet@2:
\r
2509 ; 344 : s->wrap = 0; /* avoid computing Adler-32 in read_buf */
\r
2511 0006e c7 47 18 00 00
\r
2512 00 00 mov DWORD PTR [edi+24], 0
\r
2515 ; 346 : /* if dictionary would fill window, just replace the history */
\r
2516 ; 347 : if (dictLength >= s->w_size) {
\r
2518 00075 3b 5f 2c cmp ebx, DWORD PTR [edi+44]
\r
2519 00078 72 3e jb SHORT $LN7@deflateSet@2
\r
2521 ; 348 : if (wrap == 0) { /* already empty otherwise */
\r
2523 0007a 85 c0 test eax, eax
\r
2524 0007c 75 31 jne SHORT $LN6@deflateSet@2
\r
2526 ; 349 : CLEAR_HASH(s);
\r
2528 0007e 8b 4f 4c mov ecx, DWORD PTR [edi+76]
\r
2529 00081 8b 57 44 mov edx, DWORD PTR [edi+68]
\r
2530 00084 66 89 44 4a fe mov WORD PTR [edx+ecx*2-2], ax
\r
2531 00089 8b 4f 4c mov ecx, DWORD PTR [edi+76]
\r
2532 0008c 8d 54 09 fe lea edx, DWORD PTR [ecx+ecx-2]
\r
2535 00092 8b 47 44 mov eax, DWORD PTR [edi+68]
\r
2537 00096 e8 00 00 00 00 call _memset
\r
2539 ; 350 : s->strstart = 0;
\r
2540 ; 351 : s->block_start = 0L;
\r
2541 ; 352 : s->insert = 0;
\r
2543 0009b 8b 4d 0c mov ecx, DWORD PTR _dictionary$[ebp]
\r
2544 0009e 83 c4 0c add esp, 12 ; 0000000cH
\r
2545 000a1 33 c0 xor eax, eax
\r
2546 000a3 89 47 6c mov DWORD PTR [edi+108], eax
\r
2547 000a6 89 47 5c mov DWORD PTR [edi+92], eax
\r
2548 000a9 89 87 b4 16 00
\r
2549 00 mov DWORD PTR [edi+5812], eax
\r
2550 $LN6@deflateSet@2:
\r
2553 ; 354 : dictionary += dictLength - s->w_size; /* use the tail */
\r
2555 000af 8b 47 2c mov eax, DWORD PTR [edi+44]
\r
2556 000b2 2b d8 sub ebx, eax
\r
2557 000b4 03 cb add ecx, ebx
\r
2559 ; 355 : dictLength = s->w_size;
\r
2561 000b6 8b d8 mov ebx, eax
\r
2562 $LN7@deflateSet@2:
\r
2566 ; 358 : /* insert dictionary into window and hash */
\r
2567 ; 359 : avail = strm->avail_in;
\r
2569 000b8 8b 56 04 mov edx, DWORD PTR [esi+4]
\r
2571 ; 360 : next = strm->next_in;
\r
2573 000bb 8b 06 mov eax, DWORD PTR [esi]
\r
2574 000bd 89 55 f8 mov DWORD PTR _avail$[ebp], edx
\r
2575 000c0 89 45 10 mov DWORD PTR _next$[ebp], eax
\r
2577 ; 361 : strm->avail_in = dictLength;
\r
2579 000c3 89 5e 04 mov DWORD PTR [esi+4], ebx
\r
2581 ; 362 : strm->next_in = (Bytef *)dictionary;
\r
2583 000c6 89 0e mov DWORD PTR [esi], ecx
\r
2585 ; 363 : fill_window(s);
\r
2587 000c8 e8 00 00 00 00 call _fill_window
\r
2589 ; 364 : while (s->lookahead >= MIN_MATCH) {
\r
2591 000cd 83 7f 74 03 cmp DWORD PTR [edi+116], 3
\r
2592 000d1 72 60 jb SHORT $LN4@deflateSet@2
\r
2593 $LL5@deflateSet@2:
\r
2595 ; 365 : str = s->strstart;
\r
2596 ; 366 : n = s->lookahead - (MIN_MATCH-1);
\r
2598 000d3 8b 47 74 mov eax, DWORD PTR [edi+116]
\r
2599 000d6 8b 57 6c mov edx, DWORD PTR [edi+108]
\r
2600 000d9 83 e8 02 sub eax, 2
\r
2601 000dc 89 45 0c mov DWORD PTR _n$[ebp], eax
\r
2603 $LL3@deflateSet@2:
\r
2606 ; 368 : UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
\r
2608 000e0 8b 4f 38 mov ecx, DWORD PTR [edi+56]
\r
2609 000e3 0f b6 44 11 02 movzx eax, BYTE PTR [ecx+edx+2]
\r
2610 000e8 8b 77 48 mov esi, DWORD PTR [edi+72]
\r
2611 000eb 8b 4f 58 mov ecx, DWORD PTR [edi+88]
\r
2613 ; 369 : #ifndef FASTEST
\r
2614 ; 370 : s->prev[str & s->w_mask] = s->head[s->ins_h];
\r
2616 000ee 8b 5f 40 mov ebx, DWORD PTR [edi+64]
\r
2617 000f1 d3 e6 shl esi, cl
\r
2618 000f3 8b 4f 44 mov ecx, DWORD PTR [edi+68]
\r
2619 000f6 33 c6 xor eax, esi
\r
2620 000f8 23 47 54 and eax, DWORD PTR [edi+84]
\r
2621 000fb 8b 77 34 mov esi, DWORD PTR [edi+52]
\r
2622 000fe 89 47 48 mov DWORD PTR [edi+72], eax
\r
2623 00101 66 8b 04 41 mov ax, WORD PTR [ecx+eax*2]
\r
2624 00105 23 f2 and esi, edx
\r
2625 00107 66 89 04 73 mov WORD PTR [ebx+esi*2], ax
\r
2628 ; 372 : s->head[s->ins_h] = (Pos)str;
\r
2630 0010b 8b 4f 48 mov ecx, DWORD PTR [edi+72]
\r
2631 0010e 8b 47 44 mov eax, DWORD PTR [edi+68]
\r
2632 00111 66 89 14 48 mov WORD PTR [eax+ecx*2], dx
\r
2638 ; 374 : } while (--n);
\r
2640 00116 ff 4d 0c dec DWORD PTR _n$[ebp]
\r
2641 00119 75 c5 jne SHORT $LL3@deflateSet@2
\r
2643 ; 375 : s->strstart = str;
\r
2645 0011b 89 57 6c mov DWORD PTR [edi+108], edx
\r
2647 ; 376 : s->lookahead = MIN_MATCH-1;
\r
2649 0011e c7 47 74 02 00
\r
2650 00 00 mov DWORD PTR [edi+116], 2
\r
2652 ; 377 : fill_window(s);
\r
2654 00125 e8 00 00 00 00 call _fill_window
\r
2655 0012a 83 7f 74 03 cmp DWORD PTR [edi+116], 3
\r
2656 0012e 73 a3 jae SHORT $LL5@deflateSet@2
\r
2658 ; 364 : while (s->lookahead >= MIN_MATCH) {
\r
2660 00130 8b 75 08 mov esi, DWORD PTR _strm$[ebp]
\r
2661 $LN4@deflateSet@2:
\r
2664 ; 379 : s->strstart += s->lookahead;
\r
2666 00133 8b 47 74 mov eax, DWORD PTR [edi+116]
\r
2667 00136 01 47 6c add DWORD PTR [edi+108], eax
\r
2668 00139 8b 4f 6c mov ecx, DWORD PTR [edi+108]
\r
2670 ; 380 : s->block_start = (long)s->strstart;
\r
2671 ; 381 : s->insert = s->lookahead;
\r
2672 ; 382 : s->lookahead = 0;
\r
2673 ; 383 : s->match_length = s->prev_length = MIN_MATCH-1;
\r
2674 ; 384 : s->match_available = 0;
\r
2675 ; 385 : strm->next_in = next;
\r
2676 ; 386 : strm->avail_in = avail;
\r
2678 0013c 8b 55 f8 mov edx, DWORD PTR _avail$[ebp]
\r
2679 0013f 89 4f 5c mov DWORD PTR [edi+92], ecx
\r
2680 00142 89 87 b4 16 00
\r
2681 00 mov DWORD PTR [edi+5812], eax
\r
2682 00148 33 c0 xor eax, eax
\r
2683 0014a b9 02 00 00 00 mov ecx, 2
\r
2684 0014f 89 47 74 mov DWORD PTR [edi+116], eax
\r
2685 00152 89 4f 78 mov DWORD PTR [edi+120], ecx
\r
2686 00155 89 4f 60 mov DWORD PTR [edi+96], ecx
\r
2687 00158 8b 4d 10 mov ecx, DWORD PTR _next$[ebp]
\r
2688 0015b 89 47 68 mov DWORD PTR [edi+104], eax
\r
2690 ; 387 : s->wrap = wrap;
\r
2692 0015e 8b 45 fc mov eax, DWORD PTR _wrap$[ebp]
\r
2693 00161 89 0e mov DWORD PTR [esi], ecx
\r
2694 00163 89 56 04 mov DWORD PTR [esi+4], edx
\r
2696 00167 89 47 18 mov DWORD PTR [edi+24], eax
\r
2699 ; 388 : return Z_OK;
\r
2701 0016b 33 c0 xor eax, eax
\r
2706 0016e 8b e5 mov esp, ebp
\r
2708 00171 c2 0c 00 ret 12 ; 0000000cH
\r
2709 $LN12@deflateSet@2:
\r
2712 ; 335 : return Z_STREAM_ERROR;
\r
2714 00175 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2719 0017b 8b e5 mov esp, ebp
\r
2721 0017e c2 0c 00 ret 12 ; 0000000cH
\r
2722 _deflateSetDictionary@12 ENDP
\r
2724 PUBLIC _deflateInit2_@32
\r
2725 ; Function compile flags: /Ogtp
\r
2726 ; COMDAT _deflateInit2_@32
\r
2728 _wrap$ = -4 ; size = 4
\r
2729 _strm$ = 8 ; size = 4
\r
2730 _level$ = 12 ; size = 4
\r
2731 _method$ = 16 ; size = 4
\r
2732 _windowBits$ = 20 ; size = 4
\r
2733 _memLevel$ = 24 ; size = 4
\r
2734 _strategy$ = 28 ; size = 4
\r
2735 _version$ = 32 ; size = 4
\r
2736 _stream_size$ = 36 ; size = 4
\r
2737 _deflateInit2_@32 PROC ; COMDAT
\r
2742 00001 8b ec mov ebp, esp
\r
2745 ; 224 : deflate_state *s;
\r
2746 ; 225 : int wrap = 1;
\r
2747 ; 226 : static const char my_version[] = ZLIB_VERSION;
\r
2749 ; 228 : ushf *overlay;
\r
2750 ; 229 : /* We overlay pending_buf and d_buf+l_buf. This works since the average
\r
2751 ; 230 : * output size for (length,distance) codes is <= 24 bits.
\r
2754 ; 233 : if (version == Z_NULL || version[0] != my_version[0] ||
\r
2755 ; 234 : stream_size != sizeof(z_stream)) {
\r
2757 00004 8b 45 20 mov eax, DWORD PTR _version$[ebp]
\r
2758 00007 33 c9 xor ecx, ecx
\r
2759 00009 c7 45 fc 01 00
\r
2760 00 00 mov DWORD PTR _wrap$[ebp], 1
\r
2761 00010 3b c1 cmp eax, ecx
\r
2762 00012 0f 84 16 02 00
\r
2763 00 je $LN14@deflateIni
\r
2764 00018 80 38 31 cmp BYTE PTR [eax], 49 ; 00000031H
\r
2765 0001b 0f 85 0d 02 00
\r
2766 00 jne $LN14@deflateIni
\r
2767 00021 83 7d 24 38 cmp DWORD PTR _stream_size$[ebp], 56 ; 00000038H
\r
2768 00025 0f 85 03 02 00
\r
2769 00 jne $LN14@deflateIni
\r
2772 ; 237 : if (strm == Z_NULL) return Z_STREAM_ERROR;
\r
2775 0002c 8b 7d 08 mov edi, DWORD PTR _strm$[ebp]
\r
2776 0002f 3b f9 cmp edi, ecx
\r
2777 00031 75 0a jne SHORT $LN13@deflateIni
\r
2778 00033 8d 41 fe lea eax, DWORD PTR [ecx-2]
\r
2783 00037 8b e5 mov esp, ebp
\r
2785 0003a c2 20 00 ret 32 ; 00000020H
\r
2789 ; 239 : strm->msg = Z_NULL;
\r
2791 0003d 89 4f 18 mov DWORD PTR [edi+24], ecx
\r
2793 ; 240 : if (strm->zalloc == (alloc_func)0) {
\r
2795 00040 39 4f 20 cmp DWORD PTR [edi+32], ecx
\r
2796 00043 75 0a jne SHORT $LN12@deflateIni
\r
2798 ; 241 : #ifdef Z_SOLO
\r
2799 ; 242 : return Z_STREAM_ERROR;
\r
2801 ; 244 : strm->zalloc = zcalloc;
\r
2803 00045 c7 47 20 00 00
\r
2804 00 00 mov DWORD PTR [edi+32], OFFSET _zcalloc
\r
2806 ; 245 : strm->opaque = (voidpf)0;
\r
2808 0004c 89 4f 28 mov DWORD PTR [edi+40], ecx
\r
2813 ; 248 : if (strm->zfree == (free_func)0)
\r
2815 0004f 39 4f 24 cmp DWORD PTR [edi+36], ecx
\r
2816 00052 75 07 jne SHORT $LN11@deflateIni
\r
2818 ; 249 : #ifdef Z_SOLO
\r
2819 ; 250 : return Z_STREAM_ERROR;
\r
2821 ; 252 : strm->zfree = zcfree;
\r
2823 00054 c7 47 24 00 00
\r
2824 00 00 mov DWORD PTR [edi+36], OFFSET _zcfree
\r
2829 ; 255 : #ifdef FASTEST
\r
2830 ; 256 : if (level != 0) level = 1;
\r
2832 ; 258 : if (level == Z_DEFAULT_COMPRESSION) level = 6;
\r
2834 0005b 83 7d 0c ff cmp DWORD PTR _level$[ebp], -1
\r
2835 0005f 75 07 jne SHORT $LN10@deflateIni
\r
2836 00061 c7 45 0c 06 00
\r
2837 00 00 mov DWORD PTR _level$[ebp], 6
\r
2843 ; 261 : if (windowBits < 0) { /* suppress zlib wrapper */
\r
2845 00069 8b 5d 14 mov ebx, DWORD PTR _windowBits$[ebp]
\r
2846 0006c 3b d9 cmp ebx, ecx
\r
2847 0006e 7d 07 jge SHORT $LN9@deflateIni
\r
2851 00070 89 4d fc mov DWORD PTR _wrap$[ebp], ecx
\r
2853 ; 263 : windowBits = -windowBits;
\r
2855 00073 f7 db neg ebx
\r
2856 00075 eb 0f jmp SHORT $LN21@deflateIni
\r
2860 ; 265 : #ifdef GZIP
\r
2861 ; 266 : else if (windowBits > 15) {
\r
2863 00077 83 fb 0f cmp ebx, 15 ; 0000000fH
\r
2864 0007a 7e 0d jle SHORT $LN7@deflateIni
\r
2866 ; 267 : wrap = 2; /* write gzip wrapper instead */
\r
2868 0007c c7 45 fc 02 00
\r
2869 00 00 mov DWORD PTR _wrap$[ebp], 2
\r
2871 ; 268 : windowBits -= 16;
\r
2873 00083 83 eb 10 sub ebx, 16 ; 00000010H
\r
2875 00086 89 5d 14 mov DWORD PTR _windowBits$[ebp], ebx
\r
2880 ; 271 : if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
\r
2881 ; 272 : windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
\r
2882 ; 273 : strategy < 0 || strategy > Z_FIXED) {
\r
2884 00089 8b 45 18 mov eax, DWORD PTR _memLevel$[ebp]
\r
2886 0008d 83 f8 08 cmp eax, 8
\r
2887 00090 0f 87 8b 01 00
\r
2888 00 ja $LN5@deflateIni
\r
2889 00096 83 7d 10 08 cmp DWORD PTR _method$[ebp], 8
\r
2890 0009a 0f 85 81 01 00
\r
2891 00 jne $LN5@deflateIni
\r
2892 000a0 8d 4b f8 lea ecx, DWORD PTR [ebx-8]
\r
2893 000a3 83 f9 07 cmp ecx, 7
\r
2894 000a6 0f 87 75 01 00
\r
2895 00 ja $LN5@deflateIni
\r
2896 000ac b8 09 00 00 00 mov eax, 9
\r
2897 000b1 39 45 0c cmp DWORD PTR _level$[ebp], eax
\r
2898 000b4 0f 87 67 01 00
\r
2899 00 ja $LN5@deflateIni
\r
2900 000ba 83 7d 1c 04 cmp DWORD PTR _strategy$[ebp], 4
\r
2901 000be 0f 87 5d 01 00
\r
2902 00 ja $LN5@deflateIni
\r
2905 ; 276 : if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
\r
2907 000c4 83 fb 08 cmp ebx, 8
\r
2908 000c7 75 05 jne SHORT $LN4@deflateIni
\r
2909 000c9 89 45 14 mov DWORD PTR _windowBits$[ebp], eax
\r
2910 000cc 8b d8 mov ebx, eax
\r
2913 ; 277 : s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
\r
2915 000ce 8b 57 28 mov edx, DWORD PTR [edi+40]
\r
2916 000d1 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
2918 000d5 68 c4 16 00 00 push 5828 ; 000016c4H
\r
2919 000da 6a 01 push 1
\r
2921 000dd ff d0 call eax
\r
2922 000df 8b f0 mov esi, eax
\r
2923 000e1 83 c4 0c add esp, 12 ; 0000000cH
\r
2925 ; 278 : if (s == Z_NULL) return Z_MEM_ERROR;
\r
2927 000e4 85 f6 test esi, esi
\r
2928 000e6 0f 84 27 01 00
\r
2929 00 je $LN22@deflateIni
\r
2931 ; 279 : strm->state = (struct internal_state FAR *)s;
\r
2932 ; 280 : s->strm = strm;
\r
2934 ; 282 : s->wrap = wrap;
\r
2936 000ec 8b 4d fc mov ecx, DWORD PTR _wrap$[ebp]
\r
2937 000ef 89 77 1c mov DWORD PTR [edi+28], esi
\r
2938 000f2 89 4e 18 mov DWORD PTR [esi+24], ecx
\r
2940 ; 283 : s->gzhead = Z_NULL;
\r
2941 ; 284 : s->w_bits = windowBits;
\r
2942 ; 285 : s->w_size = 1 << s->w_bits;
\r
2944 000f5 8b 4d 14 mov ecx, DWORD PTR _windowBits$[ebp]
\r
2945 000f8 89 5e 30 mov DWORD PTR [esi+48], ebx
\r
2946 000fb bb 01 00 00 00 mov ebx, 1
\r
2947 00100 d3 e3 shl ebx, cl
\r
2949 ; 286 : s->w_mask = s->w_size - 1;
\r
2951 ; 288 : s->hash_bits = memLevel + 7;
\r
2953 00102 8b 4d 18 mov ecx, DWORD PTR _memLevel$[ebp]
\r
2954 00105 83 c1 07 add ecx, 7
\r
2956 ; 289 : s->hash_size = 1 << s->hash_bits;
\r
2958 00108 b8 01 00 00 00 mov eax, 1
\r
2959 0010d d3 e0 shl eax, cl
\r
2960 0010f 89 4e 50 mov DWORD PTR [esi+80], ecx
\r
2961 00112 8d 53 ff lea edx, DWORD PTR [ebx-1]
\r
2962 00115 89 56 34 mov DWORD PTR [esi+52], edx
\r
2963 00118 89 46 4c mov DWORD PTR [esi+76], eax
\r
2965 ; 290 : s->hash_mask = s->hash_size - 1;
\r
2968 0011c 89 46 54 mov DWORD PTR [esi+84], eax
\r
2970 ; 291 : s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
\r
2972 0011f 83 c1 02 add ecx, 2
\r
2973 00122 b8 ab aa aa aa mov eax, -1431655765 ; aaaaaaabH
\r
2974 00127 f7 e1 mul ecx
\r
2975 00129 d1 ea shr edx, 1
\r
2976 0012b 89 3e mov DWORD PTR [esi], edi
\r
2977 0012d c7 46 1c 00 00
\r
2978 00 00 mov DWORD PTR [esi+28], 0
\r
2979 00134 89 5e 2c mov DWORD PTR [esi+44], ebx
\r
2980 00137 89 56 58 mov DWORD PTR [esi+88], edx
\r
2983 ; 293 : s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
\r
2985 0013a 8b 47 28 mov eax, DWORD PTR [edi+40]
\r
2986 0013d 8b 4f 20 mov ecx, DWORD PTR [edi+32]
\r
2987 00140 6a 02 push 2
\r
2990 00144 ff d1 call ecx
\r
2992 ; 294 : s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
\r
2994 00146 8b 56 2c mov edx, DWORD PTR [esi+44]
\r
2995 00149 89 46 38 mov DWORD PTR [esi+56], eax
\r
2996 0014c 8b 47 28 mov eax, DWORD PTR [edi+40]
\r
2997 0014f 8b 4f 20 mov ecx, DWORD PTR [edi+32]
\r
2998 00152 6a 02 push 2
\r
3001 00156 ff d1 call ecx
\r
3003 ; 295 : s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
\r
3005 00158 8b 56 4c mov edx, DWORD PTR [esi+76]
\r
3006 0015b 89 46 40 mov DWORD PTR [esi+64], eax
\r
3007 0015e 8b 47 28 mov eax, DWORD PTR [edi+40]
\r
3008 00161 8b 4f 20 mov ecx, DWORD PTR [edi+32]
\r
3009 00164 6a 02 push 2
\r
3012 00168 ff d1 call ecx
\r
3015 ; 297 : s->high_water = 0; /* nothing written to s->window yet */
\r
3017 ; 299 : s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
\r
3019 0016a 8b 4d 18 mov ecx, DWORD PTR _memLevel$[ebp]
\r
3020 0016d 89 46 44 mov DWORD PTR [esi+68], eax
\r
3021 00170 83 c1 06 add ecx, 6
\r
3022 00173 b8 01 00 00 00 mov eax, 1
\r
3023 00178 d3 e0 shl eax, cl
\r
3024 0017a c7 86 c0 16 00
\r
3025 00 00 00 00 00 mov DWORD PTR [esi+5824], 0
\r
3028 ; 301 : overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
\r
3030 00184 6a 04 push 4
\r
3031 00186 89 86 9c 16 00
\r
3032 00 mov DWORD PTR [esi+5788], eax
\r
3033 0018c 8b 57 28 mov edx, DWORD PTR [edi+40]
\r
3035 00190 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3037 00194 ff d0 call eax
\r
3039 ; 302 : s->pending_buf = (uchf *) overlay;
\r
3040 ; 303 : s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
\r
3042 00196 8b 8e 9c 16 00
\r
3043 00 mov ecx, DWORD PTR [esi+5788]
\r
3044 0019c 83 c4 30 add esp, 48 ; 00000030H
\r
3047 ; 305 : if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
\r
3048 ; 306 : s->pending_buf == Z_NULL) {
\r
3050 0019f 83 7e 38 00 cmp DWORD PTR [esi+56], 0
\r
3051 001a3 8d 14 8d 00 00
\r
3052 00 00 lea edx, DWORD PTR [ecx*4]
\r
3053 001aa 89 46 08 mov DWORD PTR [esi+8], eax
\r
3054 001ad 89 56 0c mov DWORD PTR [esi+12], edx
\r
3055 001b0 74 4d je SHORT $LN1@deflateIni
\r
3056 001b2 83 7e 40 00 cmp DWORD PTR [esi+64], 0
\r
3057 001b6 74 47 je SHORT $LN1@deflateIni
\r
3058 001b8 83 7e 44 00 cmp DWORD PTR [esi+68], 0
\r
3059 001bc 74 41 je SHORT $LN1@deflateIni
\r
3060 001be 85 c0 test eax, eax
\r
3061 001c0 74 3d je SHORT $LN1@deflateIni
\r
3064 ; 312 : s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
\r
3066 001c2 8b d1 mov edx, ecx
\r
3067 001c4 d1 ea shr edx, 1
\r
3068 001c6 8d 14 50 lea edx, DWORD PTR [eax+edx*2]
\r
3070 ; 313 : s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
\r
3072 001c9 8d 04 48 lea eax, DWORD PTR [eax+ecx*2]
\r
3073 001cc 03 c1 add eax, ecx
\r
3076 ; 315 : s->level = level;
\r
3078 001ce 8b 4d 0c mov ecx, DWORD PTR _level$[ebp]
\r
3079 001d1 89 96 a4 16 00
\r
3080 00 mov DWORD PTR [esi+5796], edx
\r
3082 ; 316 : s->strategy = strategy;
\r
3084 001d7 8b 55 1c mov edx, DWORD PTR _strategy$[ebp]
\r
3086 ; 317 : s->method = (Byte)method;
\r
3088 ; 319 : return deflateReset(strm);
\r
3091 001db 89 86 98 16 00
\r
3092 00 mov DWORD PTR [esi+5784], eax
\r
3093 001e1 89 8e 84 00 00
\r
3094 00 mov DWORD PTR [esi+132], ecx
\r
3095 001e7 89 96 88 00 00
\r
3096 00 mov DWORD PTR [esi+136], edx
\r
3097 001ed c6 46 24 08 mov BYTE PTR [esi+36], 8
\r
3098 001f1 e8 00 00 00 00 call _deflateReset@4
\r
3105 001f9 8b e5 mov esp, ebp
\r
3107 001fc c2 20 00 ret 32 ; 00000020H
\r
3110 ; 307 : s->status = FINISH_STATE;
\r
3112 001ff c7 46 04 9a 02
\r
3113 00 00 mov DWORD PTR [esi+4], 666 ; 0000029aH
\r
3115 ; 308 : strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
\r
3116 ; 309 : deflateEnd (strm);
\r
3119 00207 c7 47 18 00 00
\r
3120 00 00 mov DWORD PTR [edi+24], OFFSET ??_C@_0BE@OGGJBMCE@insufficient?5memory?$AA@
\r
3121 0020e e8 00 00 00 00 call _deflateEnd@4
\r
3124 ; 310 : return Z_MEM_ERROR;
\r
3128 00215 b8 fc ff ff ff mov eax, -4 ; fffffffcH
\r
3133 0021b 8b e5 mov esp, ebp
\r
3135 0021e c2 20 00 ret 32 ; 00000020H
\r
3139 ; 274 : return Z_STREAM_ERROR;
\r
3141 00222 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
3146 00228 8b e5 mov esp, ebp
\r
3148 0022b c2 20 00 ret 32 ; 00000020H
\r
3151 ; 235 : return Z_VERSION_ERROR;
\r
3153 0022e b8 fa ff ff ff mov eax, -6 ; fffffffaH
\r
3157 00233 8b e5 mov esp, ebp
\r
3159 00236 c2 20 00 ret 32 ; 00000020H
\r
3160 _deflateInit2_@32 ENDP
\r
3162 PUBLIC _deflateInit_@16
\r
3163 ; Function compile flags: /Ogtp
\r
3164 ; COMDAT _deflateInit_@16
\r
3166 _strm$ = 8 ; size = 4
\r
3167 _level$ = 12 ; size = 4
\r
3168 _version$ = 16 ; size = 4
\r
3169 _stream_size$ = 20 ; size = 4
\r
3170 _deflateInit_@16 PROC ; COMDAT
\r
3175 00001 8b ec mov ebp, esp
\r
3177 ; 207 : return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
\r
3178 ; 208 : Z_DEFAULT_STRATEGY, version, stream_size);
\r
3180 00003 8b 45 14 mov eax, DWORD PTR _stream_size$[ebp]
\r
3181 00006 8b 4d 10 mov ecx, DWORD PTR _version$[ebp]
\r
3182 00009 8b 55 0c mov edx, DWORD PTR _level$[ebp]
\r
3184 0000d 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
3186 00011 6a 00 push 0
\r
3187 00013 6a 08 push 8
\r
3188 00015 6a 0f push 15 ; 0000000fH
\r
3189 00017 6a 08 push 8
\r
3192 0001b e8 00 00 00 00 call _deflateInit2_@32
\r
3194 ; 209 : /* To do: ignore strm->next_in if we use it as window */
\r
3198 00021 c2 10 00 ret 16 ; 00000010H
\r
3199 _deflateInit_@16 ENDP
\r
3200 ; Function compile flags: /Ogtp
\r
3201 ; COMDAT _deflate_huff
\r
3203 _flush$ = 8 ; size = 4
\r
3204 _deflate_huff PROC ; COMDAT
\r
3210 00001 8b ec mov ebp, esp
\r
3214 ; 1936 : int bflush; /* set if current block must be flushed */
\r
3216 ; 1938 : for (;;) {
\r
3217 ; 1939 : /* Make sure that we have a literal to write. */
\r
3218 ; 1940 : if (s->lookahead == 0) {
\r
3220 00004 83 7e 74 00 cmp DWORD PTR [esi+116], 0
\r
3221 00008 75 11 jne SHORT $LN8@deflate_hu
\r
3223 ; 1941 : fill_window(s);
\r
3225 0000a 8b fe mov edi, esi
\r
3226 0000c e8 00 00 00 00 call _fill_window
\r
3228 ; 1942 : if (s->lookahead == 0) {
\r
3230 00011 83 7e 74 00 cmp DWORD PTR [esi+116], 0
\r
3231 00015 0f 84 a4 00 00
\r
3232 00 je $LN22@deflate_hu
\r
3235 ; 1945 : break; /* flush the current block */
\r
3239 ; 1949 : /* Output a literal byte */
\r
3240 ; 1950 : s->match_length = 0;
\r
3241 ; 1951 : Tracevv((stderr,"%c", s->window[s->strstart]));
\r
3242 ; 1952 : _tr_tally_lit (s, s->window[s->strstart], bflush);
\r
3244 0001b 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3245 0001e 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3246 00021 8b 96 a0 16 00
\r
3247 00 mov edx, DWORD PTR [esi+5792]
\r
3248 00027 c7 46 60 00 00
\r
3249 00 00 mov DWORD PTR [esi+96], 0
\r
3250 0002e 8a 04 08 mov al, BYTE PTR [eax+ecx]
\r
3251 00031 8b 8e a4 16 00
\r
3252 00 mov ecx, DWORD PTR [esi+5796]
\r
3253 00037 33 ff xor edi, edi
\r
3254 00039 66 89 3c 51 mov WORD PTR [ecx+edx*2], di
\r
3255 0003d 8b 8e a0 16 00
\r
3256 00 mov ecx, DWORD PTR [esi+5792]
\r
3257 00043 8b 96 98 16 00
\r
3258 00 mov edx, DWORD PTR [esi+5784]
\r
3259 00049 88 04 0a mov BYTE PTR [edx+ecx], al
\r
3260 0004c 0f b6 d0 movzx edx, al
\r
3261 0004f b9 01 00 00 00 mov ecx, 1
\r
3262 00054 01 8e a0 16 00
\r
3263 00 add DWORD PTR [esi+5792], ecx
\r
3264 0005a 66 01 8c 96 94
\r
3265 00 00 00 add WORD PTR [esi+edx*4+148], cx
\r
3267 ; 1953 : s->lookahead--;
\r
3268 ; 1954 : s->strstart++;
\r
3270 00062 01 4e 6c add DWORD PTR [esi+108], ecx
\r
3271 00065 ff 4e 74 dec DWORD PTR [esi+116]
\r
3272 00068 8d 84 96 94 00
\r
3273 00 00 lea eax, DWORD PTR [esi+edx*4+148]
\r
3274 0006f 8b 96 9c 16 00
\r
3275 00 mov edx, DWORD PTR [esi+5788]
\r
3276 00075 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3277 00078 2b d1 sub edx, ecx
\r
3278 0007a 39 96 a0 16 00
\r
3279 00 cmp DWORD PTR [esi+5792], edx
\r
3281 ; 1955 : if (bflush) FLUSH_BLOCK(s, 0);
\r
3283 00080 75 82 jne SHORT $LL11@deflate_hu
\r
3284 00082 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
3285 00085 85 d2 test edx, edx
\r
3286 00087 78 07 js SHORT $LN14@deflate_hu
\r
3287 00089 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3288 0008c 03 ca add ecx, edx
\r
3289 0008e eb 02 jmp SHORT $LN15@deflate_hu
\r
3291 00090 33 c9 xor ecx, ecx
\r
3293 00092 6a 00 push 0
\r
3295 00095 2b c2 sub eax, edx
\r
3296 00097 8b ce mov ecx, esi
\r
3297 00099 e8 00 00 00 00 call __tr_flush_block
\r
3298 0009e 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3299 000a1 8b 3e mov edi, DWORD PTR [esi]
\r
3300 000a3 83 c4 08 add esp, 8
\r
3301 000a6 89 46 5c mov DWORD PTR [esi+92], eax
\r
3302 000a9 e8 00 00 00 00 call _flush_pending
\r
3303 000ae 8b 0e mov ecx, DWORD PTR [esi]
\r
3304 000b0 83 79 10 00 cmp DWORD PTR [ecx+16], 0
\r
3305 000b4 0f 85 4a ff ff
\r
3306 ff jne $LL11@deflate_hu
\r
3308 000ba 33 c0 xor eax, eax
\r
3317 ; 1943 : if (flush == Z_NO_FLUSH)
\r
3319 000bf 8b 45 08 mov eax, DWORD PTR _flush$[ebp]
\r
3320 000c2 85 c0 test eax, eax
\r
3322 ; 1944 : return need_more;
\r
3324 000c4 74 f4 je SHORT $LN23@deflate_hu
\r
3327 ; 1957 : s->insert = 0;
\r
3329 000c6 c7 86 b4 16 00
\r
3330 00 00 00 00 00 mov DWORD PTR [esi+5812], 0
\r
3332 ; 1958 : if (flush == Z_FINISH) {
\r
3334 000d0 83 f8 04 cmp eax, 4
\r
3335 000d3 75 3f jne SHORT $LN4@deflate_hu
\r
3337 ; 1959 : FLUSH_BLOCK(s, 1);
\r
3339 000d5 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
3340 000d8 85 d2 test edx, edx
\r
3341 000da 78 07 js SHORT $LN16@deflate_hu
\r
3342 000dc 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3343 000df 03 ca add ecx, edx
\r
3344 000e1 eb 02 jmp SHORT $LN17@deflate_hu
\r
3346 000e3 33 c9 xor ecx, ecx
\r
3348 000e5 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3349 000e8 6a 01 push 1
\r
3351 000eb 2b c2 sub eax, edx
\r
3352 000ed 8b ce mov ecx, esi
\r
3353 000ef e8 00 00 00 00 call __tr_flush_block
\r
3354 000f4 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
3355 000f7 8b 3e mov edi, DWORD PTR [esi]
\r
3356 000f9 83 c4 08 add esp, 8
\r
3357 000fc 89 56 5c mov DWORD PTR [esi+92], edx
\r
3358 000ff e8 00 00 00 00 call _flush_pending
\r
3359 00104 8b 06 mov eax, DWORD PTR [esi]
\r
3360 00106 33 c9 xor ecx, ecx
\r
3361 00108 39 48 10 cmp DWORD PTR [eax+16], ecx
\r
3363 0010c 0f 95 c1 setne cl
\r
3364 0010f 8d 41 02 lea eax, DWORD PTR [ecx+2]
\r
3372 ; 1960 : return finish_done;
\r
3374 ; 1962 : if (s->last_lit)
\r
3376 00114 83 be a0 16 00
\r
3377 00 00 cmp DWORD PTR [esi+5792], 0
\r
3378 0011b 74 3b je SHORT $LN1@deflate_hu
\r
3380 ; 1963 : FLUSH_BLOCK(s, 0);
\r
3382 0011d 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
3383 00120 85 d2 test edx, edx
\r
3384 00122 78 07 js SHORT $LN18@deflate_hu
\r
3385 00124 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3386 00127 03 ca add ecx, edx
\r
3387 00129 eb 02 jmp SHORT $LN19@deflate_hu
\r
3389 0012b 33 c9 xor ecx, ecx
\r
3391 0012d 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3392 00130 6a 00 push 0
\r
3394 00133 2b c2 sub eax, edx
\r
3395 00135 8b ce mov ecx, esi
\r
3396 00137 e8 00 00 00 00 call __tr_flush_block
\r
3397 0013c 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
3398 0013f 8b 3e mov edi, DWORD PTR [esi]
\r
3399 00141 83 c4 08 add esp, 8
\r
3400 00144 89 56 5c mov DWORD PTR [esi+92], edx
\r
3401 00147 e8 00 00 00 00 call _flush_pending
\r
3402 0014c 8b 06 mov eax, DWORD PTR [esi]
\r
3403 0014e 83 78 10 00 cmp DWORD PTR [eax+16], 0
\r
3404 00152 0f 84 62 ff ff
\r
3405 ff je $LN23@deflate_hu
\r
3408 ; 1964 : return block_done;
\r
3410 00158 b8 01 00 00 00 mov eax, 1
\r
3417 _deflate_huff ENDP
\r
3418 ; Function compile flags: /Ogtp
\r
3420 ; COMDAT _deflate_rle
\r
3422 _flush$ = 8 ; size = 4
\r
3423 _deflate_rle PROC ; COMDAT
\r
3429 00001 8b ec mov ebp, esp
\r
3432 00005 bb 01 00 00 00 mov ebx, 1
\r
3433 0000a 8d 9b 00 00 00
\r
3437 ; 1863 : int bflush; /* set if current block must be flushed */
\r
3438 ; 1864 : uInt prev; /* byte at distance one to match */
\r
3439 ; 1865 : Bytef *scan, *strend; /* scan goes up to strend for length of run */
\r
3441 ; 1867 : for (;;) {
\r
3442 ; 1868 : /* Make sure that we always have enough lookahead, except
\r
3443 ; 1869 : * at the end of the input file. We need MAX_MATCH bytes
\r
3444 ; 1870 : * for the longest run, plus one for the unrolled loop.
\r
3446 ; 1872 : if (s->lookahead <= MAX_MATCH) {
\r
3448 00010 8b 7e 74 mov edi, DWORD PTR [esi+116]
\r
3449 00013 81 ff 02 01 00
\r
3450 00 cmp edi, 258 ; 00000102H
\r
3451 00019 77 24 ja SHORT $LN41@deflate_rl
\r
3453 ; 1873 : fill_window(s);
\r
3455 0001b 8b fe mov edi, esi
\r
3456 0001d e8 00 00 00 00 call _fill_window
\r
3458 ; 1874 : if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
\r
3460 00022 8b 7e 74 mov edi, DWORD PTR [esi+116]
\r
3461 00025 81 ff 02 01 00
\r
3462 00 cmp edi, 258 ; 00000102H
\r
3463 0002b 77 0a ja SHORT $LN40@deflate_rl
\r
3464 0002d 83 7d 08 00 cmp DWORD PTR _flush$[ebp], 0
\r
3465 00031 0f 84 cb 01 00
\r
3466 00 je $LN36@deflate_rl
\r
3469 ; 1875 : return need_more;
\r
3471 ; 1877 : if (s->lookahead == 0) break; /* flush the current block */
\r
3473 00037 85 ff test edi, edi
\r
3474 00039 0f 84 c9 01 00
\r
3475 00 je $LN35@deflate_rl
\r
3480 ; 1880 : /* See how many times the previous byte repeats */
\r
3481 ; 1881 : s->match_length = 0;
\r
3483 0003f c7 46 60 00 00
\r
3484 00 00 mov DWORD PTR [esi+96], 0
\r
3486 ; 1882 : if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
\r
3488 00046 83 ff 03 cmp edi, 3
\r
3489 00049 0f 82 a2 00 00
\r
3490 00 jb $LN9@deflate_rl
\r
3491 0004f 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3492 00052 85 c0 test eax, eax
\r
3493 00054 0f 84 97 00 00
\r
3494 00 je $LN9@deflate_rl
\r
3496 ; 1883 : scan = s->window + s->strstart - 1;
\r
3498 0005a 8b 56 38 mov edx, DWORD PTR [esi+56]
\r
3499 0005d 03 d0 add edx, eax
\r
3501 ; 1884 : prev = *scan;
\r
3503 0005f 0f b6 4a ff movzx ecx, BYTE PTR [edx-1]
\r
3504 00063 8d 42 ff lea eax, DWORD PTR [edx-1]
\r
3506 ; 1885 : if (prev == *++scan && prev == *++scan && prev == *++scan) {
\r
3508 00066 03 c3 add eax, ebx
\r
3509 00068 0f b6 18 movzx ebx, BYTE PTR [eax]
\r
3510 0006b 3b cb cmp ecx, ebx
\r
3511 0006d 75 7d jne SHORT $LN38@deflate_rl
\r
3512 0006f 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3513 00073 3b cb cmp ecx, ebx
\r
3514 00075 75 75 jne SHORT $LN38@deflate_rl
\r
3515 00077 0f b6 58 02 movzx ebx, BYTE PTR [eax+2]
\r
3516 0007b 83 c0 02 add eax, 2
\r
3517 0007e 3b cb cmp ecx, ebx
\r
3518 00080 75 6a jne SHORT $LN38@deflate_rl
\r
3520 ; 1886 : strend = s->window + s->strstart + MAX_MATCH;
\r
3522 00082 81 c2 02 01 00
\r
3523 00 add edx, 258 ; 00000102H
\r
3527 ; 1888 : } while (prev == *++scan && prev == *++scan &&
\r
3528 ; 1889 : prev == *++scan && prev == *++scan &&
\r
3529 ; 1890 : prev == *++scan && prev == *++scan &&
\r
3530 ; 1891 : prev == *++scan && prev == *++scan &&
\r
3531 ; 1892 : scan < strend);
\r
3533 00088 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3535 0008d 3b cb cmp ecx, ebx
\r
3536 0008f 75 43 jne SHORT $LN10@deflate_rl
\r
3537 00091 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3539 00096 3b cb cmp ecx, ebx
\r
3540 00098 75 3a jne SHORT $LN10@deflate_rl
\r
3541 0009a 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3543 0009f 3b cb cmp ecx, ebx
\r
3544 000a1 75 31 jne SHORT $LN10@deflate_rl
\r
3545 000a3 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3547 000a8 3b cb cmp ecx, ebx
\r
3548 000aa 75 28 jne SHORT $LN10@deflate_rl
\r
3549 000ac 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3551 000b1 3b cb cmp ecx, ebx
\r
3552 000b3 75 1f jne SHORT $LN10@deflate_rl
\r
3553 000b5 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3555 000ba 3b cb cmp ecx, ebx
\r
3556 000bc 75 16 jne SHORT $LN10@deflate_rl
\r
3557 000be 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3559 000c3 3b cb cmp ecx, ebx
\r
3560 000c5 75 0d jne SHORT $LN10@deflate_rl
\r
3561 000c7 0f b6 58 01 movzx ebx, BYTE PTR [eax+1]
\r
3563 000cc 3b cb cmp ecx, ebx
\r
3564 000ce 75 04 jne SHORT $LN10@deflate_rl
\r
3565 000d0 3b c2 cmp eax, edx
\r
3566 000d2 72 b4 jb SHORT $LL13@deflate_rl
\r
3569 ; 1893 : s->match_length = MAX_MATCH - (int)(strend - scan);
\r
3571 000d4 2b c2 sub eax, edx
\r
3572 000d6 05 02 01 00 00 add eax, 258 ; 00000102H
\r
3573 000db 89 46 60 mov DWORD PTR [esi+96], eax
\r
3575 ; 1894 : if (s->match_length > s->lookahead)
\r
3576 ; 1895 : s->match_length = s->lookahead;
\r
3578 000de bb 01 00 00 00 mov ebx, 1
\r
3579 000e3 3b c7 cmp eax, edi
\r
3580 000e5 76 0a jbe SHORT $LN9@deflate_rl
\r
3581 000e7 89 7e 60 mov DWORD PTR [esi+96], edi
\r
3582 000ea eb 05 jmp SHORT $LN9@deflate_rl
\r
3584 000ec bb 01 00 00 00 mov ebx, 1
\r
3588 ; 1897 : Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
\r
3591 ; 1900 : /* Emit match if have run of MIN_MATCH or longer, else emit literal */
\r
3592 ; 1901 : if (s->match_length >= MIN_MATCH) {
\r
3594 000f1 83 7e 60 03 cmp DWORD PTR [esi+96], 3
\r
3596 ; 1902 : check_match(s, s->strstart, s->strstart - 1, s->match_length);
\r
3598 ; 1904 : _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
\r
3600 000f5 8b 96 a0 16 00
\r
3601 00 mov edx, DWORD PTR [esi+5792]
\r
3602 000fb 72 6d jb SHORT $LN8@deflate_rl
\r
3603 000fd 8a 46 60 mov al, BYTE PTR [esi+96]
\r
3604 00100 8b 8e a4 16 00
\r
3605 00 mov ecx, DWORD PTR [esi+5796]
\r
3606 00106 2c 03 sub al, 3
\r
3607 00108 8b fb mov edi, ebx
\r
3608 0010a 66 89 3c 51 mov WORD PTR [ecx+edx*2], di
\r
3609 0010e 8b 8e a0 16 00
\r
3610 00 mov ecx, DWORD PTR [esi+5792]
\r
3611 00114 8b 96 98 16 00
\r
3612 00 mov edx, DWORD PTR [esi+5784]
\r
3613 0011a 88 04 0a mov BYTE PTR [edx+ecx], al
\r
3614 0011d 01 9e a0 16 00
\r
3615 00 add DWORD PTR [esi+5792], ebx
\r
3616 00123 0f b6 d0 movzx edx, al
\r
3617 00126 0f b6 82 00 00
\r
3618 00 00 movzx eax, BYTE PTR __length_code[edx]
\r
3619 0012d 66 01 9c 86 98
\r
3620 04 00 00 add WORD PTR [esi+eax*4+1176], bx
\r
3621 00135 66 01 9e 88 09
\r
3622 00 00 add WORD PTR [esi+2440], bx
\r
3623 0013c 8b 8e 9c 16 00
\r
3624 00 mov ecx, DWORD PTR [esi+5788]
\r
3625 00142 8d 84 86 98 04
\r
3626 00 00 lea eax, DWORD PTR [esi+eax*4+1176]
\r
3629 ; 1906 : s->lookahead -= s->match_length;
\r
3631 00149 8b 46 60 mov eax, DWORD PTR [esi+96]
\r
3632 0014c 2b cb sub ecx, ebx
\r
3633 0014e 33 d2 xor edx, edx
\r
3634 00150 39 8e a0 16 00
\r
3635 00 cmp DWORD PTR [esi+5792], ecx
\r
3637 ; 1907 : s->strstart += s->match_length;
\r
3638 ; 1908 : s->match_length = 0;
\r
3640 00156 c7 46 60 00 00
\r
3641 00 00 mov DWORD PTR [esi+96], 0
\r
3642 0015d 0f 94 c2 sete dl
\r
3643 00160 29 46 74 sub DWORD PTR [esi+116], eax
\r
3644 00163 01 46 6c add DWORD PTR [esi+108], eax
\r
3645 00166 8b ca mov ecx, edx
\r
3649 00168 eb 55 jmp SHORT $LN7@deflate_rl
\r
3652 ; 1910 : /* No match, output a literal byte */
\r
3653 ; 1911 : Tracevv((stderr,"%c", s->window[s->strstart]));
\r
3654 ; 1912 : _tr_tally_lit (s, s->window[s->strstart], bflush);
\r
3656 0016a 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
3657 0016d 8b 46 38 mov eax, DWORD PTR [esi+56]
\r
3658 00170 8a 04 08 mov al, BYTE PTR [eax+ecx]
\r
3659 00173 8b 8e a4 16 00
\r
3660 00 mov ecx, DWORD PTR [esi+5796]
\r
3661 00179 33 ff xor edi, edi
\r
3662 0017b 66 89 3c 51 mov WORD PTR [ecx+edx*2], di
\r
3663 0017f 8b 8e a0 16 00
\r
3664 00 mov ecx, DWORD PTR [esi+5792]
\r
3665 00185 8b 96 98 16 00
\r
3666 00 mov edx, DWORD PTR [esi+5784]
\r
3667 0018b 88 04 0a mov BYTE PTR [edx+ecx], al
\r
3668 0018e 01 9e a0 16 00
\r
3669 00 add DWORD PTR [esi+5792], ebx
\r
3670 00194 0f b6 d0 movzx edx, al
\r
3671 00197 66 01 9c 96 94
\r
3672 00 00 00 add WORD PTR [esi+edx*4+148], bx
\r
3673 0019f 8d 84 96 94 00
\r
3674 00 00 lea eax, DWORD PTR [esi+edx*4+148]
\r
3675 001a6 8b 86 9c 16 00
\r
3676 00 mov eax, DWORD PTR [esi+5788]
\r
3677 001ac 2b c3 sub eax, ebx
\r
3678 001ae 33 c9 xor ecx, ecx
\r
3679 001b0 39 86 a0 16 00
\r
3680 00 cmp DWORD PTR [esi+5792], eax
\r
3681 001b6 0f 94 c1 sete cl
\r
3683 ; 1913 : s->lookahead--;
\r
3685 001b9 ff 4e 74 dec DWORD PTR [esi+116]
\r
3687 ; 1914 : s->strstart++;
\r
3689 001bc 01 5e 6c add DWORD PTR [esi+108], ebx
\r
3693 ; 1916 : if (bflush) FLUSH_BLOCK(s, 0);
\r
3695 001bf 85 c9 test ecx, ecx
\r
3696 001c1 0f 84 49 fe ff
\r
3697 ff je $LL20@deflate_rl
\r
3698 001c7 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
3699 001ca 85 d2 test edx, edx
\r
3700 001cc 78 07 js SHORT $LN25@deflate_rl
\r
3701 001ce 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3702 001d1 03 ca add ecx, edx
\r
3703 001d3 eb 02 jmp SHORT $LN26@deflate_rl
\r
3705 001d5 33 c9 xor ecx, ecx
\r
3707 001d7 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3708 001da 6a 00 push 0
\r
3710 001dd 2b c2 sub eax, edx
\r
3711 001df 8b ce mov ecx, esi
\r
3712 001e1 e8 00 00 00 00 call __tr_flush_block
\r
3713 001e6 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
3714 001e9 8b 3e mov edi, DWORD PTR [esi]
\r
3715 001eb 83 c4 08 add esp, 8
\r
3716 001ee 89 4e 5c mov DWORD PTR [esi+92], ecx
\r
3717 001f1 e8 00 00 00 00 call _flush_pending
\r
3718 001f6 8b 16 mov edx, DWORD PTR [esi]
\r
3719 001f8 83 7a 10 00 cmp DWORD PTR [edx+16], 0
\r
3720 001fc 0f 85 0e fe ff
\r
3721 ff jne $LL20@deflate_rl
\r
3724 00203 33 c0 xor eax, eax
\r
3734 ; 1918 : s->insert = 0;
\r
3735 ; 1919 : if (flush == Z_FINISH) {
\r
3737 00208 83 7d 08 04 cmp DWORD PTR _flush$[ebp], 4
\r
3738 0020c c7 86 b4 16 00
\r
3739 00 00 00 00 00 mov DWORD PTR [esi+5812], 0
\r
3740 00216 75 3f jne SHORT $LN4@deflate_rl
\r
3742 ; 1920 : FLUSH_BLOCK(s, 1);
\r
3744 00218 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
3745 0021b 85 d2 test edx, edx
\r
3746 0021d 78 07 js SHORT $LN27@deflate_rl
\r
3747 0021f 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3748 00222 03 ca add ecx, edx
\r
3749 00224 eb 02 jmp SHORT $LN28@deflate_rl
\r
3751 00226 33 c9 xor ecx, ecx
\r
3753 00228 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3756 0022d 2b c2 sub eax, edx
\r
3757 0022f 8b ce mov ecx, esi
\r
3758 00231 e8 00 00 00 00 call __tr_flush_block
\r
3759 00236 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3760 00239 8b 3e mov edi, DWORD PTR [esi]
\r
3761 0023b 83 c4 08 add esp, 8
\r
3762 0023e 89 46 5c mov DWORD PTR [esi+92], eax
\r
3763 00241 e8 00 00 00 00 call _flush_pending
\r
3764 00246 8b 0e mov ecx, DWORD PTR [esi]
\r
3765 00248 33 c0 xor eax, eax
\r
3766 0024a 39 41 10 cmp DWORD PTR [ecx+16], eax
\r
3768 0024e 0f 95 c0 setne al
\r
3770 00252 83 c0 02 add eax, 2
\r
3778 ; 1921 : return finish_done;
\r
3780 ; 1923 : if (s->last_lit)
\r
3782 00257 83 be a0 16 00
\r
3783 00 00 cmp DWORD PTR [esi+5792], 0
\r
3784 0025e 74 3b je SHORT $LN1@deflate_rl
\r
3786 ; 1924 : FLUSH_BLOCK(s, 0);
\r
3788 00260 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
3789 00263 85 d2 test edx, edx
\r
3790 00265 78 07 js SHORT $LN29@deflate_rl
\r
3791 00267 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3792 0026a 03 ca add ecx, edx
\r
3793 0026c eb 02 jmp SHORT $LN30@deflate_rl
\r
3795 0026e 33 c9 xor ecx, ecx
\r
3797 00270 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
3798 00273 6a 00 push 0
\r
3800 00276 2b c2 sub eax, edx
\r
3801 00278 8b ce mov ecx, esi
\r
3802 0027a e8 00 00 00 00 call __tr_flush_block
\r
3803 0027f 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
3804 00282 8b 3e mov edi, DWORD PTR [esi]
\r
3805 00284 83 c4 08 add esp, 8
\r
3806 00287 89 56 5c mov DWORD PTR [esi+92], edx
\r
3807 0028a e8 00 00 00 00 call _flush_pending
\r
3808 0028f 8b 06 mov eax, DWORD PTR [esi]
\r
3809 00291 83 78 10 00 cmp DWORD PTR [eax+16], 0
\r
3810 00295 0f 84 67 ff ff
\r
3811 ff je $LN36@deflate_rl
\r
3815 ; 1925 : return block_done;
\r
3817 0029c 8b c3 mov eax, ebx
\r
3825 ; Function compile flags: /Ogtp
\r
3827 ; COMDAT _deflate_slow
\r
3829 _bflush$ = 8 ; size = 4
\r
3830 _s$ = 8 ; size = 4
\r
3831 _flush$ = 12 ; size = 4
\r
3832 _deflate_slow PROC ; COMDAT
\r
3837 00001 8b ec mov ebp, esp
\r
3840 00005 8b 75 08 mov esi, DWORD PTR _s$[ebp]
\r
3842 00009 bb 01 00 00 00 mov ebx, 1
\r
3843 0000e 8b ff npad 2
\r
3846 ; 1732 : IPos hash_head; /* head of hash chain */
\r
3847 ; 1733 : int bflush; /* set if current block must be flushed */
\r
3849 ; 1735 : /* Process the input block. */
\r
3850 ; 1736 : for (;;) {
\r
3851 ; 1737 : /* Make sure that we always have enough lookahead, except
\r
3852 ; 1738 : * at the end of the input file. We need MAX_MATCH bytes
\r
3853 ; 1739 : * for the next match, plus MIN_MATCH bytes to insert the
\r
3854 ; 1740 : * string following the next match.
\r
3856 ; 1742 : if (s->lookahead < MIN_LOOKAHEAD) {
\r
3858 00010 8b 4e 74 mov ecx, DWORD PTR [esi+116]
\r
3859 00013 81 f9 06 01 00
\r
3860 00 cmp ecx, 262 ; 00000106H
\r
3861 00019 73 24 jae SHORT $LN50@deflate_sl
\r
3863 ; 1743 : fill_window(s);
\r
3865 0001b 8b fe mov edi, esi
\r
3866 0001d e8 00 00 00 00 call _fill_window
\r
3868 ; 1744 : if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
\r
3870 00022 8b 4e 74 mov ecx, DWORD PTR [esi+116]
\r
3871 00025 81 f9 06 01 00
\r
3872 00 cmp ecx, 262 ; 00000106H
\r
3873 0002b 73 0a jae SHORT $LN49@deflate_sl
\r
3874 0002d 83 7d 0c 00 cmp DWORD PTR _flush$[ebp], 0
\r
3875 00031 0f 84 2d 02 00
\r
3876 00 je $LN47@deflate_sl
\r
3879 ; 1745 : return need_more;
\r
3881 ; 1747 : if (s->lookahead == 0) break; /* flush the current block */
\r
3883 00037 85 c9 test ecx, ecx
\r
3884 00039 0f 84 d1 02 00
\r
3885 00 je $LN45@deflate_sl
\r
3890 ; 1750 : /* Insert the string window[strstart .. strstart+2] in the
\r
3891 ; 1751 : * dictionary, and set hash_head to the head of the hash chain:
\r
3893 ; 1753 : hash_head = NIL;
\r
3895 0003f 33 c0 xor eax, eax
\r
3897 ; 1754 : if (s->lookahead >= MIN_MATCH) {
\r
3899 00041 83 f9 03 cmp ecx, 3
\r
3900 00044 72 49 jb SHORT $LN21@deflate_sl
\r
3902 ; 1755 : INSERT_STRING(s, s->strstart, hash_head);
\r
3904 00046 8b 46 48 mov eax, DWORD PTR [esi+72]
\r
3905 00049 8b 4e 58 mov ecx, DWORD PTR [esi+88]
\r
3906 0004c 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
3907 0004f 8b 7e 34 mov edi, DWORD PTR [esi+52]
\r
3908 00052 d3 e0 shl eax, cl
\r
3909 00054 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
3910 00057 0f b6 4c 11 02 movzx ecx, BYTE PTR [ecx+edx+2]
\r
3911 0005c 33 c1 xor eax, ecx
\r
3912 0005e 23 46 54 and eax, DWORD PTR [esi+84]
\r
3913 00061 8b 4e 44 mov ecx, DWORD PTR [esi+68]
\r
3914 00064 23 fa and edi, edx
\r
3915 00066 8b 56 40 mov edx, DWORD PTR [esi+64]
\r
3916 00069 89 46 48 mov DWORD PTR [esi+72], eax
\r
3917 0006c 66 8b 04 41 mov ax, WORD PTR [ecx+eax*2]
\r
3918 00070 66 89 04 7a mov WORD PTR [edx+edi*2], ax
\r
3919 00074 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
3920 00077 23 4e 34 and ecx, DWORD PTR [esi+52]
\r
3921 0007a 8b 56 40 mov edx, DWORD PTR [esi+64]
\r
3922 0007d 0f b7 04 4a movzx eax, WORD PTR [edx+ecx*2]
\r
3923 00081 8b 4e 48 mov ecx, DWORD PTR [esi+72]
\r
3924 00084 8b 56 44 mov edx, DWORD PTR [esi+68]
\r
3925 00087 66 8b 7e 6c mov di, WORD PTR [esi+108]
\r
3926 0008b 66 89 3c 4a mov WORD PTR [edx+ecx*2], di
\r
3931 ; 1758 : /* Find the longest match, discarding those <= prev_length.
\r
3933 ; 1760 : s->prev_length = s->match_length, s->prev_match = s->match_start;
\r
3935 0008f 8b 4e 60 mov ecx, DWORD PTR [esi+96]
\r
3936 00092 8b 56 70 mov edx, DWORD PTR [esi+112]
\r
3937 00095 89 4e 78 mov DWORD PTR [esi+120], ecx
\r
3938 00098 89 56 64 mov DWORD PTR [esi+100], edx
\r
3940 ; 1761 : s->match_length = MIN_MATCH-1;
\r
3942 0009b c7 46 60 02 00
\r
3943 00 00 mov DWORD PTR [esi+96], 2
\r
3946 ; 1763 : if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
\r
3947 ; 1764 : s->strstart - hash_head <= MAX_DIST(s)) {
\r
3949 000a2 85 c0 test eax, eax
\r
3950 000a4 74 4f je SHORT $LN52@deflate_sl
\r
3951 000a6 3b 8e 80 00 00
\r
3952 00 cmp ecx, DWORD PTR [esi+128]
\r
3953 000ac 73 47 jae SHORT $LN52@deflate_sl
\r
3954 000ae 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
3955 000b1 8b 4e 2c mov ecx, DWORD PTR [esi+44]
\r
3956 000b4 2b d0 sub edx, eax
\r
3957 000b6 81 e9 06 01 00
\r
3958 00 sub ecx, 262 ; 00000106H
\r
3959 000bc 3b d1 cmp edx, ecx
\r
3960 000be 77 35 ja SHORT $LN52@deflate_sl
\r
3962 ; 1765 : /* To simplify the code, we prevent matches with the string
\r
3963 ; 1766 : * of window index 0 (in particular we have to avoid a match
\r
3964 ; 1767 : * of the string with itself at the start of the input file).
\r
3966 ; 1769 : s->match_length = longest_match (s, hash_head);
\r
3969 000c1 8b fe mov edi, esi
\r
3970 000c3 e8 00 00 00 00 call _longest_match
\r
3971 000c8 83 c4 04 add esp, 4
\r
3972 000cb 89 46 60 mov DWORD PTR [esi+96], eax
\r
3974 ; 1770 : /* longest_match() sets match_start */
\r
3976 ; 1772 : if (s->match_length <= 5 && (s->strategy == Z_FILTERED
\r
3977 ; 1773 : #if TOO_FAR <= 32767
\r
3978 ; 1774 : || (s->match_length == MIN_MATCH &&
\r
3979 ; 1775 : s->strstart - s->match_start > TOO_FAR)
\r
3983 000ce 83 f8 05 cmp eax, 5
\r
3984 000d1 77 22 ja SHORT $LN52@deflate_sl
\r
3985 000d3 39 9e 88 00 00
\r
3986 00 cmp DWORD PTR [esi+136], ebx
\r
3987 000d9 74 13 je SHORT $LN18@deflate_sl
\r
3988 000db 83 f8 03 cmp eax, 3
\r
3989 000de 75 15 jne SHORT $LN52@deflate_sl
\r
3990 000e0 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
3991 000e3 2b 56 70 sub edx, DWORD PTR [esi+112]
\r
3992 000e6 81 fa 00 10 00
\r
3993 00 cmp edx, 4096 ; 00001000H
\r
3994 000ec 76 07 jbe SHORT $LN52@deflate_sl
\r
3998 ; 1779 : /* If prev_match is also MIN_MATCH, match_start is garbage
\r
3999 ; 1780 : * but we will ignore the current match anyway.
\r
4001 ; 1782 : s->match_length = MIN_MATCH-1;
\r
4003 000ee c7 46 60 02 00
\r
4004 00 00 mov DWORD PTR [esi+96], 2
\r
4009 ; 1785 : /* If there was a match at the previous step and the current
\r
4010 ; 1786 : * match is not better, output the previous match:
\r
4012 ; 1788 : if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
\r
4014 000f5 8b 46 78 mov eax, DWORD PTR [esi+120]
\r
4015 000f8 83 f8 03 cmp eax, 3
\r
4016 000fb 0f 82 6a 01 00
\r
4017 00 jb $LN17@deflate_sl
\r
4018 00101 39 46 60 cmp DWORD PTR [esi+96], eax
\r
4019 00104 0f 87 61 01 00
\r
4020 00 ja $LN17@deflate_sl
\r
4022 ; 1789 : uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
\r
4023 ; 1790 : /* Do not insert strings in hash table beyond this. */
\r
4025 ; 1792 : check_match(s, s->strstart-1, s->prev_match, s->prev_length);
\r
4027 ; 1794 : _tr_tally_dist(s, s->strstart -1 - s->prev_match,
\r
4028 ; 1795 : s->prev_length - MIN_MATCH, bflush);
\r
4030 0010a 66 8b 56 6c mov dx, WORD PTR [esi+108]
\r
4031 0010e 66 2b 56 64 sub dx, WORD PTR [esi+100]
\r
4032 00112 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4033 00115 8b 4e 74 mov ecx, DWORD PTR [esi+116]
\r
4034 00118 66 2b d3 sub dx, bx
\r
4035 0011b 8b 9e a4 16 00
\r
4036 00 mov ebx, DWORD PTR [esi+5796]
\r
4037 00121 8d 7c 08 fd lea edi, DWORD PTR [eax+ecx-3]
\r
4038 00125 8a 46 78 mov al, BYTE PTR [esi+120]
\r
4039 00128 0f b7 ca movzx ecx, dx
\r
4040 0012b 8b 96 a0 16 00
\r
4041 00 mov edx, DWORD PTR [esi+5792]
\r
4042 00131 66 89 0c 53 mov WORD PTR [ebx+edx*2], cx
\r
4043 00135 8b 9e a0 16 00
\r
4044 00 mov ebx, DWORD PTR [esi+5792]
\r
4045 0013b 8b 96 98 16 00
\r
4046 00 mov edx, DWORD PTR [esi+5784]
\r
4047 00141 2c 03 sub al, 3
\r
4048 00143 88 04 1a mov BYTE PTR [edx+ebx], al
\r
4049 00146 0f b6 c0 movzx eax, al
\r
4050 00149 bb 01 00 00 00 mov ebx, 1
\r
4051 0014e 01 9e a0 16 00
\r
4052 00 add DWORD PTR [esi+5792], ebx
\r
4053 00154 0f b6 90 00 00
\r
4054 00 00 movzx edx, BYTE PTR __length_code[eax]
\r
4055 0015b 66 01 9c 96 98
\r
4056 04 00 00 add WORD PTR [esi+edx*4+1176], bx
\r
4057 00163 8d 84 96 98 04
\r
4058 00 00 lea eax, DWORD PTR [esi+edx*4+1176]
\r
4059 0016a 81 c1 ff ff 00
\r
4060 00 add ecx, 65535 ; 0000ffffH
\r
4061 00170 b8 00 01 00 00 mov eax, 256 ; 00000100H
\r
4062 00175 66 3b c8 cmp cx, ax
\r
4063 00178 73 0c jae SHORT $LN29@deflate_sl
\r
4064 0017a 0f b7 c9 movzx ecx, cx
\r
4065 0017d 0f b6 81 00 00
\r
4066 00 00 movzx eax, BYTE PTR __dist_code[ecx]
\r
4067 00184 eb 0d jmp SHORT $LN30@deflate_sl
\r
4069 00186 0f b7 d1 movzx edx, cx
\r
4070 00189 c1 ea 07 shr edx, 7
\r
4071 0018c 0f b6 82 00 01
\r
4072 00 00 movzx eax, BYTE PTR __dist_code[edx+256]
\r
4074 00193 66 01 9c 86 88
\r
4075 09 00 00 add WORD PTR [esi+eax*4+2440], bx
\r
4076 0019b 8b 86 9c 16 00
\r
4077 00 mov eax, DWORD PTR [esi+5788]
\r
4078 001a1 2b c3 sub eax, ebx
\r
4079 001a3 33 c9 xor ecx, ecx
\r
4080 001a5 39 86 a0 16 00
\r
4081 00 cmp DWORD PTR [esi+5792], eax
\r
4084 ; 1797 : /* Insert in hash table all strings up to the end of the match.
\r
4085 ; 1798 : * strstart-1 and strstart are already inserted. If there is not
\r
4086 ; 1799 : * enough lookahead, the last two strings are not inserted in
\r
4087 ; 1800 : * the hash table.
\r
4089 ; 1802 : s->lookahead -= s->prev_length-1;
\r
4091 001ab 8b 46 78 mov eax, DWORD PTR [esi+120]
\r
4092 001ae 0f 94 c1 sete cl
\r
4093 001b1 8b d3 mov edx, ebx
\r
4094 001b3 2b d0 sub edx, eax
\r
4095 001b5 01 56 74 add DWORD PTR [esi+116], edx
\r
4097 ; 1803 : s->prev_length -= 2;
\r
4099 001b8 83 c0 fe add eax, -2 ; fffffffeH
\r
4100 001bb 89 46 78 mov DWORD PTR [esi+120], eax
\r
4101 001be 89 4d 08 mov DWORD PTR _bflush$[ebp], ecx
\r
4105 ; 1805 : if (++s->strstart <= max_insert) {
\r
4107 001c1 01 5e 6c add DWORD PTR [esi+108], ebx
\r
4108 001c4 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
4109 001c7 3b d7 cmp edx, edi
\r
4110 001c9 77 3e ja SHORT $LN15@deflate_sl
\r
4112 ; 1806 : INSERT_STRING(s, s->strstart, hash_head);
\r
4114 001cb 8b 46 48 mov eax, DWORD PTR [esi+72]
\r
4115 001ce 8b 4e 58 mov ecx, DWORD PTR [esi+88]
\r
4116 001d1 8b 5e 34 mov ebx, DWORD PTR [esi+52]
\r
4117 001d4 d3 e0 shl eax, cl
\r
4118 001d6 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4119 001d9 0f b6 4c 11 02 movzx ecx, BYTE PTR [ecx+edx+2]
\r
4120 001de 33 c1 xor eax, ecx
\r
4121 001e0 23 46 54 and eax, DWORD PTR [esi+84]
\r
4122 001e3 8b 4e 44 mov ecx, DWORD PTR [esi+68]
\r
4123 001e6 89 46 48 mov DWORD PTR [esi+72], eax
\r
4124 001e9 0f b7 04 41 movzx eax, WORD PTR [ecx+eax*2]
\r
4125 001ed 23 da and ebx, edx
\r
4126 001ef 8b 56 40 mov edx, DWORD PTR [esi+64]
\r
4127 001f2 66 89 04 5a mov WORD PTR [edx+ebx*2], ax
\r
4128 001f6 0f b7 46 6c movzx eax, WORD PTR [esi+108]
\r
4129 001fa 8b 4e 48 mov ecx, DWORD PTR [esi+72]
\r
4130 001fd 8b 56 44 mov edx, DWORD PTR [esi+68]
\r
4131 00200 66 89 04 4a mov WORD PTR [edx+ecx*2], ax
\r
4132 00204 bb 01 00 00 00 mov ebx, 1
\r
4136 ; 1808 : } while (--s->prev_length != 0);
\r
4138 00209 ff 4e 78 dec DWORD PTR [esi+120]
\r
4139 0020c 75 b3 jne SHORT $LL16@deflate_sl
\r
4141 ; 1809 : s->match_available = 0;
\r
4142 ; 1810 : s->match_length = MIN_MATCH-1;
\r
4143 ; 1811 : s->strstart++;
\r
4145 0020e 01 5e 6c add DWORD PTR [esi+108], ebx
\r
4148 ; 1813 : if (bflush) FLUSH_BLOCK(s, 0);
\r
4150 00211 83 7d 08 00 cmp DWORD PTR _bflush$[ebp], 0
\r
4151 00215 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4152 00218 c7 46 68 00 00
\r
4153 00 00 mov DWORD PTR [esi+104], 0
\r
4154 0021f c7 46 60 02 00
\r
4155 00 00 mov DWORD PTR [esi+96], 2
\r
4156 00226 0f 84 e4 fd ff
\r
4157 ff je $LL26@deflate_sl
\r
4158 0022c 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
4159 0022f 85 d2 test edx, edx
\r
4160 00231 78 07 js SHORT $LN31@deflate_sl
\r
4161 00233 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4162 00236 03 ca add ecx, edx
\r
4163 00238 eb 02 jmp SHORT $LN32@deflate_sl
\r
4165 0023a 33 c9 xor ecx, ecx
\r
4167 0023c 6a 00 push 0
\r
4169 0023f 2b c2 sub eax, edx
\r
4170 00241 8b ce mov ecx, esi
\r
4171 00243 e8 00 00 00 00 call __tr_flush_block
\r
4172 00248 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
4173 0024b 8b 3e mov edi, DWORD PTR [esi]
\r
4174 0024d 83 c4 08 add esp, 8
\r
4175 00250 89 4e 5c mov DWORD PTR [esi+92], ecx
\r
4176 00253 e8 00 00 00 00 call _flush_pending
\r
4178 00258 8b 16 mov edx, DWORD PTR [esi]
\r
4179 0025a 83 7a 10 00 cmp DWORD PTR [edx+16], 0
\r
4180 0025e 0f 85 ac fd ff
\r
4181 ff jne $LL26@deflate_sl
\r
4186 ; 1827 : if (s->strm->avail_out == 0) return need_more;
\r
4188 00266 33 c0 xor eax, eax
\r
4198 ; 1815 : } else if (s->match_available) {
\r
4200 0026b 83 7e 68 00 cmp DWORD PTR [esi+104], 0
\r
4201 0026f 0f 84 8d 00 00
\r
4202 00 je $LN9@deflate_sl
\r
4204 ; 1816 : /* If there was no match at the previous position, output a
\r
4205 ; 1817 : * single literal. If there was a match but the current match
\r
4206 ; 1818 : * is longer, truncate the previous match to a single literal.
\r
4208 ; 1820 : Tracevv((stderr,"%c", s->window[s->strstart-1]));
\r
4209 ; 1821 : _tr_tally_lit(s, s->window[s->strstart-1], bflush);
\r
4211 00275 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4212 00278 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4213 0027b 8a 44 08 ff mov al, BYTE PTR [eax+ecx-1]
\r
4214 0027f 8b 96 a0 16 00
\r
4215 00 mov edx, DWORD PTR [esi+5792]
\r
4216 00285 8b 8e a4 16 00
\r
4217 00 mov ecx, DWORD PTR [esi+5796]
\r
4218 0028b 33 ff xor edi, edi
\r
4219 0028d 66 89 3c 51 mov WORD PTR [ecx+edx*2], di
\r
4220 00291 8b 96 98 16 00
\r
4221 00 mov edx, DWORD PTR [esi+5784]
\r
4222 00297 8b 8e a0 16 00
\r
4223 00 mov ecx, DWORD PTR [esi+5792]
\r
4224 0029d 88 04 0a mov BYTE PTR [edx+ecx], al
\r
4225 002a0 01 9e a0 16 00
\r
4226 00 add DWORD PTR [esi+5792], ebx
\r
4227 002a6 0f b6 d0 movzx edx, al
\r
4228 002a9 66 01 9c 96 94
\r
4229 00 00 00 add WORD PTR [esi+edx*4+148], bx
\r
4230 002b1 8d 84 96 94 00
\r
4231 00 00 lea eax, DWORD PTR [esi+edx*4+148]
\r
4232 002b8 8b 86 9c 16 00
\r
4233 00 mov eax, DWORD PTR [esi+5788]
\r
4234 002be 2b c3 sub eax, ebx
\r
4235 002c0 39 86 a0 16 00
\r
4236 00 cmp DWORD PTR [esi+5792], eax
\r
4238 ; 1822 : if (bflush) {
\r
4240 002c6 75 2f jne SHORT $LN8@deflate_sl
\r
4242 ; 1823 : FLUSH_BLOCK_ONLY(s, 0);
\r
4244 002c8 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
4245 002cb 85 d2 test edx, edx
\r
4246 002cd 78 07 js SHORT $LN33@deflate_sl
\r
4247 002cf 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4248 002d2 03 ca add ecx, edx
\r
4249 002d4 eb 02 jmp SHORT $LN34@deflate_sl
\r
4251 002d6 33 c9 xor ecx, ecx
\r
4253 002d8 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4254 002db 6a 00 push 0
\r
4256 002de 2b c2 sub eax, edx
\r
4257 002e0 8b ce mov ecx, esi
\r
4258 002e2 e8 00 00 00 00 call __tr_flush_block
\r
4259 002e7 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
4260 002ea 8b 3e mov edi, DWORD PTR [esi]
\r
4261 002ec 83 c4 08 add esp, 8
\r
4262 002ef 89 4e 5c mov DWORD PTR [esi+92], ecx
\r
4263 002f2 e8 00 00 00 00 call _flush_pending
\r
4267 ; 1825 : s->strstart++;
\r
4269 002f7 01 5e 6c add DWORD PTR [esi+108], ebx
\r
4271 ; 1826 : s->lookahead--;
\r
4273 002fa ff 4e 74 dec DWORD PTR [esi+116]
\r
4277 002fd e9 56 ff ff ff jmp $LN53@deflate_sl
\r
4280 ; 1829 : /* There is no previous match to compare with, wait for
\r
4281 ; 1830 : * the next step to decide.
\r
4283 ; 1832 : s->match_available = 1;
\r
4284 ; 1833 : s->strstart++;
\r
4286 00302 01 5e 6c add DWORD PTR [esi+108], ebx
\r
4288 ; 1834 : s->lookahead--;
\r
4290 00305 ff 4e 74 dec DWORD PTR [esi+116]
\r
4291 00308 89 5e 68 mov DWORD PTR [esi+104], ebx
\r
4296 0030b e9 00 fd ff ff jmp $LL26@deflate_sl
\r
4299 ; 1837 : Assert (flush != Z_NO_FLUSH, "no flush?");
\r
4300 ; 1838 : if (s->match_available) {
\r
4302 00310 83 7e 68 00 cmp DWORD PTR [esi+104], 0
\r
4303 00314 74 46 je SHORT $LN5@deflate_sl
\r
4305 ; 1839 : Tracevv((stderr,"%c", s->window[s->strstart-1]));
\r
4306 ; 1840 : _tr_tally_lit(s, s->window[s->strstart-1], bflush);
\r
4308 00316 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4309 00319 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4310 0031c 8a 44 08 ff mov al, BYTE PTR [eax+ecx-1]
\r
4311 00320 8b 96 a0 16 00
\r
4312 00 mov edx, DWORD PTR [esi+5792]
\r
4313 00326 8b 8e a4 16 00
\r
4314 00 mov ecx, DWORD PTR [esi+5796]
\r
4315 0032c 33 ff xor edi, edi
\r
4316 0032e 66 89 3c 51 mov WORD PTR [ecx+edx*2], di
\r
4317 00332 8b 96 98 16 00
\r
4318 00 mov edx, DWORD PTR [esi+5784]
\r
4319 00338 8b 8e a0 16 00
\r
4320 00 mov ecx, DWORD PTR [esi+5792]
\r
4321 0033e 88 04 0a mov BYTE PTR [edx+ecx], al
\r
4322 00341 01 9e a0 16 00
\r
4323 00 add DWORD PTR [esi+5792], ebx
\r
4324 00347 0f b6 d0 movzx edx, al
\r
4325 0034a 66 01 9c 96 94
\r
4326 00 00 00 add WORD PTR [esi+edx*4+148], bx
\r
4327 00352 8d 84 96 94 00
\r
4328 00 00 lea eax, DWORD PTR [esi+edx*4+148]
\r
4330 ; 1841 : s->match_available = 0;
\r
4332 00359 89 7e 68 mov DWORD PTR [esi+104], edi
\r
4336 ; 1843 : s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
\r
4338 0035c 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4339 0035f 8b c8 mov ecx, eax
\r
4340 00361 83 f8 02 cmp eax, 2
\r
4341 00364 72 05 jb SHORT $LN36@deflate_sl
\r
4342 00366 b9 02 00 00 00 mov ecx, 2
\r
4345 ; 1844 : if (flush == Z_FINISH) {
\r
4347 0036b 83 7d 0c 04 cmp DWORD PTR _flush$[ebp], 4
\r
4348 0036f 89 8e b4 16 00
\r
4349 00 mov DWORD PTR [esi+5812], ecx
\r
4350 00375 75 3d jne SHORT $LN4@deflate_sl
\r
4352 ; 1845 : FLUSH_BLOCK(s, 1);
\r
4354 00377 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
4355 0037a 85 d2 test edx, edx
\r
4356 0037c 78 07 js SHORT $LN37@deflate_sl
\r
4357 0037e 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4358 00381 03 ca add ecx, edx
\r
4359 00383 eb 02 jmp SHORT $LN38@deflate_sl
\r
4361 00385 33 c9 xor ecx, ecx
\r
4365 00389 2b c2 sub eax, edx
\r
4366 0038b 8b ce mov ecx, esi
\r
4367 0038d e8 00 00 00 00 call __tr_flush_block
\r
4368 00392 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4369 00395 8b 3e mov edi, DWORD PTR [esi]
\r
4370 00397 83 c4 08 add esp, 8
\r
4371 0039a 89 46 5c mov DWORD PTR [esi+92], eax
\r
4372 0039d e8 00 00 00 00 call _flush_pending
\r
4373 003a2 8b 0e mov ecx, DWORD PTR [esi]
\r
4374 003a4 33 c0 xor eax, eax
\r
4375 003a6 39 41 10 cmp DWORD PTR [ecx+16], eax
\r
4377 003aa 0f 95 c0 setne al
\r
4380 003af 83 c0 02 add eax, 2
\r
4388 ; 1846 : return finish_done;
\r
4390 ; 1848 : if (s->last_lit)
\r
4392 003b4 83 be a0 16 00
\r
4393 00 00 cmp DWORD PTR [esi+5792], 0
\r
4394 003bb 74 38 je SHORT $LN1@deflate_sl
\r
4396 ; 1849 : FLUSH_BLOCK(s, 0);
\r
4398 003bd 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
4399 003c0 85 d2 test edx, edx
\r
4400 003c2 78 07 js SHORT $LN39@deflate_sl
\r
4401 003c4 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4402 003c7 03 ca add ecx, edx
\r
4403 003c9 eb 02 jmp SHORT $LN40@deflate_sl
\r
4405 003cb 33 c9 xor ecx, ecx
\r
4407 003cd 6a 00 push 0
\r
4409 003d0 2b c2 sub eax, edx
\r
4410 003d2 8b ce mov ecx, esi
\r
4411 003d4 e8 00 00 00 00 call __tr_flush_block
\r
4412 003d9 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
4413 003dc 8b 3e mov edi, DWORD PTR [esi]
\r
4414 003de 83 c4 08 add esp, 8
\r
4415 003e1 89 56 5c mov DWORD PTR [esi+92], edx
\r
4416 003e4 e8 00 00 00 00 call _flush_pending
\r
4417 003e9 8b 06 mov eax, DWORD PTR [esi]
\r
4418 003eb 83 78 10 00 cmp DWORD PTR [eax+16], 0
\r
4419 003ef 0f 84 6f fe ff
\r
4420 ff je $LN47@deflate_sl
\r
4425 ; 1850 : return block_done;
\r
4427 003f7 8b c3 mov eax, ebx
\r
4434 _deflate_slow ENDP
\r
4435 ; Function compile flags: /Ogtp
\r
4437 ; COMDAT _deflate_fast
\r
4439 _s$ = 8 ; size = 4
\r
4440 _flush$ = 12 ; size = 4
\r
4441 _deflate_fast PROC ; COMDAT
\r
4446 00001 8b ec mov ebp, esp
\r
4449 00005 8b 75 08 mov esi, DWORD PTR _s$[ebp]
\r
4451 00009 bb 01 00 00 00 mov ebx, 1
\r
4452 0000e 8b ff npad 2
\r
4455 ; 1630 : IPos hash_head; /* head of the hash chain */
\r
4456 ; 1631 : int bflush; /* set if current block must be flushed */
\r
4458 ; 1633 : for (;;) {
\r
4459 ; 1634 : /* Make sure that we always have enough lookahead, except
\r
4460 ; 1635 : * at the end of the input file. We need MAX_MATCH bytes
\r
4461 ; 1636 : * for the next match, plus MIN_MATCH bytes to insert the
\r
4462 ; 1637 : * string following the next match.
\r
4464 ; 1639 : if (s->lookahead < MIN_LOOKAHEAD) {
\r
4466 00010 8b 46 74 mov eax, DWORD PTR [esi+116]
\r
4467 00013 3d 06 01 00 00 cmp eax, 262 ; 00000106H
\r
4468 00018 73 23 jae SHORT $LN16@deflate_fa
\r
4470 ; 1640 : fill_window(s);
\r
4472 0001a 8b fe mov edi, esi
\r
4473 0001c e8 00 00 00 00 call _fill_window
\r
4475 ; 1641 : if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
\r
4477 00021 8b 46 74 mov eax, DWORD PTR [esi+116]
\r
4478 00024 3d 06 01 00 00 cmp eax, 262 ; 00000106H
\r
4479 00029 73 0a jae SHORT $LN40@deflate_fa
\r
4480 0002b 83 7d 0c 00 cmp DWORD PTR _flush$[ebp], 0
\r
4481 0002f 0f 84 49 02 00
\r
4482 00 je $LN38@deflate_fa
\r
4485 ; 1642 : return need_more;
\r
4487 ; 1644 : if (s->lookahead == 0) break; /* flush the current block */
\r
4489 00035 85 c0 test eax, eax
\r
4490 00037 0f 84 48 02 00
\r
4491 00 je $LN37@deflate_fa
\r
4496 ; 1647 : /* Insert the string window[strstart .. strstart+2] in the
\r
4497 ; 1648 : * dictionary, and set hash_head to the head of the hash chain:
\r
4499 ; 1650 : hash_head = NIL;
\r
4500 ; 1651 : if (s->lookahead >= MIN_MATCH) {
\r
4502 0003d 83 f8 03 cmp eax, 3
\r
4503 00040 72 6d jb SHORT $LN41@deflate_fa
\r
4505 ; 1652 : INSERT_STRING(s, s->strstart, hash_head);
\r
4507 00042 8b 46 48 mov eax, DWORD PTR [esi+72]
\r
4508 00045 8b 4e 58 mov ecx, DWORD PTR [esi+88]
\r
4509 00048 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
4510 0004b 8b 7e 34 mov edi, DWORD PTR [esi+52]
\r
4511 0004e d3 e0 shl eax, cl
\r
4512 00050 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4513 00053 0f b6 4c 11 02 movzx ecx, BYTE PTR [ecx+edx+2]
\r
4514 00058 33 c1 xor eax, ecx
\r
4515 0005a 23 46 54 and eax, DWORD PTR [esi+84]
\r
4516 0005d 8b 4e 44 mov ecx, DWORD PTR [esi+68]
\r
4517 00060 23 fa and edi, edx
\r
4518 00062 8b 56 40 mov edx, DWORD PTR [esi+64]
\r
4519 00065 89 46 48 mov DWORD PTR [esi+72], eax
\r
4520 00068 66 8b 04 41 mov ax, WORD PTR [ecx+eax*2]
\r
4521 0006c 66 89 04 7a mov WORD PTR [edx+edi*2], ax
\r
4522 00070 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
4523 00073 23 4e 34 and ecx, DWORD PTR [esi+52]
\r
4524 00076 8b 56 40 mov edx, DWORD PTR [esi+64]
\r
4525 00079 0f b7 04 4a movzx eax, WORD PTR [edx+ecx*2]
\r
4526 0007d 8b 4e 48 mov ecx, DWORD PTR [esi+72]
\r
4527 00080 8b 56 44 mov edx, DWORD PTR [esi+68]
\r
4528 00083 66 8b 7e 6c mov di, WORD PTR [esi+108]
\r
4529 00087 66 89 3c 4a mov WORD PTR [edx+ecx*2], di
\r
4533 ; 1655 : /* Find the longest match, discarding those <= prev_length.
\r
4534 ; 1656 : * At this point we have always match_length < MIN_MATCH
\r
4536 ; 1658 : if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
\r
4538 0008b 85 c0 test eax, eax
\r
4539 0008d 74 20 je SHORT $LN41@deflate_fa
\r
4540 0008f 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
4541 00092 8b 56 2c mov edx, DWORD PTR [esi+44]
\r
4542 00095 2b c8 sub ecx, eax
\r
4543 00097 81 ea 06 01 00
\r
4544 00 sub edx, 262 ; 00000106H
\r
4545 0009d 3b ca cmp ecx, edx
\r
4546 0009f 77 0e ja SHORT $LN41@deflate_fa
\r
4548 ; 1659 : /* To simplify the code, we prevent matches with the string
\r
4549 ; 1660 : * of window index 0 (in particular we have to avoid a match
\r
4550 ; 1661 : * of the string with itself at the start of the input file).
\r
4552 ; 1663 : s->match_length = longest_match (s, hash_head);
\r
4555 000a2 8b fe mov edi, esi
\r
4556 000a4 e8 00 00 00 00 call _longest_match
\r
4557 000a9 83 c4 04 add esp, 4
\r
4558 000ac 89 46 60 mov DWORD PTR [esi+96], eax
\r
4561 ; 1664 : /* longest_match() sets match_start */
\r
4563 ; 1666 : if (s->match_length >= MIN_MATCH) {
\r
4565 000af 83 7e 60 03 cmp DWORD PTR [esi+96], 3
\r
4566 000b3 0f 82 25 01 00
\r
4567 00 jb $LN13@deflate_fa
\r
4569 ; 1667 : check_match(s, s->strstart, s->match_start, s->match_length);
\r
4571 ; 1669 : _tr_tally_dist(s, s->strstart - s->match_start,
\r
4572 ; 1670 : s->match_length - MIN_MATCH, bflush);
\r
4574 000b9 66 8b 4e 6c mov cx, WORD PTR [esi+108]
\r
4575 000bd 66 2b 4e 70 sub cx, WORD PTR [esi+112]
\r
4576 000c1 8b 96 a0 16 00
\r
4577 00 mov edx, DWORD PTR [esi+5792]
\r
4578 000c7 8a 46 60 mov al, BYTE PTR [esi+96]
\r
4579 000ca 8b be a4 16 00
\r
4580 00 mov edi, DWORD PTR [esi+5796]
\r
4581 000d0 0f b7 c9 movzx ecx, cx
\r
4582 000d3 66 89 0c 57 mov WORD PTR [edi+edx*2], cx
\r
4583 000d7 8b 96 98 16 00
\r
4584 00 mov edx, DWORD PTR [esi+5784]
\r
4585 000dd 8b be a0 16 00
\r
4586 00 mov edi, DWORD PTR [esi+5792]
\r
4587 000e3 2c 03 sub al, 3
\r
4588 000e5 88 04 3a mov BYTE PTR [edx+edi], al
\r
4589 000e8 01 9e a0 16 00
\r
4590 00 add DWORD PTR [esi+5792], ebx
\r
4591 000ee 0f b6 c0 movzx eax, al
\r
4592 000f1 0f b6 90 00 00
\r
4593 00 00 movzx edx, BYTE PTR __length_code[eax]
\r
4594 000f8 66 01 9c 96 98
\r
4595 04 00 00 add WORD PTR [esi+edx*4+1176], bx
\r
4596 00100 8d 84 96 98 04
\r
4597 00 00 lea eax, DWORD PTR [esi+edx*4+1176]
\r
4598 00107 81 c1 ff ff 00
\r
4599 00 add ecx, 65535 ; 0000ffffH
\r
4600 0010d b8 00 01 00 00 mov eax, 256 ; 00000100H
\r
4601 00112 66 3b c8 cmp cx, ax
\r
4602 00115 73 0c jae SHORT $LN23@deflate_fa
\r
4603 00117 0f b7 c9 movzx ecx, cx
\r
4604 0011a 0f b6 81 00 00
\r
4605 00 00 movzx eax, BYTE PTR __dist_code[ecx]
\r
4606 00121 eb 0d jmp SHORT $LN24@deflate_fa
\r
4608 00123 0f b7 d1 movzx edx, cx
\r
4609 00126 c1 ea 07 shr edx, 7
\r
4610 00129 0f b6 82 00 01
\r
4611 00 00 movzx eax, BYTE PTR __dist_code[edx+256]
\r
4613 00130 66 01 9c 86 88
\r
4614 09 00 00 add WORD PTR [esi+eax*4+2440], bx
\r
4615 00138 8b 86 9c 16 00
\r
4616 00 mov eax, DWORD PTR [esi+5788]
\r
4617 0013e 33 c9 xor ecx, ecx
\r
4618 00140 2b c3 sub eax, ebx
\r
4619 00142 39 86 a0 16 00
\r
4620 00 cmp DWORD PTR [esi+5792], eax
\r
4623 ; 1672 : s->lookahead -= s->match_length;
\r
4625 00148 8b 46 60 mov eax, DWORD PTR [esi+96]
\r
4626 0014b 0f 94 c1 sete cl
\r
4627 0014e 29 46 74 sub DWORD PTR [esi+116], eax
\r
4628 00151 8b f9 mov edi, ecx
\r
4629 00153 8b 4e 74 mov ecx, DWORD PTR [esi+116]
\r
4632 ; 1674 : /* Insert new strings in the hash table only if the match length
\r
4633 ; 1675 : * is not too large. This saves time but degrades compression.
\r
4635 ; 1677 : #ifndef FASTEST
\r
4636 ; 1678 : if (s->match_length <= s->max_insert_length &&
\r
4637 ; 1679 : s->lookahead >= MIN_MATCH) {
\r
4639 00156 3b 86 80 00 00
\r
4640 00 cmp eax, DWORD PTR [esi+128]
\r
4641 0015c 77 57 ja SHORT $LN12@deflate_fa
\r
4642 0015e 83 f9 03 cmp ecx, 3
\r
4643 00161 72 52 jb SHORT $LN12@deflate_fa
\r
4645 ; 1680 : s->match_length--; /* string at strstart already in table */
\r
4648 00164 89 46 60 mov DWORD PTR [esi+96], eax
\r
4652 ; 1682 : s->strstart++;
\r
4654 00167 01 5e 6c add DWORD PTR [esi+108], ebx
\r
4655 0016a 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
4657 ; 1683 : INSERT_STRING(s, s->strstart, hash_head);
\r
4659 0016d 8b 5e 48 mov ebx, DWORD PTR [esi+72]
\r
4660 00170 8b 4e 58 mov ecx, DWORD PTR [esi+88]
\r
4661 00173 8b 46 38 mov eax, DWORD PTR [esi+56]
\r
4662 00176 0f b6 44 02 02 movzx eax, BYTE PTR [edx+eax+2]
\r
4663 0017b d3 e3 shl ebx, cl
\r
4664 0017d 8b 4e 44 mov ecx, DWORD PTR [esi+68]
\r
4665 00180 33 c3 xor eax, ebx
\r
4666 00182 23 46 54 and eax, DWORD PTR [esi+84]
\r
4667 00185 8b 5e 34 mov ebx, DWORD PTR [esi+52]
\r
4668 00188 89 46 48 mov DWORD PTR [esi+72], eax
\r
4669 0018b 0f b7 04 41 movzx eax, WORD PTR [ecx+eax*2]
\r
4670 0018f 23 da and ebx, edx
\r
4671 00191 8b 56 40 mov edx, DWORD PTR [esi+64]
\r
4672 00194 66 89 04 5a mov WORD PTR [edx+ebx*2], ax
\r
4673 00198 0f b7 46 6c movzx eax, WORD PTR [esi+108]
\r
4674 0019c 8b 4e 48 mov ecx, DWORD PTR [esi+72]
\r
4675 0019f 8b 56 44 mov edx, DWORD PTR [esi+68]
\r
4676 001a2 66 89 04 4a mov WORD PTR [edx+ecx*2], ax
\r
4678 ; 1684 : /* strstart never exceeds WSIZE-MAX_MATCH, so there are
\r
4679 ; 1685 : * always MIN_MATCH bytes ahead.
\r
4681 ; 1687 : } while (--s->match_length != 0);
\r
4683 001a6 ff 4e 60 dec DWORD PTR [esi+96]
\r
4685 ; 1688 : s->strstart++;
\r
4687 001a9 bb 01 00 00 00 mov ebx, 1
\r
4688 001ae 75 b7 jne SHORT $LL39@deflate_fa
\r
4692 001b0 e9 83 00 00 00 jmp $LN42@deflate_fa
\r
4697 ; 1692 : s->strstart += s->match_length;
\r
4699 001b5 01 46 6c add DWORD PTR [esi+108], eax
\r
4701 ; 1693 : s->match_length = 0;
\r
4702 ; 1694 : s->ins_h = s->window[s->strstart];
\r
4704 001b8 8b 56 38 mov edx, DWORD PTR [esi+56]
\r
4705 001bb 03 56 6c add edx, DWORD PTR [esi+108]
\r
4707 ; 1695 : UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
\r
4709 001be 8b 4e 58 mov ecx, DWORD PTR [esi+88]
\r
4710 001c1 c7 46 60 00 00
\r
4711 00 00 mov DWORD PTR [esi+96], 0
\r
4712 001c8 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4713 001cb 89 46 48 mov DWORD PTR [esi+72], eax
\r
4714 001ce d3 e0 shl eax, cl
\r
4715 001d0 0f b6 4a 01 movzx ecx, BYTE PTR [edx+1]
\r
4716 001d4 33 c1 xor eax, ecx
\r
4717 001d6 23 46 54 and eax, DWORD PTR [esi+84]
\r
4718 001d9 89 46 48 mov DWORD PTR [esi+72], eax
\r
4720 ; 1696 : #if MIN_MATCH != 3
\r
4721 ; 1697 : Call UPDATE_HASH() MIN_MATCH-3 more times
\r
4723 ; 1699 : /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
\r
4724 ; 1700 : * matter since it will be recomputed at next deflate call.
\r
4729 001dc eb 5d jmp SHORT $LN7@deflate_fa
\r
4732 ; 1704 : /* No match, output a literal byte */
\r
4733 ; 1705 : Tracevv((stderr,"%c", s->window[s->strstart]));
\r
4734 ; 1706 : _tr_tally_lit (s, s->window[s->strstart], bflush);
\r
4736 001de 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
4737 001e1 8b 46 38 mov eax, DWORD PTR [esi+56]
\r
4738 001e4 8a 04 02 mov al, BYTE PTR [edx+eax]
\r
4739 001e7 8b 8e a0 16 00
\r
4740 00 mov ecx, DWORD PTR [esi+5792]
\r
4741 001ed 8b 96 a4 16 00
\r
4742 00 mov edx, DWORD PTR [esi+5796]
\r
4743 001f3 33 ff xor edi, edi
\r
4744 001f5 66 89 3c 4a mov WORD PTR [edx+ecx*2], di
\r
4745 001f9 8b 96 a0 16 00
\r
4746 00 mov edx, DWORD PTR [esi+5792]
\r
4747 001ff 8b 8e 98 16 00
\r
4748 00 mov ecx, DWORD PTR [esi+5784]
\r
4749 00205 88 04 11 mov BYTE PTR [ecx+edx], al
\r
4750 00208 01 9e a0 16 00
\r
4751 00 add DWORD PTR [esi+5792], ebx
\r
4752 0020e 0f b6 c0 movzx eax, al
\r
4753 00211 66 01 9c 86 94
\r
4754 00 00 00 add WORD PTR [esi+eax*4+148], bx
\r
4755 00219 8b 8e 9c 16 00
\r
4756 00 mov ecx, DWORD PTR [esi+5788]
\r
4757 0021f 8d 84 86 94 00
\r
4758 00 00 lea eax, DWORD PTR [esi+eax*4+148]
\r
4759 00226 33 d2 xor edx, edx
\r
4760 00228 2b cb sub ecx, ebx
\r
4761 0022a 39 8e a0 16 00
\r
4762 00 cmp DWORD PTR [esi+5792], ecx
\r
4763 00230 0f 94 c2 sete dl
\r
4765 ; 1707 : s->lookahead--;
\r
4767 00233 ff 4e 74 dec DWORD PTR [esi+116]
\r
4768 00236 8b fa mov edi, edx
\r
4771 ; 1708 : s->strstart++;
\r
4773 00238 01 5e 6c add DWORD PTR [esi+108], ebx
\r
4777 ; 1710 : if (bflush) FLUSH_BLOCK(s, 0);
\r
4779 0023b 85 ff test edi, edi
\r
4780 0023d 0f 84 cd fd ff
\r
4781 ff je $LL20@deflate_fa
\r
4782 00243 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
4783 00246 85 d2 test edx, edx
\r
4784 00248 78 07 js SHORT $LN25@deflate_fa
\r
4785 0024a 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4786 0024d 03 ca add ecx, edx
\r
4787 0024f eb 02 jmp SHORT $LN26@deflate_fa
\r
4789 00251 33 c9 xor ecx, ecx
\r
4791 00253 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4792 00256 6a 00 push 0
\r
4794 00259 2b c2 sub eax, edx
\r
4795 0025b 8b ce mov ecx, esi
\r
4796 0025d e8 00 00 00 00 call __tr_flush_block
\r
4797 00262 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4798 00265 8b 3e mov edi, DWORD PTR [esi]
\r
4799 00267 83 c4 08 add esp, 8
\r
4800 0026a 89 46 5c mov DWORD PTR [esi+92], eax
\r
4801 0026d e8 00 00 00 00 call _flush_pending
\r
4802 00272 8b 0e mov ecx, DWORD PTR [esi]
\r
4803 00274 83 79 10 00 cmp DWORD PTR [ecx+16], 0
\r
4804 00278 0f 85 92 fd ff
\r
4805 ff jne $LL20@deflate_fa
\r
4809 00280 33 c0 xor eax, eax
\r
4819 ; 1712 : s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
\r
4821 00285 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
4822 00288 8b c8 mov ecx, eax
\r
4823 0028a 83 f8 02 cmp eax, 2
\r
4824 0028d 72 05 jb SHORT $LN28@deflate_fa
\r
4825 0028f b9 02 00 00 00 mov ecx, 2
\r
4828 ; 1713 : if (flush == Z_FINISH) {
\r
4830 00294 83 7d 0c 04 cmp DWORD PTR _flush$[ebp], 4
\r
4831 00298 89 8e b4 16 00
\r
4832 00 mov DWORD PTR [esi+5812], ecx
\r
4833 0029e 75 3d jne SHORT $LN4@deflate_fa
\r
4835 ; 1714 : FLUSH_BLOCK(s, 1);
\r
4837 002a0 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
4838 002a3 85 d2 test edx, edx
\r
4839 002a5 78 07 js SHORT $LN29@deflate_fa
\r
4840 002a7 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4841 002aa 03 ca add ecx, edx
\r
4842 002ac eb 02 jmp SHORT $LN30@deflate_fa
\r
4844 002ae 33 c9 xor ecx, ecx
\r
4848 002b2 2b c2 sub eax, edx
\r
4849 002b4 8b ce mov ecx, esi
\r
4850 002b6 e8 00 00 00 00 call __tr_flush_block
\r
4851 002bb 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
4852 002be 8b 3e mov edi, DWORD PTR [esi]
\r
4853 002c0 83 c4 08 add esp, 8
\r
4854 002c3 89 56 5c mov DWORD PTR [esi+92], edx
\r
4855 002c6 e8 00 00 00 00 call _flush_pending
\r
4856 002cb 8b 06 mov eax, DWORD PTR [esi]
\r
4857 002cd 33 c9 xor ecx, ecx
\r
4858 002cf 39 48 10 cmp DWORD PTR [eax+16], ecx
\r
4860 002d3 0f 95 c1 setne cl
\r
4863 002d8 8d 41 02 lea eax, DWORD PTR [ecx+2]
\r
4871 ; 1715 : return finish_done;
\r
4873 ; 1717 : if (s->last_lit)
\r
4875 002dd 83 be a0 16 00
\r
4876 00 00 cmp DWORD PTR [esi+5792], 0
\r
4877 002e4 74 38 je SHORT $LN1@deflate_fa
\r
4879 ; 1718 : FLUSH_BLOCK(s, 0);
\r
4881 002e6 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
4882 002e9 85 d2 test edx, edx
\r
4883 002eb 78 07 js SHORT $LN31@deflate_fa
\r
4884 002ed 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
4885 002f0 03 ca add ecx, edx
\r
4886 002f2 eb 02 jmp SHORT $LN32@deflate_fa
\r
4888 002f4 33 c9 xor ecx, ecx
\r
4890 002f6 6a 00 push 0
\r
4892 002f9 2b c2 sub eax, edx
\r
4893 002fb 8b ce mov ecx, esi
\r
4894 002fd e8 00 00 00 00 call __tr_flush_block
\r
4895 00302 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
4896 00305 8b 3e mov edi, DWORD PTR [esi]
\r
4897 00307 83 c4 08 add esp, 8
\r
4898 0030a 89 56 5c mov DWORD PTR [esi+92], edx
\r
4899 0030d e8 00 00 00 00 call _flush_pending
\r
4900 00312 8b 06 mov eax, DWORD PTR [esi]
\r
4901 00314 83 78 10 00 cmp DWORD PTR [eax+16], 0
\r
4902 00318 0f 84 60 ff ff
\r
4903 ff je $LN38@deflate_fa
\r
4908 ; 1719 : return block_done;
\r
4910 00320 8b c3 mov eax, ebx
\r
4917 _deflate_fast ENDP
\r
4918 ; Function compile flags: /Ogtp
\r
4920 ; COMDAT _deflate_stored
\r
4922 _max_block_size$ = -4 ; size = 4
\r
4923 _s$ = 8 ; size = 4
\r
4924 _flush$ = 12 ; size = 4
\r
4925 _deflate_stored PROC ; COMDAT
\r
4930 00001 8b ec mov ebp, esp
\r
4934 ; 1566 : /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
\r
4935 ; 1567 : * to pending_buf_size, and each stored block has a 5 byte header:
\r
4937 ; 1569 : ulg max_block_size = 0xffff;
\r
4938 ; 1570 : ulg max_start;
\r
4940 ; 1572 : if (max_block_size > s->pending_buf_size - 5) {
\r
4942 00005 8b 75 08 mov esi, DWORD PTR _s$[ebp]
\r
4943 00008 8b 46 0c mov eax, DWORD PTR [esi+12]
\r
4944 0000b 83 c0 fb add eax, -5 ; fffffffbH
\r
4946 0000f c7 45 fc ff ff
\r
4947 00 00 mov DWORD PTR _max_block_size$[ebp], 65535 ; 0000ffffH
\r
4948 00016 3d ff ff 00 00 cmp eax, 65535 ; 0000ffffH
\r
4949 0001b 73 03 jae SHORT $LL14@deflate_st
\r
4951 ; 1573 : max_block_size = s->pending_buf_size - 5;
\r
4953 0001d 89 45 fc mov DWORD PTR _max_block_size$[ebp], eax
\r
4958 ; 1576 : /* Copy as much as possible from input to output: */
\r
4959 ; 1577 : for (;;) {
\r
4960 ; 1578 : /* Fill the window as much as possible: */
\r
4961 ; 1579 : if (s->lookahead <= 1) {
\r
4963 00020 8b 46 74 mov eax, DWORD PTR [esi+116]
\r
4964 00023 83 f8 01 cmp eax, 1
\r
4965 00026 77 12 ja SHORT $LN10@deflate_st
\r
4968 ; 1581 : Assert(s->strstart < s->w_size+MAX_DIST(s) ||
\r
4969 ; 1582 : s->block_start >= (long)s->w_size, "slide too late");
\r
4971 ; 1584 : fill_window(s);
\r
4973 00028 8b fe mov edi, esi
\r
4974 0002a e8 00 00 00 00 call _fill_window
\r
4976 ; 1585 : if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
\r
4978 0002f 8b 46 74 mov eax, DWORD PTR [esi+116]
\r
4979 00032 85 c0 test eax, eax
\r
4980 00034 0f 84 a9 00 00
\r
4981 00 je $LN32@deflate_st
\r
4985 ; 1587 : if (s->lookahead == 0) break; /* flush the current block */
\r
4987 ; 1589 : Assert(s->block_start >= 0L, "block gone");
\r
4989 ; 1591 : s->strstart += s->lookahead;
\r
4991 0003a 01 46 6c add DWORD PTR [esi+108], eax
\r
4993 ; 1592 : s->lookahead = 0;
\r
4995 ; 1594 : /* Emit a stored block if pending_buf will be full: */
\r
4996 ; 1595 : max_start = s->block_start + max_block_size;
\r
4998 0003d 8b 4e 5c mov ecx, DWORD PTR [esi+92]
\r
4999 00040 8b 45 fc mov eax, DWORD PTR _max_block_size$[ebp]
\r
5001 ; 1596 : if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
\r
5003 00043 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
5004 00046 c7 46 74 00 00
\r
5005 00 00 mov DWORD PTR [esi+116], 0
\r
5006 0004d 8d 04 01 lea eax, DWORD PTR [ecx+eax]
\r
5007 00050 74 04 je SHORT $LN8@deflate_st
\r
5008 00052 3b d0 cmp edx, eax
\r
5009 00054 72 39 jb SHORT $LN7@deflate_st
\r
5012 ; 1597 : /* strstart == 0 is possible when wraparound on 16-bit machine */
\r
5013 ; 1598 : s->lookahead = (uInt)(s->strstart - max_start);
\r
5015 00056 2b d0 sub edx, eax
\r
5016 00058 89 56 74 mov DWORD PTR [esi+116], edx
\r
5018 ; 1599 : s->strstart = (uInt)max_start;
\r
5020 0005b 89 46 6c mov DWORD PTR [esi+108], eax
\r
5022 ; 1600 : FLUSH_BLOCK(s, 0);
\r
5024 0005e 85 c9 test ecx, ecx
\r
5025 00060 78 07 js SHORT $LN18@deflate_st
\r
5026 00062 8b 56 38 mov edx, DWORD PTR [esi+56]
\r
5027 00065 03 d1 add edx, ecx
\r
5028 00067 eb 02 jmp SHORT $LN19@deflate_st
\r
5030 00069 33 d2 xor edx, edx
\r
5032 0006b 6a 00 push 0
\r
5033 0006d 2b c1 sub eax, ecx
\r
5035 00070 8b ce mov ecx, esi
\r
5036 00072 e8 00 00 00 00 call __tr_flush_block
\r
5037 00077 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
5038 0007a 8b 3e mov edi, DWORD PTR [esi]
\r
5039 0007c 83 c4 08 add esp, 8
\r
5040 0007f 89 4e 5c mov DWORD PTR [esi+92], ecx
\r
5041 00082 e8 00 00 00 00 call _flush_pending
\r
5042 00087 8b 16 mov edx, DWORD PTR [esi]
\r
5043 00089 83 7a 10 00 cmp DWORD PTR [edx+16], 0
\r
5044 0008d 74 4c je SHORT $LN31@deflate_st
\r
5048 ; 1602 : /* Flush if we may have to slide, otherwise block_start may become
\r
5049 ; 1603 : * negative and the data will be gone:
\r
5051 ; 1605 : if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
\r
5053 0008f 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
5054 00092 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
5055 00095 8b 4e 2c mov ecx, DWORD PTR [esi+44]
\r
5056 00098 2b c2 sub eax, edx
\r
5057 0009a 81 e9 06 01 00
\r
5058 00 sub ecx, 262 ; 00000106H
\r
5059 000a0 3b c1 cmp eax, ecx
\r
5060 000a2 0f 82 78 ff ff
\r
5061 ff jb $LL14@deflate_st
\r
5063 ; 1606 : FLUSH_BLOCK(s, 0);
\r
5065 000a8 85 d2 test edx, edx
\r
5066 000aa 78 07 js SHORT $LN20@deflate_st
\r
5067 000ac 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
5068 000af 03 ca add ecx, edx
\r
5069 000b1 eb 02 jmp SHORT $LN21@deflate_st
\r
5071 000b3 33 c9 xor ecx, ecx
\r
5073 000b5 6a 00 push 0
\r
5075 000b8 8b ce mov ecx, esi
\r
5076 000ba e8 00 00 00 00 call __tr_flush_block
\r
5077 000bf 8b 56 6c mov edx, DWORD PTR [esi+108]
\r
5078 000c2 8b 3e mov edi, DWORD PTR [esi]
\r
5079 000c4 83 c4 08 add esp, 8
\r
5080 000c7 89 56 5c mov DWORD PTR [esi+92], edx
\r
5081 000ca e8 00 00 00 00 call _flush_pending
\r
5082 000cf 8b 06 mov eax, DWORD PTR [esi]
\r
5083 000d1 83 78 10 00 cmp DWORD PTR [eax+16], 0
\r
5084 000d5 0f 85 45 ff ff
\r
5085 ff jne $LL14@deflate_st
\r
5088 000dc 33 c0 xor eax, eax
\r
5093 000df 8b e5 mov esp, ebp
\r
5098 ; 1585 : if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
\r
5100 000e3 8b 45 0c mov eax, DWORD PTR _flush$[ebp]
\r
5101 000e6 85 c0 test eax, eax
\r
5102 000e8 74 f1 je SHORT $LN31@deflate_st
\r
5106 ; 1609 : s->insert = 0;
\r
5107 ; 1610 : if (flush == Z_FINISH) {
\r
5108 ; 1611 : FLUSH_BLOCK(s, 1);
\r
5110 000ea 8b 56 5c mov edx, DWORD PTR [esi+92]
\r
5111 000ed c7 86 b4 16 00
\r
5112 00 00 00 00 00 mov DWORD PTR [esi+5812], 0
\r
5113 000f7 83 f8 04 cmp eax, 4
\r
5114 000fa 75 3f jne SHORT $LN4@deflate_st
\r
5115 000fc 85 d2 test edx, edx
\r
5116 000fe 78 07 js SHORT $LN22@deflate_st
\r
5117 00100 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
5118 00103 03 ca add ecx, edx
\r
5119 00105 eb 02 jmp SHORT $LN23@deflate_st
\r
5121 00107 33 c9 xor ecx, ecx
\r
5123 00109 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
5124 0010c 6a 01 push 1
\r
5126 0010f 2b c2 sub eax, edx
\r
5127 00111 8b ce mov ecx, esi
\r
5128 00113 e8 00 00 00 00 call __tr_flush_block
\r
5129 00118 8b 4e 6c mov ecx, DWORD PTR [esi+108]
\r
5130 0011b 8b 3e mov edi, DWORD PTR [esi]
\r
5131 0011d 83 c4 08 add esp, 8
\r
5132 00120 89 4e 5c mov DWORD PTR [esi+92], ecx
\r
5133 00123 e8 00 00 00 00 call _flush_pending
\r
5134 00128 8b 16 mov edx, DWORD PTR [esi]
\r
5135 0012a 33 c0 xor eax, eax
\r
5136 0012c 39 42 10 cmp DWORD PTR [edx+16], eax
\r
5138 00130 0f 95 c0 setne al
\r
5140 00134 83 c0 02 add eax, 2
\r
5144 00137 8b e5 mov esp, ebp
\r
5149 ; 1612 : return finish_done;
\r
5151 ; 1614 : if ((long)s->strstart > s->block_start)
\r
5153 0013b 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
5154 0013e 3b c2 cmp eax, edx
\r
5155 00140 7e 35 jle SHORT $LN1@deflate_st
\r
5157 ; 1615 : FLUSH_BLOCK(s, 0);
\r
5159 00142 85 d2 test edx, edx
\r
5160 00144 78 07 js SHORT $LN24@deflate_st
\r
5161 00146 8b 4e 38 mov ecx, DWORD PTR [esi+56]
\r
5162 00149 03 ca add ecx, edx
\r
5163 0014b eb 02 jmp SHORT $LN25@deflate_st
\r
5165 0014d 33 c9 xor ecx, ecx
\r
5167 0014f 6a 00 push 0
\r
5169 00152 2b c2 sub eax, edx
\r
5170 00154 8b ce mov ecx, esi
\r
5171 00156 e8 00 00 00 00 call __tr_flush_block
\r
5172 0015b 8b 46 6c mov eax, DWORD PTR [esi+108]
\r
5173 0015e 8b 3e mov edi, DWORD PTR [esi]
\r
5174 00160 83 c4 08 add esp, 8
\r
5175 00163 89 46 5c mov DWORD PTR [esi+92], eax
\r
5176 00166 e8 00 00 00 00 call _flush_pending
\r
5177 0016b 8b 0e mov ecx, DWORD PTR [esi]
\r
5178 0016d 83 79 10 00 cmp DWORD PTR [ecx+16], 0
\r
5179 00171 0f 84 64 ff ff
\r
5180 ff je $LN31@deflate_st
\r
5184 ; 1616 : return block_done;
\r
5186 00178 b8 01 00 00 00 mov eax, 1
\r
5191 0017e 8b e5 mov esp, ebp
\r
5194 _deflate_stored ENDP
\r
5197 ; Function compile flags: /Ogtp
\r
5198 ; COMDAT _deflate@8
\r
5200 _old_flush$ = -4 ; size = 4
\r
5201 tv1136 = 8 ; size = 4
\r
5202 _beg$80590 = 8 ; size = 4
\r
5203 _strm$ = 8 ; size = 4
\r
5204 _flush$ = 12 ; size = 4
\r
5205 _deflate@8 PROC ; COMDAT
\r
5210 00001 8b ec mov ebp, esp
\r
5215 ; 667 : int old_flush; /* value of flush param for previous deflate call */
\r
5216 ; 668 : deflate_state *s;
\r
5218 ; 670 : if (strm == Z_NULL || strm->state == Z_NULL ||
\r
5219 ; 671 : flush > Z_BLOCK || flush < 0) {
\r
5221 00006 8b 7d 08 mov edi, DWORD PTR _strm$[ebp]
\r
5222 00009 85 ff test edi, edi
\r
5223 0000b 0f 84 40 08 00
\r
5224 00 je $LN82@deflate
\r
5225 00011 8b 77 1c mov esi, DWORD PTR [edi+28]
\r
5226 00014 85 f6 test esi, esi
\r
5227 00016 0f 84 35 08 00
\r
5228 00 je $LN82@deflate
\r
5229 0001c 8b 4d 0c mov ecx, DWORD PTR _flush$[ebp]
\r
5230 0001f 83 f9 05 cmp ecx, 5
\r
5231 00022 0f 87 29 08 00
\r
5232 00 ja $LN82@deflate
\r
5234 ; 672 : return Z_STREAM_ERROR;
\r
5236 ; 674 : s = strm->state;
\r
5238 ; 676 : if (strm->next_out == Z_NULL ||
\r
5239 ; 677 : (strm->next_in == Z_NULL && strm->avail_in != 0) ||
\r
5240 ; 678 : (s->status == FINISH_STATE && flush != Z_FINISH)) {
\r
5242 00028 83 7f 0c 00 cmp DWORD PTR [edi+12], 0
\r
5243 0002c 0f 84 18 08 00
\r
5244 00 je $LN80@deflate
\r
5245 00032 83 3f 00 cmp DWORD PTR [edi], 0
\r
5246 00035 75 0a jne SHORT $LN79@deflate
\r
5247 00037 83 7f 04 00 cmp DWORD PTR [edi+4], 0
\r
5248 0003b 0f 85 09 08 00
\r
5249 00 jne $LN80@deflate
\r
5251 00041 8b 46 04 mov eax, DWORD PTR [esi+4]
\r
5252 00044 3d 9a 02 00 00 cmp eax, 666 ; 0000029aH
\r
5253 00049 75 09 jne SHORT $LN81@deflate
\r
5254 0004b 83 f9 04 cmp ecx, 4
\r
5255 0004e 0f 85 f6 07 00
\r
5256 00 jne $LN80@deflate
\r
5260 ; 681 : if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
\r
5262 00054 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
5263 00058 75 14 jne SHORT $LN78@deflate
\r
5264 0005a c7 47 18 00 00
\r
5265 00 00 mov DWORD PTR [edi+24], OFFSET ??_C@_0N@DFPGLBGC@buffer?5error?$AA@
\r
5267 00062 b8 fb ff ff ff mov eax, -5 ; fffffffbH
\r
5272 00068 8b e5 mov esp, ebp
\r
5274 0006b c2 08 00 ret 8
\r
5278 ; 683 : s->strm = strm; /* just in case */
\r
5279 ; 684 : old_flush = s->last_flush;
\r
5281 0006e 8b 56 28 mov edx, DWORD PTR [esi+40]
\r
5283 00072 89 3e mov DWORD PTR [esi], edi
\r
5284 00074 89 55 fc mov DWORD PTR _old_flush$[ebp], edx
\r
5286 ; 685 : s->last_flush = flush;
\r
5288 00077 89 4e 28 mov DWORD PTR [esi+40], ecx
\r
5291 ; 687 : /* Write the header */
\r
5292 ; 688 : if (s->status == INIT_STATE) {
\r
5294 0007a bb 01 00 00 00 mov ebx, 1
\r
5295 0007f 83 f8 2a cmp eax, 42 ; 0000002aH
\r
5296 00082 0f 85 a1 02 00
\r
5297 00 jne $LN71@deflate
\r
5299 ; 689 : #ifdef GZIP
\r
5300 ; 690 : if (s->wrap == 2) {
\r
5302 00088 ba 02 00 00 00 mov edx, 2
\r
5303 0008d 39 56 18 cmp DWORD PTR [esi+24], edx
\r
5304 00090 0f 85 fe 01 00
\r
5305 00 jne $LN76@deflate
\r
5307 ; 691 : strm->adler = crc32(0L, Z_NULL, 0);
\r
5309 00096 6a 00 push 0
\r
5310 00098 6a 00 push 0
\r
5311 0009a 6a 00 push 0
\r
5312 0009c e8 00 00 00 00 call _crc32@12
\r
5313 000a1 89 47 30 mov DWORD PTR [edi+48], eax
\r
5315 ; 692 : put_byte(s, 31);
\r
5317 000a4 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5318 000a7 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
5319 000aa c6 04 08 1f mov BYTE PTR [eax+ecx], 31 ; 0000001fH
\r
5320 000ae 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5321 000b1 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5323 ; 693 : put_byte(s, 139);
\r
5325 000b4 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5326 000b7 c6 04 10 8b mov BYTE PTR [eax+edx], 139 ; 0000008bH
\r
5327 000bb 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5328 000be 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5330 ; 694 : put_byte(s, 8);
\r
5332 000c1 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5333 000c4 c6 04 08 08 mov BYTE PTR [eax+ecx], 8
\r
5334 000c8 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5336 ; 695 : if (s->gzhead == Z_NULL) {
\r
5338 000cb 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
5339 000ce 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5340 000d1 89 4d 08 mov DWORD PTR tv1136[ebp], ecx
\r
5341 000d4 85 c0 test eax, eax
\r
5342 000d6 0f 85 89 00 00
\r
5343 00 jne $LN75@deflate
\r
5345 ; 696 : put_byte(s, 0);
\r
5347 000dc 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5348 000df 88 04 11 mov BYTE PTR [ecx+edx], al
\r
5349 000e2 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5350 000e5 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5352 ; 697 : put_byte(s, 0);
\r
5354 000e8 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5355 000eb c6 04 08 00 mov BYTE PTR [eax+ecx], 0
\r
5356 000ef 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5357 000f2 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5359 ; 698 : put_byte(s, 0);
\r
5361 000f5 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5362 000f8 c6 04 10 00 mov BYTE PTR [eax+edx], 0
\r
5363 000fc 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5364 000ff 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5366 ; 699 : put_byte(s, 0);
\r
5368 00102 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5369 00105 c6 04 08 00 mov BYTE PTR [eax+ecx], 0
\r
5370 00109 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5371 0010c 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5373 ; 700 : put_byte(s, 0);
\r
5375 0010f 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5376 00112 c6 04 10 00 mov BYTE PTR [eax+edx], 0
\r
5377 00116 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5379 ; 701 : put_byte(s, s->level == 9 ? 2 :
\r
5380 ; 702 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
\r
5383 00119 8b 86 84 00 00
\r
5384 00 mov eax, DWORD PTR [esi+132]
\r
5385 0011f 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5386 00122 83 f8 09 cmp eax, 9
\r
5387 00125 75 05 jne SHORT $LN88@deflate
\r
5388 00127 8d 43 01 lea eax, DWORD PTR [ebx+1]
\r
5389 0012a eb 17 jmp SHORT $LN87@deflate
\r
5391 0012c 83 be 88 00 00
\r
5392 00 02 cmp DWORD PTR [esi+136], 2
\r
5393 00133 7d 09 jge SHORT $LN86@deflate
\r
5394 00135 83 f8 02 cmp eax, 2
\r
5395 00138 7c 04 jl SHORT $LN86@deflate
\r
5396 0013a 33 c0 xor eax, eax
\r
5397 0013c eb 05 jmp SHORT $LN87@deflate
\r
5399 0013e b8 04 00 00 00 mov eax, 4
\r
5401 00143 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5402 00146 88 04 11 mov BYTE PTR [ecx+edx], al
\r
5403 00149 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5404 0014c 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5406 ; 704 : put_byte(s, OS_CODE);
\r
5408 0014f 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5409 00152 c6 04 08 0b mov BYTE PTR [eax+ecx], 11 ; 0000000bH
\r
5410 00156 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5412 ; 705 : s->status = BUSY_STATE;
\r
5414 00159 c7 46 04 71 00
\r
5415 00 00 mov DWORD PTR [esi+4], 113 ; 00000071H
\r
5420 00160 e9 c4 01 00 00 jmp $LN71@deflate
\r
5423 ; 708 : put_byte(s, (s->gzhead->text ? 1 : 0) +
\r
5424 ; 709 : (s->gzhead->hcrc ? 2 : 0) +
\r
5425 ; 710 : (s->gzhead->extra == Z_NULL ? 0 : 4) +
\r
5426 ; 711 : (s->gzhead->name == Z_NULL ? 0 : 8) +
\r
5427 ; 712 : (s->gzhead->comment == Z_NULL ? 0 : 16)
\r
5430 00165 8b 50 24 mov edx, DWORD PTR [eax+36]
\r
5431 00168 8b 48 2c mov ecx, DWORD PTR [eax+44]
\r
5432 0016b f7 da neg edx
\r
5433 0016d 1a d2 sbb dl, dl
\r
5434 0016f 80 e2 10 and dl, 16 ; 00000010H
\r
5435 00172 f7 d9 neg ecx
\r
5436 00174 1a c9 sbb cl, cl
\r
5437 00176 80 e1 02 and cl, 2
\r
5438 00179 02 d1 add dl, cl
\r
5439 0017b 8b 48 1c mov ecx, DWORD PTR [eax+28]
\r
5440 0017e f7 d9 neg ecx
\r
5441 00180 1a c9 sbb cl, cl
\r
5442 00182 80 e1 08 and cl, 8
\r
5443 00185 02 d1 add dl, cl
\r
5444 00187 8b 48 10 mov ecx, DWORD PTR [eax+16]
\r
5445 0018a f7 d9 neg ecx
\r
5446 0018c 1a c9 sbb cl, cl
\r
5447 0018e 80 e1 04 and cl, 4
\r
5448 00191 02 d1 add dl, cl
\r
5449 00193 83 38 00 cmp DWORD PTR [eax], 0
\r
5450 00196 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5451 00199 0f 95 c0 setne al
\r
5452 0019c 02 d0 add dl, al
\r
5453 0019e 8b 45 08 mov eax, DWORD PTR tv1136[ebp]
\r
5454 001a1 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
5455 001a4 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5456 001a7 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5458 ; 714 : put_byte(s, (Byte)(s->gzhead->time & 0xff));
\r
5460 001aa 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
5461 001ad 0f b6 49 04 movzx ecx, BYTE PTR [ecx+4]
\r
5462 001b1 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5463 001b4 88 0c 10 mov BYTE PTR [eax+edx], cl
\r
5464 001b7 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5466 ; 715 : put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
\r
5468 001ba 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5469 001bd 0f b6 52 05 movzx edx, BYTE PTR [edx+5]
\r
5470 001c1 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5471 001c4 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5472 001c7 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
5473 001ca 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5475 ; 716 : put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
\r
5477 001cd 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
5478 001d0 0f b6 49 06 movzx ecx, BYTE PTR [ecx+6]
\r
5479 001d4 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5480 001d7 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5481 001da 88 0c 10 mov BYTE PTR [eax+edx], cl
\r
5482 001dd 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5484 ; 717 : put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
\r
5486 001e0 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5487 001e3 0f b6 52 07 movzx edx, BYTE PTR [edx+7]
\r
5488 001e7 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5489 001ea 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5490 001ed 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
5491 001f0 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5493 ; 718 : put_byte(s, s->level == 9 ? 2 :
\r
5494 ; 719 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
\r
5497 001f3 8b 86 84 00 00
\r
5498 00 mov eax, DWORD PTR [esi+132]
\r
5499 001f9 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5500 001fc 83 f8 09 cmp eax, 9
\r
5501 001ff 75 07 jne SHORT $LN92@deflate
\r
5502 00201 b8 02 00 00 00 mov eax, 2
\r
5503 00206 eb 17 jmp SHORT $LN91@deflate
\r
5505 00208 83 be 88 00 00
\r
5506 00 02 cmp DWORD PTR [esi+136], 2
\r
5507 0020f 7d 09 jge SHORT $LN90@deflate
\r
5508 00211 83 f8 02 cmp eax, 2
\r
5509 00214 7c 04 jl SHORT $LN90@deflate
\r
5510 00216 33 c0 xor eax, eax
\r
5511 00218 eb 05 jmp SHORT $LN91@deflate
\r
5513 0021a b8 04 00 00 00 mov eax, 4
\r
5515 0021f 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5516 00222 88 04 11 mov BYTE PTR [ecx+edx], al
\r
5517 00225 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5519 ; 721 : put_byte(s, s->gzhead->os & 0xff);
\r
5521 00228 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
5522 0022b 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5523 0022e 8a 49 0c mov cl, BYTE PTR [ecx+12]
\r
5524 00231 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5525 00234 88 0c 10 mov BYTE PTR [eax+edx], cl
\r
5526 00237 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5528 ; 722 : if (s->gzhead->extra != Z_NULL) {
\r
5530 0023a 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
5531 0023d 83 78 10 00 cmp DWORD PTR [eax+16], 0
\r
5532 00241 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5533 00244 74 21 je SHORT $LN73@deflate
\r
5535 ; 723 : put_byte(s, s->gzhead->extra_len & 0xff);
\r
5537 00246 8a 40 14 mov al, BYTE PTR [eax+20]
\r
5538 00249 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5539 0024c 88 04 11 mov BYTE PTR [ecx+edx], al
\r
5540 0024f 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5542 ; 724 : put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
\r
5544 00252 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
5545 00255 8a 49 15 mov cl, BYTE PTR [ecx+21]
\r
5546 00258 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5547 0025b 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5548 0025e 88 0c 10 mov BYTE PTR [eax+edx], cl
\r
5549 00261 01 5e 14 add DWORD PTR [esi+20], ebx
\r
5550 00264 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5554 ; 726 : if (s->gzhead->hcrc)
\r
5556 00267 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5557 0026a 83 7a 2c 00 cmp DWORD PTR [edx+44], 0
\r
5558 0026e 74 11 je SHORT $LN72@deflate
\r
5560 ; 727 : strm->adler = crc32(strm->adler, s->pending_buf,
\r
5561 ; 728 : s->pending);
\r
5563 00270 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
5565 00274 8b 4f 30 mov ecx, DWORD PTR [edi+48]
\r
5568 00279 e8 00 00 00 00 call _crc32@12
\r
5569 0027e 89 47 30 mov DWORD PTR [edi+48], eax
\r
5572 ; 729 : s->gzindex = 0;
\r
5574 00281 c7 46 20 00 00
\r
5575 00 00 mov DWORD PTR [esi+32], 0
\r
5577 ; 730 : s->status = EXTRA_STATE;
\r
5579 00288 c7 46 04 45 00
\r
5580 00 00 mov DWORD PTR [esi+4], 69 ; 00000045H
\r
5586 0028f e9 95 00 00 00 jmp $LN71@deflate
\r
5591 ; 736 : uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
\r
5593 00294 8b 4e 30 mov ecx, DWORD PTR [esi+48]
\r
5594 00297 83 e9 08 sub ecx, 8
\r
5595 0029a c1 e1 0c shl ecx, 12 ; 0000000cH
\r
5596 0029d 81 c1 00 08 00
\r
5597 00 add ecx, 2048 ; 00000800H
\r
5599 ; 737 : uInt level_flags;
\r
5601 ; 739 : if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
\r
5603 002a3 39 96 88 00 00
\r
5604 00 cmp DWORD PTR [esi+136], edx
\r
5605 002a9 7d 20 jge SHORT $LN69@deflate
\r
5606 002ab 8b 86 84 00 00
\r
5607 00 mov eax, DWORD PTR [esi+132]
\r
5608 002b1 3b c2 cmp eax, edx
\r
5609 002b3 7c 16 jl SHORT $LN69@deflate
\r
5611 ; 741 : else if (s->level < 6)
\r
5613 002b5 83 f8 06 cmp eax, 6
\r
5614 002b8 7d 04 jge SHORT $LN67@deflate
\r
5616 ; 742 : level_flags = 1;
\r
5618 002ba 8b c3 mov eax, ebx
\r
5619 002bc eb 0f jmp SHORT $LN64@deflate
\r
5622 ; 743 : else if (s->level == 6)
\r
5624 002be 33 d2 xor edx, edx
\r
5625 002c0 83 f8 06 cmp eax, 6
\r
5626 002c3 0f 95 c2 setne dl
\r
5627 002c6 8d 42 02 lea eax, DWORD PTR [edx+2]
\r
5629 ; 744 : level_flags = 2;
\r
5631 ; 746 : level_flags = 3;
\r
5633 002c9 eb 02 jmp SHORT $LN64@deflate
\r
5636 ; 740 : level_flags = 0;
\r
5638 002cb 33 c0 xor eax, eax
\r
5641 ; 747 : header |= (level_flags << 6);
\r
5643 002cd c1 e0 06 shl eax, 6
\r
5644 002d0 0b c8 or ecx, eax
\r
5646 ; 748 : if (s->strstart != 0) header |= PRESET_DICT;
\r
5648 002d2 83 7e 6c 00 cmp DWORD PTR [esi+108], 0
\r
5649 002d6 74 03 je SHORT $LN63@deflate
\r
5650 002d8 83 c9 20 or ecx, 32 ; 00000020H
\r
5653 ; 749 : header += 31 - (header % 31);
\r
5655 002db b8 85 10 42 08 mov eax, 138547333 ; 08421085H
\r
5656 002e0 f7 e1 mul ecx
\r
5657 002e2 2b ca sub ecx, edx
\r
5658 002e4 d1 e9 shr ecx, 1
\r
5659 002e6 8d 04 0a lea eax, DWORD PTR [edx+ecx]
\r
5660 002e9 c1 e8 04 shr eax, 4
\r
5663 ; 751 : s->status = BUSY_STATE;
\r
5664 ; 752 : putShortMSB(s, header);
\r
5666 002ec 03 c3 add eax, ebx
\r
5667 002ee 8b c8 mov ecx, eax
\r
5668 002f0 c1 e1 05 shl ecx, 5
\r
5669 002f3 2b c8 sub ecx, eax
\r
5670 002f5 8b c6 mov eax, esi
\r
5671 002f7 c7 46 04 71 00
\r
5672 00 00 mov DWORD PTR [esi+4], 113 ; 00000071H
\r
5673 002fe e8 00 00 00 00 call _putShortMSB
\r
5676 ; 754 : /* Save the adler32 of the preset dictionary: */
\r
5677 ; 755 : if (s->strstart != 0) {
\r
5679 00303 83 7e 6c 00 cmp DWORD PTR [esi+108], 0
\r
5680 00307 74 12 je SHORT $LN62@deflate
\r
5682 ; 756 : putShortMSB(s, (uInt)(strm->adler >> 16));
\r
5684 00309 0f b7 4f 32 movzx ecx, WORD PTR [edi+50]
\r
5685 0030d e8 00 00 00 00 call _putShortMSB
\r
5687 ; 757 : putShortMSB(s, (uInt)(strm->adler & 0xffff));
\r
5689 00312 0f b7 4f 30 movzx ecx, WORD PTR [edi+48]
\r
5690 00316 e8 00 00 00 00 call _putShortMSB
\r
5694 ; 759 : strm->adler = adler32(0L, Z_NULL, 0);
\r
5696 0031b 6a 00 push 0
\r
5697 0031d 6a 00 push 0
\r
5698 0031f 6a 00 push 0
\r
5699 00321 e8 00 00 00 00 call _adler32@12
\r
5700 00326 89 47 30 mov DWORD PTR [edi+48], eax
\r
5705 ; 762 : #ifdef GZIP
\r
5706 ; 763 : if (s->status == EXTRA_STATE) {
\r
5708 00329 83 7e 04 45 cmp DWORD PTR [esi+4], 69 ; 00000045H
\r
5709 0032d 0f 85 c3 00 00
\r
5710 00 jne $LN109@deflate
\r
5712 ; 764 : if (s->gzhead->extra != Z_NULL) {
\r
5714 00333 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
5715 00336 83 78 10 00 cmp DWORD PTR [eax+16], 0
\r
5716 0033a 0f 84 af 00 00
\r
5717 00 je $LN60@deflate
\r
5719 ; 765 : uInt beg = s->pending; /* start of bytes to update crc */
\r
5721 ; 767 : while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
\r
5723 00340 0f b7 40 14 movzx eax, WORD PTR [eax+20]
\r
5724 00344 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5725 00347 89 4d 08 mov DWORD PTR _beg$80590[ebp], ecx
\r
5726 0034a 39 46 20 cmp DWORD PTR [esi+32], eax
\r
5727 0034d 73 69 jae SHORT $LN101@deflate
\r
5731 ; 768 : if (s->pending == s->pending_buf_size) {
\r
5733 00350 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5734 00353 3b 46 0c cmp eax, DWORD PTR [esi+12]
\r
5735 00356 75 34 jne SHORT $LN55@deflate
\r
5737 ; 769 : if (s->gzhead->hcrc && s->pending > beg)
\r
5739 00358 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5740 0035b 83 7a 2c 00 cmp DWORD PTR [edx+44], 0
\r
5741 0035f 74 19 je SHORT $LN56@deflate
\r
5742 00361 3b c1 cmp eax, ecx
\r
5743 00363 76 15 jbe SHORT $LN56@deflate
\r
5745 ; 770 : strm->adler = crc32(strm->adler, s->pending_buf + beg,
\r
5746 ; 771 : s->pending - beg);
\r
5748 00365 2b c1 sub eax, ecx
\r
5750 00368 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
5751 0036b 03 c1 add eax, ecx
\r
5752 0036d 8b 4f 30 mov ecx, DWORD PTR [edi+48]
\r
5755 00372 e8 00 00 00 00 call _crc32@12
\r
5756 00377 89 47 30 mov DWORD PTR [edi+48], eax
\r
5759 ; 772 : flush_pending(strm);
\r
5761 0037a e8 00 00 00 00 call _flush_pending
\r
5763 ; 773 : beg = s->pending;
\r
5765 0037f 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5766 00382 8b c8 mov ecx, eax
\r
5767 00384 89 4d 08 mov DWORD PTR _beg$80590[ebp], ecx
\r
5769 ; 774 : if (s->pending == s->pending_buf_size)
\r
5771 00387 3b 46 0c cmp eax, DWORD PTR [esi+12]
\r
5772 0038a 74 2c je SHORT $LN101@deflate
\r
5777 ; 777 : put_byte(s, s->gzhead->extra[s->gzindex]);
\r
5779 0038c 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5780 0038f 8b 4a 10 mov ecx, DWORD PTR [edx+16]
\r
5781 00392 8b 56 20 mov edx, DWORD PTR [esi+32]
\r
5782 00395 8a 0c 11 mov cl, BYTE PTR [ecx+edx]
\r
5783 00398 8b 5e 08 mov ebx, DWORD PTR [esi+8]
\r
5784 0039b 88 0c 18 mov BYTE PTR [eax+ebx], cl
\r
5785 0039e 8b 4d 08 mov ecx, DWORD PTR _beg$80590[ebp]
\r
5786 003a1 b8 01 00 00 00 mov eax, 1
\r
5787 003a6 01 46 14 add DWORD PTR [esi+20], eax
\r
5789 ; 778 : s->gzindex++;
\r
5791 003a9 01 46 20 add DWORD PTR [esi+32], eax
\r
5792 003ac 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5793 003af 0f b7 42 14 movzx eax, WORD PTR [edx+20]
\r
5794 003b3 39 46 20 cmp DWORD PTR [esi+32], eax
\r
5795 003b6 72 98 jb SHORT $LL59@deflate
\r
5799 ; 780 : if (s->gzhead->hcrc && s->pending > beg)
\r
5801 003b8 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5802 003bb 83 7a 2c 00 cmp DWORD PTR [edx+44], 0
\r
5803 003bf 74 1c je SHORT $LN54@deflate
\r
5804 003c1 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5805 003c4 3b c1 cmp eax, ecx
\r
5806 003c6 76 15 jbe SHORT $LN54@deflate
\r
5808 ; 781 : strm->adler = crc32(strm->adler, s->pending_buf + beg,
\r
5809 ; 782 : s->pending - beg);
\r
5811 003c8 2b c1 sub eax, ecx
\r
5813 003cb 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
5814 003ce 03 c1 add eax, ecx
\r
5815 003d0 8b 4f 30 mov ecx, DWORD PTR [edi+48]
\r
5818 003d5 e8 00 00 00 00 call _crc32@12
\r
5819 003da 89 47 30 mov DWORD PTR [edi+48], eax
\r
5822 ; 783 : if (s->gzindex == s->gzhead->extra_len) {
\r
5824 003dd 8b 56 1c mov edx, DWORD PTR [esi+28]
\r
5825 003e0 8b 46 20 mov eax, DWORD PTR [esi+32]
\r
5826 003e3 3b 42 14 cmp eax, DWORD PTR [edx+20]
\r
5827 003e6 75 0e jne SHORT $LN109@deflate
\r
5829 ; 784 : s->gzindex = 0;
\r
5831 003e8 c7 46 20 00 00
\r
5832 00 00 mov DWORD PTR [esi+32], 0
\r
5835 ; 785 : s->status = NAME_STATE;
\r
5839 ; 789 : s->status = NAME_STATE;
\r
5841 003ef c7 46 04 49 00
\r
5842 00 00 mov DWORD PTR [esi+4], 73 ; 00000049H
\r
5846 ; 791 : if (s->status == NAME_STATE) {
\r
5848 003f6 83 7e 04 49 cmp DWORD PTR [esi+4], 73 ; 00000049H
\r
5849 003fa 0f 85 a1 00 00
\r
5850 00 jne $LN41@deflate
\r
5852 ; 792 : if (s->gzhead->name != Z_NULL) {
\r
5854 00400 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
5855 00403 83 79 1c 00 cmp DWORD PTR [ecx+28], 0
\r
5856 00407 0f 84 8d 00 00
\r
5857 00 je $LN50@deflate
\r
5859 ; 793 : uInt beg = s->pending; /* start of bytes to update crc */
\r
5861 0040d 8b 56 14 mov edx, DWORD PTR [esi+20]
\r
5867 ; 797 : if (s->pending == s->pending_buf_size) {
\r
5869 00410 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5870 00413 3b 46 0c cmp eax, DWORD PTR [esi+12]
\r
5871 00416 75 31 jne SHORT $LN44@deflate
\r
5873 ; 798 : if (s->gzhead->hcrc && s->pending > beg)
\r
5875 00418 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
5876 0041b 83 79 2c 00 cmp DWORD PTR [ecx+44], 0
\r
5877 0041f 74 19 je SHORT $LN45@deflate
\r
5878 00421 3b c2 cmp eax, edx
\r
5879 00423 76 15 jbe SHORT $LN45@deflate
\r
5881 ; 799 : strm->adler = crc32(strm->adler, s->pending_buf + beg,
\r
5882 ; 800 : s->pending - beg);
\r
5884 00425 8b 4f 30 mov ecx, DWORD PTR [edi+48]
\r
5885 00428 2b c2 sub eax, edx
\r
5887 0042b 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
5888 0042e 03 c2 add eax, edx
\r
5891 00432 e8 00 00 00 00 call _crc32@12
\r
5892 00437 89 47 30 mov DWORD PTR [edi+48], eax
\r
5895 ; 801 : flush_pending(strm);
\r
5897 0043a e8 00 00 00 00 call _flush_pending
\r
5899 ; 802 : beg = s->pending;
\r
5901 0043f 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5902 00442 8b d0 mov edx, eax
\r
5904 ; 803 : if (s->pending == s->pending_buf_size) {
\r
5906 00444 3b 46 0c cmp eax, DWORD PTR [esi+12]
\r
5907 00447 74 20 je SHORT $LN102@deflate
\r
5913 ; 808 : val = s->gzhead->name[s->gzindex++];
\r
5915 00449 8b 4e 20 mov ecx, DWORD PTR [esi+32]
\r
5916 0044c 8b 5e 1c mov ebx, DWORD PTR [esi+28]
\r
5917 0044f 8b 5b 1c mov ebx, DWORD PTR [ebx+28]
\r
5918 00452 0f b6 1c 0b movzx ebx, BYTE PTR [ebx+ecx]
\r
5920 00457 89 4e 20 mov DWORD PTR [esi+32], ecx
\r
5922 ; 809 : put_byte(s, val);
\r
5924 0045a 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5925 0045d 88 1c 08 mov BYTE PTR [eax+ecx], bl
\r
5926 00460 ff 46 14 inc DWORD PTR [esi+20]
\r
5928 ; 810 : } while (val != 0);
\r
5930 00463 85 db test ebx, ebx
\r
5931 00465 75 a9 jne SHORT $LL49@deflate
\r
5932 00467 eb 05 jmp SHORT $LN47@deflate
\r
5937 00469 bb 01 00 00 00 mov ebx, 1
\r
5940 ; 811 : if (s->gzhead->hcrc && s->pending > beg)
\r
5942 0046e 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
5943 00471 83 78 2c 00 cmp DWORD PTR [eax+44], 0
\r
5944 00475 74 1c je SHORT $LN43@deflate
\r
5945 00477 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
5946 0047a 3b c2 cmp eax, edx
\r
5947 0047c 76 15 jbe SHORT $LN43@deflate
\r
5949 ; 812 : strm->adler = crc32(strm->adler, s->pending_buf + beg,
\r
5950 ; 813 : s->pending - beg);
\r
5952 0047e 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
5953 00481 2b c2 sub eax, edx
\r
5955 00484 03 ca add ecx, edx
\r
5956 00486 8b 57 30 mov edx, DWORD PTR [edi+48]
\r
5959 0048b e8 00 00 00 00 call _crc32@12
\r
5960 00490 89 47 30 mov DWORD PTR [edi+48], eax
\r
5963 ; 814 : if (val == 0) {
\r
5965 00493 85 db test ebx, ebx
\r
5966 00495 75 0a jne SHORT $LN41@deflate
\r
5968 ; 815 : s->gzindex = 0;
\r
5970 00497 89 5e 20 mov DWORD PTR [esi+32], ebx
\r
5973 ; 816 : s->status = COMMENT_STATE;
\r
5977 ; 820 : s->status = COMMENT_STATE;
\r
5979 0049a c7 46 04 5b 00
\r
5980 00 00 mov DWORD PTR [esi+4], 91 ; 0000005bH
\r
5984 ; 822 : if (s->status == COMMENT_STATE) {
\r
5986 004a1 83 7e 04 5b cmp DWORD PTR [esi+4], 91 ; 0000005bH
\r
5987 004a5 0f 85 a3 00 00
\r
5988 00 jne $LN30@deflate
\r
5990 ; 823 : if (s->gzhead->comment != Z_NULL) {
\r
5992 004ab 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
5993 004ae 83 78 24 00 cmp DWORD PTR [eax+36], 0
\r
5994 004b2 0f 84 8f 00 00
\r
5995 00 je $LN39@deflate
\r
5997 ; 824 : uInt beg = s->pending; /* start of bytes to update crc */
\r
5999 004b8 8b 56 14 mov edx, DWORD PTR [esi+20]
\r
6000 004bb eb 03 8d 49 00 npad 5
\r
6006 ; 828 : if (s->pending == s->pending_buf_size) {
\r
6008 004c0 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6009 004c3 3b 46 0c cmp eax, DWORD PTR [esi+12]
\r
6010 004c6 75 31 jne SHORT $LN33@deflate
\r
6012 ; 829 : if (s->gzhead->hcrc && s->pending > beg)
\r
6014 004c8 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
6015 004cb 83 79 2c 00 cmp DWORD PTR [ecx+44], 0
\r
6016 004cf 74 19 je SHORT $LN34@deflate
\r
6017 004d1 3b c2 cmp eax, edx
\r
6018 004d3 76 15 jbe SHORT $LN34@deflate
\r
6020 ; 830 : strm->adler = crc32(strm->adler, s->pending_buf + beg,
\r
6021 ; 831 : s->pending - beg);
\r
6023 004d5 8b 4f 30 mov ecx, DWORD PTR [edi+48]
\r
6024 004d8 2b c2 sub eax, edx
\r
6026 004db 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
6027 004de 03 c2 add eax, edx
\r
6030 004e2 e8 00 00 00 00 call _crc32@12
\r
6031 004e7 89 47 30 mov DWORD PTR [edi+48], eax
\r
6034 ; 832 : flush_pending(strm);
\r
6036 004ea e8 00 00 00 00 call _flush_pending
\r
6038 ; 833 : beg = s->pending;
\r
6040 004ef 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6041 004f2 8b d0 mov edx, eax
\r
6043 ; 834 : if (s->pending == s->pending_buf_size) {
\r
6045 004f4 3b 46 0c cmp eax, DWORD PTR [esi+12]
\r
6046 004f7 74 20 je SHORT $LN103@deflate
\r
6052 ; 839 : val = s->gzhead->comment[s->gzindex++];
\r
6054 004f9 8b 4e 20 mov ecx, DWORD PTR [esi+32]
\r
6055 004fc 8b 5e 1c mov ebx, DWORD PTR [esi+28]
\r
6056 004ff 8b 5b 24 mov ebx, DWORD PTR [ebx+36]
\r
6057 00502 0f b6 1c 0b movzx ebx, BYTE PTR [ebx+ecx]
\r
6059 00507 89 4e 20 mov DWORD PTR [esi+32], ecx
\r
6061 ; 840 : put_byte(s, val);
\r
6063 0050a 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6064 0050d 88 1c 08 mov BYTE PTR [eax+ecx], bl
\r
6065 00510 ff 46 14 inc DWORD PTR [esi+20]
\r
6067 ; 841 : } while (val != 0);
\r
6069 00513 85 db test ebx, ebx
\r
6070 00515 75 a9 jne SHORT $LL38@deflate
\r
6071 00517 eb 05 jmp SHORT $LN36@deflate
\r
6076 00519 bb 01 00 00 00 mov ebx, 1
\r
6079 ; 842 : if (s->gzhead->hcrc && s->pending > beg)
\r
6081 0051e 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
6082 00521 83 78 2c 00 cmp DWORD PTR [eax+44], 0
\r
6083 00525 74 1c je SHORT $LN32@deflate
\r
6084 00527 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6085 0052a 3b c2 cmp eax, edx
\r
6086 0052c 76 15 jbe SHORT $LN32@deflate
\r
6088 ; 843 : strm->adler = crc32(strm->adler, s->pending_buf + beg,
\r
6089 ; 844 : s->pending - beg);
\r
6091 0052e 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6092 00531 2b c2 sub eax, edx
\r
6094 00534 03 ca add ecx, edx
\r
6095 00536 8b 57 30 mov edx, DWORD PTR [edi+48]
\r
6098 0053b e8 00 00 00 00 call _crc32@12
\r
6099 00540 89 47 30 mov DWORD PTR [edi+48], eax
\r
6102 ; 845 : if (val == 0)
\r
6104 00543 85 db test ebx, ebx
\r
6105 00545 75 07 jne SHORT $LN30@deflate
\r
6108 ; 846 : s->status = HCRC_STATE;
\r
6111 ; 849 : s->status = HCRC_STATE;
\r
6113 00547 c7 46 04 67 00
\r
6114 00 00 mov DWORD PTR [esi+4], 103 ; 00000067H
\r
6118 ; 851 : if (s->status == HCRC_STATE) {
\r
6120 0054e 83 7e 04 67 cmp DWORD PTR [esi+4], 103 ; 00000067H
\r
6121 00552 75 59 jne SHORT $LN25@deflate
\r
6123 ; 852 : if (s->gzhead->hcrc) {
\r
6125 00554 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
6126 00557 83 78 2c 00 cmp DWORD PTR [eax+44], 0
\r
6127 0055b 74 49 je SHORT $LN28@deflate
\r
6129 ; 853 : if (s->pending + 2 > s->pending_buf_size)
\r
6131 0055d 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
6132 00560 83 c1 02 add ecx, 2
\r
6133 00563 3b 4e 0c cmp ecx, DWORD PTR [esi+12]
\r
6134 00566 76 05 jbe SHORT $LN27@deflate
\r
6136 ; 854 : flush_pending(strm);
\r
6138 00568 e8 00 00 00 00 call _flush_pending
\r
6141 ; 855 : if (s->pending + 2 <= s->pending_buf_size) {
\r
6143 0056d 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6144 00570 8d 50 02 lea edx, DWORD PTR [eax+2]
\r
6145 00573 3b 56 0c cmp edx, DWORD PTR [esi+12]
\r
6146 00576 77 35 ja SHORT $LN25@deflate
\r
6148 ; 856 : put_byte(s, (Byte)(strm->adler & 0xff));
\r
6150 00578 8a 57 30 mov dl, BYTE PTR [edi+48]
\r
6151 0057b 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6152 0057e 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6154 ; 857 : put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
\r
6156 00581 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
6157 00584 b9 01 00 00 00 mov ecx, 1
\r
6158 00589 01 4e 14 add DWORD PTR [esi+20], ecx
\r
6159 0058c 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6160 0058f 8a 5f 31 mov bl, BYTE PTR [edi+49]
\r
6162 ; 858 : strm->adler = crc32(0L, Z_NULL, 0);
\r
6164 00592 6a 00 push 0
\r
6165 00594 6a 00 push 0
\r
6166 00596 88 1c 10 mov BYTE PTR [eax+edx], bl
\r
6167 00599 01 4e 14 add DWORD PTR [esi+20], ecx
\r
6168 0059c 6a 00 push 0
\r
6169 0059e e8 00 00 00 00 call _crc32@12
\r
6170 005a3 89 47 30 mov DWORD PTR [edi+48], eax
\r
6173 ; 859 : s->status = BUSY_STATE;
\r
6177 ; 863 : s->status = BUSY_STATE;
\r
6179 005a6 c7 46 04 71 00
\r
6180 00 00 mov DWORD PTR [esi+4], 113 ; 00000071H
\r
6186 ; 867 : /* Flush as much pending output as possible */
\r
6187 ; 868 : if (s->pending != 0) {
\r
6189 005ad 83 7e 14 00 cmp DWORD PTR [esi+20], 0
\r
6190 005b1 74 1d je SHORT $LN24@deflate
\r
6192 ; 869 : flush_pending(strm);
\r
6194 005b3 e8 00 00 00 00 call _flush_pending
\r
6196 ; 870 : if (strm->avail_out == 0) {
\r
6198 005b8 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
6199 005bc 75 5e jne SHORT $LN106@deflate
\r
6201 ; 940 : s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
\r
6203 005be c7 46 28 ff ff
\r
6204 ff ff mov DWORD PTR [esi+40], -1
\r
6209 ; 941 : return Z_OK;
\r
6211 005c7 33 c0 xor eax, eax
\r
6216 005ca 8b e5 mov esp, ebp
\r
6218 005cd c2 08 00 ret 8
\r
6221 ; 871 : /* Since avail_out is 0, deflate will be called again with
\r
6222 ; 872 : * more output space, but possibly with both pending and
\r
6223 ; 873 : * avail_in equal to zero. There won't be anything to do,
\r
6224 ; 874 : * but this is not an error situation so make sure we
\r
6225 ; 875 : * return OK instead of BUF_ERROR at next call of deflate:
\r
6227 ; 877 : s->last_flush = -1;
\r
6228 ; 878 : return Z_OK;
\r
6231 ; 881 : /* Make sure there is something to do and avoid duplicate consecutive
\r
6232 ; 882 : * flushes. For repeated and useless calls with Z_FINISH, we keep
\r
6233 ; 883 : * returning Z_STREAM_END instead of Z_BUF_ERROR.
\r
6235 ; 885 : } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
\r
6236 ; 886 : flush != Z_FINISH) {
\r
6238 005d0 83 7f 04 00 cmp DWORD PTR [edi+4], 0
\r
6239 005d4 75 46 jne SHORT $LN106@deflate
\r
6240 005d6 8b 45 fc mov eax, DWORD PTR _old_flush$[ebp]
\r
6241 005d9 33 c9 xor ecx, ecx
\r
6242 005db 83 f8 04 cmp eax, 4
\r
6243 005de 0f 9e c1 setle cl
\r
6244 005e1 8d 14 00 lea edx, DWORD PTR [eax+eax]
\r
6245 005e4 8b 45 0c mov eax, DWORD PTR _flush$[ebp]
\r
6246 005e7 8d 1c 00 lea ebx, DWORD PTR [eax+eax]
\r
6248 005eb 83 e1 09 and ecx, 9
\r
6249 005ee 2b d1 sub edx, ecx
\r
6250 005f0 33 c9 xor ecx, ecx
\r
6251 005f2 83 f8 04 cmp eax, 4
\r
6252 005f5 0f 9e c1 setle cl
\r
6254 005f9 83 e1 09 and ecx, 9
\r
6255 005fc 2b d9 sub ebx, ecx
\r
6256 005fe 3b da cmp ebx, edx
\r
6257 00600 7f 1d jg SHORT $LN108@deflate
\r
6258 00602 83 f8 04 cmp eax, 4
\r
6259 00605 74 18 je SHORT $LN108@deflate
\r
6261 ; 887 : ERR_RETURN(strm, Z_BUF_ERROR);
\r
6264 00608 c7 47 18 00 00
\r
6265 00 00 mov DWORD PTR [edi+24], OFFSET ??_C@_0N@DFPGLBGC@buffer?5error?$AA@
\r
6267 00610 b8 fb ff ff ff mov eax, -5 ; fffffffbH
\r
6272 00616 8b e5 mov esp, ebp
\r
6274 00619 c2 08 00 ret 8
\r
6277 ; 871 : /* Since avail_out is 0, deflate will be called again with
\r
6278 ; 872 : * more output space, but possibly with both pending and
\r
6279 ; 873 : * avail_in equal to zero. There won't be anything to do,
\r
6280 ; 874 : * but this is not an error situation so make sure we
\r
6281 ; 875 : * return OK instead of BUF_ERROR at next call of deflate:
\r
6283 ; 877 : s->last_flush = -1;
\r
6284 ; 878 : return Z_OK;
\r
6287 ; 881 : /* Make sure there is something to do and avoid duplicate consecutive
\r
6288 ; 882 : * flushes. For repeated and useless calls with Z_FINISH, we keep
\r
6289 ; 883 : * returning Z_STREAM_END instead of Z_BUF_ERROR.
\r
6291 ; 885 : } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
\r
6292 ; 886 : flush != Z_FINISH) {
\r
6294 0061c 8b 45 0c mov eax, DWORD PTR _flush$[ebp]
\r
6299 ; 890 : /* User must not provide more input after the first FINISH: */
\r
6300 ; 891 : if (s->status == FINISH_STATE && strm->avail_in != 0) {
\r
6302 0061f 8b 4e 04 mov ecx, DWORD PTR [esi+4]
\r
6303 00622 81 f9 9a 02 00
\r
6304 00 cmp ecx, 666 ; 0000029aH
\r
6305 00628 75 1b jne SHORT $LN110@deflate
\r
6306 0062a 83 7f 04 00 cmp DWORD PTR [edi+4], 0
\r
6307 0062e 74 1b je SHORT $LN113@deflate
\r
6309 ; 892 : ERR_RETURN(strm, Z_BUF_ERROR);
\r
6312 00631 c7 47 18 00 00
\r
6313 00 00 mov DWORD PTR [edi+24], OFFSET ??_C@_0N@DFPGLBGC@buffer?5error?$AA@
\r
6315 00639 b8 fb ff ff ff mov eax, -5 ; fffffffbH
\r
6320 0063f 8b e5 mov esp, ebp
\r
6322 00642 c2 08 00 ret 8
\r
6327 ; 895 : /* Start a new block or continue the current one.
\r
6329 ; 897 : if (strm->avail_in != 0 || s->lookahead != 0 ||
\r
6330 ; 898 : (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
\r
6332 00645 83 7f 04 00 cmp DWORD PTR [edi+4], 0
\r
6333 00649 75 1a jne SHORT $LN18@deflate
\r
6335 0064b 83 7e 74 00 cmp DWORD PTR [esi+116], 0
\r
6336 0064f 75 14 jne SHORT $LN18@deflate
\r
6337 00651 85 c0 test eax, eax
\r
6338 00653 0f 84 f4 00 00
\r
6339 00 je $LN107@deflate
\r
6340 00659 81 f9 9a 02 00
\r
6341 00 cmp ecx, 666 ; 0000029aH
\r
6342 0065f 0f 84 e8 00 00
\r
6343 00 je $LN107@deflate
\r
6346 ; 899 : block_state bstate;
\r
6348 ; 901 : bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
\r
6349 ; 902 : (s->strategy == Z_RLE ? deflate_rle(s, flush) :
\r
6350 ; 903 : (*(configuration_table[s->level].func))(s, flush));
\r
6352 00665 8b 8e 88 00 00
\r
6353 00 mov ecx, DWORD PTR [esi+136]
\r
6355 0066c 83 f9 02 cmp ecx, 2
\r
6356 0066f 75 0a jne SHORT $LN96@deflate
\r
6357 00671 e8 00 00 00 00 call _deflate_huff
\r
6358 00676 83 c4 04 add esp, 4
\r
6359 00679 eb 25 jmp SHORT $LN95@deflate
\r
6361 0067b 83 f9 03 cmp ecx, 3
\r
6362 0067e 75 0a jne SHORT $LN94@deflate
\r
6363 00680 e8 00 00 00 00 call _deflate_rle
\r
6364 00685 83 c4 04 add esp, 4
\r
6365 00688 eb 16 jmp SHORT $LN95@deflate
\r
6367 0068a 8b 8e 84 00 00
\r
6368 00 mov ecx, DWORD PTR [esi+132]
\r
6369 00690 8d 14 49 lea edx, DWORD PTR [ecx+ecx*2]
\r
6370 00693 8b 04 95 08 00
\r
6371 00 00 mov eax, DWORD PTR _configuration_table[edx*4+8]
\r
6373 0069b ff d0 call eax
\r
6374 0069d 83 c4 08 add esp, 8
\r
6378 ; 905 : if (bstate == finish_started || bstate == finish_done) {
\r
6380 006a0 83 f8 02 cmp eax, 2
\r
6381 006a3 74 05 je SHORT $LN16@deflate
\r
6382 006a5 83 f8 03 cmp eax, 3
\r
6383 006a8 75 07 jne SHORT $LN17@deflate
\r
6386 ; 906 : s->status = FINISH_STATE;
\r
6388 006aa c7 46 04 9a 02
\r
6389 00 00 mov DWORD PTR [esi+4], 666 ; 0000029aH
\r
6393 ; 908 : if (bstate == need_more || bstate == finish_started) {
\r
6395 006b1 85 c0 test eax, eax
\r
6396 006b3 0f 84 75 01 00
\r
6397 00 je $LN14@deflate
\r
6398 006b9 83 f8 02 cmp eax, 2
\r
6399 006bc 0f 84 6c 01 00
\r
6400 00 je $LN14@deflate
\r
6402 ; 910 : s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
\r
6404 ; 912 : return Z_OK;
\r
6405 ; 913 : /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
\r
6406 ; 914 : * of deflate should use the same flush parameter to make sure
\r
6407 ; 915 : * that the flush is complete. So we don't have to output an
\r
6408 ; 916 : * empty block here, this will be done at next call. This also
\r
6409 ; 917 : * ensures that for a very small output buffer, we emit at most
\r
6410 ; 918 : * one empty block.
\r
6413 ; 921 : if (bstate == block_done) {
\r
6415 006c2 bb 01 00 00 00 mov ebx, 1
\r
6416 006c7 3b c3 cmp eax, ebx
\r
6417 006c9 0f 85 83 00 00
\r
6418 00 jne $LN6@deflate
\r
6420 ; 922 : if (flush == Z_PARTIAL_FLUSH) {
\r
6422 006cf 8b 45 0c mov eax, DWORD PTR _flush$[ebp]
\r
6423 006d2 3b c3 cmp eax, ebx
\r
6424 006d4 75 09 jne SHORT $LN11@deflate
\r
6426 ; 923 : _tr_align(s);
\r
6428 006d6 8b c6 mov eax, esi
\r
6429 006d8 e8 00 00 00 00 call __tr_align
\r
6430 006dd eb 51 jmp SHORT $LN7@deflate
\r
6433 ; 924 : } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
\r
6435 006df 83 f8 05 cmp eax, 5
\r
6436 006e2 74 4c je SHORT $LN7@deflate
\r
6438 ; 925 : _tr_stored_block(s, (char*)0, 0L, 0);
\r
6440 006e4 6a 00 push 0
\r
6441 006e6 6a 00 push 0
\r
6442 006e8 33 c9 xor ecx, ecx
\r
6443 006ea 8b c6 mov eax, esi
\r
6444 006ec e8 00 00 00 00 call __tr_stored_block
\r
6445 006f1 83 c4 08 add esp, 8
\r
6447 ; 926 : /* For a full flush, this empty block will be recognized
\r
6448 ; 927 : * as a special marker by inflate_sync().
\r
6450 ; 929 : if (flush == Z_FULL_FLUSH) {
\r
6452 006f4 83 7d 0c 03 cmp DWORD PTR _flush$[ebp], 3
\r
6453 006f8 75 36 jne SHORT $LN7@deflate
\r
6455 ; 930 : CLEAR_HASH(s); /* forget history */
\r
6457 006fa 8b 4e 4c mov ecx, DWORD PTR [esi+76]
\r
6458 006fd 8b 56 44 mov edx, DWORD PTR [esi+68]
\r
6459 00700 33 c0 xor eax, eax
\r
6460 00702 66 89 44 4a fe mov WORD PTR [edx+ecx*2-2], ax
\r
6461 00707 8b 4e 4c mov ecx, DWORD PTR [esi+76]
\r
6462 0070a 8d 54 09 fe lea edx, DWORD PTR [ecx+ecx-2]
\r
6465 00710 8b 46 44 mov eax, DWORD PTR [esi+68]
\r
6467 00714 e8 00 00 00 00 call _memset
\r
6468 00719 83 c4 0c add esp, 12 ; 0000000cH
\r
6470 ; 931 : if (s->lookahead == 0) {
\r
6472 0071c 83 7e 74 00 cmp DWORD PTR [esi+116], 0
\r
6473 00720 75 0e jne SHORT $LN7@deflate
\r
6475 ; 932 : s->strstart = 0;
\r
6477 00722 33 c0 xor eax, eax
\r
6478 00724 89 46 6c mov DWORD PTR [esi+108], eax
\r
6480 ; 933 : s->block_start = 0L;
\r
6482 00727 89 46 5c mov DWORD PTR [esi+92], eax
\r
6484 ; 934 : s->insert = 0;
\r
6486 0072a 89 86 b4 16 00
\r
6487 00 mov DWORD PTR [esi+5812], eax
\r
6493 ; 938 : flush_pending(strm);
\r
6495 00730 e8 00 00 00 00 call _flush_pending
\r
6497 ; 939 : if (strm->avail_out == 0) {
\r
6499 00735 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
6500 00739 75 17 jne SHORT $LN6@deflate
\r
6502 ; 940 : s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
\r
6506 0073d c7 46 28 ff ff
\r
6507 ff ff mov DWORD PTR [esi+40], -1
\r
6509 ; 941 : return Z_OK;
\r
6511 00744 33 c0 xor eax, eax
\r
6516 00747 8b e5 mov esp, ebp
\r
6518 0074a c2 08 00 ret 8
\r
6521 ; 939 : if (strm->avail_out == 0) {
\r
6523 0074d bb 01 00 00 00 mov ebx, 1
\r
6529 ; 945 : Assert(strm->avail_out > 0, "bug2");
\r
6531 ; 947 : if (flush != Z_FINISH) return Z_OK;
\r
6533 00752 83 7d 0c 04 cmp DWORD PTR _flush$[ebp], 4
\r
6534 00756 0f 85 69 fe ff
\r
6535 ff jne $LN13@deflate
\r
6537 ; 948 : if (s->wrap <= 0) return Z_STREAM_END;
\r
6539 0075c 8b 46 18 mov eax, DWORD PTR [esi+24]
\r
6540 0075f 85 c0 test eax, eax
\r
6541 00761 7f 0b jg SHORT $LN4@deflate
\r
6542 00763 8b c3 mov eax, ebx
\r
6549 00768 8b e5 mov esp, ebp
\r
6551 0076b c2 08 00 ret 8
\r
6555 ; 950 : /* Write the trailer */
\r
6556 ; 951 : #ifdef GZIP
\r
6557 ; 952 : if (s->wrap == 2) {
\r
6559 0076e 83 f8 02 cmp eax, 2
\r
6560 00771 0f 85 81 00 00
\r
6561 00 jne $LN3@deflate
\r
6563 ; 953 : put_byte(s, (Byte)(strm->adler & 0xff));
\r
6565 00777 8b 56 14 mov edx, DWORD PTR [esi+20]
\r
6566 0077a 8a 47 30 mov al, BYTE PTR [edi+48]
\r
6567 0077d 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6568 00780 88 04 11 mov BYTE PTR [ecx+edx], al
\r
6569 00783 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6571 ; 954 : put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
\r
6573 00786 0f b6 57 31 movzx edx, BYTE PTR [edi+49]
\r
6574 0078a 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6575 0078d 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6576 00790 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6577 00793 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6579 ; 955 : put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
\r
6581 00796 0f b6 57 32 movzx edx, BYTE PTR [edi+50]
\r
6582 0079a 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6583 0079d 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6584 007a0 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6585 007a3 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6587 ; 956 : put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
\r
6589 007a6 0f b6 57 33 movzx edx, BYTE PTR [edi+51]
\r
6590 007aa 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6591 007ad 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6592 007b0 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6593 007b3 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6595 ; 957 : put_byte(s, (Byte)(strm->total_in & 0xff));
\r
6597 007b6 0f b6 57 08 movzx edx, BYTE PTR [edi+8]
\r
6598 007ba 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6599 007bd 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6600 007c0 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6601 007c3 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6603 ; 958 : put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
\r
6605 007c6 0f b6 57 09 movzx edx, BYTE PTR [edi+9]
\r
6606 007ca 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6607 007cd 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6608 007d0 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6609 007d3 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6611 ; 959 : put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
\r
6613 007d6 0f b6 57 0a movzx edx, BYTE PTR [edi+10]
\r
6614 007da 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6615 007dd 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6616 007e0 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6617 007e3 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6619 ; 960 : put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
\r
6621 007e6 0f b6 57 0b movzx edx, BYTE PTR [edi+11]
\r
6622 007ea 8b 46 14 mov eax, DWORD PTR [esi+20]
\r
6623 007ed 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
6624 007f0 88 14 08 mov BYTE PTR [eax+ecx], dl
\r
6625 007f3 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6630 007f6 eb 14 jmp SHORT $LN2@deflate
\r
6635 ; 965 : putShortMSB(s, (uInt)(strm->adler >> 16));
\r
6637 007f8 0f b7 4f 32 movzx ecx, WORD PTR [edi+50]
\r
6638 007fc 8b c6 mov eax, esi
\r
6639 007fe e8 00 00 00 00 call _putShortMSB
\r
6641 ; 966 : putShortMSB(s, (uInt)(strm->adler & 0xffff));
\r
6643 00803 0f b7 4f 30 movzx ecx, WORD PTR [edi+48]
\r
6644 00807 e8 00 00 00 00 call _putShortMSB
\r
6648 ; 968 : flush_pending(strm);
\r
6650 0080c e8 00 00 00 00 call _flush_pending
\r
6652 ; 969 : /* If avail_out is zero, the application will call deflate again
\r
6653 ; 970 : * to flush the rest.
\r
6655 ; 972 : if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
\r
6657 00811 8b 46 18 mov eax, DWORD PTR [esi+24]
\r
6658 00814 85 c0 test eax, eax
\r
6659 00816 7e 05 jle SHORT $LN1@deflate
\r
6660 00818 f7 d8 neg eax
\r
6661 0081a 89 46 18 mov DWORD PTR [esi+24], eax
\r
6664 ; 973 : return s->pending != 0 ? Z_OK : Z_STREAM_END;
\r
6666 0081d 33 c0 xor eax, eax
\r
6667 0081f 39 46 14 cmp DWORD PTR [esi+20], eax
\r
6670 00824 0f 94 c0 sete al
\r
6675 00828 8b e5 mov esp, ebp
\r
6677 0082b c2 08 00 ret 8
\r
6680 ; 909 : if (strm->avail_out == 0) {
\r
6682 0082e 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
6683 00832 0f 85 8d fd ff
\r
6684 ff jne $LN13@deflate
\r
6686 ; 940 : s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
\r
6690 0083a c7 46 28 ff ff
\r
6691 ff ff mov DWORD PTR [esi+40], -1
\r
6693 ; 941 : return Z_OK;
\r
6695 00841 33 c0 xor eax, eax
\r
6700 00844 8b e5 mov esp, ebp
\r
6702 00847 c2 08 00 ret 8
\r
6705 ; 679 : ERR_RETURN(strm, Z_STREAM_ERROR);
\r
6707 0084a c7 47 18 00 00
\r
6708 00 00 mov DWORD PTR [edi+24], OFFSET ??_C@_0N@MKKNPMJD@stream?5error?$AA@
\r
6711 00852 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
6716 00858 8b e5 mov esp, ebp
\r
6718 0085b c2 08 00 ret 8
\r
6721 PUBLIC _deflateParams@12
\r
6722 ; Function compile flags: /Ogtp
\r
6723 ; COMDAT _deflateParams@12
\r
6725 _err$ = -4 ; size = 4
\r
6726 _strm$ = 8 ; size = 4
\r
6727 _level$ = 12 ; size = 4
\r
6728 _strategy$ = 16 ; size = 4
\r
6729 _deflateParams@12 PROC ; COMDAT
\r
6734 00001 8b ec mov ebp, esp
\r
6737 ; 495 : deflate_state *s;
\r
6738 ; 496 : compress_func func;
\r
6739 ; 497 : int err = Z_OK;
\r
6741 ; 499 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
6743 00004 8b 55 08 mov edx, DWORD PTR _strm$[ebp]
\r
6745 00008 c7 45 fc 00 00
\r
6746 00 00 mov DWORD PTR _err$[ebp], 0
\r
6747 0000f 85 d2 test edx, edx
\r
6748 00011 0f 84 d5 00 00
\r
6749 00 je $LN7@deflatePar
\r
6750 00017 8b 72 1c mov esi, DWORD PTR [edx+28]
\r
6751 0001a 85 f6 test esi, esi
\r
6752 0001c 0f 84 ca 00 00
\r
6753 00 je $LN7@deflatePar
\r
6755 ; 500 : s = strm->state;
\r
6757 ; 502 : #ifdef FASTEST
\r
6758 ; 503 : if (level != 0) level = 1;
\r
6760 ; 505 : if (level == Z_DEFAULT_COMPRESSION) level = 6;
\r
6764 00024 8b 7d 0c mov edi, DWORD PTR _level$[ebp]
\r
6765 00027 83 ff ff cmp edi, -1
\r
6766 0002a 75 07 jne SHORT $LN6@deflatePar
\r
6767 0002c bf 06 00 00 00 mov edi, 6
\r
6770 ; 507 : if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
\r
6772 00031 eb 11 jmp SHORT $LN12@deflatePar
\r
6774 00033 85 ff test edi, edi
\r
6775 00035 0f 88 a3 00 00
\r
6776 00 js $LN4@deflatePar
\r
6777 0003b 83 ff 09 cmp edi, 9
\r
6778 0003e 0f 8f 9a 00 00
\r
6779 00 jg $LN4@deflatePar
\r
6781 00044 8b 5d 10 mov ebx, DWORD PTR _strategy$[ebp]
\r
6782 00047 83 fb 04 cmp ebx, 4
\r
6783 0004a 0f 87 8e 00 00
\r
6784 00 ja $LN4@deflatePar
\r
6787 ; 512 : if ((strategy != s->strategy || func != configuration_table[level].func) &&
\r
6788 ; 513 : strm->total_in != 0) {
\r
6790 00050 3b 9e 88 00 00
\r
6791 00 cmp ebx, DWORD PTR [esi+136]
\r
6792 00056 75 1c jne SHORT $LN2@deflatePar
\r
6795 ; 510 : func = configuration_table[s->level].func;
\r
6797 00058 8b 8e 84 00 00
\r
6798 00 mov ecx, DWORD PTR [esi+132]
\r
6799 0005e 8d 04 49 lea eax, DWORD PTR [ecx+ecx*2]
\r
6802 ; 512 : if ((strategy != s->strategy || func != configuration_table[level].func) &&
\r
6803 ; 513 : strm->total_in != 0) {
\r
6805 00061 8b 04 85 08 00
\r
6806 00 00 mov eax, DWORD PTR _configuration_table[eax*4+8]
\r
6807 00068 8d 0c 7f lea ecx, DWORD PTR [edi+edi*2]
\r
6808 0006b 3b 04 8d 08 00
\r
6809 00 00 cmp eax, DWORD PTR _configuration_table[ecx*4+8]
\r
6810 00072 74 11 je SHORT $LN13@deflatePar
\r
6812 00074 83 7a 08 00 cmp DWORD PTR [edx+8], 0
\r
6813 00078 74 0b je SHORT $LN13@deflatePar
\r
6815 ; 514 : /* Flush the last buffer: */
\r
6816 ; 515 : err = deflate(strm, Z_BLOCK);
\r
6818 0007a 6a 05 push 5
\r
6820 0007d e8 00 00 00 00 call _deflate@8
\r
6821 00082 89 45 fc mov DWORD PTR _err$[ebp], eax
\r
6825 ; 517 : if (s->level != level) {
\r
6827 00085 39 be 84 00 00
\r
6828 00 cmp DWORD PTR [esi+132], edi
\r
6829 0008b 74 3f je SHORT $LN1@deflatePar
\r
6831 ; 518 : s->level = level;
\r
6832 ; 519 : s->max_lazy_match = configuration_table[level].max_lazy;
\r
6834 0008d 8d 0c 7f lea ecx, DWORD PTR [edi+edi*2]
\r
6835 00090 89 be 84 00 00
\r
6836 00 mov DWORD PTR [esi+132], edi
\r
6837 00096 03 c9 add ecx, ecx
\r
6838 00098 0f b7 94 09 02
\r
6839 00 00 00 movzx edx, WORD PTR _configuration_table[ecx+ecx+2]
\r
6840 000a0 03 c9 add ecx, ecx
\r
6841 000a2 89 96 80 00 00
\r
6842 00 mov DWORD PTR [esi+128], edx
\r
6844 ; 520 : s->good_match = configuration_table[level].good_length;
\r
6846 000a8 0f b7 81 00 00
\r
6847 00 00 movzx eax, WORD PTR _configuration_table[ecx]
\r
6848 000af 89 86 8c 00 00
\r
6849 00 mov DWORD PTR [esi+140], eax
\r
6851 ; 521 : s->nice_match = configuration_table[level].nice_length;
\r
6853 000b5 0f b7 91 04 00
\r
6854 00 00 movzx edx, WORD PTR _configuration_table[ecx+4]
\r
6855 000bc 89 96 90 00 00
\r
6856 00 mov DWORD PTR [esi+144], edx
\r
6858 ; 522 : s->max_chain_length = configuration_table[level].max_chain;
\r
6860 000c2 0f b7 81 06 00
\r
6861 00 00 movzx eax, WORD PTR _configuration_table[ecx+6]
\r
6862 000c9 89 46 7c mov DWORD PTR [esi+124], eax
\r
6866 ; 524 : s->strategy = strategy;
\r
6867 ; 525 : return err;
\r
6869 000cc 8b 45 fc mov eax, DWORD PTR _err$[ebp]
\r
6871 000d0 89 9e 88 00 00
\r
6872 00 mov DWORD PTR [esi+136], ebx
\r
6878 000d8 8b e5 mov esp, ebp
\r
6880 000db c2 0c 00 ret 12 ; 0000000cH
\r
6885 ; 508 : return Z_STREAM_ERROR;
\r
6887 000e0 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
6892 000e6 8b e5 mov esp, ebp
\r
6894 000e9 c2 0c 00 ret 12 ; 0000000cH
\r
6897 ; 495 : deflate_state *s;
\r
6898 ; 496 : compress_func func;
\r
6899 ; 497 : int err = Z_OK;
\r
6901 ; 499 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
6903 000ec b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
6908 000f2 8b e5 mov esp, ebp
\r
6910 000f5 c2 0c 00 ret 12 ; 0000000cH
\r
6911 _deflateParams@12 ENDP
\r
Code Review / simantics / sysdyn.git / blob