--- /dev/null
+; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.40219.01
+
+ TITLE C:\Documents and Settings\yyagi\My Documents\Visual Studio 2010\Projects\dtxmania\branches\111222(DTXViewer023 with #26977)\@libpng\[V\zlib-1.2.8\contrib\minizip\zip.c
+ .686P
+ .XMM
+ include listing.inc
+ .model flat
+
+INCLUDELIB OLDNAMES
+
+PUBLIC _zip_copyright
+PUBLIC ??_C@_01JOAMLHOP@?9?$AA@ ; `string'
+EXTRN _rand:PROC
+EXTRN _srand:PROC
+EXTRN __time64:PROC
+?calls@?1??crypthead@@9@9 DD 01H DUP (?) ; `crypthead'::`2'::calls
+; COMDAT ??_C@_01JOAMLHOP@?9?$AA@
+CONST SEGMENT
+??_C@_01JOAMLHOP@?9?$AA@ DB '-', 00H ; `string'
+_zip_copyright DB ' zip 1.01 Copyright 1998-2004 Gilles Vollant - http://'
+ DB 'www.winimage.com/zLibDll', 00H
+; Function compile flags: /Ogtp
+; File c:\documents and settings\yyagi\my documents\visual studio 2010\projects\dtxmania\branches\111222(dtxviewer023 with #26977)\@libpng\83\\83\8a\83\85\81[\83V\83\87\83\93\zlib-1.2.8\contrib\minizip\zip.c
+; COMDAT _zip64local_getByte
+_TEXT SEGMENT
+_c$ = -1 ; size = 1
+_pi$ = 8 ; size = 4
+_zip64local_getByte PROC ; COMDAT
+; _pzlib_filefunc_def$ = esi
+; _filestream$ = edi
+
+; 350 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 51 push ecx
+
+; 351 : unsigned char c;
+; 352 : int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
+
+ 00004 8b 4e 1c mov ecx, DWORD PTR [esi+28]
+ 00007 8b 56 04 mov edx, DWORD PTR [esi+4]
+ 0000a 6a 01 push 1
+ 0000c 8d 45 ff lea eax, DWORD PTR _c$[ebp]
+ 0000f 50 push eax
+ 00010 57 push edi
+ 00011 51 push ecx
+ 00012 ff d2 call edx
+ 00014 83 c4 10 add esp, 16 ; 00000010H
+
+; 353 : if (err==1)
+
+ 00017 83 f8 01 cmp eax, 1
+ 0001a 75 0f jne SHORT $LN4@zip64local
+
+; 354 : {
+; 355 : *pi = (int)c;
+
+ 0001c 0f b6 45 ff movzx eax, BYTE PTR _c$[ebp]
+ 00020 8b 4d 08 mov ecx, DWORD PTR _pi$[ebp]
+ 00023 89 01 mov DWORD PTR [ecx], eax
+
+; 356 : return ZIP_OK;
+
+ 00025 33 c0 xor eax, eax
+
+; 361 : return ZIP_ERRNO;
+; 362 : else
+; 363 : return ZIP_EOF;
+; 364 : }
+; 365 : }
+
+ 00027 8b e5 mov esp, ebp
+ 00029 5d pop ebp
+ 0002a c3 ret 0
+$LN4@zip64local:
+
+; 357 : }
+; 358 : else
+; 359 : {
+; 360 : if (ZERROR64(*pzlib_filefunc_def,filestream))
+
+ 0002b 8b 56 1c mov edx, DWORD PTR [esi+28]
+ 0002e 8b 46 18 mov eax, DWORD PTR [esi+24]
+ 00031 57 push edi
+ 00032 52 push edx
+ 00033 ff d0 call eax
+ 00035 83 c4 08 add esp, 8
+ 00038 f7 d8 neg eax
+ 0003a 1b c0 sbb eax, eax
+
+; 361 : return ZIP_ERRNO;
+; 362 : else
+; 363 : return ZIP_EOF;
+; 364 : }
+; 365 : }
+
+ 0003c 8b e5 mov esp, ebp
+ 0003e 5d pop ebp
+ 0003f c3 ret 0
+_zip64local_getByte ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _zip64local_TmzDateToDosDate
+_TEXT SEGMENT
+_zip64local_TmzDateToDosDate PROC ; COMDAT
+; _ptm$ = edx
+
+; 334 : uLong year = (uLong)ptm->tm_year;
+
+ 00000 8b 4a 14 mov ecx, DWORD PTR [edx+20]
+
+; 335 : if (year>=1980)
+
+ 00003 81 f9 bc 07 00
+ 00 cmp ecx, 1980 ; 000007bcH
+ 00009 72 08 jb SHORT $LN3@zip64local@2
+
+; 336 : year-=1980;
+
+ 0000b 81 e9 bc 07 00
+ 00 sub ecx, 1980 ; 000007bcH
+ 00011 eb 08 jmp SHORT $LN1@zip64local@2
+$LN3@zip64local@2:
+
+; 337 : else if (year>=80)
+
+ 00013 83 f9 50 cmp ecx, 80 ; 00000050H
+ 00016 72 03 jb SHORT $LN1@zip64local@2
+
+; 338 : year-=80;
+
+ 00018 83 e9 50 sub ecx, 80 ; 00000050H
+$LN1@zip64local@2:
+
+; 339 : return
+; 340 : (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
+; 341 : ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
+
+ 0001b 8b 42 08 mov eax, DWORD PTR [edx+8]
+ 0001e c1 e0 06 shl eax, 6
+ 00021 03 42 04 add eax, DWORD PTR [edx+4]
+ 00024 56 push esi
+ 00025 8b 32 mov esi, DWORD PTR [edx]
+ 00027 d1 ee shr esi, 1
+ 00029 c1 e0 05 shl eax, 5
+ 0002c 03 c6 add eax, esi
+ 0002e 8b 72 10 mov esi, DWORD PTR [edx+16]
+ 00031 03 c9 add ecx, ecx
+ 00033 8d 4c ce 01 lea ecx, DWORD PTR [esi+ecx*8+1]
+ 00037 c1 e1 05 shl ecx, 5
+ 0003a 03 4a 0c add ecx, DWORD PTR [edx+12]
+ 0003d 5e pop esi
+ 0003e c1 e1 10 shl ecx, 16 ; 00000010H
+ 00041 0b c1 or eax, ecx
+
+; 342 : }
+
+ 00043 c3 ret 0
+_zip64local_TmzDateToDosDate ENDP
+_TEXT ENDS
+EXTRN _memset:PROC
+; Function compile flags: /Ogtp
+; COMDAT _zip64local_putValue_inmemory
+_TEXT SEGMENT
+_x$ = 8 ; size = 8
+_zip64local_putValue_inmemory PROC ; COMDAT
+; _dest$ = edi
+; _nbByte$ = esi
+
+; 312 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 313 : unsigned char* buf=(unsigned char*)dest;
+; 314 : int n;
+; 315 : for (n = 0; n < nbByte; n++) {
+
+ 00003 8b 55 0c mov edx, DWORD PTR _x$[ebp+4]
+ 00006 8b 45 08 mov eax, DWORD PTR _x$[ebp]
+ 00009 33 c9 xor ecx, ecx
+ 0000b 85 f6 test esi, esi
+ 0000d 7e 10 jle SHORT $LN5@zip64local@3
+ 0000f 90 npad 1
+$LL7@zip64local@3:
+
+; 316 : buf[n] = (unsigned char)(x & 0xff);
+
+ 00010 88 04 39 mov BYTE PTR [ecx+edi], al
+
+; 317 : x >>= 8;
+
+ 00013 0f ac d0 08 shrd eax, edx, 8
+ 00017 41 inc ecx
+ 00018 c1 ea 08 shr edx, 8
+ 0001b 3b ce cmp ecx, esi
+ 0001d 7c f1 jl SHORT $LL7@zip64local@3
+$LN5@zip64local@3:
+
+; 318 : }
+; 319 :
+; 320 : if (x != 0)
+
+ 0001f 0b c2 or eax, edx
+ 00021 74 13 je SHORT $LN3@zip64local@3
+
+; 321 : { /* data overflow - hack for ZIP64 */
+; 322 : for (n = 0; n < nbByte; n++)
+
+ 00023 85 f6 test esi, esi
+ 00025 7e 0f jle SHORT $LN3@zip64local@3
+ 00027 56 push esi
+ 00028 68 ff 00 00 00 push 255 ; 000000ffH
+ 0002d 57 push edi
+ 0002e e8 00 00 00 00 call _memset
+ 00033 83 c4 0c add esp, 12 ; 0000000cH
+$LN3@zip64local@3:
+
+; 323 : {
+; 324 : buf[n] = 0xff;
+; 325 : }
+; 326 : }
+; 327 : }
+
+ 00036 5d pop ebp
+ 00037 c3 ret 0
+_zip64local_putValue_inmemory ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _zip64local_putValue
+_TEXT SEGMENT
+_filestream$ = 8 ; size = 4
+_buf$ = 12 ; size = 8
+_x$ = 12 ; size = 8
+_zip64local_putValue PROC ; COMDAT
+; _pzlib_filefunc_def$ = edi
+; _nbByte$ = esi
+
+; 288 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 289 : unsigned char buf[8];
+; 290 : int n;
+; 291 : for (n = 0; n < nbByte; n++)
+
+ 00003 8b 55 10 mov edx, DWORD PTR _x$[ebp+4]
+ 00006 8b 45 0c mov eax, DWORD PTR _x$[ebp]
+ 00009 33 c9 xor ecx, ecx
+ 0000b 85 f6 test esi, esi
+ 0000d 7e 11 jle SHORT $LN7@zip64local@4
+ 0000f 90 npad 1
+$LL9@zip64local@4:
+
+; 292 : {
+; 293 : buf[n] = (unsigned char)(x & 0xff);
+
+ 00010 88 44 0d 0c mov BYTE PTR _buf$[ebp+ecx], al
+
+; 294 : x >>= 8;
+
+ 00014 0f ac d0 08 shrd eax, edx, 8
+ 00018 41 inc ecx
+ 00019 c1 ea 08 shr edx, 8
+ 0001c 3b ce cmp ecx, esi
+ 0001e 7c f0 jl SHORT $LL9@zip64local@4
+$LN7@zip64local@4:
+
+; 295 : }
+; 296 : if (x != 0)
+
+ 00020 0b c2 or eax, edx
+ 00022 74 16 je SHORT $LN5@zip64local@4
+
+; 297 : { /* data overflow - hack for ZIP64 (X Roche) */
+; 298 : for (n = 0; n < nbByte; n++)
+
+ 00024 85 f6 test esi, esi
+ 00026 7e 12 jle SHORT $LN5@zip64local@4
+ 00028 56 push esi
+ 00029 8d 45 0c lea eax, DWORD PTR _buf$[ebp]
+ 0002c 68 ff 00 00 00 push 255 ; 000000ffH
+ 00031 50 push eax
+ 00032 e8 00 00 00 00 call _memset
+ 00037 83 c4 0c add esp, 12 ; 0000000cH
+$LN5@zip64local@4:
+
+; 299 : {
+; 300 : buf[n] = 0xff;
+; 301 : }
+; 302 : }
+; 303 :
+; 304 : if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
+
+ 0003a 8b 55 08 mov edx, DWORD PTR _filestream$[ebp]
+ 0003d 8b 47 1c mov eax, DWORD PTR [edi+28]
+ 00040 56 push esi
+ 00041 8d 4d 0c lea ecx, DWORD PTR _buf$[ebp]
+ 00044 51 push ecx
+ 00045 8b 4f 08 mov ecx, DWORD PTR [edi+8]
+ 00048 52 push edx
+ 00049 50 push eax
+ 0004a ff d1 call ecx
+ 0004c 2b c6 sub eax, esi
+ 0004e 83 c4 10 add esp, 16 ; 00000010H
+ 00051 f7 d8 neg eax
+ 00053 1b c0 sbb eax, eax
+
+; 305 : return ZIP_ERRNO;
+; 306 : else
+; 307 : return ZIP_OK;
+; 308 : }
+
+ 00055 5d pop ebp
+ 00056 c3 ret 0
+_zip64local_putValue ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _init_linkedlist
+_TEXT SEGMENT
+_init_linkedlist PROC ; COMDAT
+; _ll$ = eax
+
+; 215 : ll->first_block = ll->last_block = NULL;
+
+ 00000 c7 40 04 00 00
+ 00 00 mov DWORD PTR [eax+4], 0
+ 00007 c7 00 00 00 00
+ 00 mov DWORD PTR [eax], 0
+
+; 216 : }
+
+ 0000d c3 ret 0
+_init_linkedlist ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _free_datablock
+_TEXT SEGMENT
+_free_datablock PROC ; COMDAT
+; _ldi$ = eax
+
+; 205 : while (ldi!=NULL)
+
+ 00000 85 c0 test eax, eax
+ 00002 74 13 je SHORT $LN2@free_datab
+ 00004 56 push esi
+$LL3@free_datab:
+
+; 206 : {
+; 207 : linkedlist_datablock_internal* ldinext = ldi->next_datablock;
+
+ 00005 8b 30 mov esi, DWORD PTR [eax]
+
+; 208 : TRYFREE(ldi);
+
+ 00007 50 push eax
+ 00008 e8 00 00 00 00 call _free
+ 0000d 83 c4 04 add esp, 4
+
+; 209 : ldi = ldinext;
+
+ 00010 8b c6 mov eax, esi
+ 00012 85 f6 test esi, esi
+ 00014 75 ef jne SHORT $LL3@free_datab
+ 00016 5e pop esi
+$LN2@free_datab:
+
+; 210 : }
+; 211 : }
+
+ 00017 c3 ret 0
+_free_datablock ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _allocate_new_datablock
+_TEXT SEGMENT
+_allocate_new_datablock PROC ; COMDAT
+
+; 191 : linkedlist_datablock_internal* ldi;
+; 192 : ldi = (linkedlist_datablock_internal*)
+; 193 : ALLOC(sizeof(linkedlist_datablock_internal));
+
+ 00000 68 00 10 00 00 push 4096 ; 00001000H
+ 00005 e8 00 00 00 00 call _malloc
+ 0000a 83 c4 04 add esp, 4
+
+; 194 : if (ldi!=NULL)
+
+ 0000d 85 c0 test eax, eax
+ 0000f 74 14 je SHORT $LN1@allocate_n
+
+; 195 : {
+; 196 : ldi->next_datablock = NULL ;
+
+ 00011 c7 00 00 00 00
+ 00 mov DWORD PTR [eax], 0
+
+; 197 : ldi->filled_in_this_block = 0 ;
+
+ 00017 c7 40 08 00 00
+ 00 00 mov DWORD PTR [eax+8], 0
+
+; 198 : ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
+
+ 0001e c7 40 04 f0 0f
+ 00 00 mov DWORD PTR [eax+4], 4080 ; 00000ff0H
+$LN1@allocate_n:
+
+; 199 : }
+; 200 : return ldi;
+; 201 : }
+
+ 00025 c3 ret 0
+_allocate_new_datablock ENDP
+; Function compile flags: /Ogtp
+; File c:\documents and settings\yyagi\my documents\visual studio 2010\projects\dtxmania\branches\111222(dtxviewer023 with #26977)\@libpng\83\\83\8a\83\85\81[\83V\83\87\83\93\zlib-1.2.8\contrib\minizip\crypt.h
+_TEXT ENDS
+; COMDAT _update_keys
+_TEXT SEGMENT
+_update_keys PROC ; COMDAT
+; _pkeys$ = esi
+; _pcrc_32_tab$ = edi
+; _c$ = eax
+
+; 50 : (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
+
+ 00000 8b 0e mov ecx, DWORD PTR [esi]
+ 00002 8b d1 mov edx, ecx
+ 00004 33 d0 xor edx, eax
+ 00006 c1 e9 08 shr ecx, 8
+ 00009 81 e2 ff 00 00
+ 00 and edx, 255 ; 000000ffH
+ 0000f 8b 14 97 mov edx, DWORD PTR [edi+edx*4]
+ 00012 33 d1 xor edx, ecx
+
+; 51 : (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
+
+ 00014 0f b6 ca movzx ecx, dl
+
+; 52 : (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
+
+ 00017 03 4e 04 add ecx, DWORD PTR [esi+4]
+ 0001a 89 16 mov DWORD PTR [esi], edx
+
+; 53 : {
+; 54 : register int keyshift = (int)((*(pkeys+1)) >> 24);
+; 55 : (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
+
+ 0001c 8b 56 08 mov edx, DWORD PTR [esi+8]
+ 0001f 69 c9 05 84 08
+ 08 imul ecx, 134775813 ; 08088405H
+ 00025 41 inc ecx
+ 00026 89 4e 04 mov DWORD PTR [esi+4], ecx
+ 00029 c1 e9 18 shr ecx, 24 ; 00000018H
+ 0002c 33 ca xor ecx, edx
+ 0002e 81 e1 ff 00 00
+ 00 and ecx, 255 ; 000000ffH
+ 00034 c1 ea 08 shr edx, 8
+ 00037 33 14 8f xor edx, DWORD PTR [edi+ecx*4]
+ 0003a 89 56 08 mov DWORD PTR [esi+8], edx
+
+; 56 : }
+; 57 : return c;
+; 58 : }
+
+ 0003d c3 ret 0
+_update_keys ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _decrypt_byte
+_TEXT SEGMENT
+_decrypt_byte PROC ; COMDAT
+; _pkeys$ = eax
+
+; 37 : unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
+; 38 : * unpredictable manner on 16-bit systems; not a problem
+; 39 : * with any known compiler so far, though */
+; 40 :
+; 41 : temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
+
+ 00000 8b 48 08 mov ecx, DWORD PTR [eax+8]
+ 00003 81 e1 fd ff 00
+ 00 and ecx, 65533 ; 0000fffdH
+ 00009 83 c9 02 or ecx, 2
+
+; 42 : return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
+
+ 0000c 8b c1 mov eax, ecx
+ 0000e 83 f0 01 xor eax, 1
+ 00011 0f af c1 imul eax, ecx
+ 00014 c1 e8 08 shr eax, 8
+ 00017 25 ff 00 00 00 and eax, 255 ; 000000ffH
+
+; 43 : }
+
+ 0001c c3 ret 0
+_decrypt_byte ENDP
+; Function compile flags: /Ogtp
+; File c:\program files\microsoft visual studio 10.0\vc\include\time.inl
+_TEXT ENDS
+; COMDAT _time
+_TEXT SEGMENT
+_time PROC ; COMDAT
+
+; 133 : return _time64(_Time);
+
+ 00000 6a 00 push 0
+ 00002 e8 00 00 00 00 call __time64
+ 00007 83 c4 04 add esp, 4
+
+; 134 : }
+
+ 0000a c3 ret 0
+_time ENDP
+PUBLIC _Write_GlobalComment
+; Function compile flags: /Ogtp
+; File c:\documents and settings\yyagi\my documents\visual studio 2010\projects\dtxmania\branches\111222(dtxviewer023 with #26977)\@libpng\83\\83\8a\83\85\81[\83V\83\87\83\93\zlib-1.2.8\contrib\minizip\zip.c
+; COMDAT _Write_GlobalComment
+_TEXT SEGMENT
+_global_comment$ = 8 ; size = 4
+_Write_GlobalComment PROC ; COMDAT
+; _zi$ = eax
+
+; 1865 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 53 push ebx
+ 00004 56 push esi
+ 00005 57 push edi
+ 00006 8b f8 mov edi, eax
+
+; 1866 : int err = ZIP_OK;
+; 1867 : uInt size_global_comment = 0;
+; 1868 :
+; 1869 : if(global_comment != NULL)
+
+ 00008 8b 45 08 mov eax, DWORD PTR _global_comment$[ebp]
+ 0000b 33 db xor ebx, ebx
+ 0000d 85 c0 test eax, eax
+ 0000f 74 0e je SHORT $LN3@Write_Glob
+
+; 1870 : size_global_comment = (uInt)strlen(global_comment);
+
+ 00011 8d 50 01 lea edx, DWORD PTR [eax+1]
+$LL6@Write_Glob:
+ 00014 8a 08 mov cl, BYTE PTR [eax]
+ 00016 40 inc eax
+ 00017 84 c9 test cl, cl
+ 00019 75 f9 jne SHORT $LL6@Write_Glob
+ 0001b 2b c2 sub eax, edx
+ 0001d 8b d8 mov ebx, eax
+$LN3@Write_Glob:
+
+; 1871 :
+; 1872 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
+
+ 0001f 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00022 6a 00 push 0
+ 00024 53 push ebx
+ 00025 50 push eax
+ 00026 be 02 00 00 00 mov esi, 2
+ 0002b e8 00 00 00 00 call _zip64local_putValue
+ 00030 8b f0 mov esi, eax
+ 00032 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1873 :
+; 1874 : if (err == ZIP_OK && size_global_comment > 0)
+
+ 00035 85 f6 test esi, esi
+ 00037 75 25 jne SHORT $LN9@Write_Glob
+ 00039 85 db test ebx, ebx
+ 0003b 74 21 je SHORT $LN9@Write_Glob
+
+; 1875 : {
+; 1876 : if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)
+
+ 0003d 8b 4d 08 mov ecx, DWORD PTR _global_comment$[ebp]
+ 00040 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00043 8b 47 1c mov eax, DWORD PTR [edi+28]
+ 00046 53 push ebx
+ 00047 51 push ecx
+ 00048 8b 4f 08 mov ecx, DWORD PTR [edi+8]
+ 0004b 52 push edx
+ 0004c 50 push eax
+ 0004d ff d1 call ecx
+ 0004f 83 c4 10 add esp, 16 ; 00000010H
+ 00052 3b c3 cmp eax, ebx
+ 00054 74 08 je SHORT $LN9@Write_Glob
+
+; 1877 : err = ZIP_ERRNO;
+
+ 00056 83 c8 ff or eax, -1
+
+; 1878 : }
+; 1879 : return err;
+; 1880 : }
+
+ 00059 5f pop edi
+ 0005a 5e pop esi
+ 0005b 5b pop ebx
+ 0005c 5d pop ebp
+ 0005d c3 ret 0
+$LN9@Write_Glob:
+ 0005e 5f pop edi
+ 0005f 8b c6 mov eax, esi
+ 00061 5e pop esi
+ 00062 5b pop ebx
+ 00063 5d pop ebp
+ 00064 c3 ret 0
+_Write_GlobalComment ENDP
+_TEXT ENDS
+PUBLIC _Write_EndOfCentralDirectoryRecord
+; Function compile flags: /Ogtp
+; COMDAT _Write_EndOfCentralDirectoryRecord
+_TEXT SEGMENT
+tv145 = -8 ; size = 8
+_size_centraldir$ = 8 ; size = 4
+_centraldir_pos_inzip$ = 12 ; size = 8
+_Write_EndOfCentralDirectoryRecord PROC ; COMDAT
+; _zi$ = eax
+
+; 1817 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 ec 08 sub esp, 8
+ 00006 56 push esi
+ 00007 57 push edi
+ 00008 8b f8 mov edi, eax
+
+; 1818 : int err = ZIP_OK;
+; 1819 :
+; 1820 : /*signature*/
+; 1821 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
+
+ 0000a 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0000d 6a 00 push 0
+ 0000f 68 50 4b 05 06 push 101010256 ; 06054b50H
+ 00014 50 push eax
+ 00015 be 04 00 00 00 mov esi, 4
+ 0001a e8 00 00 00 00 call _zip64local_putValue
+ 0001f 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1822 :
+; 1823 : if (err==ZIP_OK) /* number of this disk */
+
+ 00022 85 c0 test eax, eax
+ 00024 0f 85 0f 01 00
+ 00 jne $LN1@Write_EndO
+
+; 1824 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+ 0002a 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 0002d 50 push eax
+ 0002e 50 push eax
+ 0002f 51 push ecx
+ 00030 8d 70 02 lea esi, DWORD PTR [eax+2]
+ 00033 e8 00 00 00 00 call _zip64local_putValue
+ 00038 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1825 :
+; 1826 : if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+
+ 0003b 85 c0 test eax, eax
+ 0003d 0f 85 f6 00 00
+ 00 jne $LN1@Write_EndO
+
+; 1827 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+ 00043 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00046 50 push eax
+ 00047 50 push eax
+ 00048 52 push edx
+ 00049 e8 00 00 00 00 call _zip64local_putValue
+ 0004e 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1828 :
+; 1829 : if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+
+ 00051 85 c0 test eax, eax
+ 00053 0f 85 e0 00 00
+ 00 jne $LN1@Write_EndO
+
+; 1830 : {
+; 1831 : {
+; 1832 : if(zi->number_entry >= 0xFFFF)
+
+ 00059 39 87 fc 00 01
+ 00 cmp DWORD PTR [edi+65788], eax
+ 0005f 77 0c ja SHORT $LN15@Write_EndO
+ 00061 81 bf f8 00 01
+ 00 ff ff 00 00 cmp DWORD PTR [edi+65784], 65535 ; 0000ffffH
+ 0006b 72 0d jb SHORT $LN9@Write_EndO
+$LN15@Write_EndO:
+
+; 1833 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+
+ 0006d 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00070 6a 00 push 0
+ 00072 68 ff ff 00 00 push 65535 ; 0000ffffH
+ 00077 50 push eax
+
+; 1834 : else
+
+ 00078 eb 0d jmp SHORT $LN24@Write_EndO
+$LN9@Write_EndO:
+
+; 1835 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+
+ 0007a 8b 8f f8 00 01
+ 00 mov ecx, DWORD PTR [edi+65784]
+ 00080 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00083 6a 00 push 0
+ 00085 51 push ecx
+ 00086 52 push edx
+$LN24@Write_EndO:
+ 00087 e8 00 00 00 00 call _zip64local_putValue
+ 0008c 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1836 : }
+; 1837 : }
+; 1838 :
+; 1839 : if (err==ZIP_OK) /* total number of entries in the central dir */
+
+ 0008f 85 c0 test eax, eax
+ 00091 0f 85 a2 00 00
+ 00 jne $LN1@Write_EndO
+
+; 1840 : {
+; 1841 : if(zi->number_entry >= 0xFFFF)
+
+ 00097 39 87 fc 00 01
+ 00 cmp DWORD PTR [edi+65788], eax
+ 0009d 77 0c ja SHORT $LN16@Write_EndO
+ 0009f 81 bf f8 00 01
+ 00 ff ff 00 00 cmp DWORD PTR [edi+65784], 65535 ; 0000ffffH
+ 000a9 72 0d jb SHORT $LN6@Write_EndO
+$LN16@Write_EndO:
+
+; 1842 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+
+ 000ab 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 000ae 6a 00 push 0
+ 000b0 68 ff ff 00 00 push 65535 ; 0000ffffH
+ 000b5 50 push eax
+
+; 1843 : else
+
+ 000b6 eb 0d jmp SHORT $LN25@Write_EndO
+$LN6@Write_EndO:
+
+; 1844 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+
+ 000b8 8b 8f f8 00 01
+ 00 mov ecx, DWORD PTR [edi+65784]
+ 000be 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 000c1 6a 00 push 0
+ 000c3 51 push ecx
+ 000c4 52 push edx
+$LN25@Write_EndO:
+ 000c5 be 02 00 00 00 mov esi, 2
+ 000ca e8 00 00 00 00 call _zip64local_putValue
+ 000cf 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1845 : }
+; 1846 :
+; 1847 : if (err==ZIP_OK) /* size of the central directory */
+
+ 000d2 85 c0 test eax, eax
+ 000d4 75 63 jne SHORT $LN1@Write_EndO
+
+; 1848 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
+
+ 000d6 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 000d9 50 push eax
+ 000da 8b 45 08 mov eax, DWORD PTR _size_centraldir$[ebp]
+ 000dd 50 push eax
+ 000de 51 push ecx
+ 000df be 04 00 00 00 mov esi, 4
+ 000e4 e8 00 00 00 00 call _zip64local_putValue
+ 000e9 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1849 :
+; 1850 : if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
+
+ 000ec 85 c0 test eax, eax
+ 000ee 75 49 jne SHORT $LN1@Write_EndO
+
+; 1851 : {
+; 1852 : ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
+
+ 000f0 8b 45 0c mov eax, DWORD PTR _centraldir_pos_inzip$[ebp]
+ 000f3 8b 55 10 mov edx, DWORD PTR _centraldir_pos_inzip$[ebp+4]
+ 000f6 8b c8 mov ecx, eax
+ 000f8 2b 8f f0 00 01
+ 00 sub ecx, DWORD PTR [edi+65776]
+ 000fe 1b 97 f4 00 01
+ 00 sbb edx, DWORD PTR [edi+65780]
+
+; 1853 : if(pos >= 0xffffffff)
+
+ 00104 89 55 fc mov DWORD PTR tv145[ebp+4], edx
+ 00107 75 05 jne SHORT $LN17@Write_EndO
+ 00109 83 f9 ff cmp ecx, -1
+ 0010c 72 16 jb SHORT $LN2@Write_EndO
+$LN17@Write_EndO:
+
+; 1854 : {
+; 1855 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4);
+
+ 0010e 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00111 6a 00 push 0
+ 00113 6a ff push -1
+ 00115 50 push eax
+
+; 1856 : }
+; 1857 : else
+; 1858 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
+
+ 00116 e8 00 00 00 00 call _zip64local_putValue
+ 0011b 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1859 : }
+; 1860 :
+; 1861 : return err;
+; 1862 : }
+
+ 0011e 5f pop edi
+ 0011f 5e pop esi
+ 00120 8b e5 mov esp, ebp
+ 00122 5d pop ebp
+ 00123 c3 ret 0
+$LN2@Write_EndO:
+
+; 1856 : }
+; 1857 : else
+; 1858 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
+
+ 00124 2b 87 f0 00 01
+ 00 sub eax, DWORD PTR [edi+65776]
+ 0012a 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 0012d 6a 00 push 0
+ 0012f 50 push eax
+ 00130 51 push ecx
+ 00131 e8 00 00 00 00 call _zip64local_putValue
+ 00136 83 c4 0c add esp, 12 ; 0000000cH
+$LN1@Write_EndO:
+
+; 1859 : }
+; 1860 :
+; 1861 : return err;
+; 1862 : }
+
+ 00139 5f pop edi
+ 0013a 5e pop esi
+ 0013b 8b e5 mov esp, ebp
+ 0013d 5d pop ebp
+ 0013e c3 ret 0
+_Write_EndOfCentralDirectoryRecord ENDP
+_TEXT ENDS
+PUBLIC _Write_Zip64EndOfCentralDirectoryRecord
+; Function compile flags: /Ogtp
+; COMDAT _Write_Zip64EndOfCentralDirectoryRecord
+_TEXT SEGMENT
+_size_centraldir$ = 8 ; size = 4
+_centraldir_pos_inzip$ = 12 ; size = 8
+_Write_Zip64EndOfCentralDirectoryRecord PROC ; COMDAT
+; _zi$ = eax
+
+; 1778 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 56 push esi
+ 00004 57 push edi
+ 00005 8b f8 mov edi, eax
+
+; 1779 : int err = ZIP_OK;
+; 1780 :
+; 1781 : uLong Zip64DataSize = 44;
+; 1782 :
+; 1783 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
+
+ 00007 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0000a 6a 00 push 0
+ 0000c 68 50 4b 06 06 push 101075792 ; 06064b50H
+ 00011 50 push eax
+ 00012 be 04 00 00 00 mov esi, 4
+ 00017 e8 00 00 00 00 call _zip64local_putValue
+ 0001c 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1784 :
+; 1785 : if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */
+
+ 0001f 85 c0 test eax, eax
+ 00021 0f 85 ec 00 00
+ 00 jne $LN1@Write_Zip6
+
+; 1786 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?
+
+ 00027 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 0002a 50 push eax
+ 0002b 6a 2c push 44 ; 0000002cH
+ 0002d 51 push ecx
+ 0002e 8d 70 08 lea esi, DWORD PTR [eax+8]
+ 00031 e8 00 00 00 00 call _zip64local_putValue
+ 00036 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1787 :
+; 1788 : if (err==ZIP_OK) /* version made by */
+
+ 00039 85 c0 test eax, eax
+ 0003b 0f 85 d2 00 00
+ 00 jne $LN1@Write_Zip6
+
+; 1789 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
+
+ 00041 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00044 50 push eax
+ 00045 6a 2d push 45 ; 0000002dH
+ 00047 52 push edx
+ 00048 8d 70 02 lea esi, DWORD PTR [eax+2]
+ 0004b e8 00 00 00 00 call _zip64local_putValue
+ 00050 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1790 :
+; 1791 : if (err==ZIP_OK) /* version needed */
+
+ 00053 85 c0 test eax, eax
+ 00055 0f 85 b8 00 00
+ 00 jne $LN1@Write_Zip6
+
+; 1792 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
+
+ 0005b 50 push eax
+ 0005c 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0005f 6a 2d push 45 ; 0000002dH
+ 00061 50 push eax
+ 00062 e8 00 00 00 00 call _zip64local_putValue
+ 00067 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1793 :
+; 1794 : if (err==ZIP_OK) /* number of this disk */
+
+ 0006a 85 c0 test eax, eax
+ 0006c 0f 85 a1 00 00
+ 00 jne $LN1@Write_Zip6
+
+; 1795 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+ 00072 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00075 50 push eax
+ 00076 50 push eax
+ 00077 51 push ecx
+ 00078 8d 70 04 lea esi, DWORD PTR [eax+4]
+ 0007b e8 00 00 00 00 call _zip64local_putValue
+ 00080 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1796 :
+; 1797 : if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+
+ 00083 85 c0 test eax, eax
+ 00085 0f 85 88 00 00
+ 00 jne $LN1@Write_Zip6
+
+; 1798 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+ 0008b 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 0008e 50 push eax
+ 0008f 50 push eax
+ 00090 52 push edx
+ 00091 e8 00 00 00 00 call _zip64local_putValue
+ 00096 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1799 :
+; 1800 : if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+
+ 00099 85 c0 test eax, eax
+ 0009b 75 76 jne SHORT $LN1@Write_Zip6
+
+; 1801 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
+
+ 0009d 8b 87 fc 00 01
+ 00 mov eax, DWORD PTR [edi+65788]
+ 000a3 8b 8f f8 00 01
+ 00 mov ecx, DWORD PTR [edi+65784]
+ 000a9 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 000ac 50 push eax
+ 000ad 51 push ecx
+ 000ae 52 push edx
+ 000af be 08 00 00 00 mov esi, 8
+ 000b4 e8 00 00 00 00 call _zip64local_putValue
+ 000b9 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1802 :
+; 1803 : if (err==ZIP_OK) /* total number of entries in the central dir */
+
+ 000bc 85 c0 test eax, eax
+ 000be 75 53 jne SHORT $LN1@Write_Zip6
+
+; 1804 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
+
+ 000c0 8b 87 fc 00 01
+ 00 mov eax, DWORD PTR [edi+65788]
+ 000c6 8b 8f f8 00 01
+ 00 mov ecx, DWORD PTR [edi+65784]
+ 000cc 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 000cf 50 push eax
+ 000d0 51 push ecx
+ 000d1 52 push edx
+ 000d2 e8 00 00 00 00 call _zip64local_putValue
+ 000d7 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1805 :
+; 1806 : if (err==ZIP_OK) /* size of the central directory */
+
+ 000da 85 c0 test eax, eax
+ 000dc 75 35 jne SHORT $LN1@Write_Zip6
+
+; 1807 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8);
+
+ 000de 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 000e1 50 push eax
+ 000e2 8b 45 08 mov eax, DWORD PTR _size_centraldir$[ebp]
+ 000e5 50 push eax
+ 000e6 51 push ecx
+ 000e7 e8 00 00 00 00 call _zip64local_putValue
+ 000ec 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1808 :
+; 1809 : if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
+
+ 000ef 85 c0 test eax, eax
+ 000f1 75 20 jne SHORT $LN1@Write_Zip6
+
+; 1810 : {
+; 1811 : ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
+
+ 000f3 8b 45 0c mov eax, DWORD PTR _centraldir_pos_inzip$[ebp]
+ 000f6 2b 87 f0 00 01
+ 00 sub eax, DWORD PTR [edi+65776]
+ 000fc 8b 4d 10 mov ecx, DWORD PTR _centraldir_pos_inzip$[ebp+4]
+ 000ff 1b 8f f4 00 01
+ 00 sbb ecx, DWORD PTR [edi+65780]
+
+; 1812 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
+
+ 00105 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00108 51 push ecx
+ 00109 50 push eax
+ 0010a 52 push edx
+ 0010b e8 00 00 00 00 call _zip64local_putValue
+ 00110 83 c4 0c add esp, 12 ; 0000000cH
+$LN1@Write_Zip6:
+
+; 1813 : }
+; 1814 : return err;
+; 1815 : }
+
+ 00113 5f pop edi
+ 00114 5e pop esi
+ 00115 5d pop ebp
+ 00116 c3 ret 0
+_Write_Zip64EndOfCentralDirectoryRecord ENDP
+_TEXT ENDS
+PUBLIC _Write_Zip64EndOfCentralDirectoryLocator
+; Function compile flags: /Ogtp
+; COMDAT _Write_Zip64EndOfCentralDirectoryLocator
+_TEXT SEGMENT
+_pos$ = 8 ; size = 8
+_zip64eocd_pos_inzip$ = 8 ; size = 8
+_Write_Zip64EndOfCentralDirectoryLocator PROC ; COMDAT
+; _zi$ = eax
+
+; 1756 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 53 push ebx
+
+; 1757 : int err = ZIP_OK;
+; 1758 : ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset;
+
+ 00004 8b 5d 08 mov ebx, DWORD PTR _zip64eocd_pos_inzip$[ebp]
+ 00007 56 push esi
+ 00008 57 push edi
+ 00009 8b f8 mov edi, eax
+ 0000b 2b 9f f0 00 01
+ 00 sub ebx, DWORD PTR [edi+65776]
+ 00011 8b 45 0c mov eax, DWORD PTR _zip64eocd_pos_inzip$[ebp+4]
+ 00014 1b 87 f4 00 01
+ 00 sbb eax, DWORD PTR [edi+65780]
+
+; 1759 :
+; 1760 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);
+
+ 0001a 6a 00 push 0
+ 0001c 89 45 0c mov DWORD PTR _pos$[ebp+4], eax
+ 0001f 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00022 68 50 4b 06 07 push 117853008 ; 07064b50H
+ 00027 50 push eax
+ 00028 be 04 00 00 00 mov esi, 4
+ 0002d e8 00 00 00 00 call _zip64local_putValue
+ 00032 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1761 :
+; 1762 : /*num disks*/
+; 1763 : if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+
+ 00035 85 c0 test eax, eax
+ 00037 75 3e jne SHORT $LN1@Write_Zip6@2
+
+; 1764 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+ 00039 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 0003c 50 push eax
+ 0003d 50 push eax
+ 0003e 51 push ecx
+ 0003f e8 00 00 00 00 call _zip64local_putValue
+ 00044 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1765 :
+; 1766 : /*relative offset*/
+; 1767 : if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */
+
+ 00047 85 c0 test eax, eax
+ 00049 75 2c jne SHORT $LN1@Write_Zip6@2
+
+; 1768 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);
+
+ 0004b 8b 55 0c mov edx, DWORD PTR _pos$[ebp+4]
+ 0004e 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00051 52 push edx
+ 00052 53 push ebx
+ 00053 50 push eax
+ 00054 be 08 00 00 00 mov esi, 8
+ 00059 e8 00 00 00 00 call _zip64local_putValue
+ 0005e 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1769 :
+; 1770 : /*total disks*/ /* Do not support spawning of disk so always say 1 here*/
+; 1771 : if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+
+ 00061 85 c0 test eax, eax
+ 00063 75 12 jne SHORT $LN1@Write_Zip6@2
+
+; 1772 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);
+
+ 00065 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00068 50 push eax
+ 00069 6a 01 push 1
+ 0006b 51 push ecx
+ 0006c 8d 70 04 lea esi, DWORD PTR [eax+4]
+ 0006f e8 00 00 00 00 call _zip64local_putValue
+ 00074 83 c4 0c add esp, 12 ; 0000000cH
+$LN1@Write_Zip6@2:
+
+; 1773 :
+; 1774 : return err;
+; 1775 : }
+
+ 00077 5f pop edi
+ 00078 5e pop esi
+ 00079 5b pop ebx
+ 0007a 5d pop ebp
+ 0007b c3 ret 0
+_Write_Zip64EndOfCentralDirectoryLocator ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _zip64FlushWriteBuffer
+_TEXT SEGMENT
+tv232 = -16 ; size = 4
+_t$83568 = -12 ; size = 4
+_err$ = -8 ; size = 4
+tv222 = -4 ; size = 4
+_zip64FlushWriteBuffer PROC ; COMDAT
+; _zi$ = ebx
+
+; 1364 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 ec 10 sub esp, 16 ; 00000010H
+ 00006 56 push esi
+ 00007 57 push edi
+
+; 1365 : int err=ZIP_OK;
+
+ 00008 33 ff xor edi, edi
+ 0000a 89 7d f8 mov DWORD PTR _err$[ebp], edi
+
+; 1366 :
+; 1367 : if (zi->ci.encrypt != 0)
+
+ 0000d 39 bb ac 00 01
+ 00 cmp DWORD PTR [ebx+65708], edi
+ 00013 74 51 je SHORT $LN2@zip64Flush
+
+; 1368 : {
+; 1369 : #ifndef NOCRYPT
+; 1370 : uInt i;
+; 1371 : int t;
+; 1372 : for (i=0;i<zi->ci.pos_in_buffered_data;i++)
+
+ 00015 39 7b 7c cmp DWORD PTR [ebx+124], edi
+ 00018 76 4c jbe SHORT $LN2@zip64Flush
+ 0001a 8d 83 a4 00 00
+ 00 lea eax, DWORD PTR [ebx+164]
+ 00020 89 45 fc mov DWORD PTR tv222[ebp], eax
+ 00023 b8 5c ff ff ff mov eax, -164 ; ffffff5cH
+ 00028 2b c3 sub eax, ebx
+ 0002a 8d b3 d0 00 01
+ 00 lea esi, DWORD PTR [ebx+65744]
+ 00030 89 45 f0 mov DWORD PTR tv232[ebp], eax
+$LL10@zip64Flush:
+
+; 1373 : zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);
+
+ 00033 8b c6 mov eax, esi
+ 00035 e8 00 00 00 00 call _decrypt_byte
+ 0003a 8b 4d fc mov ecx, DWORD PTR tv222[ebp]
+ 0003d 8b bb dc 00 01
+ 00 mov edi, DWORD PTR [ebx+65756]
+ 00043 89 45 f4 mov DWORD PTR _t$83568[ebp], eax
+ 00046 0f b6 01 movzx eax, BYTE PTR [ecx]
+ 00049 e8 00 00 00 00 call _update_keys
+ 0004e 8b 45 fc mov eax, DWORD PTR tv222[ebp]
+ 00051 8a 55 f4 mov dl, BYTE PTR _t$83568[ebp]
+ 00054 30 10 xor BYTE PTR [eax], dl
+ 00056 8b 4d f0 mov ecx, DWORD PTR tv232[ebp]
+ 00059 40 inc eax
+ 0005a 03 c8 add ecx, eax
+ 0005c 89 45 fc mov DWORD PTR tv222[ebp], eax
+ 0005f 3b 4b 7c cmp ecx, DWORD PTR [ebx+124]
+ 00062 72 cf jb SHORT $LL10@zip64Flush
+
+; 1368 : {
+; 1369 : #ifndef NOCRYPT
+; 1370 : uInt i;
+; 1371 : int t;
+; 1372 : for (i=0;i<zi->ci.pos_in_buffered_data;i++)
+
+ 00064 33 ff xor edi, edi
+$LN2@zip64Flush:
+
+; 1374 : #endif
+; 1375 : }
+; 1376 :
+; 1377 : if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data)
+
+ 00066 8b 73 7c mov esi, DWORD PTR [ebx+124]
+ 00069 8b 4b 2c mov ecx, DWORD PTR [ebx+44]
+ 0006c 8b 53 1c mov edx, DWORD PTR [ebx+28]
+ 0006f 56 push esi
+ 00070 8d 83 a4 00 00
+ 00 lea eax, DWORD PTR [ebx+164]
+ 00076 50 push eax
+ 00077 8b 43 08 mov eax, DWORD PTR [ebx+8]
+ 0007a 51 push ecx
+ 0007b 52 push edx
+ 0007c ff d0 call eax
+ 0007e 83 c4 10 add esp, 16 ; 00000010H
+ 00081 3b c6 cmp eax, esi
+ 00083 74 07 je SHORT $LN1@zip64Flush
+
+; 1378 : err = ZIP_ERRNO;
+
+ 00085 c7 45 f8 ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+$LN1@zip64Flush:
+
+; 1379 :
+; 1380 : zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;
+
+ 0008c 01 b3 c0 00 01
+ 00 add DWORD PTR [ebx+65728], esi
+
+; 1381 :
+; 1382 : #ifdef HAVE_BZIP2
+; 1383 : if(zi->ci.method == Z_BZIP2ED)
+; 1384 : {
+; 1385 : zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32;
+; 1386 : zi->ci.bstream.total_in_lo32 = 0;
+; 1387 : zi->ci.bstream.total_in_hi32 = 0;
+; 1388 : }
+; 1389 : else
+; 1390 : #endif
+; 1391 : {
+; 1392 : zi->ci.totalUncompressedData += zi->ci.stream.total_in;
+
+ 00092 8b 4b 48 mov ecx, DWORD PTR [ebx+72]
+
+; 1393 : zi->ci.stream.total_in = 0;
+; 1394 : }
+; 1395 :
+; 1396 :
+; 1397 : zi->ci.pos_in_buffered_data = 0;
+; 1398 :
+; 1399 : return err;
+
+ 00095 8b 45 f8 mov eax, DWORD PTR _err$[ebp]
+ 00098 11 bb c4 00 01
+ 00 adc DWORD PTR [ebx+65732], edi
+ 0009e 01 8b c8 00 01
+ 00 add DWORD PTR [ebx+65736], ecx
+ 000a4 89 7b 48 mov DWORD PTR [ebx+72], edi
+ 000a7 89 7b 7c mov DWORD PTR [ebx+124], edi
+ 000aa 11 bb cc 00 01
+ 00 adc DWORD PTR [ebx+65740], edi
+ 000b0 5f pop edi
+ 000b1 5e pop esi
+
+; 1400 : }
+
+ 000b2 8b e5 mov esp, ebp
+ 000b4 5d pop ebp
+ 000b5 c3 ret 0
+_zip64FlushWriteBuffer ENDP
+_TEXT ENDS
+PUBLIC _Write_LocalFileHeader
+; Function compile flags: /Ogtp
+; COMDAT _Write_LocalFileHeader
+_TEXT SEGMENT
+_size_extrafield$ = -4 ; size = 4
+_filename$ = 8 ; size = 4
+_size_extrafield_local$ = 12 ; size = 4
+_extrafield_local$ = 16 ; size = 4
+_Write_LocalFileHeader PROC ; COMDAT
+; _zi$ = eax
+
+; 959 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 51 push ecx
+ 00004 53 push ebx
+ 00005 56 push esi
+ 00006 57 push edi
+ 00007 8b f8 mov edi, eax
+
+; 960 : /* write the local header */
+; 961 : int err;
+; 962 : uInt size_filename = (uInt)strlen(filename);
+
+ 00009 8b 45 08 mov eax, DWORD PTR _filename$[ebp]
+ 0000c 8d 48 01 lea ecx, DWORD PTR [eax+1]
+ 0000f 90 npad 1
+$LL26@Write_Loca:
+ 00010 8a 10 mov dl, BYTE PTR [eax]
+ 00012 40 inc eax
+ 00013 84 d2 test dl, dl
+ 00015 75 f9 jne SHORT $LL26@Write_Loca
+ 00017 2b c1 sub eax, ecx
+
+; 963 : uInt size_extrafield = size_extrafield_local;
+; 964 :
+; 965 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4);
+
+ 00019 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 0001c 6a 00 push 0
+ 0001e 8b d8 mov ebx, eax
+ 00020 8b 45 0c mov eax, DWORD PTR _size_extrafield_local$[ebp]
+ 00023 68 50 4b 03 04 push 67324752 ; 04034b50H
+ 00028 51 push ecx
+ 00029 be 04 00 00 00 mov esi, 4
+ 0002e 89 45 fc mov DWORD PTR _size_extrafield$[ebp], eax
+ 00031 e8 00 00 00 00 call _zip64local_putValue
+ 00036 83 c4 0c add esp, 12 ; 0000000cH
+
+; 966 :
+; 967 : if (err==ZIP_OK)
+
+ 00039 85 c0 test eax, eax
+ 0003b 0f 85 f1 00 00
+ 00 jne $LN8@Write_Loca
+
+; 968 : {
+; 969 : if(zi->ci.zip64)
+; 970 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */
+
+ 00041 50 push eax
+ 00042 8d 70 02 lea esi, DWORD PTR [eax+2]
+ 00045 39 87 b0 00 01
+ 00 cmp DWORD PTR [edi+65712], eax
+ 0004b 74 08 je SHORT $LN20@Write_Loca
+ 0004d 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00050 6a 2d push 45 ; 0000002dH
+ 00052 52 push edx
+
+; 971 : else
+
+ 00053 eb 06 jmp SHORT $LN34@Write_Loca
+$LN20@Write_Loca:
+
+; 972 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
+
+ 00055 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00058 6a 14 push 20 ; 00000014H
+ 0005a 50 push eax
+$LN34@Write_Loca:
+ 0005b e8 00 00 00 00 call _zip64local_putValue
+ 00060 83 c4 0c add esp, 12 ; 0000000cH
+
+; 973 : }
+; 974 :
+; 975 : if (err==ZIP_OK)
+
+ 00063 85 c0 test eax, eax
+ 00065 0f 85 c7 00 00
+ 00 jne $LN8@Write_Loca
+
+; 976 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
+
+ 0006b 8b 8f 98 00 00
+ 00 mov ecx, DWORD PTR [edi+152]
+ 00071 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00074 50 push eax
+ 00075 51 push ecx
+ 00076 52 push edx
+ 00077 8d 70 02 lea esi, DWORD PTR [eax+2]
+ 0007a e8 00 00 00 00 call _zip64local_putValue
+ 0007f 83 c4 0c add esp, 12 ; 0000000cH
+
+; 977 :
+; 978 : if (err==ZIP_OK)
+
+ 00082 85 c0 test eax, eax
+ 00084 0f 85 a8 00 00
+ 00 jne $LN8@Write_Loca
+
+; 979 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
+
+ 0008a 8b 87 9c 00 00
+ 00 mov eax, DWORD PTR [edi+156]
+ 00090 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00093 6a 00 push 0
+ 00095 50 push eax
+ 00096 51 push ecx
+ 00097 e8 00 00 00 00 call _zip64local_putValue
+ 0009c 83 c4 0c add esp, 12 ; 0000000cH
+
+; 980 :
+; 981 : if (err==ZIP_OK)
+
+ 0009f 85 c0 test eax, eax
+ 000a1 0f 85 8b 00 00
+ 00 jne $LN8@Write_Loca
+
+; 982 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
+
+ 000a7 8b 97 a4 00 01
+ 00 mov edx, DWORD PTR [edi+65700]
+ 000ad 50 push eax
+ 000ae 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 000b1 52 push edx
+ 000b2 50 push eax
+ 000b3 be 04 00 00 00 mov esi, 4
+ 000b8 e8 00 00 00 00 call _zip64local_putValue
+ 000bd 83 c4 0c add esp, 12 ; 0000000cH
+
+; 983 :
+; 984 : // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
+; 985 : if (err==ZIP_OK)
+
+ 000c0 85 c0 test eax, eax
+ 000c2 75 6e jne SHORT $LN8@Write_Loca
+
+; 986 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
+
+ 000c4 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 000c7 50 push eax
+ 000c8 50 push eax
+ 000c9 51 push ecx
+ 000ca e8 00 00 00 00 call _zip64local_putValue
+ 000cf 83 c4 0c add esp, 12 ; 0000000cH
+
+; 987 : if (err==ZIP_OK)
+
+ 000d2 85 c0 test eax, eax
+ 000d4 75 5c jne SHORT $LN8@Write_Loca
+
+; 988 : {
+; 989 : if(zi->ci.zip64)
+; 990 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */
+
+ 000d6 50 push eax
+ 000d7 39 87 b0 00 01
+ 00 cmp DWORD PTR [edi+65712], eax
+ 000dd 74 08 je SHORT $LN13@Write_Loca
+ 000df 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 000e2 6a ff push -1
+ 000e4 52 push edx
+
+; 991 : else
+
+ 000e5 eb 06 jmp SHORT $LN35@Write_Loca
+$LN13@Write_Loca:
+
+; 992 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
+
+ 000e7 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 000ea 6a 00 push 0
+ 000ec 50 push eax
+$LN35@Write_Loca:
+ 000ed e8 00 00 00 00 call _zip64local_putValue
+ 000f2 83 c4 0c add esp, 12 ; 0000000cH
+
+; 993 : }
+; 994 : if (err==ZIP_OK)
+
+ 000f5 85 c0 test eax, eax
+ 000f7 75 39 jne SHORT $LN8@Write_Loca
+
+; 995 : {
+; 996 : if(zi->ci.zip64)
+; 997 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */
+
+ 000f9 50 push eax
+ 000fa 8d 70 04 lea esi, DWORD PTR [eax+4]
+ 000fd 39 87 b0 00 01
+ 00 cmp DWORD PTR [edi+65712], eax
+ 00103 74 08 je SHORT $LN10@Write_Loca
+ 00105 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00108 6a ff push -1
+ 0010a 51 push ecx
+
+; 998 : else
+
+ 0010b eb 06 jmp SHORT $LN36@Write_Loca
+$LN10@Write_Loca:
+
+; 999 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
+
+ 0010d 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00110 6a 00 push 0
+ 00112 52 push edx
+$LN36@Write_Loca:
+ 00113 e8 00 00 00 00 call _zip64local_putValue
+ 00118 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1000 : }
+; 1001 :
+; 1002 : if (err==ZIP_OK)
+
+ 0011b 85 c0 test eax, eax
+ 0011d 75 13 jne SHORT $LN8@Write_Loca
+
+; 1003 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
+
+ 0011f 50 push eax
+ 00120 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00123 53 push ebx
+ 00124 50 push eax
+ 00125 be 02 00 00 00 mov esi, 2
+ 0012a e8 00 00 00 00 call _zip64local_putValue
+ 0012f 83 c4 0c add esp, 12 ; 0000000cH
+$LN8@Write_Loca:
+
+; 1004 :
+; 1005 : if(zi->ci.zip64)
+
+ 00132 83 bf b0 00 01
+ 00 00 cmp DWORD PTR [edi+65712], 0
+ 00139 74 08 je SHORT $LN31@Write_Loca
+
+; 1006 : {
+; 1007 : size_extrafield += 20;
+
+ 0013b 8b 4d 0c mov ecx, DWORD PTR _size_extrafield_local$[ebp]
+ 0013e 83 c1 14 add ecx, 20 ; 00000014H
+ 00141 eb 03 jmp SHORT $LN7@Write_Loca
+$LN31@Write_Loca:
+ 00143 8b 4d fc mov ecx, DWORD PTR _size_extrafield$[ebp]
+$LN7@Write_Loca:
+
+; 1008 : }
+; 1009 :
+; 1010 : if (err==ZIP_OK)
+
+ 00146 85 c0 test eax, eax
+ 00148 0f 85 cb 00 00
+ 00 jne $LN1@Write_Loca
+
+; 1011 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2);
+
+ 0014e 50 push eax
+ 0014f 51 push ecx
+ 00150 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00153 51 push ecx
+ 00154 8d 70 02 lea esi, DWORD PTR [eax+2]
+ 00157 e8 00 00 00 00 call _zip64local_putValue
+ 0015c 8b f0 mov esi, eax
+ 0015e 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1012 :
+; 1013 : if ((err==ZIP_OK) && (size_filename > 0))
+
+ 00161 85 f6 test esi, esi
+ 00163 0f 85 ae 00 00
+ 00 jne $LN28@Write_Loca
+ 00169 85 db test ebx, ebx
+ 0016b 74 23 je SHORT $LN24@Write_Loca
+
+; 1014 : {
+; 1015 : if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
+
+ 0016d 8b 55 08 mov edx, DWORD PTR _filename$[ebp]
+ 00170 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00173 8b 4f 1c mov ecx, DWORD PTR [edi+28]
+ 00176 53 push ebx
+ 00177 52 push edx
+ 00178 8b 57 08 mov edx, DWORD PTR [edi+8]
+ 0017b 50 push eax
+ 0017c 51 push ecx
+ 0017d ff d2 call edx
+ 0017f 83 c4 10 add esp, 16 ; 00000010H
+ 00182 3b c3 cmp eax, ebx
+ 00184 74 0a je SHORT $LN24@Write_Loca
+$LN37@Write_Loca:
+
+; 1016 : err = ZIP_ERRNO;
+
+ 00186 83 c8 ff or eax, -1
+
+; 1045 : }
+
+ 00189 5f pop edi
+ 0018a 5e pop esi
+ 0018b 5b pop ebx
+ 0018c 8b e5 mov esp, ebp
+ 0018e 5d pop ebp
+ 0018f c3 ret 0
+$LN24@Write_Loca:
+
+; 1017 : }
+; 1018 :
+; 1019 : if ((err==ZIP_OK) && (size_extrafield_local > 0))
+
+ 00190 8b 5d 0c mov ebx, DWORD PTR _size_extrafield_local$[ebp]
+ 00193 85 db test ebx, ebx
+ 00195 74 19 je SHORT $LN25@Write_Loca
+
+; 1020 : {
+; 1021 : if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)
+
+ 00197 8b 45 10 mov eax, DWORD PTR _extrafield_local$[ebp]
+ 0019a 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 0019d 8b 57 1c mov edx, DWORD PTR [edi+28]
+ 001a0 53 push ebx
+ 001a1 50 push eax
+ 001a2 8b 47 08 mov eax, DWORD PTR [edi+8]
+ 001a5 51 push ecx
+ 001a6 52 push edx
+ 001a7 ff d0 call eax
+ 001a9 83 c4 10 add esp, 16 ; 00000010H
+ 001ac 3b c3 cmp eax, ebx
+
+; 1022 : err = ZIP_ERRNO;
+; 1023 : }
+; 1024 :
+; 1025 :
+; 1026 : if ((err==ZIP_OK) && (zi->ci.zip64))
+
+ 001ae 75 d6 jne SHORT $LN37@Write_Loca
+$LN25@Write_Loca:
+ 001b0 83 bf b0 00 01
+ 00 00 cmp DWORD PTR [edi+65712], 0
+ 001b7 74 5e je SHORT $LN28@Write_Loca
+
+; 1027 : {
+; 1028 : // write the Zip64 extended info
+; 1029 : short HeaderID = 1;
+; 1030 : short DataSize = 16;
+; 1031 : ZPOS64_T CompressedSize = 0;
+; 1032 : ZPOS64_T UncompressedSize = 0;
+; 1033 :
+; 1034 : // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
+; 1035 : zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ 001b9 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 001bc 8b c7 mov eax, edi
+ 001be e8 00 00 00 00 call _call_ztell64
+
+; 1036 :
+; 1037 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2);
+
+ 001c3 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 001c6 6a 00 push 0
+ 001c8 6a 01 push 1
+ 001ca 51 push ecx
+ 001cb be 02 00 00 00 mov esi, 2
+ 001d0 89 87 b8 00 01
+ 00 mov DWORD PTR [edi+65720], eax
+ 001d6 89 97 bc 00 01
+ 00 mov DWORD PTR [edi+65724], edx
+ 001dc e8 00 00 00 00 call _zip64local_putValue
+
+; 1038 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2);
+
+ 001e1 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 001e4 6a 00 push 0
+ 001e6 6a 10 push 16 ; 00000010H
+ 001e8 52 push edx
+ 001e9 e8 00 00 00 00 call _zip64local_putValue
+
+; 1039 :
+; 1040 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
+
+ 001ee 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 001f1 6a 00 push 0
+ 001f3 6a 00 push 0
+ 001f5 50 push eax
+ 001f6 be 08 00 00 00 mov esi, 8
+ 001fb e8 00 00 00 00 call _zip64local_putValue
+
+; 1041 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
+
+ 00200 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00203 6a 00 push 0
+ 00205 6a 00 push 0
+ 00207 51 push ecx
+ 00208 e8 00 00 00 00 call _zip64local_putValue
+ 0020d 83 c4 30 add esp, 48 ; 00000030H
+
+; 1045 : }
+
+ 00210 5f pop edi
+ 00211 5e pop esi
+ 00212 5b pop ebx
+ 00213 8b e5 mov esp, ebp
+ 00215 5d pop ebp
+ 00216 c3 ret 0
+$LN28@Write_Loca:
+
+; 1042 : }
+; 1043 :
+; 1044 : return err;
+
+ 00217 8b c6 mov eax, esi
+$LN1@Write_Loca:
+
+; 1045 : }
+
+ 00219 5f pop edi
+ 0021a 5e pop esi
+ 0021b 5b pop ebx
+ 0021c 8b e5 mov esp, ebp
+ 0021e 5d pop ebp
+ 0021f c3 ret 0
+_Write_LocalFileHeader ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _zip64local_SearchCentralDir
+_TEXT SEGMENT
+_uSizeFile$ = -40 ; size = 8
+_uPosFound$ = -32 ; size = 8
+_uBackRead$ = -24 ; size = 8
+_uMaxBack$ = -16 ; size = 8
+_uReadSize$82954 = -8 ; size = 4
+_buf$ = -4 ; size = 4
+_pzlib_filefunc_def$ = 8 ; size = 4
+_filestream$ = 12 ; size = 4
+_zip64local_SearchCentralDir PROC ; COMDAT
+
+; 481 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 ec 2c sub esp, 44 ; 0000002cH
+ 00006 53 push ebx
+
+; 482 : unsigned char* buf;
+; 483 : ZPOS64_T uSizeFile;
+; 484 : ZPOS64_T uBackRead;
+; 485 : ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+; 486 : ZPOS64_T uPosFound=0;
+; 487 :
+; 488 : if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+
+ 00007 8b 5d 08 mov ebx, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 0000a 56 push esi
+ 0000b 8b 75 0c mov esi, DWORD PTR _filestream$[ebp]
+ 0000e 57 push edi
+ 0000f 33 ff xor edi, edi
+ 00011 57 push edi
+ 00012 57 push edi
+ 00013 8d 57 02 lea edx, DWORD PTR [edi+2]
+ 00016 8b c3 mov eax, ebx
+ 00018 c7 45 f0 ff ff
+ 00 00 mov DWORD PTR _uMaxBack$[ebp], 65535 ; 0000ffffH
+ 0001f 89 7d f4 mov DWORD PTR _uMaxBack$[ebp+4], edi
+ 00022 89 7d e0 mov DWORD PTR _uPosFound$[ebp], edi
+ 00025 89 7d e4 mov DWORD PTR _uPosFound$[ebp+4], edi
+ 00028 e8 00 00 00 00 call _call_zseek64
+ 0002d 83 c4 08 add esp, 8
+ 00030 85 c0 test eax, eax
+ 00032 74 0b je SHORT $LN14@zip64local@5
+$LN40@zip64local@5:
+
+; 489 : return 0;
+
+ 00034 33 c0 xor eax, eax
+ 00036 33 d2 xor edx, edx
+
+; 534 : }
+
+ 00038 5f pop edi
+ 00039 5e pop esi
+ 0003a 5b pop ebx
+ 0003b 8b e5 mov esp, ebp
+ 0003d 5d pop ebp
+ 0003e c3 ret 0
+$LN14@zip64local@5:
+
+; 490 :
+; 491 :
+; 492 : uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+ 0003f 8b ce mov ecx, esi
+ 00041 8b c3 mov eax, ebx
+ 00043 e8 00 00 00 00 call _call_ztell64
+ 00048 8b da mov ebx, edx
+ 0004a 8b f0 mov esi, eax
+ 0004c 89 75 d8 mov DWORD PTR _uSizeFile$[ebp], esi
+ 0004f 89 5d dc mov DWORD PTR _uSizeFile$[ebp+4], ebx
+
+; 493 :
+; 494 : if (uMaxBack>uSizeFile)
+
+ 00052 85 db test ebx, ebx
+ 00054 77 12 ja SHORT $LN13@zip64local@5
+ 00056 72 08 jb SHORT $LN27@zip64local@5
+ 00058 81 fe ff ff 00
+ 00 cmp esi, 65535 ; 0000ffffH
+ 0005e 73 08 jae SHORT $LN13@zip64local@5
+$LN27@zip64local@5:
+
+; 495 : uMaxBack = uSizeFile;
+
+ 00060 89 75 f0 mov DWORD PTR _uMaxBack$[ebp], esi
+ 00063 89 5d f4 mov DWORD PTR _uMaxBack$[ebp+4], ebx
+ 00066 8b fb mov edi, ebx
+$LN13@zip64local@5:
+
+; 496 :
+; 497 : buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+
+ 00068 68 04 04 00 00 push 1028 ; 00000404H
+ 0006d e8 00 00 00 00 call _malloc
+ 00072 83 c4 04 add esp, 4
+ 00075 89 45 fc mov DWORD PTR _buf$[ebp], eax
+
+; 498 : if (buf==NULL)
+
+ 00078 85 c0 test eax, eax
+
+; 499 : return 0;
+
+ 0007a 74 b8 je SHORT $LN40@zip64local@5
+
+; 500 :
+; 501 : uBackRead = 4;
+
+ 0007c 33 c9 xor ecx, ecx
+ 0007e ba 04 00 00 00 mov edx, 4
+
+; 502 : while (uBackRead<uMaxBack)
+
+ 00083 3b cf cmp ecx, edi
+ 00085 0f 87 03 01 00
+ 00 ja $LN31@zip64local@5
+ 0008b 8b 45 f0 mov eax, DWORD PTR _uMaxBack$[ebp]
+ 0008e 72 22 jb SHORT $LN11@zip64local@5
+ 00090 3b d0 cmp edx, eax
+ 00092 0f 83 f6 00 00
+ 00 jae $LN31@zip64local@5
+ 00098 eb 18 jmp SHORT $LN11@zip64local@5
+ 0009a 8d 9b 00 00 00
+ 00 npad 6
+$LL34@zip64local@5:
+ 000a0 8b 75 d8 mov esi, DWORD PTR _uSizeFile$[ebp]
+ 000a3 8b 7d f4 mov edi, DWORD PTR _uMaxBack$[ebp+4]
+ 000a6 8b 55 e8 mov edx, DWORD PTR _uBackRead$[ebp]
+ 000a9 8b 4d ec mov ecx, DWORD PTR _uBackRead$[ebp+4]
+ 000ac 8b 5d dc mov ebx, DWORD PTR _uSizeFile$[ebp+4]
+ 000af 8b 45 f0 mov eax, DWORD PTR _uMaxBack$[ebp]
+$LN11@zip64local@5:
+
+; 503 : {
+; 504 : uLong uReadSize;
+; 505 : ZPOS64_T uReadPos ;
+; 506 : int i;
+; 507 : if (uBackRead+BUFREADCOMMENT>uMaxBack)
+
+ 000b2 81 c2 00 04 00
+ 00 add edx, 1024 ; 00000400H
+ 000b8 83 d1 00 adc ecx, 0
+ 000bb 3b cf cmp ecx, edi
+ 000bd 72 0e jb SHORT $LN9@zip64local@5
+ 000bf 77 04 ja SHORT $LN29@zip64local@5
+ 000c1 3b d0 cmp edx, eax
+ 000c3 76 08 jbe SHORT $LN9@zip64local@5
+$LN29@zip64local@5:
+
+; 508 : uBackRead = uMaxBack;
+
+ 000c5 89 45 e8 mov DWORD PTR _uBackRead$[ebp], eax
+ 000c8 89 7d ec mov DWORD PTR _uBackRead$[ebp+4], edi
+
+; 509 : else
+
+ 000cb eb 06 jmp SHORT $LN8@zip64local@5
+$LN9@zip64local@5:
+
+; 510 : uBackRead+=BUFREADCOMMENT;
+
+ 000cd 89 55 e8 mov DWORD PTR _uBackRead$[ebp], edx
+ 000d0 89 4d ec mov DWORD PTR _uBackRead$[ebp+4], ecx
+$LN8@zip64local@5:
+
+; 511 : uReadPos = uSizeFile-uBackRead ;
+; 512 :
+; 513 : uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+; 514 : (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+
+ 000d3 8b 45 dc mov eax, DWORD PTR _uSizeFile$[ebp+4]
+ 000d6 8b fe mov edi, esi
+ 000d8 2b 7d e8 sub edi, DWORD PTR _uBackRead$[ebp]
+ 000db 8b ce mov ecx, esi
+ 000dd 1b 5d ec sbb ebx, DWORD PTR _uBackRead$[ebp+4]
+ 000e0 2b cf sub ecx, edi
+ 000e2 1b c3 sbb eax, ebx
+ 000e4 85 c0 test eax, eax
+ 000e6 72 13 jb SHORT $LN17@zip64local@5
+ 000e8 77 08 ja SHORT $LN30@zip64local@5
+ 000ea 81 f9 04 04 00
+ 00 cmp ecx, 1028 ; 00000404H
+ 000f0 76 09 jbe SHORT $LN17@zip64local@5
+$LN30@zip64local@5:
+ 000f2 c7 45 f8 04 04
+ 00 00 mov DWORD PTR _uReadSize$82954[ebp], 1028 ; 00000404H
+ 000f9 eb 05 jmp SHORT $LN18@zip64local@5
+$LN17@zip64local@5:
+ 000fb 2b f7 sub esi, edi
+ 000fd 89 75 f8 mov DWORD PTR _uReadSize$82954[ebp], esi
+$LN18@zip64local@5:
+
+; 515 : if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 00100 8b 75 0c mov esi, DWORD PTR _filestream$[ebp]
+ 00103 8b 45 08 mov eax, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 00106 53 push ebx
+ 00107 57 push edi
+ 00108 33 d2 xor edx, edx
+ 0010a e8 00 00 00 00 call _call_zseek64
+ 0010f 83 c4 08 add esp, 8
+ 00112 85 c0 test eax, eax
+ 00114 75 78 jne SHORT $LN31@zip64local@5
+
+; 516 : break;
+; 517 :
+; 518 : if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+
+ 00116 8b 75 f8 mov esi, DWORD PTR _uReadSize$82954[ebp]
+ 00119 8b 45 fc mov eax, DWORD PTR _buf$[ebp]
+ 0011c 8b 4d 0c mov ecx, DWORD PTR _filestream$[ebp]
+ 0011f 56 push esi
+ 00120 50 push eax
+ 00121 8b 45 08 mov eax, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 00124 8b 50 1c mov edx, DWORD PTR [eax+28]
+ 00127 8b 40 04 mov eax, DWORD PTR [eax+4]
+ 0012a 51 push ecx
+ 0012b 52 push edx
+ 0012c ff d0 call eax
+ 0012e 83 c4 10 add esp, 16 ; 00000010H
+ 00131 3b c6 cmp eax, esi
+ 00133 75 59 jne SHORT $LN31@zip64local@5
+
+; 519 : break;
+; 520 :
+; 521 : for (i=(int)uReadSize-3; (i--)>0;)
+
+ 00135 8d 46 fd lea eax, DWORD PTR [esi-3]
+ 00138 85 c0 test eax, eax
+ 0013a 7e 38 jle SHORT $LN26@zip64local@5
+ 0013c 8d 64 24 00 npad 4
+$LL5@zip64local@5:
+
+; 522 : if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+; 523 : ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+
+ 00140 8b 4d fc mov ecx, DWORD PTR _buf$[ebp]
+ 00143 48 dec eax
+ 00144 80 3c 08 50 cmp BYTE PTR [eax+ecx], 80 ; 00000050H
+ 00148 75 15 jne SHORT $LN3@zip64local@5
+ 0014a 80 7c 08 01 4b cmp BYTE PTR [eax+ecx+1], 75 ; 0000004bH
+ 0014f 75 0e jne SHORT $LN3@zip64local@5
+ 00151 80 7c 08 02 05 cmp BYTE PTR [eax+ecx+2], 5
+ 00156 75 07 jne SHORT $LN3@zip64local@5
+ 00158 80 7c 08 03 06 cmp BYTE PTR [eax+ecx+3], 6
+ 0015d 74 06 je SHORT $LN21@zip64local@5
+$LN3@zip64local@5:
+
+; 519 : break;
+; 520 :
+; 521 : for (i=(int)uReadSize-3; (i--)>0;)
+
+ 0015f 85 c0 test eax, eax
+ 00161 7f dd jg SHORT $LL5@zip64local@5
+
+; 526 : break;
+; 527 : }
+; 528 :
+; 529 : if (uPosFound!=0)
+
+ 00163 eb 0f jmp SHORT $LN26@zip64local@5
+$LN21@zip64local@5:
+
+; 524 : {
+; 525 : uPosFound = uReadPos+i;
+
+ 00165 99 cdq
+ 00166 03 c7 add eax, edi
+ 00168 13 d3 adc edx, ebx
+ 0016a 89 45 e0 mov DWORD PTR _uPosFound$[ebp], eax
+
+; 526 : break;
+; 527 : }
+; 528 :
+; 529 : if (uPosFound!=0)
+
+ 0016d 0b c2 or eax, edx
+ 0016f 89 55 e4 mov DWORD PTR _uPosFound$[ebp+4], edx
+ 00172 75 1a jne SHORT $LN31@zip64local@5
+$LN26@zip64local@5:
+
+; 502 : while (uBackRead<uMaxBack)
+
+ 00174 8b 4d f4 mov ecx, DWORD PTR _uMaxBack$[ebp+4]
+ 00177 39 4d ec cmp DWORD PTR _uBackRead$[ebp+4], ecx
+ 0017a 0f 82 20 ff ff
+ ff jb $LL34@zip64local@5
+ 00180 77 0c ja SHORT $LN31@zip64local@5
+ 00182 8b 55 f0 mov edx, DWORD PTR _uMaxBack$[ebp]
+ 00185 39 55 e8 cmp DWORD PTR _uBackRead$[ebp], edx
+ 00188 0f 82 12 ff ff
+ ff jb $LL34@zip64local@5
+$LN31@zip64local@5:
+
+; 530 : break;
+; 531 : }
+; 532 : TRYFREE(buf);
+
+ 0018e 8b 45 fc mov eax, DWORD PTR _buf$[ebp]
+ 00191 50 push eax
+ 00192 e8 00 00 00 00 call _free
+
+; 533 : return uPosFound;
+
+ 00197 8b 45 e0 mov eax, DWORD PTR _uPosFound$[ebp]
+ 0019a 8b 55 e4 mov edx, DWORD PTR _uPosFound$[ebp+4]
+ 0019d 83 c4 04 add esp, 4
+
+; 534 : }
+
+ 001a0 5f pop edi
+ 001a1 5e pop esi
+ 001a2 5b pop ebx
+ 001a3 8b e5 mov esp, ebp
+ 001a5 5d pop ebp
+ 001a6 c3 ret 0
+_zip64local_SearchCentralDir ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _zip64local_getLong64
+_TEXT SEGMENT
+_x$ = -16 ; size = 8
+_i$ = -4 ; size = 4
+_pX$ = 8 ; size = 4
+_zip64local_getLong64 PROC ; COMDAT
+; _pzlib_filefunc_def$ = ecx
+; _filestream$ = eax
+
+; 427 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 ec 10 sub esp, 16 ; 00000010H
+ 00006 53 push ebx
+ 00007 56 push esi
+ 00008 57 push edi
+ 00009 8b f8 mov edi, eax
+
+; 428 : ZPOS64_T x;
+; 429 : int i = 0;
+; 430 : int err;
+; 431 :
+; 432 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 0000b 8d 45 fc lea eax, DWORD PTR _i$[ebp]
+ 0000e 8b f1 mov esi, ecx
+ 00010 50 push eax
+ 00011 c7 45 fc 00 00
+ 00 00 mov DWORD PTR _i$[ebp], 0
+ 00018 e8 00 00 00 00 call _zip64local_getByte
+ 0001d 8b c8 mov ecx, eax
+
+; 433 : x = (ZPOS64_T)i;
+
+ 0001f 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 00022 99 cdq
+ 00023 83 c4 04 add esp, 4
+ 00026 8b d8 mov ebx, eax
+ 00028 89 55 f4 mov DWORD PTR _x$[ebp+4], edx
+
+; 434 :
+; 435 : if (err==ZIP_OK)
+
+ 0002b 85 c9 test ecx, ecx
+ 0002d 75 0e jne SHORT $LN9@zip64local@6
+
+; 436 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 0002f 8d 4d fc lea ecx, DWORD PTR _i$[ebp]
+ 00032 51 push ecx
+ 00033 e8 00 00 00 00 call _zip64local_getByte
+ 00038 83 c4 04 add esp, 4
+ 0003b 8b c8 mov ecx, eax
+$LN9@zip64local@6:
+
+; 437 : x += ((ZPOS64_T)i)<<8;
+
+ 0003d 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 00040 99 cdq
+ 00041 0f a4 c2 08 shld edx, eax, 8
+ 00045 c1 e0 08 shl eax, 8
+ 00048 03 d8 add ebx, eax
+ 0004a 11 55 f4 adc DWORD PTR _x$[ebp+4], edx
+
+; 438 :
+; 439 : if (err==ZIP_OK)
+
+ 0004d 85 c9 test ecx, ecx
+ 0004f 75 0e jne SHORT $LN8@zip64local@6
+
+; 440 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00051 8d 55 fc lea edx, DWORD PTR _i$[ebp]
+ 00054 52 push edx
+ 00055 e8 00 00 00 00 call _zip64local_getByte
+ 0005a 83 c4 04 add esp, 4
+ 0005d 8b c8 mov ecx, eax
+$LN8@zip64local@6:
+
+; 441 : x += ((ZPOS64_T)i)<<16;
+
+ 0005f 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 00062 99 cdq
+ 00063 0f a4 c2 10 shld edx, eax, 16
+ 00067 c1 e0 10 shl eax, 16 ; 00000010H
+ 0006a 03 d8 add ebx, eax
+ 0006c 11 55 f4 adc DWORD PTR _x$[ebp+4], edx
+
+; 442 :
+; 443 : if (err==ZIP_OK)
+
+ 0006f 85 c9 test ecx, ecx
+ 00071 75 0e jne SHORT $LN7@zip64local@6
+
+; 444 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00073 8d 45 fc lea eax, DWORD PTR _i$[ebp]
+ 00076 50 push eax
+ 00077 e8 00 00 00 00 call _zip64local_getByte
+ 0007c 83 c4 04 add esp, 4
+ 0007f 8b c8 mov ecx, eax
+$LN7@zip64local@6:
+
+; 445 : x += ((ZPOS64_T)i)<<24;
+
+ 00081 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 00084 99 cdq
+ 00085 0f a4 c2 18 shld edx, eax, 24
+ 00089 c1 e0 18 shl eax, 24 ; 00000018H
+ 0008c 03 d8 add ebx, eax
+ 0008e 11 55 f4 adc DWORD PTR _x$[ebp+4], edx
+
+; 446 :
+; 447 : if (err==ZIP_OK)
+
+ 00091 85 c9 test ecx, ecx
+ 00093 75 0e jne SHORT $LN6@zip64local@6
+
+; 448 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00095 8d 4d fc lea ecx, DWORD PTR _i$[ebp]
+ 00098 51 push ecx
+ 00099 e8 00 00 00 00 call _zip64local_getByte
+ 0009e 83 c4 04 add esp, 4
+ 000a1 8b c8 mov ecx, eax
+$LN6@zip64local@6:
+
+; 449 : x += ((ZPOS64_T)i)<<32;
+
+ 000a3 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 000a6 99 cdq
+ 000a7 83 c3 00 add ebx, 0
+ 000aa 11 45 f4 adc DWORD PTR _x$[ebp+4], eax
+
+; 450 :
+; 451 : if (err==ZIP_OK)
+
+ 000ad 85 c9 test ecx, ecx
+ 000af 75 0e jne SHORT $LN5@zip64local@6
+
+; 452 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 000b1 8d 55 fc lea edx, DWORD PTR _i$[ebp]
+ 000b4 52 push edx
+ 000b5 e8 00 00 00 00 call _zip64local_getByte
+ 000ba 83 c4 04 add esp, 4
+ 000bd 8b c8 mov ecx, eax
+$LN5@zip64local@6:
+
+; 453 : x += ((ZPOS64_T)i)<<40;
+
+ 000bf 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 000c2 99 cdq
+ 000c3 c1 e0 08 shl eax, 8
+ 000c6 83 c3 00 add ebx, 0
+ 000c9 11 45 f4 adc DWORD PTR _x$[ebp+4], eax
+
+; 454 :
+; 455 : if (err==ZIP_OK)
+
+ 000cc 85 c9 test ecx, ecx
+ 000ce 75 0e jne SHORT $LN4@zip64local@6
+
+; 456 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 000d0 8d 45 fc lea eax, DWORD PTR _i$[ebp]
+ 000d3 50 push eax
+ 000d4 e8 00 00 00 00 call _zip64local_getByte
+ 000d9 83 c4 04 add esp, 4
+ 000dc 8b c8 mov ecx, eax
+$LN4@zip64local@6:
+
+; 457 : x += ((ZPOS64_T)i)<<48;
+
+ 000de 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 000e1 99 cdq
+ 000e2 c1 e0 10 shl eax, 16 ; 00000010H
+ 000e5 83 c3 00 add ebx, 0
+ 000e8 11 45 f4 adc DWORD PTR _x$[ebp+4], eax
+
+; 458 :
+; 459 : if (err==ZIP_OK)
+
+ 000eb 85 c9 test ecx, ecx
+ 000ed 75 33 jne SHORT $LN2@zip64local@6
+
+; 460 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 000ef 8d 4d fc lea ecx, DWORD PTR _i$[ebp]
+ 000f2 51 push ecx
+ 000f3 e8 00 00 00 00 call _zip64local_getByte
+ 000f8 8b c8 mov ecx, eax
+ 000fa 83 c4 04 add esp, 4
+
+; 461 : x += ((ZPOS64_T)i)<<56;
+; 462 :
+; 463 : if (err==ZIP_OK)
+
+ 000fd 85 c9 test ecx, ecx
+ 000ff 75 21 jne SHORT $LN2@zip64local@6
+
+; 464 : *pX = x;
+
+ 00101 8b 45 fc mov eax, DWORD PTR _i$[ebp]
+ 00104 99 cdq
+ 00105 8b d0 mov edx, eax
+ 00107 8b 45 08 mov eax, DWORD PTR _pX$[ebp]
+ 0010a 33 f6 xor esi, esi
+ 0010c c1 e2 18 shl edx, 24 ; 00000018H
+ 0010f 03 f3 add esi, ebx
+ 00111 13 55 f4 adc edx, DWORD PTR _x$[ebp+4]
+ 00114 89 30 mov DWORD PTR [eax], esi
+ 00116 89 50 04 mov DWORD PTR [eax+4], edx
+
+; 467 :
+; 468 : return err;
+
+ 00119 8b c1 mov eax, ecx
+
+; 469 : }
+
+ 0011b 5f pop edi
+ 0011c 5e pop esi
+ 0011d 5b pop ebx
+ 0011e 8b e5 mov esp, ebp
+ 00120 5d pop ebp
+ 00121 c3 ret 0
+$LN2@zip64local@6:
+
+; 465 : else
+; 466 : *pX = 0;
+
+ 00122 8b 45 08 mov eax, DWORD PTR _pX$[ebp]
+
+; 469 : }
+
+ 00125 5f pop edi
+ 00126 5e pop esi
+ 00127 c7 00 00 00 00
+ 00 mov DWORD PTR [eax], 0
+ 0012d c7 40 04 00 00
+ 00 00 mov DWORD PTR [eax+4], 0
+ 00134 8b c1 mov eax, ecx
+ 00136 5b pop ebx
+ 00137 8b e5 mov esp, ebp
+ 00139 5d pop ebp
+ 0013a c3 ret 0
+_zip64local_getLong64 ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _zip64local_getLong
+_TEXT SEGMENT
+_i$ = -4 ; size = 4
+_pX$ = 8 ; size = 4
+_zip64local_getLong PROC ; COMDAT
+; _pzlib_filefunc_def$ = ecx
+; _filestream$ = eax
+
+; 396 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 51 push ecx
+ 00004 53 push ebx
+ 00005 56 push esi
+ 00006 57 push edi
+ 00007 8b f8 mov edi, eax
+
+; 397 : uLong x ;
+; 398 : int i = 0;
+; 399 : int err;
+; 400 :
+; 401 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00009 8d 45 fc lea eax, DWORD PTR _i$[ebp]
+ 0000c 8b f1 mov esi, ecx
+ 0000e 50 push eax
+ 0000f c7 45 fc 00 00
+ 00 00 mov DWORD PTR _i$[ebp], 0
+ 00016 e8 00 00 00 00 call _zip64local_getByte
+
+; 402 : x = (uLong)i;
+
+ 0001b 8b 4d fc mov ecx, DWORD PTR _i$[ebp]
+ 0001e 83 c4 04 add esp, 4
+ 00021 8b d9 mov ebx, ecx
+
+; 403 :
+; 404 : if (err==ZIP_OK)
+
+ 00023 85 c0 test eax, eax
+ 00025 75 0f jne SHORT $LN5@zip64local@7
+
+; 405 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00027 8d 4d fc lea ecx, DWORD PTR _i$[ebp]
+ 0002a 51 push ecx
+ 0002b e8 00 00 00 00 call _zip64local_getByte
+ 00030 8b 4d fc mov ecx, DWORD PTR _i$[ebp]
+ 00033 83 c4 04 add esp, 4
+$LN5@zip64local@7:
+
+; 406 : x += ((uLong)i)<<8;
+
+ 00036 8b d1 mov edx, ecx
+ 00038 c1 e2 08 shl edx, 8
+ 0003b 03 da add ebx, edx
+
+; 407 :
+; 408 : if (err==ZIP_OK)
+
+ 0003d 85 c0 test eax, eax
+ 0003f 75 0f jne SHORT $LN4@zip64local@7
+
+; 409 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00041 8d 45 fc lea eax, DWORD PTR _i$[ebp]
+ 00044 50 push eax
+ 00045 e8 00 00 00 00 call _zip64local_getByte
+ 0004a 8b 4d fc mov ecx, DWORD PTR _i$[ebp]
+ 0004d 83 c4 04 add esp, 4
+$LN4@zip64local@7:
+
+; 410 : x += ((uLong)i)<<16;
+
+ 00050 c1 e1 10 shl ecx, 16 ; 00000010H
+ 00053 03 d9 add ebx, ecx
+
+; 411 :
+; 412 : if (err==ZIP_OK)
+
+ 00055 85 c0 test eax, eax
+ 00057 75 24 jne SHORT $LN8@zip64local@7
+
+; 413 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00059 8d 4d fc lea ecx, DWORD PTR _i$[ebp]
+ 0005c 51 push ecx
+ 0005d e8 00 00 00 00 call _zip64local_getByte
+ 00062 83 c4 04 add esp, 4
+
+; 414 : x += ((uLong)i)<<24;
+; 415 :
+; 416 : if (err==ZIP_OK)
+
+ 00065 85 c0 test eax, eax
+ 00067 75 14 jne SHORT $LN8@zip64local@7
+
+; 417 : *pX = x;
+
+ 00069 8b 55 fc mov edx, DWORD PTR _i$[ebp]
+ 0006c 8b 4d 08 mov ecx, DWORD PTR _pX$[ebp]
+ 0006f 5f pop edi
+ 00070 c1 e2 18 shl edx, 24 ; 00000018H
+ 00073 03 d3 add edx, ebx
+ 00075 5e pop esi
+ 00076 89 11 mov DWORD PTR [ecx], edx
+ 00078 5b pop ebx
+
+; 420 : return err;
+; 421 : }
+
+ 00079 8b e5 mov esp, ebp
+ 0007b 5d pop ebp
+ 0007c c3 ret 0
+$LN8@zip64local@7:
+
+; 418 : else
+; 419 : *pX = 0;
+
+ 0007d 8b 55 08 mov edx, DWORD PTR _pX$[ebp]
+ 00080 5f pop edi
+ 00081 5e pop esi
+ 00082 c7 02 00 00 00
+ 00 mov DWORD PTR [edx], 0
+ 00088 5b pop ebx
+
+; 420 : return err;
+; 421 : }
+
+ 00089 8b e5 mov esp, ebp
+ 0008b 5d pop ebp
+ 0008c c3 ret 0
+_zip64local_getLong ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _zip64local_getShort
+_TEXT SEGMENT
+_i$ = -4 ; size = 4
+_pX$ = 8 ; size = 4
+_zip64local_getShort PROC ; COMDAT
+; _pzlib_filefunc_def$ = ecx
+; _filestream$ = eax
+
+; 374 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 51 push ecx
+ 00004 53 push ebx
+ 00005 56 push esi
+ 00006 57 push edi
+ 00007 8b f8 mov edi, eax
+
+; 375 : uLong x ;
+; 376 : int i = 0;
+; 377 : int err;
+; 378 :
+; 379 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00009 8d 45 fc lea eax, DWORD PTR _i$[ebp]
+ 0000c 8b f1 mov esi, ecx
+ 0000e 50 push eax
+ 0000f c7 45 fc 00 00
+ 00 00 mov DWORD PTR _i$[ebp], 0
+ 00016 e8 00 00 00 00 call _zip64local_getByte
+
+; 380 : x = (uLong)i;
+
+ 0001b 8b 5d fc mov ebx, DWORD PTR _i$[ebp]
+ 0001e 83 c4 04 add esp, 4
+
+; 381 :
+; 382 : if (err==ZIP_OK)
+
+ 00021 85 c0 test eax, eax
+ 00023 75 24 jne SHORT $LN6@zip64local@8
+
+; 383 : err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+
+ 00025 8d 4d fc lea ecx, DWORD PTR _i$[ebp]
+ 00028 51 push ecx
+ 00029 e8 00 00 00 00 call _zip64local_getByte
+ 0002e 83 c4 04 add esp, 4
+
+; 384 : x += ((uLong)i)<<8;
+; 385 :
+; 386 : if (err==ZIP_OK)
+
+ 00031 85 c0 test eax, eax
+ 00033 75 14 jne SHORT $LN6@zip64local@8
+
+; 387 : *pX = x;
+
+ 00035 8b 55 fc mov edx, DWORD PTR _i$[ebp]
+ 00038 8b 4d 08 mov ecx, DWORD PTR _pX$[ebp]
+ 0003b 5f pop edi
+ 0003c c1 e2 08 shl edx, 8
+ 0003f 03 d3 add edx, ebx
+ 00041 5e pop esi
+ 00042 89 11 mov DWORD PTR [ecx], edx
+ 00044 5b pop ebx
+
+; 390 : return err;
+; 391 : }
+
+ 00045 8b e5 mov esp, ebp
+ 00047 5d pop ebp
+ 00048 c3 ret 0
+$LN6@zip64local@8:
+
+; 388 : else
+; 389 : *pX = 0;
+
+ 00049 8b 55 08 mov edx, DWORD PTR _pX$[ebp]
+ 0004c 5f pop edi
+ 0004d 5e pop esi
+ 0004e c7 02 00 00 00
+ 00 mov DWORD PTR [edx], 0
+ 00054 5b pop ebx
+
+; 390 : return err;
+; 391 : }
+
+ 00055 8b e5 mov esp, ebp
+ 00057 5d pop ebp
+ 00058 c3 ret 0
+_zip64local_getShort ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _add_data_in_datablock
+_TEXT SEGMENT
+_from_copy$ = -4 ; size = 4
+_ll$ = 8 ; size = 4
+_buf$ = 12 ; size = 4
+_len$ = 16 ; size = 4
+_add_data_in_datablock PROC ; COMDAT
+
+; 226 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 51 push ecx
+ 00004 53 push ebx
+ 00005 8b 5d 08 mov ebx, DWORD PTR _ll$[ebp]
+ 00008 57 push edi
+ 00009 8b 7d 10 mov edi, DWORD PTR _len$[ebp]
+
+; 227 : linkedlist_datablock_internal* ldi;
+; 228 : const unsigned char* from_copy;
+; 229 :
+; 230 : if (ll==NULL)
+
+ 0000c 85 db test ebx, ebx
+ 0000e 75 0b jne SHORT $LN12@add_data_i
+$LN22@add_data_i:
+ 00010 5f pop edi
+
+; 231 : return ZIP_INTERNALERROR;
+
+ 00011 b8 98 ff ff ff mov eax, -104 ; ffffff98H
+ 00016 5b pop ebx
+
+; 274 : }
+
+ 00017 8b e5 mov esp, ebp
+ 00019 5d pop ebp
+ 0001a c3 ret 0
+$LN12@add_data_i:
+
+; 232 :
+; 233 : if (ll->last_block == NULL)
+
+ 0001b 83 7b 04 00 cmp DWORD PTR [ebx+4], 0
+ 0001f 75 0e jne SHORT $LN10@add_data_i
+
+; 234 : {
+; 235 : ll->first_block = ll->last_block = allocate_new_datablock();
+
+ 00021 e8 00 00 00 00 call _allocate_new_datablock
+ 00026 89 43 04 mov DWORD PTR [ebx+4], eax
+ 00029 89 03 mov DWORD PTR [ebx], eax
+
+; 236 : if (ll->first_block == NULL)
+
+ 0002b 85 c0 test eax, eax
+
+; 237 : return ZIP_INTERNALERROR;
+
+ 0002d 74 e1 je SHORT $LN22@add_data_i
+$LN10@add_data_i:
+
+; 238 : }
+; 239 :
+; 240 : ldi = ll->last_block;
+; 241 : from_copy = (unsigned char*)buf;
+
+ 0002f 8b 45 0c mov eax, DWORD PTR _buf$[ebp]
+ 00032 56 push esi
+ 00033 8b 73 04 mov esi, DWORD PTR [ebx+4]
+ 00036 89 45 fc mov DWORD PTR _from_copy$[ebp], eax
+
+; 242 :
+; 243 : while (len>0)
+
+ 00039 85 ff test edi, edi
+ 0003b 74 53 je SHORT $LN8@add_data_i
+ 0003d 8d 49 00 npad 3
+$LL9@add_data_i:
+
+; 244 : {
+; 245 : uInt copy_this;
+; 246 : uInt i;
+; 247 : unsigned char* to_copy;
+; 248 :
+; 249 : if (ldi->avail_in_this_block==0)
+
+ 00040 83 7e 04 00 cmp DWORD PTR [esi+4], 0
+ 00044 75 10 jne SHORT $LN7@add_data_i
+
+; 250 : {
+; 251 : ldi->next_datablock = allocate_new_datablock();
+
+ 00046 e8 00 00 00 00 call _allocate_new_datablock
+ 0004b 89 06 mov DWORD PTR [esi], eax
+
+; 252 : if (ldi->next_datablock == NULL)
+
+ 0004d 85 c0 test eax, eax
+ 0004f 74 48 je SHORT $LN17@add_data_i
+
+; 254 : ldi = ldi->next_datablock ;
+
+ 00051 8b f0 mov esi, eax
+
+; 255 : ll->last_block = ldi;
+
+ 00053 89 73 04 mov DWORD PTR [ebx+4], esi
+$LN7@add_data_i:
+
+; 256 : }
+; 257 :
+; 258 : if (ldi->avail_in_this_block < len)
+
+ 00056 8b 4e 04 mov ecx, DWORD PTR [esi+4]
+ 00059 3b cf cmp ecx, edi
+
+; 259 : copy_this = (uInt)ldi->avail_in_this_block;
+; 260 : else
+
+ 0005b 72 02 jb SHORT $LN4@add_data_i
+
+; 261 : copy_this = (uInt)len;
+
+ 0005d 8b cf mov ecx, edi
+$LN4@add_data_i:
+
+; 262 :
+; 263 : to_copy = &(ldi->data[ldi->filled_in_this_block]);
+
+ 0005f 8b 56 08 mov edx, DWORD PTR [esi+8]
+ 00062 8d 44 32 10 lea eax, DWORD PTR [edx+esi+16]
+
+; 264 :
+; 265 : for (i=0;i<copy_this;i++)
+
+ 00066 85 c9 test ecx, ecx
+ 00068 74 16 je SHORT $LN1@add_data_i
+ 0006a 8b 7d fc mov edi, DWORD PTR _from_copy$[ebp]
+ 0006d 2b f8 sub edi, eax
+ 0006f 8b d1 mov edx, ecx
+$LL3@add_data_i:
+
+; 266 : *(to_copy+i)=*(from_copy+i);
+
+ 00071 8a 1c 07 mov bl, BYTE PTR [edi+eax]
+ 00074 88 18 mov BYTE PTR [eax], bl
+ 00076 40 inc eax
+ 00077 4a dec edx
+ 00078 75 f7 jne SHORT $LL3@add_data_i
+
+; 264 :
+; 265 : for (i=0;i<copy_this;i++)
+
+ 0007a 8b 5d 08 mov ebx, DWORD PTR _ll$[ebp]
+ 0007d 8b 7d 10 mov edi, DWORD PTR _len$[ebp]
+$LN1@add_data_i:
+
+; 267 :
+; 268 : ldi->filled_in_this_block += copy_this;
+
+ 00080 01 4e 08 add DWORD PTR [esi+8], ecx
+
+; 269 : ldi->avail_in_this_block -= copy_this;
+
+ 00083 29 4e 04 sub DWORD PTR [esi+4], ecx
+
+; 270 : from_copy += copy_this ;
+
+ 00086 01 4d fc add DWORD PTR _from_copy$[ebp], ecx
+
+; 271 : len -= copy_this;
+
+ 00089 2b f9 sub edi, ecx
+ 0008b 89 7d 10 mov DWORD PTR _len$[ebp], edi
+ 0008e 75 b0 jne SHORT $LL9@add_data_i
+$LN8@add_data_i:
+ 00090 5e pop esi
+ 00091 5f pop edi
+
+; 272 : }
+; 273 : return ZIP_OK;
+
+ 00092 33 c0 xor eax, eax
+ 00094 5b pop ebx
+
+; 274 : }
+
+ 00095 8b e5 mov esp, ebp
+ 00097 5d pop ebp
+ 00098 c3 ret 0
+$LN17@add_data_i:
+ 00099 5e pop esi
+ 0009a 5f pop edi
+
+; 253 : return ZIP_INTERNALERROR;
+
+ 0009b b8 98 ff ff ff mov eax, -104 ; ffffff98H
+ 000a0 5b pop ebx
+
+; 274 : }
+
+ 000a1 8b e5 mov esp, ebp
+ 000a3 5d pop ebp
+ 000a4 c3 ret 0
+_add_data_in_datablock ENDP
+; Function compile flags: /Ogtp
+_TEXT ENDS
+; COMDAT _free_linkedlist
+_TEXT SEGMENT
+_free_linkedlist PROC ; COMDAT
+; _ll$ = esi
+
+; 220 : free_datablock(ll->first_block);
+
+ 00000 8b 06 mov eax, DWORD PTR [esi]
+ 00002 e8 00 00 00 00 call _free_datablock
+
+; 221 : ll->first_block = ll->last_block = NULL;
+
+ 00007 c7 46 04 00 00
+ 00 00 mov DWORD PTR [esi+4], 0
+ 0000e c7 06 00 00 00
+ 00 mov DWORD PTR [esi], 0
+
+; 222 : }
+
+ 00014 c3 ret 0
+_free_linkedlist ENDP
+; Function compile flags: /Ogtp
+; File c:\documents and settings\yyagi\my documents\visual studio 2010\projects\dtxmania\branches\111222(dtxviewer023 with #26977)\@libpng\83\\83\8a\83\85\81[\83V\83\87\83\93\zlib-1.2.8\contrib\minizip\crypt.h
+_TEXT ENDS
+; COMDAT _init_keys
+_TEXT SEGMENT
+_init_keys PROC ; COMDAT
+; _passwd$ = edx
+; _pkeys$ = ecx
+; _pcrc_32_tab$ = eax
+
+; 66 : {
+
+ 00000 53 push ebx
+ 00001 56 push esi
+ 00002 8b f1 mov esi, ecx
+ 00004 57 push edi
+ 00005 8b da mov ebx, edx
+ 00007 8b f8 mov edi, eax
+
+; 67 : *(pkeys+0) = 305419896L;
+
+ 00009 c7 06 78 56 34
+ 12 mov DWORD PTR [esi], 305419896 ; 12345678H
+
+; 68 : *(pkeys+1) = 591751049L;
+
+ 0000f c7 46 04 89 67
+ 45 23 mov DWORD PTR [esi+4], 591751049 ; 23456789H
+
+; 69 : *(pkeys+2) = 878082192L;
+
+ 00016 c7 46 08 90 78
+ 56 34 mov DWORD PTR [esi+8], 878082192 ; 34567890H
+
+; 70 : while (*passwd != '\0') {
+
+ 0001d 8a 03 mov al, BYTE PTR [ebx]
+ 0001f 84 c0 test al, al
+ 00021 74 10 je SHORT $LN1@init_keys
+$LL2@init_keys:
+
+; 71 : update_keys(pkeys,pcrc_32_tab,(int)*passwd);
+
+ 00023 0f be c0 movsx eax, al
+ 00026 e8 00 00 00 00 call _update_keys
+ 0002b 8a 43 01 mov al, BYTE PTR [ebx+1]
+
+; 72 : passwd++;
+
+ 0002e 43 inc ebx
+ 0002f 84 c0 test al, al
+ 00031 75 f0 jne SHORT $LL2@init_keys
+$LN1@init_keys:
+ 00033 5f pop edi
+ 00034 5e pop esi
+ 00035 5b pop ebx
+
+; 73 : }
+; 74 : }
+
+ 00036 c3 ret 0
+_init_keys ENDP
+; Function compile flags: /Ogtp
+; File c:\documents and settings\yyagi\my documents\visual studio 2010\projects\dtxmania\branches\111222(dtxviewer023 with #26977)\@libpng\83\\83\8a\83\85\81[\83V\83\87\83\93\zlib-1.2.8\contrib\minizip\zip.c
+; COMDAT _zip64local_SearchCentralDir64
+_TEXT SEGMENT
+_relativeOffset$ = -40 ; size = 8
+_uSizeFile$ = -40 ; size = 8
+_uPosFound$ = -32 ; size = 8
+_uBackRead$ = -24 ; size = 8
+_uMaxBack$ = -16 ; size = 8
+_uReadSize$82994 = -8 ; size = 4
+_uL$ = -4 ; size = 4
+_buf$ = -4 ; size = 4
+_pzlib_filefunc_def$ = 8 ; size = 4
+_filestream$ = 12 ; size = 4
+_zip64local_SearchCentralDir64 PROC ; COMDAT
+
+; 543 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 ec 2c sub esp, 44 ; 0000002cH
+
+; 544 : unsigned char* buf;
+; 545 : ZPOS64_T uSizeFile;
+; 546 : ZPOS64_T uBackRead;
+; 547 : ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+; 548 : ZPOS64_T uPosFound=0;
+; 549 : uLong uL;
+; 550 : ZPOS64_T relativeOffset;
+; 551 :
+; 552 : if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+
+ 00006 8b 45 08 mov eax, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 00009 53 push ebx
+ 0000a 8b 5d 0c mov ebx, DWORD PTR _filestream$[ebp]
+ 0000d 56 push esi
+ 0000e 57 push edi
+ 0000f 33 ff xor edi, edi
+ 00011 57 push edi
+ 00012 57 push edi
+ 00013 8d 57 02 lea edx, DWORD PTR [edi+2]
+ 00016 8b f3 mov esi, ebx
+ 00018 c7 45 f0 ff ff
+ 00 00 mov DWORD PTR _uMaxBack$[ebp], 65535 ; 0000ffffH
+ 0001f 89 7d f4 mov DWORD PTR _uMaxBack$[ebp+4], edi
+ 00022 89 7d e0 mov DWORD PTR _uPosFound$[ebp], edi
+ 00025 89 7d e4 mov DWORD PTR _uPosFound$[ebp+4], edi
+ 00028 e8 00 00 00 00 call _call_zseek64
+ 0002d 83 c4 08 add esp, 8
+ 00030 85 c0 test eax, eax
+ 00032 74 0b je SHORT $LN25@zip64local@9
+$LN50@zip64local@9:
+
+; 553 : return 0;
+
+ 00034 33 c0 xor eax, eax
+ 00036 33 d2 xor edx, edx
+
+; 638 : }
+
+ 00038 5f pop edi
+ 00039 5e pop esi
+ 0003a 5b pop ebx
+ 0003b 8b e5 mov esp, ebp
+ 0003d 5d pop ebp
+ 0003e c3 ret 0
+$LN25@zip64local@9:
+
+; 554 :
+; 555 : uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+ 0003f 8b 45 08 mov eax, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 00042 8b cb mov ecx, ebx
+ 00044 e8 00 00 00 00 call _call_ztell64
+ 00049 8b f0 mov esi, eax
+ 0004b 89 75 d8 mov DWORD PTR _uSizeFile$[ebp], esi
+ 0004e 89 55 dc mov DWORD PTR _uSizeFile$[ebp+4], edx
+
+; 556 :
+; 557 : if (uMaxBack>uSizeFile)
+
+ 00051 85 d2 test edx, edx
+ 00053 77 12 ja SHORT $LN24@zip64local@9
+ 00055 72 08 jb SHORT $LN38@zip64local@9
+ 00057 81 fe ff ff 00
+ 00 cmp esi, 65535 ; 0000ffffH
+ 0005d 73 08 jae SHORT $LN24@zip64local@9
+$LN38@zip64local@9:
+
+; 558 : uMaxBack = uSizeFile;
+
+ 0005f 89 75 f0 mov DWORD PTR _uMaxBack$[ebp], esi
+ 00062 89 55 f4 mov DWORD PTR _uMaxBack$[ebp+4], edx
+ 00065 8b fa mov edi, edx
+$LN24@zip64local@9:
+
+; 559 :
+; 560 : buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+
+ 00067 68 04 04 00 00 push 1028 ; 00000404H
+ 0006c e8 00 00 00 00 call _malloc
+ 00071 83 c4 04 add esp, 4
+ 00074 89 45 fc mov DWORD PTR _buf$[ebp], eax
+
+; 561 : if (buf==NULL)
+
+ 00077 85 c0 test eax, eax
+
+; 562 : return 0;
+
+ 00079 74 b9 je SHORT $LN50@zip64local@9
+
+; 563 :
+; 564 : uBackRead = 4;
+
+ 0007b 33 c9 xor ecx, ecx
+ 0007d ba 04 00 00 00 mov edx, 4
+
+; 565 : while (uBackRead<uMaxBack)
+
+ 00082 3b cf cmp ecx, edi
+ 00084 0f 87 07 01 00
+ 00 ja $LN42@zip64local@9
+ 0008a 8b 45 f0 mov eax, DWORD PTR _uMaxBack$[ebp]
+ 0008d 72 20 jb SHORT $LN22@zip64local@9
+ 0008f 3b d0 cmp edx, eax
+ 00091 0f 83 fa 00 00
+ 00 jae $LN42@zip64local@9
+ 00097 eb 16 jmp SHORT $LN22@zip64local@9
+ 00099 8d a4 24 00 00
+ 00 00 npad 7
+$LL45@zip64local@9:
+ 000a0 8b 75 d8 mov esi, DWORD PTR _uSizeFile$[ebp]
+ 000a3 8b 7d f4 mov edi, DWORD PTR _uMaxBack$[ebp+4]
+ 000a6 8b 55 e8 mov edx, DWORD PTR _uBackRead$[ebp]
+ 000a9 8b 4d ec mov ecx, DWORD PTR _uBackRead$[ebp+4]
+ 000ac 8b 45 f0 mov eax, DWORD PTR _uMaxBack$[ebp]
+$LN22@zip64local@9:
+
+; 566 : {
+; 567 : uLong uReadSize;
+; 568 : ZPOS64_T uReadPos;
+; 569 : int i;
+; 570 : if (uBackRead+BUFREADCOMMENT>uMaxBack)
+
+ 000af 81 c2 00 04 00
+ 00 add edx, 1024 ; 00000400H
+ 000b5 83 d1 00 adc ecx, 0
+ 000b8 3b cf cmp ecx, edi
+ 000ba 72 0e jb SHORT $LN20@zip64local@9
+ 000bc 77 04 ja SHORT $LN40@zip64local@9
+ 000be 3b d0 cmp edx, eax
+ 000c0 76 08 jbe SHORT $LN20@zip64local@9
+$LN40@zip64local@9:
+
+; 571 : uBackRead = uMaxBack;
+
+ 000c2 89 45 e8 mov DWORD PTR _uBackRead$[ebp], eax
+ 000c5 89 7d ec mov DWORD PTR _uBackRead$[ebp+4], edi
+
+; 572 : else
+
+ 000c8 eb 06 jmp SHORT $LN19@zip64local@9
+$LN20@zip64local@9:
+
+; 573 : uBackRead+=BUFREADCOMMENT;
+
+ 000ca 89 55 e8 mov DWORD PTR _uBackRead$[ebp], edx
+ 000cd 89 4d ec mov DWORD PTR _uBackRead$[ebp+4], ecx
+$LN19@zip64local@9:
+
+; 574 : uReadPos = uSizeFile-uBackRead ;
+
+ 000d0 8b 5d dc mov ebx, DWORD PTR _uSizeFile$[ebp+4]
+
+; 575 :
+; 576 : uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+; 577 : (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+
+ 000d3 8b 45 dc mov eax, DWORD PTR _uSizeFile$[ebp+4]
+ 000d6 8b fe mov edi, esi
+ 000d8 2b 7d e8 sub edi, DWORD PTR _uBackRead$[ebp]
+ 000db 8b ce mov ecx, esi
+ 000dd 1b 5d ec sbb ebx, DWORD PTR _uBackRead$[ebp+4]
+ 000e0 2b cf sub ecx, edi
+ 000e2 1b c3 sbb eax, ebx
+ 000e4 85 c0 test eax, eax
+ 000e6 72 13 jb SHORT $LN28@zip64local@9
+ 000e8 77 08 ja SHORT $LN41@zip64local@9
+ 000ea 81 f9 04 04 00
+ 00 cmp ecx, 1028 ; 00000404H
+ 000f0 76 09 jbe SHORT $LN28@zip64local@9
+$LN41@zip64local@9:
+ 000f2 c7 45 f8 04 04
+ 00 00 mov DWORD PTR _uReadSize$82994[ebp], 1028 ; 00000404H
+ 000f9 eb 05 jmp SHORT $LN29@zip64local@9
+$LN28@zip64local@9:
+ 000fb 2b f7 sub esi, edi
+ 000fd 89 75 f8 mov DWORD PTR _uReadSize$82994[ebp], esi
+$LN29@zip64local@9:
+
+; 578 : if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 00100 8b 75 0c mov esi, DWORD PTR _filestream$[ebp]
+ 00103 8b 45 08 mov eax, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 00106 53 push ebx
+ 00107 57 push edi
+ 00108 33 d2 xor edx, edx
+ 0010a e8 00 00 00 00 call _call_zseek64
+ 0010f 83 c4 08 add esp, 8
+ 00112 85 c0 test eax, eax
+ 00114 75 78 jne SHORT $LN46@zip64local@9
+
+; 579 : break;
+; 580 :
+; 581 : if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+
+ 00116 8b 75 f8 mov esi, DWORD PTR _uReadSize$82994[ebp]
+ 00119 8b 45 fc mov eax, DWORD PTR _buf$[ebp]
+ 0011c 8b 4d 0c mov ecx, DWORD PTR _filestream$[ebp]
+ 0011f 56 push esi
+ 00120 50 push eax
+ 00121 8b 45 08 mov eax, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 00124 8b 50 1c mov edx, DWORD PTR [eax+28]
+ 00127 8b 40 04 mov eax, DWORD PTR [eax+4]
+ 0012a 51 push ecx
+ 0012b 52 push edx
+ 0012c ff d0 call eax
+ 0012e 83 c4 10 add esp, 16 ; 00000010H
+ 00131 3b c6 cmp eax, esi
+ 00133 75 59 jne SHORT $LN46@zip64local@9
+
+; 582 : break;
+; 583 :
+; 584 : for (i=(int)uReadSize-3; (i--)>0;)
+
+ 00135 8d 46 fd lea eax, DWORD PTR [esi-3]
+ 00138 85 c0 test eax, eax
+ 0013a 7e 38 jle SHORT $LN37@zip64local@9
+ 0013c 8d 64 24 00 npad 4
+$LL16@zip64local@9:
+
+; 585 : {
+; 586 : // Signature "0x07064b50" Zip64 end of central directory locater
+; 587 : if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
+
+ 00140 8b 4d fc mov ecx, DWORD PTR _buf$[ebp]
+ 00143 48 dec eax
+ 00144 80 3c 08 50 cmp BYTE PTR [eax+ecx], 80 ; 00000050H
+ 00148 75 15 jne SHORT $LN14@zip64local@9
+ 0014a 80 7c 08 01 4b cmp BYTE PTR [eax+ecx+1], 75 ; 0000004bH
+ 0014f 75 0e jne SHORT $LN14@zip64local@9
+ 00151 80 7c 08 02 06 cmp BYTE PTR [eax+ecx+2], 6
+ 00156 75 07 jne SHORT $LN14@zip64local@9
+ 00158 80 7c 08 03 07 cmp BYTE PTR [eax+ecx+3], 7
+ 0015d 74 06 je SHORT $LN32@zip64local@9
+$LN14@zip64local@9:
+
+; 582 : break;
+; 583 :
+; 584 : for (i=(int)uReadSize-3; (i--)>0;)
+
+ 0015f 85 c0 test eax, eax
+ 00161 7f dd jg SHORT $LL16@zip64local@9
+
+; 590 : break;
+; 591 : }
+; 592 : }
+; 593 :
+; 594 : if (uPosFound!=0)
+
+ 00163 eb 0f jmp SHORT $LN37@zip64local@9
+$LN32@zip64local@9:
+
+; 588 : {
+; 589 : uPosFound = uReadPos+i;
+
+ 00165 99 cdq
+ 00166 03 c7 add eax, edi
+ 00168 13 d3 adc edx, ebx
+ 0016a 89 45 e0 mov DWORD PTR _uPosFound$[ebp], eax
+
+; 590 : break;
+; 591 : }
+; 592 : }
+; 593 :
+; 594 : if (uPosFound!=0)
+
+ 0016d 0b c2 or eax, edx
+ 0016f 89 55 e4 mov DWORD PTR _uPosFound$[ebp+4], edx
+ 00172 75 1a jne SHORT $LN46@zip64local@9
+$LN37@zip64local@9:
+
+; 565 : while (uBackRead<uMaxBack)
+
+ 00174 8b 4d f4 mov ecx, DWORD PTR _uMaxBack$[ebp+4]
+ 00177 39 4d ec cmp DWORD PTR _uBackRead$[ebp+4], ecx
+ 0017a 0f 82 20 ff ff
+ ff jb $LL45@zip64local@9
+ 00180 77 0c ja SHORT $LN46@zip64local@9
+ 00182 8b 55 f0 mov edx, DWORD PTR _uMaxBack$[ebp]
+ 00185 39 55 e8 cmp DWORD PTR _uBackRead$[ebp], edx
+ 00188 0f 82 12 ff ff
+ ff jb $LL45@zip64local@9
+$LN46@zip64local@9:
+ 0018e 8b 5d 0c mov ebx, DWORD PTR _filestream$[ebp]
+$LN42@zip64local@9:
+
+; 595 : break;
+; 596 : }
+; 597 :
+; 598 : TRYFREE(buf);
+
+ 00191 8b 45 fc mov eax, DWORD PTR _buf$[ebp]
+ 00194 50 push eax
+ 00195 e8 00 00 00 00 call _free
+
+; 599 : if (uPosFound == 0)
+
+ 0019a 8b 45 e0 mov eax, DWORD PTR _uPosFound$[ebp]
+ 0019d 8b 4d e4 mov ecx, DWORD PTR _uPosFound$[ebp+4]
+ 001a0 8b d0 mov edx, eax
+ 001a2 83 c4 04 add esp, 4
+ 001a5 0b d1 or edx, ecx
+
+; 600 : return 0;
+
+ 001a7 0f 84 87 fe ff
+ ff je $LN50@zip64local@9
+
+; 601 :
+; 602 : /* Zip64 end of central directory locator */
+; 603 : if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 001ad 8b 7d 08 mov edi, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 001b0 51 push ecx
+ 001b1 50 push eax
+ 001b2 33 d2 xor edx, edx
+ 001b4 8b f3 mov esi, ebx
+ 001b6 8b c7 mov eax, edi
+ 001b8 e8 00 00 00 00 call _call_zseek64
+ 001bd 83 c4 08 add esp, 8
+ 001c0 85 c0 test eax, eax
+
+; 604 : return 0;
+
+ 001c2 0f 85 6c fe ff
+ ff jne $LN50@zip64local@9
+
+; 605 :
+; 606 : /* the signature, already checked */
+; 607 : if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+
+ 001c8 8d 45 fc lea eax, DWORD PTR _uL$[ebp]
+ 001cb 50 push eax
+ 001cc 8b c3 mov eax, ebx
+ 001ce 8b cf mov ecx, edi
+ 001d0 e8 00 00 00 00 call _zip64local_getLong
+ 001d5 83 c4 04 add esp, 4
+ 001d8 85 c0 test eax, eax
+
+; 608 : return 0;
+
+ 001da 0f 85 54 fe ff
+ ff jne $LN50@zip64local@9
+
+; 609 :
+; 610 : /* number of the disk with the start of the zip64 end of central directory */
+; 611 : if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+
+ 001e0 8d 4d fc lea ecx, DWORD PTR _uL$[ebp]
+ 001e3 51 push ecx
+ 001e4 8b c3 mov eax, ebx
+ 001e6 8b cf mov ecx, edi
+ 001e8 e8 00 00 00 00 call _zip64local_getLong
+ 001ed 83 c4 04 add esp, 4
+ 001f0 85 c0 test eax, eax
+
+; 612 : return 0;
+
+ 001f2 0f 85 3c fe ff
+ ff jne $LN50@zip64local@9
+
+; 613 : if (uL != 0)
+
+ 001f8 39 45 fc cmp DWORD PTR _uL$[ebp], eax
+
+; 614 : return 0;
+
+ 001fb 0f 85 33 fe ff
+ ff jne $LN50@zip64local@9
+
+; 615 :
+; 616 : /* relative offset of the zip64 end of central directory record */
+; 617 : if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK)
+
+ 00201 8d 55 d8 lea edx, DWORD PTR _relativeOffset$[ebp]
+ 00204 52 push edx
+ 00205 8b c3 mov eax, ebx
+ 00207 8b cf mov ecx, edi
+ 00209 e8 00 00 00 00 call _zip64local_getLong64
+ 0020e 83 c4 04 add esp, 4
+ 00211 85 c0 test eax, eax
+
+; 618 : return 0;
+
+ 00213 0f 85 1b fe ff
+ ff jne $LN50@zip64local@9
+
+; 619 :
+; 620 : /* total number of disks */
+; 621 : if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+
+ 00219 8d 45 fc lea eax, DWORD PTR _uL$[ebp]
+ 0021c 50 push eax
+ 0021d 8b c3 mov eax, ebx
+ 0021f 8b cf mov ecx, edi
+ 00221 e8 00 00 00 00 call _zip64local_getLong
+ 00226 83 c4 04 add esp, 4
+ 00229 85 c0 test eax, eax
+
+; 622 : return 0;
+
+ 0022b 0f 85 03 fe ff
+ ff jne $LN50@zip64local@9
+
+; 623 : if (uL != 1)
+
+ 00231 83 7d fc 01 cmp DWORD PTR _uL$[ebp], 1
+
+; 624 : return 0;
+
+ 00235 0f 85 f9 fd ff
+ ff jne $LN50@zip64local@9
+
+; 625 :
+; 626 : /* Goto Zip64 end of central directory record */
+; 627 : if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 0023b 8b 4d dc mov ecx, DWORD PTR _relativeOffset$[ebp+4]
+ 0023e 8b 55 d8 mov edx, DWORD PTR _relativeOffset$[ebp]
+ 00241 51 push ecx
+ 00242 52 push edx
+ 00243 33 d2 xor edx, edx
+ 00245 8b c7 mov eax, edi
+ 00247 e8 00 00 00 00 call _call_zseek64
+ 0024c 83 c4 08 add esp, 8
+ 0024f 85 c0 test eax, eax
+
+; 628 : return 0;
+
+ 00251 0f 85 dd fd ff
+ ff jne $LN50@zip64local@9
+
+; 629 :
+; 630 : /* the signature */
+; 631 : if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+
+ 00257 8d 45 fc lea eax, DWORD PTR _uL$[ebp]
+ 0025a 50 push eax
+ 0025b 8b c3 mov eax, ebx
+ 0025d 8b cf mov ecx, edi
+ 0025f e8 00 00 00 00 call _zip64local_getLong
+ 00264 83 c4 04 add esp, 4
+ 00267 85 c0 test eax, eax
+
+; 632 : return 0;
+
+ 00269 0f 85 c5 fd ff
+ ff jne $LN50@zip64local@9
+
+; 633 :
+; 634 : if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'
+
+ 0026f 81 7d fc 50 4b
+ 06 06 cmp DWORD PTR _uL$[ebp], 101075792 ; 06064b50H
+
+; 635 : return 0;
+
+ 00276 0f 85 b8 fd ff
+ ff jne $LN50@zip64local@9
+
+; 636 :
+; 637 : return relativeOffset;
+
+ 0027c 8b 45 d8 mov eax, DWORD PTR _relativeOffset$[ebp]
+ 0027f 8b 55 dc mov edx, DWORD PTR _relativeOffset$[ebp+4]
+
+; 638 : }
+
+ 00282 5f pop edi
+ 00283 5e pop esi
+ 00284 5b pop ebx
+ 00285 8b e5 mov esp, ebp
+ 00287 5d pop ebp
+ 00288 c3 ret 0
+_zip64local_SearchCentralDir64 ENDP
+; Function compile flags: /Ogtp
+; File c:\documents and settings\yyagi\my documents\visual studio 2010\projects\dtxmania\branches\111222(dtxviewer023 with #26977)\@libpng\83\\83\8a\83\85\81[\83V\83\87\83\93\zlib-1.2.8\contrib\minizip\crypt.h
+_TEXT ENDS
+; COMDAT _crypthead
+_TEXT SEGMENT
+_header$ = -24 ; size = 10
+tv280 = -12 ; size = 4
+tv243 = -12 ; size = 4
+_n$ = -12 ; size = 4
+_t$ = -8 ; size = 4
+tv238 = -1 ; size = 1
+_passwd$ = 8 ; size = 4
+_buf$ = 12 ; size = 4
+_crcForCrypting$ = 16 ; size = 4
+_crypthead PROC ; COMDAT
+; _pkeys$ = ecx
+; _pcrc_32_tab$ = eax
+
+; 96 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 ec 18 sub esp, 24 ; 00000018H
+ 00006 53 push ebx
+ 00007 56 push esi
+ 00008 57 push edi
+ 00009 8b f8 mov edi, eax
+
+; 97 : int n; /* index in random header */
+; 98 : int t; /* temporary */
+; 99 : int c; /* random byte */
+; 100 : unsigned char header[RAND_HEAD_LEN-2]; /* random header */
+; 101 : static unsigned calls = 0; /* ensure different random header each time */
+; 102 :
+; 103 : if (bufSize<RAND_HEAD_LEN)
+; 104 : return 0;
+; 105 :
+; 106 : /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
+; 107 : * output of rand() to get less predictability, since rand() is
+; 108 : * often poorly implemented.
+; 109 : */
+; 110 : if (++calls == 1)
+
+ 0000b a1 00 00 00 00 mov eax, DWORD PTR ?calls@?1??crypthead@@9@9
+ 00010 40 inc eax
+ 00011 8b f1 mov esi, ecx
+ 00013 a3 00 00 00 00 mov DWORD PTR ?calls@?1??crypthead@@9@9, eax
+ 00018 83 f8 01 cmp eax, 1
+ 0001b 75 15 jne SHORT $LN17@crypthead
+
+; 111 : {
+; 112 : srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+
+ 0001d 6a 00 push 0
+ 0001f e8 00 00 00 00 call __time64
+ 00024 35 4e e6 40 bb xor eax, -1153374642 ; bb40e64eH
+ 00029 50 push eax
+ 0002a e8 00 00 00 00 call _srand
+ 0002f 83 c4 08 add esp, 8
+$LN17@crypthead:
+
+; 113 : }
+; 114 : init_keys(passwd, pkeys, pcrc_32_tab);
+
+ 00032 8b 55 08 mov edx, DWORD PTR _passwd$[ebp]
+ 00035 8b c7 mov eax, edi
+ 00037 8b ce mov ecx, esi
+ 00039 e8 00 00 00 00 call _init_keys
+
+; 115 : for (n = 0; n < RAND_HEAD_LEN-2; n++)
+
+ 0003e c7 45 f4 00 00
+ 00 00 mov DWORD PTR _n$[ebp], 0
+$LL6@crypthead:
+
+; 116 : {
+; 117 : c = (rand() >> 7) & 0xff;
+
+ 00045 e8 00 00 00 00 call _rand
+ 0004a 8b d8 mov ebx, eax
+ 0004c c1 fb 07 sar ebx, 7
+
+; 118 : header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
+
+ 0004f 8b c6 mov eax, esi
+ 00051 81 e3 ff 00 00
+ 00 and ebx, 255 ; 000000ffH
+ 00057 e8 00 00 00 00 call _decrypt_byte
+ 0005c 89 45 f8 mov DWORD PTR _t$[ebp], eax
+ 0005f 8b c3 mov eax, ebx
+ 00061 e8 00 00 00 00 call _update_keys
+ 00066 32 5d f8 xor bl, BYTE PTR _t$[ebp]
+ 00069 8b 45 f4 mov eax, DWORD PTR _n$[ebp]
+ 0006c 88 5c 05 e8 mov BYTE PTR _header$[ebp+eax], bl
+ 00070 40 inc eax
+ 00071 89 45 f4 mov DWORD PTR _n$[ebp], eax
+ 00074 83 f8 0a cmp eax, 10 ; 0000000aH
+ 00077 7c cc jl SHORT $LL6@crypthead
+
+; 119 : }
+; 120 : /* Encrypt random header (last two bytes is high word of crc) */
+; 121 : init_keys(passwd, pkeys, pcrc_32_tab);
+
+ 00079 8b 55 08 mov edx, DWORD PTR _passwd$[ebp]
+ 0007c 8b c7 mov eax, edi
+ 0007e 8b ce mov ecx, esi
+ 00080 e8 00 00 00 00 call _init_keys
+
+; 122 : for (n = 0; n < RAND_HEAD_LEN-2; n++)
+
+ 00085 8b 45 0c mov eax, DWORD PTR _buf$[ebp]
+ 00088 8d 4d e8 lea ecx, DWORD PTR _header$[ebp]
+ 0008b 33 db xor ebx, ebx
+ 0008d 2b c1 sub eax, ecx
+ 0008f 89 45 f4 mov DWORD PTR tv280[ebp], eax
+$LL3@crypthead:
+
+; 123 : {
+; 124 : buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
+
+ 00092 8b c6 mov eax, esi
+ 00094 e8 00 00 00 00 call _decrypt_byte
+ 00099 89 45 f8 mov DWORD PTR _t$[ebp], eax
+ 0009c 0f b6 44 1d e8 movzx eax, BYTE PTR _header$[ebp+ebx]
+ 000a1 e8 00 00 00 00 call _update_keys
+ 000a6 8a 44 1d e8 mov al, BYTE PTR _header$[ebp+ebx]
+ 000aa 8b 55 f4 mov edx, DWORD PTR tv280[ebp]
+ 000ad 32 45 f8 xor al, BYTE PTR _t$[ebp]
+ 000b0 03 d3 add edx, ebx
+ 000b2 43 inc ebx
+ 000b3 88 44 15 e8 mov BYTE PTR _header$[ebp+edx], al
+ 000b7 83 fb 0a cmp ebx, 10 ; 0000000aH
+ 000ba 7c d6 jl SHORT $LL3@crypthead
+
+; 125 : }
+; 126 : buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
+
+ 000bc 8b c6 mov eax, esi
+ 000be e8 00 00 00 00 call _decrypt_byte
+ 000c3 89 45 f8 mov DWORD PTR _t$[ebp], eax
+ 000c6 8b 45 10 mov eax, DWORD PTR _crcForCrypting$[ebp]
+ 000c9 c1 e8 10 shr eax, 16 ; 00000010H
+ 000cc 89 45 f4 mov DWORD PTR tv243[ebp], eax
+ 000cf 25 ff 00 00 00 and eax, 255 ; 000000ffH
+ 000d4 e8 00 00 00 00 call _update_keys
+ 000d9 8a 45 f4 mov al, BYTE PTR tv243[ebp]
+ 000dc 32 45 f8 xor al, BYTE PTR _t$[ebp]
+ 000df 8b 4d 0c mov ecx, DWORD PTR _buf$[ebp]
+ 000e2 88 04 0b mov BYTE PTR [ebx+ecx], al
+
+; 127 : buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
+
+ 000e5 8b c6 mov eax, esi
+ 000e7 e8 00 00 00 00 call _decrypt_byte
+ 000ec 89 45 f8 mov DWORD PTR _t$[ebp], eax
+ 000ef 8b 45 10 mov eax, DWORD PTR _crcForCrypting$[ebp]
+ 000f2 c1 e8 18 shr eax, 24 ; 00000018H
+ 000f5 e8 00 00 00 00 call _update_keys
+ 000fa 32 45 f8 xor al, BYTE PTR _t$[ebp]
+ 000fd 8b 55 0c mov edx, DWORD PTR _buf$[ebp]
+ 00100 5f pop edi
+ 00101 88 44 13 01 mov BYTE PTR [ebx+edx+1], al
+ 00105 5e pop esi
+ 00106 8d 43 02 lea eax, DWORD PTR [ebx+2]
+ 00109 5b pop ebx
+
+; 128 : return n;
+; 129 : }
+
+ 0010a 8b e5 mov esp, ebp
+ 0010c 5d pop ebp
+ 0010d c3 ret 0
+_crypthead ENDP
+PUBLIC _LoadCentralDirectoryRecord
+; Function compile flags: /Ogtp
+; File c:\documents and settings\yyagi\my documents\visual studio 2010\projects\dtxmania\branches\111222(dtxviewer023 with #26977)\@libpng\83\\83\8a\83\85\81[\83V\83\87\83\93\zlib-1.2.8\contrib\minizip\zip.c
+; COMDAT _LoadCentralDirectoryRecord
+_TEXT SEGMENT
+tv439 = -56 ; size = 8
+_offset_central_dir$ = -56 ; size = 8
+_number_entry$ = -56 ; size = 8
+_sizeEndOfCentralDirectory$83042 = -56 ; size = 8
+_number_entry_CD$ = -48 ; size = 8
+_size_central_dir_to_read$83077 = -40 ; size = 8
+_central_pos$ = -40 ; size = 8
+_buf_read$83079 = -28 ; size = 4
+_size_comment$ = -28 ; size = 4
+_number_disk$ = -28 ; size = 4
+_VersionNeeded$ = -28 ; size = 4
+_VersionMadeBy$ = -28 ; size = 4
+_read_this$83085 = -24 ; size = 8
+_size_central_dir$ = -24 ; size = 8
+_number_disk_with_CD$ = -20 ; size = 4
+_byte_before_the_zipfile$ = -16 ; size = 8
+_uL$ = -12 ; size = 4
+_err$ = -4 ; size = 4
+_LoadCentralDirectoryRecord PROC ; COMDAT
+; _pziinit$ = edi
+
+; 641 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 ec 38 sub esp, 56 ; 00000038H
+
+; 642 : int err=ZIP_OK;
+; 643 : ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+; 644 :
+; 645 : ZPOS64_T size_central_dir; /* size of the central directory */
+; 646 : ZPOS64_T offset_central_dir; /* offset of start of central directory */
+; 647 : ZPOS64_T central_pos;
+; 648 : uLong uL;
+; 649 :
+; 650 : uLong number_disk; /* number of the current dist, used for
+; 651 : spaning ZIP, unsupported, always 0*/
+; 652 : uLong number_disk_with_CD; /* number the the disk with central dir, used
+; 653 : for spaning ZIP, unsupported, always 0*/
+; 654 : ZPOS64_T number_entry;
+; 655 : ZPOS64_T number_entry_CD; /* total number of entries in
+; 656 : the central dir
+; 657 : (same than number_entry on nospan) */
+; 658 : uLong VersionMadeBy;
+; 659 : uLong VersionNeeded;
+; 660 : uLong size_comment;
+; 661 :
+; 662 : int hasZIP64Record = 0;
+; 663 :
+; 664 : // check first if we find a ZIP64 record
+; 665 : central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream);
+
+ 00006 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00009 53 push ebx
+ 0000a 56 push esi
+ 0000b 50 push eax
+ 0000c 33 db xor ebx, ebx
+ 0000e 57 push edi
+ 0000f 89 5d fc mov DWORD PTR _err$[ebp], ebx
+ 00012 e8 00 00 00 00 call _zip64local_SearchCentralDir64
+ 00017 83 c4 08 add esp, 8
+ 0001a 89 45 d8 mov DWORD PTR _central_pos$[ebp], eax
+ 0001d 89 55 dc mov DWORD PTR _central_pos$[ebp+4], edx
+
+; 666 : if(central_pos > 0)
+
+ 00020 3b d3 cmp edx, ebx
+ 00022 0f 87 ad 00 00
+ 00 ja $LN51@LoadCentra
+ 00028 72 08 jb SHORT $LN53@LoadCentra
+ 0002a 3b c3 cmp eax, ebx
+
+; 667 : {
+; 668 : hasZIP64Record = 1;
+
+ 0002c 0f 87 a3 00 00
+ 00 ja $LN51@LoadCentra
+$LN53@LoadCentra:
+
+; 669 : }
+; 670 : else if(central_pos == 0)
+
+ 00032 8b c8 mov ecx, eax
+ 00034 0b ca or ecx, edx
+ 00036 75 13 jne SHORT $LN42@LoadCentra
+
+; 671 : {
+; 672 : central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream);
+
+ 00038 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 0003b 52 push edx
+ 0003c 57 push edi
+ 0003d e8 00 00 00 00 call _zip64local_SearchCentralDir
+ 00042 83 c4 08 add esp, 8
+ 00045 89 45 d8 mov DWORD PTR _central_pos$[ebp], eax
+ 00048 89 55 dc mov DWORD PTR _central_pos$[ebp+4], edx
+$LN42@LoadCentra:
+
+; 735 : {
+; 736 : // Read End of central Directory info
+; 737 : if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 0004b 8b 77 2c mov esi, DWORD PTR [edi+44]
+ 0004e 52 push edx
+ 0004f 50 push eax
+ 00050 33 d2 xor edx, edx
+ 00052 8b c7 mov eax, edi
+ 00054 e8 00 00 00 00 call _call_zseek64
+ 00059 83 c4 08 add esp, 8
+
+; 738 : err=ZIP_ERRNO;
+
+ 0005c 83 ce ff or esi, -1
+ 0005f 85 c0 test eax, eax
+ 00061 74 03 je SHORT $LN27@LoadCentra
+ 00063 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN27@LoadCentra:
+
+; 739 :
+; 740 : /* the signature, already checked */
+; 741 : if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
+
+ 00066 8d 45 f4 lea eax, DWORD PTR _uL$[ebp]
+ 00069 50 push eax
+ 0006a 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0006d 8b cf mov ecx, edi
+ 0006f e8 00 00 00 00 call _zip64local_getLong
+ 00074 83 c4 04 add esp, 4
+ 00077 85 c0 test eax, eax
+ 00079 74 03 je SHORT $LN26@LoadCentra
+
+; 742 : err=ZIP_ERRNO;
+
+ 0007b 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN26@LoadCentra:
+
+; 743 :
+; 744 : /* number of this disk */
+; 745 : if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
+
+ 0007e 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00081 8d 4d e4 lea ecx, DWORD PTR _number_disk$[ebp]
+ 00084 51 push ecx
+ 00085 8b cf mov ecx, edi
+ 00087 e8 00 00 00 00 call _zip64local_getShort
+ 0008c 83 c4 04 add esp, 4
+ 0008f 85 c0 test eax, eax
+ 00091 74 03 je SHORT $LN25@LoadCentra
+
+; 746 : err=ZIP_ERRNO;
+
+ 00093 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN25@LoadCentra:
+
+; 747 :
+; 748 : /* number of the disk with the start of the central directory */
+; 749 : if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
+
+ 00096 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00099 8d 55 ec lea edx, DWORD PTR _number_disk_with_CD$[ebp]
+ 0009c 52 push edx
+ 0009d 8b cf mov ecx, edi
+ 0009f e8 00 00 00 00 call _zip64local_getShort
+ 000a4 83 c4 04 add esp, 4
+ 000a7 85 c0 test eax, eax
+ 000a9 74 03 je SHORT $LN24@LoadCentra
+
+; 750 : err=ZIP_ERRNO;
+
+ 000ab 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN24@LoadCentra:
+
+; 751 :
+; 752 : /* total number of entries in the central dir on this disk */
+; 753 : number_entry = 0;
+; 754 : if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+
+ 000ae 8d 45 f4 lea eax, DWORD PTR _uL$[ebp]
+ 000b1 50 push eax
+ 000b2 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 000b5 8b cf mov ecx, edi
+ 000b7 33 f6 xor esi, esi
+ 000b9 e8 00 00 00 00 call _zip64local_getShort
+ 000be 83 c4 04 add esp, 4
+ 000c1 85 c0 test eax, eax
+ 000c3 0f 84 46 01 00
+ 00 je $LN23@LoadCentra
+
+; 755 : err=ZIP_ERRNO;
+
+ 000c9 c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+
+; 756 : else
+
+ 000d0 e9 3f 01 00 00 jmp $LN22@LoadCentra
+$LN51@LoadCentra:
+
+; 673 : }
+; 674 :
+; 675 : /* disable to allow appending to empty ZIP archive
+; 676 : if (central_pos==0)
+; 677 : err=ZIP_ERRNO;
+; 678 : */
+; 679 :
+; 680 : if(hasZIP64Record)
+; 681 : {
+; 682 : ZPOS64_T sizeEndOfCentralDirectory;
+; 683 : if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+
+ 000d5 8b 77 2c mov esi, DWORD PTR [edi+44]
+ 000d8 52 push edx
+ 000d9 50 push eax
+ 000da 33 d2 xor edx, edx
+ 000dc 8b c7 mov eax, edi
+ 000de e8 00 00 00 00 call _call_zseek64
+ 000e3 83 c4 08 add esp, 8
+
+; 684 : err=ZIP_ERRNO;
+
+ 000e6 83 ce ff or esi, -1
+ 000e9 85 c0 test eax, eax
+ 000eb 74 03 je SHORT $LN41@LoadCentra
+ 000ed 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN41@LoadCentra:
+
+; 685 :
+; 686 : /* the signature, already checked */
+; 687 : if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
+
+ 000f0 8d 45 f4 lea eax, DWORD PTR _uL$[ebp]
+ 000f3 50 push eax
+ 000f4 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 000f7 8b cf mov ecx, edi
+ 000f9 e8 00 00 00 00 call _zip64local_getLong
+ 000fe 83 c4 04 add esp, 4
+ 00101 85 c0 test eax, eax
+ 00103 74 03 je SHORT $LN40@LoadCentra
+
+; 688 : err=ZIP_ERRNO;
+
+ 00105 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN40@LoadCentra:
+
+; 689 :
+; 690 : /* size of zip64 end of central directory record */
+; 691 : if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK)
+
+ 00108 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0010b 8d 4d c8 lea ecx, DWORD PTR _sizeEndOfCentralDirectory$83042[ebp]
+ 0010e 51 push ecx
+ 0010f 8b cf mov ecx, edi
+ 00111 e8 00 00 00 00 call _zip64local_getLong64
+ 00116 83 c4 04 add esp, 4
+ 00119 85 c0 test eax, eax
+ 0011b 74 03 je SHORT $LN39@LoadCentra
+
+; 692 : err=ZIP_ERRNO;
+
+ 0011d 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN39@LoadCentra:
+
+; 693 :
+; 694 : /* version made by */
+; 695 : if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK)
+
+ 00120 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00123 8d 55 e4 lea edx, DWORD PTR _VersionMadeBy$[ebp]
+ 00126 52 push edx
+ 00127 8b cf mov ecx, edi
+ 00129 e8 00 00 00 00 call _zip64local_getShort
+ 0012e 83 c4 04 add esp, 4
+ 00131 85 c0 test eax, eax
+ 00133 74 03 je SHORT $LN38@LoadCentra
+
+; 696 : err=ZIP_ERRNO;
+
+ 00135 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN38@LoadCentra:
+
+; 697 :
+; 698 : /* version needed to extract */
+; 699 : if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK)
+
+ 00138 8d 45 e4 lea eax, DWORD PTR _VersionNeeded$[ebp]
+ 0013b 50 push eax
+ 0013c 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0013f 8b cf mov ecx, edi
+ 00141 e8 00 00 00 00 call _zip64local_getShort
+ 00146 83 c4 04 add esp, 4
+ 00149 85 c0 test eax, eax
+ 0014b 74 03 je SHORT $LN37@LoadCentra
+
+; 700 : err=ZIP_ERRNO;
+
+ 0014d 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN37@LoadCentra:
+
+; 701 :
+; 702 : /* number of this disk */
+; 703 : if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
+
+ 00150 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00153 8d 4d e4 lea ecx, DWORD PTR _number_disk$[ebp]
+ 00156 51 push ecx
+ 00157 8b cf mov ecx, edi
+ 00159 e8 00 00 00 00 call _zip64local_getLong
+ 0015e 83 c4 04 add esp, 4
+ 00161 85 c0 test eax, eax
+ 00163 74 03 je SHORT $LN36@LoadCentra
+
+; 704 : err=ZIP_ERRNO;
+
+ 00165 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN36@LoadCentra:
+
+; 705 :
+; 706 : /* number of the disk with the start of the central directory */
+; 707 : if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
+
+ 00168 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0016b 8d 55 ec lea edx, DWORD PTR _number_disk_with_CD$[ebp]
+ 0016e 52 push edx
+ 0016f 8b cf mov ecx, edi
+ 00171 e8 00 00 00 00 call _zip64local_getLong
+ 00176 83 c4 04 add esp, 4
+ 00179 85 c0 test eax, eax
+ 0017b 74 03 je SHORT $LN35@LoadCentra
+
+; 708 : err=ZIP_ERRNO;
+
+ 0017d 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN35@LoadCentra:
+
+; 709 :
+; 710 : /* total number of entries in the central directory on this disk */
+; 711 : if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK)
+
+ 00180 8d 45 c8 lea eax, DWORD PTR _number_entry$[ebp]
+ 00183 50 push eax
+ 00184 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00187 8b cf mov ecx, edi
+ 00189 e8 00 00 00 00 call _zip64local_getLong64
+ 0018e 83 c4 04 add esp, 4
+ 00191 85 c0 test eax, eax
+ 00193 74 03 je SHORT $LN34@LoadCentra
+
+; 712 : err=ZIP_ERRNO;
+
+ 00195 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN34@LoadCentra:
+
+; 713 :
+; 714 : /* total number of entries in the central directory */
+; 715 : if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK)
+
+ 00198 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0019b 8d 4d d0 lea ecx, DWORD PTR _number_entry_CD$[ebp]
+ 0019e 51 push ecx
+ 0019f 8b cf mov ecx, edi
+ 001a1 e8 00 00 00 00 call _zip64local_getLong64
+ 001a6 83 c4 04 add esp, 4
+ 001a9 85 c0 test eax, eax
+ 001ab 74 03 je SHORT $LN33@LoadCentra
+
+; 716 : err=ZIP_ERRNO;
+
+ 001ad 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN33@LoadCentra:
+
+; 717 :
+; 718 : if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
+
+ 001b0 8b 55 d0 mov edx, DWORD PTR _number_entry_CD$[ebp]
+ 001b3 3b 55 c8 cmp edx, DWORD PTR _number_entry$[ebp]
+ 001b6 75 12 jne SHORT $LN31@LoadCentra
+ 001b8 8b 45 d4 mov eax, DWORD PTR _number_entry_CD$[ebp+4]
+ 001bb 3b 45 cc cmp eax, DWORD PTR _number_entry$[ebp+4]
+ 001be 75 0a jne SHORT $LN31@LoadCentra
+ 001c0 39 5d ec cmp DWORD PTR _number_disk_with_CD$[ebp], ebx
+ 001c3 75 05 jne SHORT $LN31@LoadCentra
+ 001c5 39 5d e4 cmp DWORD PTR _number_disk$[ebp], ebx
+ 001c8 74 07 je SHORT $LN32@LoadCentra
+$LN31@LoadCentra:
+
+; 719 : err=ZIP_BADZIPFILE;
+
+ 001ca c7 45 fc 99 ff
+ ff ff mov DWORD PTR _err$[ebp], -103 ; ffffff99H
+$LN32@LoadCentra:
+
+; 720 :
+; 721 : /* size of the central directory */
+; 722 : if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK)
+
+ 001d1 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 001d4 8d 4d e8 lea ecx, DWORD PTR _size_central_dir$[ebp]
+ 001d7 51 push ecx
+ 001d8 8b cf mov ecx, edi
+ 001da e8 00 00 00 00 call _zip64local_getLong64
+ 001df 83 c4 04 add esp, 4
+ 001e2 85 c0 test eax, eax
+ 001e4 74 03 je SHORT $LN30@LoadCentra
+
+; 723 : err=ZIP_ERRNO;
+
+ 001e6 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN30@LoadCentra:
+
+; 724 :
+; 725 : /* offset of start of central directory with respect to the
+; 726 : starting disk number */
+; 727 : if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK)
+
+ 001e9 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 001ec 8d 55 c8 lea edx, DWORD PTR _offset_central_dir$[ebp]
+ 001ef 52 push edx
+ 001f0 8b cf mov ecx, edi
+ 001f2 e8 00 00 00 00 call _zip64local_getLong64
+ 001f7 83 c4 04 add esp, 4
+ 001fa 85 c0 test eax, eax
+ 001fc 74 03 je SHORT $LN29@LoadCentra
+
+; 728 : err=ZIP_ERRNO;
+
+ 001fe 89 75 fc mov DWORD PTR _err$[ebp], esi
+$LN29@LoadCentra:
+
+; 729 :
+; 730 : // TODO..
+; 731 : // read the comment from the standard central header.
+; 732 : size_comment = 0;
+; 733 : }
+; 734 : else
+
+ 00201 8b 75 c8 mov esi, DWORD PTR _offset_central_dir$[ebp]
+ 00204 89 5d e4 mov DWORD PTR _size_comment$[ebp], ebx
+ 00207 8b 5d cc mov ebx, DWORD PTR _offset_central_dir$[ebp+4]
+ 0020a e9 c7 00 00 00 jmp $LN13@LoadCentra
+$LN23@LoadCentra:
+
+; 757 : number_entry = uL;
+
+ 0020f 8b 75 f4 mov esi, DWORD PTR _uL$[ebp]
+ 00212 33 db xor ebx, ebx
+$LN22@LoadCentra:
+
+; 758 :
+; 759 : /* total number of entries in the central dir */
+; 760 : number_entry_CD = 0;
+
+ 00214 33 c0 xor eax, eax
+
+; 761 : if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+
+ 00216 8d 4d f4 lea ecx, DWORD PTR _uL$[ebp]
+ 00219 89 45 d0 mov DWORD PTR _number_entry_CD$[ebp], eax
+ 0021c 89 45 d4 mov DWORD PTR _number_entry_CD$[ebp+4], eax
+ 0021f 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00222 51 push ecx
+ 00223 8b cf mov ecx, edi
+ 00225 e8 00 00 00 00 call _zip64local_getShort
+ 0022a 83 c4 04 add esp, 4
+ 0022d 85 c0 test eax, eax
+ 0022f 74 0b je SHORT $LN21@LoadCentra
+
+; 762 : err=ZIP_ERRNO;
+
+ 00231 c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+
+; 763 : else
+
+ 00238 33 c0 xor eax, eax
+ 0023a eb 0b jmp SHORT $LN20@LoadCentra
+$LN21@LoadCentra:
+
+; 764 : number_entry_CD = uL;
+
+ 0023c 8b 55 f4 mov edx, DWORD PTR _uL$[ebp]
+ 0023f 33 c0 xor eax, eax
+ 00241 89 55 d0 mov DWORD PTR _number_entry_CD$[ebp], edx
+ 00244 89 45 d4 mov DWORD PTR _number_entry_CD$[ebp+4], eax
+$LN20@LoadCentra:
+
+; 765 :
+; 766 : if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
+
+ 00247 39 75 d0 cmp DWORD PTR _number_entry_CD$[ebp], esi
+ 0024a 75 0f jne SHORT $LN18@LoadCentra
+ 0024c 39 5d d4 cmp DWORD PTR _number_entry_CD$[ebp+4], ebx
+ 0024f 75 0a jne SHORT $LN18@LoadCentra
+ 00251 39 45 ec cmp DWORD PTR _number_disk_with_CD$[ebp], eax
+ 00254 75 05 jne SHORT $LN18@LoadCentra
+ 00256 39 45 e4 cmp DWORD PTR _number_disk$[ebp], eax
+ 00259 74 07 je SHORT $LN19@LoadCentra
+$LN18@LoadCentra:
+
+; 767 : err=ZIP_BADZIPFILE;
+
+ 0025b c7 45 fc 99 ff
+ ff ff mov DWORD PTR _err$[ebp], -103 ; ffffff99H
+$LN19@LoadCentra:
+
+; 768 :
+; 769 : /* size of the central directory */
+; 770 : size_central_dir = 0;
+
+ 00262 89 45 e8 mov DWORD PTR _size_central_dir$[ebp], eax
+ 00265 89 45 ec mov DWORD PTR _size_central_dir$[ebp+4], eax
+
+; 771 : if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+
+ 00268 8d 45 f4 lea eax, DWORD PTR _uL$[ebp]
+ 0026b 50 push eax
+ 0026c 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 0026f 8b cf mov ecx, edi
+ 00271 e8 00 00 00 00 call _zip64local_getLong
+ 00276 83 c4 04 add esp, 4
+ 00279 85 c0 test eax, eax
+ 0027b 74 09 je SHORT $LN17@LoadCentra
+
+; 772 : err=ZIP_ERRNO;
+
+ 0027d c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+
+; 773 : else
+
+ 00284 eb 0d jmp SHORT $LN16@LoadCentra
+$LN17@LoadCentra:
+
+; 774 : size_central_dir = uL;
+
+ 00286 8b 4d f4 mov ecx, DWORD PTR _uL$[ebp]
+ 00289 89 4d e8 mov DWORD PTR _size_central_dir$[ebp], ecx
+ 0028c c7 45 ec 00 00
+ 00 00 mov DWORD PTR _size_central_dir$[ebp+4], 0
+$LN16@LoadCentra:
+
+; 775 :
+; 776 : /* offset of start of central directory with respect to the starting disk number */
+; 777 : offset_central_dir = 0;
+; 778 : if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+
+ 00293 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 00296 8d 55 f4 lea edx, DWORD PTR _uL$[ebp]
+ 00299 52 push edx
+ 0029a 8b cf mov ecx, edi
+ 0029c 33 f6 xor esi, esi
+ 0029e 33 db xor ebx, ebx
+ 002a0 e8 00 00 00 00 call _zip64local_getLong
+ 002a5 83 c4 04 add esp, 4
+ 002a8 85 c0 test eax, eax
+ 002aa 74 09 je SHORT $LN15@LoadCentra
+
+; 779 : err=ZIP_ERRNO;
+
+ 002ac c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+
+; 780 : else
+
+ 002b3 eb 05 jmp SHORT $LN14@LoadCentra
+$LN15@LoadCentra:
+
+; 781 : offset_central_dir = uL;
+
+ 002b5 8b 75 f4 mov esi, DWORD PTR _uL$[ebp]
+ 002b8 33 db xor ebx, ebx
+$LN14@LoadCentra:
+
+; 782 :
+; 783 :
+; 784 : /* zipfile global comment length */
+; 785 : if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK)
+
+ 002ba 8d 45 e4 lea eax, DWORD PTR _size_comment$[ebp]
+ 002bd 50 push eax
+ 002be 8b 47 2c mov eax, DWORD PTR [edi+44]
+ 002c1 8b cf mov ecx, edi
+ 002c3 e8 00 00 00 00 call _zip64local_getShort
+ 002c8 83 c4 04 add esp, 4
+ 002cb 85 c0 test eax, eax
+ 002cd 74 07 je SHORT $LN13@LoadCentra
+
+; 786 : err=ZIP_ERRNO;
+
+ 002cf c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+$LN13@LoadCentra:
+
+; 787 : }
+; 788 :
+; 789 : if ((central_pos<offset_central_dir+size_central_dir) &&
+; 790 : (err==ZIP_OK))
+
+ 002d6 8b 45 dc mov eax, DWORD PTR _central_pos$[ebp+4]
+ 002d9 8b d6 mov edx, esi
+ 002db 03 55 e8 add edx, DWORD PTR _size_central_dir$[ebp]
+ 002de 8b cb mov ecx, ebx
+ 002e0 13 4d ec adc ecx, DWORD PTR _size_central_dir$[ebp+4]
+ 002e3 3b c1 cmp eax, ecx
+ 002e5 72 0f jb SHORT $LN50@LoadCentra
+ 002e7 8b 4d d8 mov ecx, DWORD PTR _central_pos$[ebp]
+ 002ea 77 04 ja SHORT $LN54@LoadCentra
+ 002ec 3b ca cmp ecx, edx
+
+; 791 : err=ZIP_BADZIPFILE;
+; 792 :
+; 793 : if (err!=ZIP_OK)
+
+ 002ee 72 06 jb SHORT $LN50@LoadCentra
+$LN54@LoadCentra:
+ 002f0 83 7d fc 00 cmp DWORD PTR _err$[ebp], 0
+ 002f4 74 19 je SHORT $LN11@LoadCentra
+$LN50@LoadCentra:
+
+; 794 : {
+; 795 : ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);
+
+ 002f6 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 002f9 8b 57 1c mov edx, DWORD PTR [edi+28]
+ 002fc 8b 47 14 mov eax, DWORD PTR [edi+20]
+ 002ff 51 push ecx
+ 00300 52 push edx
+ 00301 ff d0 call eax
+ 00303 83 c4 08 add esp, 8
+
+; 796 : return ZIP_ERRNO;
+
+ 00306 83 c8 ff or eax, -1
+
+; 842 : }
+
+ 00309 5e pop esi
+ 0030a 5b pop ebx
+ 0030b 8b e5 mov esp, ebp
+ 0030d 5d pop ebp
+ 0030e c3 ret 0
+$LN11@LoadCentra:
+
+; 797 : }
+; 798 :
+; 799 : if (size_comment>0)
+
+ 0030f 8b 55 e4 mov edx, DWORD PTR _size_comment$[ebp]
+ 00312 85 d2 test edx, edx
+ 00314 74 39 je SHORT $LN9@LoadCentra
+
+; 800 : {
+; 801 : pziinit->globalcomment = (char*)ALLOC(size_comment+1);
+
+ 00316 42 inc edx
+ 00317 52 push edx
+ 00318 e8 00 00 00 00 call _malloc
+ 0031d 83 c4 04 add esp, 4
+ 00320 89 87 00 01 01
+ 00 mov DWORD PTR [edi+65792], eax
+
+; 802 : if (pziinit->globalcomment)
+
+ 00326 85 c0 test eax, eax
+ 00328 74 1f je SHORT $LN64@LoadCentra
+
+; 803 : {
+; 804 : size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment);
+
+ 0032a 8b 4d e4 mov ecx, DWORD PTR _size_comment$[ebp]
+ 0032d 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 00330 51 push ecx
+ 00331 8b 4f 04 mov ecx, DWORD PTR [edi+4]
+ 00334 50 push eax
+ 00335 8b 47 1c mov eax, DWORD PTR [edi+28]
+ 00338 52 push edx
+ 00339 50 push eax
+ 0033a ff d1 call ecx
+
+; 805 : pziinit->globalcomment[size_comment]=0;
+
+ 0033c 8b 97 00 01 01
+ 00 mov edx, DWORD PTR [edi+65792]
+ 00342 83 c4 10 add esp, 16 ; 00000010H
+ 00345 c6 04 10 00 mov BYTE PTR [eax+edx], 0
+$LN64@LoadCentra:
+ 00349 8b 45 dc mov eax, DWORD PTR _central_pos$[ebp+4]
+ 0034c 8b 4d d8 mov ecx, DWORD PTR _central_pos$[ebp]
+$LN9@LoadCentra:
+
+; 806 : }
+; 807 : }
+; 808 :
+; 809 : byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);
+
+ 0034f 8b 55 ec mov edx, DWORD PTR _size_central_dir$[ebp+4]
+ 00352 2b ce sub ecx, esi
+ 00354 1b c3 sbb eax, ebx
+ 00356 2b 4d e8 sub ecx, DWORD PTR _size_central_dir$[ebp]
+
+; 810 : pziinit->add_position_when_writting_offset = byte_before_the_zipfile;
+; 811 :
+; 812 : {
+; 813 : ZPOS64_T size_central_dir_to_read = size_central_dir;
+; 814 : size_t buf_size = SIZEDATA_INDATABLOCK;
+; 815 : void* buf_read = (void*)ALLOC(buf_size);
+
+ 00359 68 f0 0f 00 00 push 4080 ; 00000ff0H
+ 0035e 1b c2 sbb eax, edx
+ 00360 89 45 f4 mov DWORD PTR _byte_before_the_zipfile$[ebp+4], eax
+ 00363 89 87 f4 00 01
+ 00 mov DWORD PTR [edi+65780], eax
+ 00369 8b 45 e8 mov eax, DWORD PTR _size_central_dir$[ebp]
+ 0036c 89 4d f0 mov DWORD PTR _byte_before_the_zipfile$[ebp], ecx
+ 0036f 89 8f f0 00 01
+ 00 mov DWORD PTR [edi+65776], ecx
+ 00375 89 45 d8 mov DWORD PTR _size_central_dir_to_read$83077[ebp], eax
+ 00378 89 55 dc mov DWORD PTR _size_central_dir_to_read$83077[ebp+4], edx
+ 0037b e8 00 00 00 00 call _malloc
+
+; 816 : if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
+
+ 00380 8b 4d f4 mov ecx, DWORD PTR _byte_before_the_zipfile$[ebp+4]
+ 00383 89 45 e4 mov DWORD PTR _buf_read$83079[ebp], eax
+ 00386 8b 45 f0 mov eax, DWORD PTR _byte_before_the_zipfile$[ebp]
+ 00389 83 c4 04 add esp, 4
+ 0038c 03 c6 add eax, esi
+ 0038e 8b 77 2c mov esi, DWORD PTR [edi+44]
+ 00391 13 cb adc ecx, ebx
+ 00393 51 push ecx
+ 00394 89 45 c8 mov DWORD PTR tv439[ebp], eax
+ 00397 50 push eax
+ 00398 33 d2 xor edx, edx
+ 0039a 8b c7 mov eax, edi
+ 0039c 89 4d cc mov DWORD PTR tv439[ebp+4], ecx
+ 0039f e8 00 00 00 00 call _call_zseek64
+ 003a4 83 c4 08 add esp, 8
+ 003a7 85 c0 test eax, eax
+ 003a9 74 07 je SHORT $LN48@LoadCentra
+
+; 817 : err=ZIP_ERRNO;
+
+ 003ab c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+$LN48@LoadCentra:
+
+; 818 :
+; 819 : while ((size_central_dir_to_read>0) && (err==ZIP_OK))
+
+ 003b2 83 7d ec 00 cmp DWORD PTR _size_central_dir$[ebp+4], 0
+ 003b6 77 06 ja SHORT $LN7@LoadCentra
+ 003b8 83 7d e8 00 cmp DWORD PTR _size_central_dir$[ebp], 0
+ 003bc 76 78 jbe SHORT $LN58@LoadCentra
+$LN7@LoadCentra:
+ 003be 83 7d fc 00 cmp DWORD PTR _err$[ebp], 0
+ 003c2 75 72 jne SHORT $LN58@LoadCentra
+
+; 820 : {
+; 821 : ZPOS64_T read_this = SIZEDATA_INDATABLOCK;
+; 822 : if (read_this > size_central_dir_to_read)
+
+ 003c4 8b 5d dc mov ebx, DWORD PTR _size_central_dir_to_read$83077[ebp+4]
+ 003c7 be f0 0f 00 00 mov esi, 4080 ; 00000ff0H
+ 003cc c7 45 ec 00 00
+ 00 00 mov DWORD PTR _read_this$83085[ebp+4], 0
+ 003d3 85 db test ebx, ebx
+ 003d5 77 0d ja SHORT $LN5@LoadCentra
+ 003d7 72 05 jb SHORT $LN56@LoadCentra
+ 003d9 39 75 d8 cmp DWORD PTR _size_central_dir_to_read$83077[ebp], esi
+ 003dc 73 06 jae SHORT $LN5@LoadCentra
+$LN56@LoadCentra:
+
+; 823 : read_this = size_central_dir_to_read;
+
+ 003de 8b 75 d8 mov esi, DWORD PTR _size_central_dir_to_read$83077[ebp]
+ 003e1 89 5d ec mov DWORD PTR _read_this$83085[ebp+4], ebx
+$LN5@LoadCentra:
+
+; 824 :
+; 825 : if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this)
+
+ 003e4 8b 4d e4 mov ecx, DWORD PTR _buf_read$83079[ebp]
+ 003e7 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 003ea 8b 47 1c mov eax, DWORD PTR [edi+28]
+ 003ed 56 push esi
+ 003ee 51 push ecx
+ 003ef 8b 4f 04 mov ecx, DWORD PTR [edi+4]
+ 003f2 52 push edx
+ 003f3 50 push eax
+ 003f4 ff d1 call ecx
+ 003f6 83 c4 10 add esp, 16 ; 00000010H
+ 003f9 33 c9 xor ecx, ecx
+ 003fb 3b c6 cmp eax, esi
+ 003fd 75 05 jne SHORT $LN57@LoadCentra
+ 003ff 3b 4d ec cmp ecx, DWORD PTR _read_this$83085[ebp+4]
+ 00402 74 09 je SHORT $LN52@LoadCentra
+$LN57@LoadCentra:
+
+; 826 : err=ZIP_ERRNO;
+
+ 00404 c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+
+; 827 :
+; 828 : if (err==ZIP_OK)
+
+ 0040b eb 14 jmp SHORT $LN3@LoadCentra
+$LN52@LoadCentra:
+
+; 829 : err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);
+
+ 0040d 8b 55 e4 mov edx, DWORD PTR _buf_read$83079[ebp]
+ 00410 56 push esi
+ 00411 52 push edx
+ 00412 8d 47 30 lea eax, DWORD PTR [edi+48]
+ 00415 50 push eax
+ 00416 e8 00 00 00 00 call _add_data_in_datablock
+ 0041b 83 c4 0c add esp, 12 ; 0000000cH
+ 0041e 89 45 fc mov DWORD PTR _err$[ebp], eax
+$LN3@LoadCentra:
+
+; 830 :
+; 831 : size_central_dir_to_read-=read_this;
+
+ 00421 29 75 d8 sub DWORD PTR _size_central_dir_to_read$83077[ebp], esi
+ 00424 1b 5d ec sbb ebx, DWORD PTR _read_this$83085[ebp+4]
+ 00427 89 5d dc mov DWORD PTR _size_central_dir_to_read$83077[ebp+4], ebx
+ 0042a 85 db test ebx, ebx
+ 0042c 77 90 ja SHORT $LN7@LoadCentra
+
+; 818 :
+; 819 : while ((size_central_dir_to_read>0) && (err==ZIP_OK))
+
+ 0042e 72 06 jb SHORT $LN58@LoadCentra
+ 00430 83 7d d8 00 cmp DWORD PTR _size_central_dir_to_read$83077[ebp], 0
+ 00434 77 88 ja SHORT $LN7@LoadCentra
+$LN58@LoadCentra:
+
+; 832 : }
+; 833 : TRYFREE(buf_read);
+
+ 00436 8b 45 e4 mov eax, DWORD PTR _buf_read$83079[ebp]
+ 00439 85 c0 test eax, eax
+ 0043b 74 09 je SHORT $LN2@LoadCentra
+ 0043d 50 push eax
+ 0043e e8 00 00 00 00 call _free
+ 00443 83 c4 04 add esp, 4
+$LN2@LoadCentra:
+
+; 834 : }
+; 835 : pziinit->begin_pos = byte_before_the_zipfile;
+
+ 00446 8b 55 f4 mov edx, DWORD PTR _byte_before_the_zipfile$[ebp+4]
+
+; 836 : pziinit->number_entry = number_entry_CD;
+
+ 00449 8b 45 d0 mov eax, DWORD PTR _number_entry_CD$[ebp]
+ 0044c 8b 4d f0 mov ecx, DWORD PTR _byte_before_the_zipfile$[ebp]
+
+; 837 :
+; 838 : if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)
+
+ 0044f 8b 77 2c mov esi, DWORD PTR [edi+44]
+ 00452 89 97 ec 00 01
+ 00 mov DWORD PTR [edi+65772], edx
+ 00458 8b 55 cc mov edx, DWORD PTR tv439[ebp+4]
+ 0045b 89 87 f8 00 01
+ 00 mov DWORD PTR [edi+65784], eax
+ 00461 8b 45 c8 mov eax, DWORD PTR tv439[ebp]
+ 00464 52 push edx
+ 00465 89 8f e8 00 01
+ 00 mov DWORD PTR [edi+65768], ecx
+ 0046b 8b 4d d4 mov ecx, DWORD PTR _number_entry_CD$[ebp+4]
+ 0046e 50 push eax
+ 0046f 33 d2 xor edx, edx
+ 00471 8b c7 mov eax, edi
+ 00473 89 8f fc 00 01
+ 00 mov DWORD PTR [edi+65788], ecx
+ 00479 e8 00 00 00 00 call _call_zseek64
+ 0047e 83 c4 08 add esp, 8
+ 00481 85 c0 test eax, eax
+ 00483 74 07 je SHORT $LN1@LoadCentra
+
+; 839 : err=ZIP_ERRNO;
+
+ 00485 c7 45 fc ff ff
+ ff ff mov DWORD PTR _err$[ebp], -1
+$LN1@LoadCentra:
+
+; 840 :
+; 841 : return err;
+
+ 0048c 8b 45 fc mov eax, DWORD PTR _err$[ebp]
+
+; 842 : }
+
+ 0048f 5e pop esi
+ 00490 5b pop ebx
+ 00491 8b e5 mov esp, ebp
+ 00493 5d pop ebp
+ 00494 c3 ret 0
+_LoadCentralDirectoryRecord ENDP
+PUBLIC _zipCloseFileInZipRaw64@16
+; Function compile flags: /Ogtp
+; COMDAT _zipCloseFileInZipRaw64@16
+_TEXT SEGMENT
+_err$ = -28 ; size = 4
+tv525 = -24 ; size = 4
+_datasize$ = -24 ; size = 2
+_cur_pos_inzip$83677 = -24 ; size = 8
+_compressed_size$ = -16 ; size = 8
+tv511 = -8 ; size = 8
+_file$ = 8 ; size = 4
+_uncompressed_size$ = 12 ; size = 8
+_crc32$ = 20 ; size = 4
+_zipCloseFileInZipRaw64@16 PROC ; COMDAT
+
+; 1515 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 e4 f8 and esp, -8 ; fffffff8H
+ 00006 83 ec 1c sub esp, 28 ; 0000001cH
+ 00009 53 push ebx
+
+; 1516 : zip64_internal* zi;
+; 1517 : ZPOS64_T compressed_size;
+; 1518 : uLong invalidValue = 0xffffffff;
+; 1519 : short datasize = 0;
+; 1520 : int err=ZIP_OK;
+; 1521 :
+; 1522 : if (file == NULL)
+
+ 0000a 8b 5d 08 mov ebx, DWORD PTR _file$[ebp]
+ 0000d 33 c0 xor eax, eax
+ 0000f 56 push esi
+ 00010 57 push edi
+ 00011 89 44 24 10 mov DWORD PTR _datasize$[esp+40], eax
+ 00015 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+ 00019 3b d8 cmp ebx, eax
+ 0001b 75 0e jne SHORT $LN45@zipCloseFi
+$LN89@zipCloseFi:
+
+; 1523 : return ZIP_PARAMERROR;
+
+ 0001d b8 9a ff ff ff mov eax, -102 ; ffffff9aH
+
+; 1745 : zi->in_opened_file_inzip = 0;
+; 1746 :
+; 1747 : return err;
+; 1748 : }
+
+ 00022 5f pop edi
+ 00023 5e pop esi
+ 00024 5b pop ebx
+ 00025 8b e5 mov esp, ebp
+ 00027 5d pop ebp
+ 00028 c2 10 00 ret 16 ; 00000010H
+$LN45@zipCloseFi:
+
+; 1524 : zi = (zip64_internal*)file;
+; 1525 :
+; 1526 : if (zi->in_opened_file_inzip == 0)
+
+ 0002b 39 43 38 cmp DWORD PTR [ebx+56], eax
+
+; 1527 : return ZIP_PARAMERROR;
+
+ 0002e 74 ed je SHORT $LN89@zipCloseFi
+
+; 1528 : zi->ci.stream.avail_in = 0;
+; 1529 :
+; 1530 : if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+
+ 00030 83 bb 9c 00 00
+ 00 08 cmp DWORD PTR [ebx+156], 8
+ 00037 89 43 44 mov DWORD PTR [ebx+68], eax
+ 0003a 75 4e jne SHORT $LN36@zipCloseFi
+ 0003c 39 83 a0 00 00
+ 00 cmp DWORD PTR [ebx+160], eax
+ 00042 75 46 jne SHORT $LN36@zipCloseFi
+ 00044 8d 7b 40 lea edi, DWORD PTR [ebx+64]
+$LN42@zipCloseFi:
+
+; 1531 : {
+; 1532 : while (err==ZIP_OK)
+; 1533 : {
+; 1534 : uLong uTotalOutBefore;
+; 1535 : if (zi->ci.stream.avail_out == 0)
+
+ 00047 83 7b 50 00 cmp DWORD PTR [ebx+80], 0
+ 0004b 75 15 jne SHORT $LN40@zipCloseFi
+
+; 1536 : {
+; 1537 : if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+
+ 0004d e8 00 00 00 00 call _zip64FlushWriteBuffer
+
+; 1538 : err = ZIP_ERRNO;
+; 1539 : zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+; 1540 : zi->ci.stream.next_out = zi->ci.buffered_data;
+
+ 00052 8d 83 a4 00 00
+ 00 lea eax, DWORD PTR [ebx+164]
+ 00058 c7 43 50 00 00
+ 01 00 mov DWORD PTR [ebx+80], 65536 ; 00010000H
+ 0005f 89 43 4c mov DWORD PTR [ebx+76], eax
+$LN40@zipCloseFi:
+
+; 1541 : }
+; 1542 : uTotalOutBefore = zi->ci.stream.total_out;
+
+ 00062 8b 73 54 mov esi, DWORD PTR [ebx+84]
+
+; 1543 : err=deflate(&zi->ci.stream, Z_FINISH);
+
+ 00065 6a 04 push 4
+ 00067 57 push edi
+ 00068 e8 00 00 00 00 call _deflate@8
+
+; 1544 : zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+
+ 0006d 8b 4b 54 mov ecx, DWORD PTR [ebx+84]
+ 00070 2b ce sub ecx, esi
+ 00072 01 4b 7c add DWORD PTR [ebx+124], ecx
+ 00075 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+ 00079 85 c0 test eax, eax
+ 0007b 74 ca je SHORT $LN42@zipCloseFi
+
+; 1545 : }
+; 1546 : }
+; 1547 : else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+; 1548 : {
+; 1549 : #ifdef HAVE_BZIP2
+; 1550 : err = BZ_FINISH_OK;
+; 1551 : while (err==BZ_FINISH_OK)
+; 1552 : {
+; 1553 : uLong uTotalOutBefore;
+; 1554 : if (zi->ci.bstream.avail_out == 0)
+; 1555 : {
+; 1556 : if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+; 1557 : err = ZIP_ERRNO;
+; 1558 : zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+; 1559 : zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+; 1560 : }
+; 1561 : uTotalOutBefore = zi->ci.bstream.total_out_lo32;
+; 1562 : err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH);
+; 1563 : if(err == BZ_STREAM_END)
+; 1564 : err = Z_STREAM_END;
+; 1565 :
+; 1566 : zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore);
+; 1567 : }
+; 1568 :
+; 1569 : if(err == BZ_FINISH_OK)
+; 1570 : err = ZIP_OK;
+; 1571 : #endif
+; 1572 : }
+; 1573 :
+; 1574 : if (err==Z_STREAM_END)
+
+ 0007d 83 f8 01 cmp eax, 1
+ 00080 75 08 jne SHORT $LN36@zipCloseFi
+
+; 1575 : err=ZIP_OK; /* this is normal */
+
+ 00082 c7 44 24 0c 00
+ 00 00 00 mov DWORD PTR _err$[esp+40], 0
+$LN36@zipCloseFi:
+
+; 1576 :
+; 1577 : if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
+
+ 0008a 83 7b 7c 00 cmp DWORD PTR [ebx+124], 0
+ 0008e 76 19 jbe SHORT $LN69@zipCloseFi
+ 00090 83 7c 24 0c 00 cmp DWORD PTR _err$[esp+40], 0
+ 00095 75 12 jne SHORT $LN69@zipCloseFi
+
+; 1578 : {
+; 1579 : if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO)
+
+ 00097 e8 00 00 00 00 call _zip64FlushWriteBuffer
+ 0009c 83 ce ff or esi, -1
+ 0009f 3b c6 cmp eax, esi
+ 000a1 75 09 jne SHORT $LN34@zipCloseFi
+
+; 1580 : err = ZIP_ERRNO;
+
+ 000a3 89 74 24 0c mov DWORD PTR _err$[esp+40], esi
+ 000a7 eb 03 jmp SHORT $LN34@zipCloseFi
+$LN69@zipCloseFi:
+ 000a9 83 ce ff or esi, -1
+$LN34@zipCloseFi:
+
+; 1581 : }
+; 1582 :
+; 1583 : if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+
+ 000ac 83 bb 9c 00 00
+ 00 08 cmp DWORD PTR [ebx+156], 8
+ 000b3 75 24 jne SHORT $LN33@zipCloseFi
+ 000b5 83 bb a0 00 00
+ 00 00 cmp DWORD PTR [ebx+160], 0
+ 000bc 75 3f jne SHORT $LN31@zipCloseFi
+
+; 1584 : {
+; 1585 : int tmp_err = deflateEnd(&zi->ci.stream);
+
+ 000be 8d 53 40 lea edx, DWORD PTR [ebx+64]
+ 000c1 52 push edx
+ 000c2 e8 00 00 00 00 call _deflateEnd@4
+
+; 1586 : if (err == ZIP_OK)
+
+ 000c7 83 7c 24 0c 00 cmp DWORD PTR _err$[esp+40], 0
+ 000cc 75 04 jne SHORT $LN32@zipCloseFi
+
+; 1587 : err = tmp_err;
+
+ 000ce 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+$LN32@zipCloseFi:
+
+; 1588 : zi->ci.stream_initialised = 0;
+
+ 000d2 c7 43 78 00 00
+ 00 00 mov DWORD PTR [ebx+120], 0
+$LN33@zipCloseFi:
+
+; 1589 : }
+; 1590 : #ifdef HAVE_BZIP2
+; 1591 : else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+; 1592 : {
+; 1593 : int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream);
+; 1594 : if (err==ZIP_OK)
+; 1595 : err = tmperr;
+; 1596 : zi->ci.stream_initialised = 0;
+; 1597 : }
+; 1598 : #endif
+; 1599 :
+; 1600 : if (!zi->ci.raw)
+
+ 000d9 83 bb a0 00 00
+ 00 00 cmp DWORD PTR [ebx+160], 0
+ 000e0 75 1b jne SHORT $LN31@zipCloseFi
+
+; 1601 : {
+; 1602 : crc32 = (uLong)zi->ci.crc32;
+
+ 000e2 8b 83 a8 00 01
+ 00 mov eax, DWORD PTR [ebx+65704]
+
+; 1603 : uncompressed_size = zi->ci.totalUncompressedData;
+
+ 000e8 8b 8b c8 00 01
+ 00 mov ecx, DWORD PTR [ebx+65736]
+ 000ee 8b 93 cc 00 01
+ 00 mov edx, DWORD PTR [ebx+65740]
+ 000f4 89 45 14 mov DWORD PTR _crc32$[ebp], eax
+ 000f7 89 4d 0c mov DWORD PTR _uncompressed_size$[ebp], ecx
+ 000fa 89 55 10 mov DWORD PTR _uncompressed_size$[ebp+4], edx
+$LN31@zipCloseFi:
+
+; 1604 : }
+; 1605 : compressed_size = zi->ci.totalCompressedData;
+; 1606 :
+; 1607 : # ifndef NOCRYPT
+; 1608 : compressed_size += zi->ci.crypt_header_size;
+
+ 000fd 8b 83 e0 00 01
+ 00 mov eax, DWORD PTR [ebx+65760]
+ 00103 99 cdq
+ 00104 03 83 c0 00 01
+ 00 add eax, DWORD PTR [ebx+65728]
+ 0010a 13 93 c4 00 01
+ 00 adc edx, DWORD PTR [ebx+65732]
+ 00110 89 44 24 18 mov DWORD PTR _compressed_size$[esp+40], eax
+ 00114 89 54 24 1c mov DWORD PTR _compressed_size$[esp+44], edx
+
+; 1609 : # endif
+; 1610 :
+; 1611 : // update Current Item crc and sizes,
+; 1612 : if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)
+
+ 00118 85 d2 test edx, edx
+ 0011a 77 24 ja SHORT $LN55@zipCloseFi
+ 0011c 72 04 jb SHORT $LN53@zipCloseFi
+ 0011e 3b c6 cmp eax, esi
+ 00120 73 1e jae SHORT $LN55@zipCloseFi
+$LN53@zipCloseFi:
+ 00122 83 7d 10 00 cmp DWORD PTR _uncompressed_size$[ebp+4], 0
+ 00126 77 18 ja SHORT $LN55@zipCloseFi
+ 00128 72 05 jb SHORT $LN54@zipCloseFi
+ 0012a 39 75 0c cmp DWORD PTR _uncompressed_size$[ebp], esi
+ 0012d 73 11 jae SHORT $LN55@zipCloseFi
+$LN54@zipCloseFi:
+ 0012f 83 bb 84 00 00
+ 00 00 cmp DWORD PTR [ebx+132], 0
+ 00136 77 08 ja SHORT $LN55@zipCloseFi
+ 00138 39 b3 80 00 00
+ 00 cmp DWORD PTR [ebx+128], esi
+ 0013e 72 2c jb SHORT $LN30@zipCloseFi
+$LN55@zipCloseFi:
+
+; 1613 : {
+; 1614 : /*version Made by*/
+; 1615 : zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2);
+
+ 00140 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00146 6a 00 push 0
+ 00148 6a 2d push 45 ; 0000002dH
+ 0014a 83 c7 04 add edi, 4
+ 0014d be 02 00 00 00 mov esi, 2
+ 00152 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1616 : /*version needed*/
+; 1617 : zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2);
+
+ 00157 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 0015d 6a 00 push 0
+ 0015f 6a 2d push 45 ; 0000002dH
+ 00161 83 c7 06 add edi, 6
+ 00164 e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 00169 83 c4 10 add esp, 16 ; 00000010H
+$LN30@zipCloseFi:
+
+; 1618 :
+; 1619 : }
+; 1620 :
+; 1621 : zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
+
+ 0016c 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00172 33 c0 xor eax, eax
+ 00174 50 push eax
+ 00175 89 44 24 28 mov DWORD PTR tv511[esp+48], eax
+ 00179 8b 45 14 mov eax, DWORD PTR _crc32$[ebp]
+ 0017c 50 push eax
+ 0017d 83 c7 10 add edi, 16 ; 00000010H
+ 00180 be 04 00 00 00 mov esi, 4
+ 00185 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1622 :
+; 1623 :
+; 1624 : if(compressed_size >= 0xffffffff)
+
+ 0018a 8b 44 24 24 mov eax, DWORD PTR _compressed_size$[esp+52]
+ 0018e 83 c4 08 add esp, 8
+ 00191 85 c0 test eax, eax
+ 00193 75 09 jne SHORT $LN56@zipCloseFi
+ 00195 8b 4c 24 18 mov ecx, DWORD PTR _compressed_size$[esp+40]
+ 00199 83 f9 ff cmp ecx, -1
+ 0019c 72 06 jb SHORT $LN28@zipCloseFi
+$LN56@zipCloseFi:
+
+; 1625 : zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/
+
+ 0019e 6a 00 push 0
+ 001a0 6a ff push -1
+
+; 1626 : else
+
+ 001a2 eb 02 jmp SHORT $LN86@zipCloseFi
+$LN28@zipCloseFi:
+
+; 1627 : zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/
+
+ 001a4 50 push eax
+ 001a5 51 push ecx
+$LN86@zipCloseFi:
+ 001a6 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001ac 83 c7 14 add edi, 20 ; 00000014H
+ 001af e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 001b4 83 c4 08 add esp, 8
+
+; 1628 :
+; 1629 : /// set internal file attributes field
+; 1630 : if (zi->ci.stream.data_type == Z_ASCII)
+
+ 001b7 83 7b 6c 01 cmp DWORD PTR [ebx+108], 1
+ 001bb 75 1a jne SHORT $LN26@zipCloseFi
+
+; 1631 : zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
+
+ 001bd 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001c3 6a 00 push 0
+ 001c5 6a 01 push 1
+ 001c7 83 c7 24 add edi, 36 ; 00000024H
+ 001ca be 02 00 00 00 mov esi, 2
+ 001cf e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 001d4 83 c4 08 add esp, 8
+$LN26@zipCloseFi:
+
+; 1632 :
+; 1633 : if(uncompressed_size >= 0xffffffff)
+
+ 001d7 8b 4d 10 mov ecx, DWORD PTR _uncompressed_size$[ebp+4]
+ 001da 85 c9 test ecx, ecx
+ 001dc 75 08 jne SHORT $LN57@zipCloseFi
+ 001de 8b 45 0c mov eax, DWORD PTR _uncompressed_size$[ebp]
+ 001e1 83 f8 ff cmp eax, -1
+ 001e4 72 06 jb SHORT $LN25@zipCloseFi
+$LN57@zipCloseFi:
+
+; 1634 : zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/
+
+ 001e6 6a 00 push 0
+ 001e8 6a ff push -1
+
+; 1635 : else
+
+ 001ea eb 02 jmp SHORT $LN87@zipCloseFi
+$LN25@zipCloseFi:
+
+; 1636 : zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/
+
+ 001ec 51 push ecx
+ 001ed 50 push eax
+$LN87@zipCloseFi:
+ 001ee 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001f4 be 04 00 00 00 mov esi, 4
+ 001f9 83 c7 18 add edi, 24 ; 00000018H
+ 001fc e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 00201 83 c4 08 add esp, 8
+
+; 1637 :
+; 1638 : // Add ZIP64 extra info field for uncompressed size
+; 1639 : if(uncompressed_size >= 0xffffffff)
+
+ 00204 83 7d 10 00 cmp DWORD PTR _uncompressed_size$[ebp+4], 0
+ 00208 77 08 ja SHORT $LN58@zipCloseFi
+ 0020a 83 c9 ff or ecx, -1
+ 0020d 39 4d 0c cmp DWORD PTR _uncompressed_size$[ebp], ecx
+ 00210 72 0a jb SHORT $LN71@zipCloseFi
+$LN58@zipCloseFi:
+
+; 1640 : datasize += 8;
+
+ 00212 b8 08 00 00 00 mov eax, 8
+ 00217 83 c9 ff or ecx, -1
+ 0021a eb 04 jmp SHORT $LN23@zipCloseFi
+$LN71@zipCloseFi:
+ 0021c 8b 44 24 10 mov eax, DWORD PTR _datasize$[esp+40]
+$LN23@zipCloseFi:
+
+; 1641 :
+; 1642 : // Add ZIP64 extra info field for compressed size
+; 1643 : if(compressed_size >= 0xffffffff)
+
+ 00220 83 7c 24 1c 00 cmp DWORD PTR _compressed_size$[esp+44], 0
+ 00225 77 06 ja SHORT $LN59@zipCloseFi
+ 00227 39 4c 24 18 cmp DWORD PTR _compressed_size$[esp+40], ecx
+ 0022b 72 03 jb SHORT $LN22@zipCloseFi
+$LN59@zipCloseFi:
+
+; 1644 : datasize += 8;
+
+ 0022d 83 c0 08 add eax, 8
+$LN22@zipCloseFi:
+
+; 1645 :
+; 1646 : // Add ZIP64 extra info field for relative offset to local file header of current file
+; 1647 : if(zi->ci.pos_local_header >= 0xffffffff)
+
+ 00230 83 bb 84 00 00
+ 00 00 cmp DWORD PTR [ebx+132], 0
+ 00237 77 08 ja SHORT $LN60@zipCloseFi
+ 00239 39 8b 80 00 00
+ 00 cmp DWORD PTR [ebx+128], ecx
+ 0023f 72 03 jb SHORT $LN21@zipCloseFi
+$LN60@zipCloseFi:
+
+; 1648 : datasize += 8;
+
+ 00241 83 c0 08 add eax, 8
+$LN21@zipCloseFi:
+
+; 1649 :
+; 1650 : if(datasize > 0)
+
+ 00244 66 85 c0 test ax, ax
+ 00247 0f 8e f6 00 00
+ 00 jle $LN20@zipCloseFi
+
+; 1651 : {
+; 1652 : char* p = NULL;
+; 1653 :
+; 1654 : if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)
+
+ 0024d 98 cwde
+ 0024e 89 44 24 10 mov DWORD PTR tv525[esp+40], eax
+ 00252 83 c0 04 add eax, 4
+ 00255 3b 83 94 00 00
+ 00 cmp eax, DWORD PTR [ebx+148]
+ 0025b 76 0e jbe SHORT $LN19@zipCloseFi
+
+; 1655 : {
+; 1656 : // we can not write more data to the buffer that we have room for.
+; 1657 : return ZIP_BADZIPFILE;
+
+ 0025d b8 99 ff ff ff mov eax, -103 ; ffffff99H
+
+; 1745 : zi->in_opened_file_inzip = 0;
+; 1746 :
+; 1747 : return err;
+; 1748 : }
+
+ 00262 5f pop edi
+ 00263 5e pop esi
+ 00264 5b pop ebx
+ 00265 8b e5 mov esp, ebp
+ 00267 5d pop ebp
+ 00268 c2 10 00 ret 16 ; 00000010H
+$LN19@zipCloseFi:
+
+; 1658 : }
+; 1659 :
+; 1660 : p = zi->ci.central_header + zi->ci.size_centralheader;
+
+ 0026b 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00271 03 bb 90 00 00
+ 00 add edi, DWORD PTR [ebx+144]
+
+; 1661 :
+; 1662 : // Add Extra Information Header for 'ZIP64 information'
+; 1663 : zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID
+
+ 00277 6a 00 push 0
+ 00279 6a 01 push 1
+ 0027b be 02 00 00 00 mov esi, 2
+ 00280 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1664 : p += 2;
+; 1665 : zip64local_putValue_inmemory(p, datasize, 2); // DataSize
+
+ 00285 8b 44 24 18 mov eax, DWORD PTR tv525[esp+48]
+ 00289 99 cdq
+ 0028a 52 push edx
+ 0028b 03 fe add edi, esi
+ 0028d 50 push eax
+ 0028e e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1666 : p += 2;
+; 1667 :
+; 1668 : if(uncompressed_size >= 0xffffffff)
+
+ 00293 8b 45 10 mov eax, DWORD PTR _uncompressed_size$[ebp+4]
+ 00296 83 c4 10 add esp, 16 ; 00000010H
+ 00299 03 fe add edi, esi
+ 0029b 85 c0 test eax, eax
+ 0029d 75 06 jne SHORT $LN61@zipCloseFi
+ 0029f 83 7d 0c ff cmp DWORD PTR _uncompressed_size$[ebp], -1
+ 002a3 72 14 jb SHORT $LN18@zipCloseFi
+$LN61@zipCloseFi:
+
+; 1669 : {
+; 1670 : zip64local_putValue_inmemory(p, uncompressed_size, 8);
+
+ 002a5 8b 4d 0c mov ecx, DWORD PTR _uncompressed_size$[ebp]
+ 002a8 50 push eax
+ 002a9 51 push ecx
+ 002aa be 08 00 00 00 mov esi, 8
+ 002af e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 002b4 83 c4 08 add esp, 8
+
+; 1671 : p += 8;
+
+ 002b7 03 fe add edi, esi
+$LN18@zipCloseFi:
+
+; 1672 : }
+; 1673 :
+; 1674 : if(compressed_size >= 0xffffffff)
+
+ 002b9 8b 44 24 1c mov eax, DWORD PTR _compressed_size$[esp+44]
+ 002bd 85 c0 test eax, eax
+ 002bf 75 07 jne SHORT $LN62@zipCloseFi
+ 002c1 83 7c 24 18 ff cmp DWORD PTR _compressed_size$[esp+40], -1
+ 002c6 72 15 jb SHORT $LN17@zipCloseFi
+$LN62@zipCloseFi:
+
+; 1675 : {
+; 1676 : zip64local_putValue_inmemory(p, compressed_size, 8);
+
+ 002c8 8b 54 24 18 mov edx, DWORD PTR _compressed_size$[esp+40]
+ 002cc 50 push eax
+ 002cd 52 push edx
+ 002ce be 08 00 00 00 mov esi, 8
+ 002d3 e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 002d8 83 c4 08 add esp, 8
+
+; 1677 : p += 8;
+
+ 002db 03 fe add edi, esi
+$LN17@zipCloseFi:
+
+; 1678 : }
+; 1679 :
+; 1680 : if(zi->ci.pos_local_header >= 0xffffffff)
+
+ 002dd 8b 83 84 00 00
+ 00 mov eax, DWORD PTR [ebx+132]
+ 002e3 8b 8b 80 00 00
+ 00 mov ecx, DWORD PTR [ebx+128]
+ 002e9 85 c0 test eax, eax
+ 002eb 75 05 jne SHORT $LN63@zipCloseFi
+ 002ed 83 f9 ff cmp ecx, -1
+ 002f0 72 0f jb SHORT $LN16@zipCloseFi
+$LN63@zipCloseFi:
+
+; 1681 : {
+; 1682 : zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);
+
+ 002f2 50 push eax
+ 002f3 51 push ecx
+ 002f4 be 08 00 00 00 mov esi, 8
+ 002f9 e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 002fe 83 c4 08 add esp, 8
+$LN16@zipCloseFi:
+
+; 1683 : p += 8;
+; 1684 : }
+; 1685 :
+; 1686 : // Update how much extra free space we got in the memory buffer
+; 1687 : // and increase the centralheader size so the new ZIP64 fields are included
+; 1688 : // ( 4 below is the size of HeaderID and DataSize field )
+; 1689 : zi->ci.size_centralExtraFree -= datasize + 4;
+
+ 00301 8b 44 24 10 mov eax, DWORD PTR tv525[esp+40]
+
+; 1690 : zi->ci.size_centralheader += datasize + 4;
+; 1691 :
+; 1692 : // Update the extra info size field
+; 1693 : zi->ci.size_centralExtra += datasize + 4;
+; 1694 : zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2);
+
+ 00305 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 0030b 8d 50 04 lea edx, DWORD PTR [eax+4]
+ 0030e 01 93 90 00 00
+ 00 add DWORD PTR [ebx+144], edx
+ 00314 b9 fc ff ff ff mov ecx, -4 ; fffffffcH
+ 00319 2b c8 sub ecx, eax
+ 0031b 01 8b 94 00 00
+ 00 add DWORD PTR [ebx+148], ecx
+ 00321 83 c0 04 add eax, 4
+ 00324 01 83 8c 00 00
+ 00 add DWORD PTR [ebx+140], eax
+ 0032a 8b 83 8c 00 00
+ 00 mov eax, DWORD PTR [ebx+140]
+ 00330 6a 00 push 0
+ 00332 50 push eax
+ 00333 83 c7 1e add edi, 30 ; 0000001eH
+ 00336 be 02 00 00 00 mov esi, 2
+ 0033b e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 00340 83 c4 08 add esp, 8
+$LN20@zipCloseFi:
+
+; 1695 : }
+; 1696 :
+; 1697 : if (err==ZIP_OK)
+
+ 00343 83 7c 24 0c 00 cmp DWORD PTR _err$[esp+40], 0
+ 00348 75 1e jne SHORT $LN15@zipCloseFi
+
+; 1698 : err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);
+
+ 0034a 8b 83 90 00 00
+ 00 mov eax, DWORD PTR [ebx+144]
+ 00350 8b 8b 88 00 00
+ 00 mov ecx, DWORD PTR [ebx+136]
+ 00356 50 push eax
+ 00357 51 push ecx
+ 00358 8d 53 30 lea edx, DWORD PTR [ebx+48]
+ 0035b 52 push edx
+ 0035c e8 00 00 00 00 call _add_data_in_datablock
+ 00361 83 c4 0c add esp, 12 ; 0000000cH
+ 00364 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+$LN15@zipCloseFi:
+
+; 1699 :
+; 1700 : free(zi->ci.central_header);
+
+ 00368 8b 83 88 00 00
+ 00 mov eax, DWORD PTR [ebx+136]
+ 0036e 50 push eax
+ 0036f e8 00 00 00 00 call _free
+ 00374 83 c4 04 add esp, 4
+
+; 1701 :
+; 1702 : if (err==ZIP_OK)
+
+ 00377 83 7c 24 0c 00 cmp DWORD PTR _err$[esp+40], 0
+ 0037c 0f 85 5d 01 00
+ 00 jne $LN1@zipCloseFi
+
+; 1703 : {
+; 1704 : // Update the LocalFileHeader with the new values.
+; 1705 :
+; 1706 : ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ 00382 8b 4b 2c mov ecx, DWORD PTR [ebx+44]
+ 00385 8b c3 mov eax, ebx
+ 00387 e8 00 00 00 00 call _call_ztell64
+
+; 1707 :
+; 1708 : if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 0038c 8b 8b 80 00 00
+ 00 mov ecx, DWORD PTR [ebx+128]
+ 00392 8b 73 2c mov esi, DWORD PTR [ebx+44]
+ 00395 89 54 24 14 mov DWORD PTR _cur_pos_inzip$83677[esp+44], edx
+ 00399 8b 93 84 00 00
+ 00 mov edx, DWORD PTR [ebx+132]
+ 0039f 83 c1 0e add ecx, 14 ; 0000000eH
+ 003a2 83 d2 00 adc edx, 0
+ 003a5 52 push edx
+ 003a6 89 44 24 14 mov DWORD PTR _cur_pos_inzip$83677[esp+44], eax
+ 003aa 51 push ecx
+ 003ab 33 d2 xor edx, edx
+ 003ad 8b c3 mov eax, ebx
+ 003af e8 00 00 00 00 call _call_zseek64
+ 003b4 83 c4 08 add esp, 8
+ 003b7 85 c0 test eax, eax
+ 003b9 74 09 je SHORT $LN51@zipCloseFi
+
+; 1709 : err = ZIP_ERRNO;
+
+ 003bb 83 cf ff or edi, -1
+ 003be 89 7c 24 0c mov DWORD PTR _err$[esp+40], edi
+
+; 1710 :
+; 1711 : if (err==ZIP_OK)
+
+ 003c2 eb 22 jmp SHORT $LN12@zipCloseFi
+$LN51@zipCloseFi:
+
+; 1712 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
+
+ 003c4 8b 44 24 24 mov eax, DWORD PTR tv511[esp+44]
+ 003c8 8b 4d 14 mov ecx, DWORD PTR _crc32$[ebp]
+ 003cb 8b 53 2c mov edx, DWORD PTR [ebx+44]
+ 003ce 50 push eax
+ 003cf 51 push ecx
+ 003d0 52 push edx
+ 003d1 be 04 00 00 00 mov esi, 4
+ 003d6 8b fb mov edi, ebx
+ 003d8 e8 00 00 00 00 call _zip64local_putValue
+ 003dd 83 c4 0c add esp, 12 ; 0000000cH
+ 003e0 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+ 003e4 8b f8 mov edi, eax
+$LN12@zipCloseFi:
+
+; 1713 :
+; 1714 : if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff )
+
+ 003e6 83 7d 10 00 cmp DWORD PTR _uncompressed_size$[ebp+4], 0
+ 003ea 77 4c ja SHORT $LN10@zipCloseFi
+ 003ec 72 06 jb SHORT $LN64@zipCloseFi
+ 003ee 83 7d 0c ff cmp DWORD PTR _uncompressed_size$[ebp], -1
+ 003f2 73 44 jae SHORT $LN10@zipCloseFi
+$LN64@zipCloseFi:
+ 003f4 8b 44 24 1c mov eax, DWORD PTR _compressed_size$[esp+44]
+ 003f8 85 c0 test eax, eax
+ 003fa 77 3c ja SHORT $LN10@zipCloseFi
+ 003fc 72 07 jb SHORT $LN65@zipCloseFi
+ 003fe 83 7c 24 18 ff cmp DWORD PTR _compressed_size$[esp+40], -1
+ 00403 73 33 jae SHORT $LN10@zipCloseFi
+$LN65@zipCloseFi:
+
+; 1730 : }
+; 1731 : else
+; 1732 : {
+; 1733 : if (err==ZIP_OK) /* compressed size, unknown */
+
+ 00405 85 ff test edi, edi
+ 00407 0f 85 ad 00 00
+ 00 jne $LN5@zipCloseFi
+
+; 1734 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
+
+ 0040d 8b 4b 2c mov ecx, DWORD PTR [ebx+44]
+ 00410 50 push eax
+ 00411 8b 44 24 1c mov eax, DWORD PTR _compressed_size$[esp+44]
+ 00415 50 push eax
+ 00416 8d 77 04 lea esi, DWORD PTR [edi+4]
+ 00419 51 push ecx
+ 0041a 8b fb mov edi, ebx
+ 0041c e8 00 00 00 00 call _zip64local_putValue
+ 00421 83 c4 0c add esp, 12 ; 0000000cH
+ 00424 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+
+; 1735 :
+; 1736 : if (err==ZIP_OK) /* uncompressed size, unknown */
+
+ 00428 85 c0 test eax, eax
+ 0042a 0f 85 8a 00 00
+ 00 jne $LN5@zipCloseFi
+
+; 1737 : err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
+
+ 00430 8b 55 10 mov edx, DWORD PTR _uncompressed_size$[ebp+4]
+ 00433 8b 45 0c mov eax, DWORD PTR _uncompressed_size$[ebp]
+ 00436 eb 66 jmp SHORT $LN90@zipCloseFi
+$LN10@zipCloseFi:
+
+; 1715 : {
+; 1716 : if(zi->ci.pos_zip64extrainfo > 0)
+
+ 00438 8b 83 bc 00 01
+ 00 mov eax, DWORD PTR [ebx+65724]
+ 0043e 8b 8b b8 00 01
+ 00 mov ecx, DWORD PTR [ebx+65720]
+ 00444 85 c0 test eax, eax
+ 00446 75 04 jne SHORT $LN66@zipCloseFi
+ 00448 85 c9 test ecx, ecx
+ 0044a 74 66 je SHORT $LN9@zipCloseFi
+$LN66@zipCloseFi:
+
+; 1717 : {
+; 1718 : // Update the size in the ZIP64 extended field.
+; 1719 : if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 0044c 8b 73 2c mov esi, DWORD PTR [ebx+44]
+ 0044f 83 c1 04 add ecx, 4
+ 00452 83 d0 00 adc eax, 0
+ 00455 50 push eax
+ 00456 51 push ecx
+ 00457 33 d2 xor edx, edx
+ 00459 8b c3 mov eax, ebx
+ 0045b e8 00 00 00 00 call _call_zseek64
+ 00460 83 c4 08 add esp, 8
+ 00463 85 c0 test eax, eax
+ 00465 74 0a je SHORT $LN8@zipCloseFi
+
+; 1720 : err = ZIP_ERRNO;
+
+ 00467 c7 44 24 0c ff
+ ff ff ff mov DWORD PTR _err$[esp+40], -1
+
+; 1721 :
+; 1722 : if (err==ZIP_OK) /* compressed size, unknown */
+
+ 0046f eb 49 jmp SHORT $LN5@zipCloseFi
+$LN8@zipCloseFi:
+ 00471 85 ff test edi, edi
+ 00473 75 45 jne SHORT $LN5@zipCloseFi
+
+; 1723 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);
+
+ 00475 8b 55 10 mov edx, DWORD PTR _uncompressed_size$[ebp+4]
+ 00478 8b 45 0c mov eax, DWORD PTR _uncompressed_size$[ebp]
+ 0047b 8b 4b 2c mov ecx, DWORD PTR [ebx+44]
+ 0047e 52 push edx
+ 0047f 50 push eax
+ 00480 8d 77 08 lea esi, DWORD PTR [edi+8]
+ 00483 51 push ecx
+ 00484 8b fb mov edi, ebx
+ 00486 e8 00 00 00 00 call _zip64local_putValue
+ 0048b 83 c4 0c add esp, 12 ; 0000000cH
+ 0048e 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+
+; 1724 :
+; 1725 : if (err==ZIP_OK) /* uncompressed size, unknown */
+
+ 00492 85 c0 test eax, eax
+ 00494 75 24 jne SHORT $LN5@zipCloseFi
+
+; 1726 : err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);
+
+ 00496 8b 54 24 1c mov edx, DWORD PTR _compressed_size$[esp+44]
+ 0049a 8b 44 24 18 mov eax, DWORD PTR _compressed_size$[esp+40]
+$LN90@zipCloseFi:
+ 0049e 8b 4b 2c mov ecx, DWORD PTR [ebx+44]
+ 004a1 52 push edx
+ 004a2 50 push eax
+ 004a3 51 push ecx
+ 004a4 e8 00 00 00 00 call _zip64local_putValue
+ 004a9 83 c4 0c add esp, 12 ; 0000000cH
+ 004ac 89 44 24 0c mov DWORD PTR _err$[esp+40], eax
+
+; 1727 : }
+; 1728 : else
+
+ 004b0 eb 08 jmp SHORT $LN5@zipCloseFi
+$LN9@zipCloseFi:
+
+; 1729 : err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal
+
+ 004b2 c7 44 24 0c 99
+ ff ff ff mov DWORD PTR _err$[esp+40], -103 ; ffffff99H
+$LN5@zipCloseFi:
+
+; 1738 : }
+; 1739 :
+; 1740 : if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
+
+ 004ba 8b 54 24 14 mov edx, DWORD PTR _cur_pos_inzip$83677[esp+44]
+ 004be 8b 44 24 10 mov eax, DWORD PTR _cur_pos_inzip$83677[esp+40]
+ 004c2 8b 73 2c mov esi, DWORD PTR [ebx+44]
+ 004c5 52 push edx
+ 004c6 50 push eax
+ 004c7 33 d2 xor edx, edx
+ 004c9 8b c3 mov eax, ebx
+ 004cb e8 00 00 00 00 call _call_zseek64
+ 004d0 83 c4 08 add esp, 8
+ 004d3 85 c0 test eax, eax
+ 004d5 74 08 je SHORT $LN1@zipCloseFi
+
+; 1741 : err = ZIP_ERRNO;
+
+ 004d7 c7 44 24 0c ff
+ ff ff ff mov DWORD PTR _err$[esp+40], -1
+$LN1@zipCloseFi:
+
+; 1742 : }
+; 1743 :
+; 1744 : zi->number_entry ++;
+
+ 004df 83 83 f8 00 01
+ 00 01 add DWORD PTR [ebx+65784], 1
+ 004e6 b8 00 00 00 00 mov eax, 0
+
+; 1745 : zi->in_opened_file_inzip = 0;
+; 1746 :
+; 1747 : return err;
+; 1748 : }
+
+ 004eb 5f pop edi
+ 004ec 11 83 fc 00 01
+ 00 adc DWORD PTR [ebx+65788], eax
+ 004f2 89 43 38 mov DWORD PTR [ebx+56], eax
+ 004f5 8b 44 24 08 mov eax, DWORD PTR _err$[esp+36]
+ 004f9 5e pop esi
+ 004fa 5b pop ebx
+ 004fb 8b e5 mov esp, ebp
+ 004fd 5d pop ebp
+ 004fe c2 10 00 ret 16 ; 00000010H
+_zipCloseFileInZipRaw64@16 ENDP
+_TEXT ENDS
+PUBLIC _zipCloseFileInZipRaw@12
+; Function compile flags: /Ogtp
+; COMDAT _zipCloseFileInZipRaw@12
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_uncompressed_size$ = 12 ; size = 4
+_crc32$ = 16 ; size = 4
+_zipCloseFileInZipRaw@12 PROC ; COMDAT
+
+; 1510 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 e4 f8 and esp, -8 ; fffffff8H
+
+; 1511 : return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
+
+ 00006 8b 45 10 mov eax, DWORD PTR _crc32$[ebp]
+ 00009 8b 4d 0c mov ecx, DWORD PTR _uncompressed_size$[ebp]
+ 0000c 8b 55 08 mov edx, DWORD PTR _file$[ebp]
+ 0000f 50 push eax
+ 00010 6a 00 push 0
+ 00012 51 push ecx
+ 00013 52 push edx
+ 00014 e8 00 00 00 00 call _zipCloseFileInZipRaw64@16
+
+; 1512 : }
+
+ 00019 8b e5 mov esp, ebp
+ 0001b 5d pop ebp
+ 0001c c2 0c 00 ret 12 ; 0000000cH
+_zipCloseFileInZipRaw@12 ENDP
+_TEXT ENDS
+PUBLIC _zipWriteInFileInZip@12
+; Function compile flags: /Ogtp
+; COMDAT _zipWriteInFileInZip@12
+_TEXT SEGMENT
+_err$ = -4 ; size = 4
+_file$ = 8 ; size = 4
+_buf$ = 12 ; size = 4
+_len$ = 16 ; size = 4
+_zipWriteInFileInZip@12 PROC ; COMDAT
+
+; 1403 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 51 push ecx
+ 00004 53 push ebx
+
+; 1404 : zip64_internal* zi;
+; 1405 : int err=ZIP_OK;
+; 1406 :
+; 1407 : if (file == NULL)
+
+ 00005 8b 5d 08 mov ebx, DWORD PTR _file$[ebp]
+ 00008 c7 45 fc 00 00
+ 00 00 mov DWORD PTR _err$[ebp], 0
+ 0000f 85 db test ebx, ebx
+ 00011 75 0c jne SHORT $LN15@zipWriteIn
+$LN24@zipWriteIn:
+
+; 1408 : return ZIP_PARAMERROR;
+
+ 00013 b8 9a ff ff ff mov eax, -102 ; ffffff9aH
+ 00018 5b pop ebx
+
+; 1507 : }
+
+ 00019 8b e5 mov esp, ebp
+ 0001b 5d pop ebp
+ 0001c c2 0c 00 ret 12 ; 0000000cH
+$LN15@zipWriteIn:
+
+; 1409 : zi = (zip64_internal*)file;
+; 1410 :
+; 1411 : if (zi->in_opened_file_inzip == 0)
+
+ 0001f 83 7b 38 00 cmp DWORD PTR [ebx+56], 0
+
+; 1412 : return ZIP_PARAMERROR;
+
+ 00023 74 ee je SHORT $LN24@zipWriteIn
+
+; 1413 :
+; 1414 : zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len);
+
+ 00025 8b 45 0c mov eax, DWORD PTR _buf$[ebp]
+ 00028 8b 8b a8 00 01
+ 00 mov ecx, DWORD PTR [ebx+65704]
+ 0002e 56 push esi
+ 0002f 8b 75 10 mov esi, DWORD PTR _len$[ebp]
+ 00032 57 push edi
+ 00033 56 push esi
+ 00034 50 push eax
+ 00035 51 push ecx
+ 00036 e8 00 00 00 00 call _crc32@12
+
+; 1415 :
+; 1416 : #ifdef HAVE_BZIP2
+; 1417 : if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw))
+; 1418 : {
+; 1419 : zi->ci.bstream.next_in = (void*)buf;
+; 1420 : zi->ci.bstream.avail_in = len;
+; 1421 : err = BZ_RUN_OK;
+; 1422 :
+; 1423 : while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0))
+; 1424 : {
+; 1425 : if (zi->ci.bstream.avail_out == 0)
+; 1426 : {
+; 1427 : if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+; 1428 : err = ZIP_ERRNO;
+; 1429 : zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+; 1430 : zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+; 1431 : }
+; 1432 :
+; 1433 :
+; 1434 : if(err != BZ_RUN_OK)
+; 1435 : break;
+; 1436 :
+; 1437 : if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+; 1438 : {
+; 1439 : uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;
+; 1440 : // uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;
+; 1441 : err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN);
+; 1442 :
+; 1443 : zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ;
+; 1444 : }
+; 1445 : }
+; 1446 :
+; 1447 : if(err == BZ_RUN_OK)
+; 1448 : err = ZIP_OK;
+; 1449 : }
+; 1450 : else
+; 1451 : #endif
+; 1452 : {
+; 1453 : zi->ci.stream.next_in = (Bytef*)buf;
+
+ 0003b 8b 55 0c mov edx, DWORD PTR _buf$[ebp]
+ 0003e 8d 7b 40 lea edi, DWORD PTR [ebx+64]
+ 00041 89 83 a8 00 01
+ 00 mov DWORD PTR [ebx+65704], eax
+ 00047 89 17 mov DWORD PTR [edi], edx
+
+; 1454 : zi->ci.stream.avail_in = len;
+
+ 00049 89 73 44 mov DWORD PTR [ebx+68], esi
+ 0004c 8d 64 24 00 npad 4
+$LL13@zipWriteIn:
+
+; 1455 :
+; 1456 : while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
+
+ 00050 83 7b 44 00 cmp DWORD PTR [ebx+68], 0
+ 00054 76 55 jbe SHORT $LN23@zipWriteIn
+
+; 1457 : {
+; 1458 : if (zi->ci.stream.avail_out == 0)
+
+ 00056 83 7b 50 00 cmp DWORD PTR [ebx+80], 0
+ 0005a 75 1d jne SHORT $LN11@zipWriteIn
+
+; 1459 : {
+; 1460 : if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+
+ 0005c e8 00 00 00 00 call _zip64FlushWriteBuffer
+ 00061 83 f8 ff cmp eax, -1
+ 00064 75 03 jne SHORT $LN10@zipWriteIn
+
+; 1461 : err = ZIP_ERRNO;
+
+ 00066 89 45 fc mov DWORD PTR _err$[ebp], eax
+$LN10@zipWriteIn:
+
+; 1462 : zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+; 1463 : zi->ci.stream.next_out = zi->ci.buffered_data;
+
+ 00069 8d 83 a4 00 00
+ 00 lea eax, DWORD PTR [ebx+164]
+ 0006f c7 43 50 00 00
+ 01 00 mov DWORD PTR [ebx+80], 65536 ; 00010000H
+ 00076 89 43 4c mov DWORD PTR [ebx+76], eax
+$LN11@zipWriteIn:
+
+; 1464 : }
+; 1465 :
+; 1466 :
+; 1467 : if(err != ZIP_OK)
+
+ 00079 83 7d fc 00 cmp DWORD PTR _err$[ebp], 0
+ 0007d 75 2c jne SHORT $LN23@zipWriteIn
+
+; 1468 : break;
+; 1469 :
+; 1470 : if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+
+ 0007f 83 bb 9c 00 00
+ 00 08 cmp DWORD PTR [ebx+156], 8
+ 00086 75 2f jne SHORT $LN8@zipWriteIn
+ 00088 83 bb a0 00 00
+ 00 00 cmp DWORD PTR [ebx+160], 0
+ 0008f 75 26 jne SHORT $LN8@zipWriteIn
+
+; 1471 : {
+; 1472 : uLong uTotalOutBefore = zi->ci.stream.total_out;
+
+ 00091 8b 73 54 mov esi, DWORD PTR [ebx+84]
+
+; 1473 : err=deflate(&zi->ci.stream, Z_NO_FLUSH);
+
+ 00094 6a 00 push 0
+ 00096 57 push edi
+ 00097 e8 00 00 00 00 call _deflate@8
+
+; 1474 : if(uTotalOutBefore > zi->ci.stream.total_out)
+; 1475 : {
+; 1476 : int bBreak = 0;
+; 1477 : bBreak++;
+; 1478 : }
+; 1479 :
+; 1480 : zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+
+ 0009c 8b 4b 54 mov ecx, DWORD PTR [ebx+84]
+ 0009f 2b ce sub ecx, esi
+ 000a1 01 4b 7c add DWORD PTR [ebx+124], ecx
+ 000a4 89 45 fc mov DWORD PTR _err$[ebp], eax
+ 000a7 85 c0 test eax, eax
+ 000a9 74 a5 je SHORT $LL13@zipWriteIn
+$LN23@zipWriteIn:
+
+; 1501 : }
+; 1502 : }
+; 1503 : }// while(...)
+; 1504 : }
+; 1505 :
+; 1506 : return err;
+
+ 000ab 8b 45 fc mov eax, DWORD PTR _err$[ebp]
+ 000ae 5f pop edi
+ 000af 5e pop esi
+ 000b0 5b pop ebx
+
+; 1507 : }
+
+ 000b1 8b e5 mov esp, ebp
+ 000b3 5d pop ebp
+ 000b4 c2 0c 00 ret 12 ; 0000000cH
+$LN8@zipWriteIn:
+
+; 1481 : }
+; 1482 : else
+; 1483 : {
+; 1484 : uInt copy_this,i;
+; 1485 : if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
+
+ 000b7 8b 43 50 mov eax, DWORD PTR [ebx+80]
+ 000ba 8b 73 44 mov esi, DWORD PTR [ebx+68]
+ 000bd 3b f0 cmp esi, eax
+
+; 1486 : copy_this = zi->ci.stream.avail_in;
+; 1487 : else
+
+ 000bf 72 02 jb SHORT $LN4@zipWriteIn
+
+; 1488 : copy_this = zi->ci.stream.avail_out;
+
+ 000c1 8b f0 mov esi, eax
+$LN4@zipWriteIn:
+
+; 1489 :
+; 1490 : for (i = 0; i < copy_this; i++)
+
+ 000c3 33 c0 xor eax, eax
+ 000c5 85 f6 test esi, esi
+ 000c7 74 17 je SHORT $LN1@zipWriteIn
+ 000c9 8d a4 24 00 00
+ 00 00 npad 7
+$LL3@zipWriteIn:
+
+; 1491 : *(((char*)zi->ci.stream.next_out)+i) =
+; 1492 : *(((const char*)zi->ci.stream.next_in)+i);
+
+ 000d0 8b 17 mov edx, DWORD PTR [edi]
+ 000d2 8a 14 10 mov dl, BYTE PTR [eax+edx]
+ 000d5 8b 4b 4c mov ecx, DWORD PTR [ebx+76]
+ 000d8 88 14 08 mov BYTE PTR [eax+ecx], dl
+ 000db 40 inc eax
+ 000dc 3b c6 cmp eax, esi
+ 000de 72 f0 jb SHORT $LL3@zipWriteIn
+$LN1@zipWriteIn:
+
+; 1493 : {
+; 1494 : zi->ci.stream.avail_in -= copy_this;
+
+ 000e0 29 73 44 sub DWORD PTR [ebx+68], esi
+
+; 1495 : zi->ci.stream.avail_out-= copy_this;
+
+ 000e3 29 73 50 sub DWORD PTR [ebx+80], esi
+
+; 1496 : zi->ci.stream.next_in+= copy_this;
+
+ 000e6 01 37 add DWORD PTR [edi], esi
+
+; 1497 : zi->ci.stream.next_out+= copy_this;
+
+ 000e8 01 73 4c add DWORD PTR [ebx+76], esi
+
+; 1498 : zi->ci.stream.total_in+= copy_this;
+
+ 000eb 01 73 48 add DWORD PTR [ebx+72], esi
+
+; 1499 : zi->ci.stream.total_out+= copy_this;
+
+ 000ee 01 73 54 add DWORD PTR [ebx+84], esi
+
+; 1500 : zi->ci.pos_in_buffered_data += copy_this;
+
+ 000f1 01 73 7c add DWORD PTR [ebx+124], esi
+ 000f4 e9 57 ff ff ff jmp $LL13@zipWriteIn
+_zipWriteInFileInZip@12 ENDP
+_TEXT ENDS
+PUBLIC _zipOpen3@16
+EXTRN __chkstk:PROC
+; Function compile flags: /Ogtp
+; COMDAT _zipOpen3@16
+_TEXT SEGMENT
+_ziinit$ = -65800 ; size = 65800
+_pathname$ = 8 ; size = 4
+_append$ = 12 ; size = 4
+_globalcomment$ = 16 ; size = 4
+_zipOpen3@16 PROC ; COMDAT
+; _pzlib_filefunc64_32_def$ = ecx
+
+; 850 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 e4 f8 and esp, -8 ; fffffff8H
+ 00006 b8 0c 01 01 00 mov eax, 65804 ; 0001010cH
+ 0000b e8 00 00 00 00 call __chkstk
+ 00010 53 push ebx
+ 00011 56 push esi
+
+; 851 : zip64_internal ziinit;
+; 852 : zip64_internal* zi;
+; 853 : int err=ZIP_OK;
+
+ 00012 33 db xor ebx, ebx
+ 00014 8b f1 mov esi, ecx
+ 00016 57 push edi
+
+; 854 :
+; 855 : ziinit.z_filefunc.zseek32_file = NULL;
+
+ 00017 89 5c 24 38 mov DWORD PTR _ziinit$[esp+65856], ebx
+
+; 856 : ziinit.z_filefunc.ztell32_file = NULL;
+
+ 0001b 89 5c 24 34 mov DWORD PTR _ziinit$[esp+65852], ebx
+
+; 857 : if (pzlib_filefunc64_32_def==NULL)
+
+ 0001f 3b f3 cmp esi, ebx
+ 00021 75 0b jne SHORT $LN11@zipOpen3
+
+; 858 : fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);
+
+ 00023 8d 44 24 10 lea eax, DWORD PTR _ziinit$[esp+65816]
+ 00027 e8 00 00 00 00 call _fill_fopen64_filefunc
+
+; 859 : else
+
+ 0002c eb 0b jmp SHORT $LN10@zipOpen3
+$LN11@zipOpen3:
+
+; 860 : ziinit.z_filefunc = *pzlib_filefunc64_32_def;
+
+ 0002e b9 0b 00 00 00 mov ecx, 11 ; 0000000bH
+ 00033 8d 7c 24 10 lea edi, DWORD PTR _ziinit$[esp+65816]
+ 00037 f3 a5 rep movsd
+$LN10@zipOpen3:
+
+; 861 :
+; 862 : ziinit.filestream = ZOPEN64(ziinit.z_filefunc,
+; 863 : pathname,
+; 864 : (append == APPEND_STATUS_CREATE) ?
+; 865 : (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
+; 866 : (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
+
+ 00039 8b 7d 0c mov edi, DWORD PTR _append$[ebp]
+ 0003c 8b 75 08 mov esi, DWORD PTR _pathname$[ebp]
+ 0003f 33 d2 xor edx, edx
+ 00041 3b fb cmp edi, ebx
+ 00043 0f 94 c2 sete dl
+ 00046 8d 44 24 10 lea eax, DWORD PTR _ziinit$[esp+65816]
+ 0004a 8d 14 95 07 00
+ 00 00 lea edx, DWORD PTR [edx*4+7]
+ 00051 e8 00 00 00 00 call _call_zopen64
+ 00056 8b f0 mov esi, eax
+ 00058 89 74 24 3c mov DWORD PTR _ziinit$[esp+65860], esi
+
+; 867 :
+; 868 : if (ziinit.filestream == NULL)
+
+ 0005c 3b f3 cmp esi, ebx
+
+; 869 : return NULL;
+
+ 0005e 0f 84 83 00 00
+ 00 je $LN15@zipOpen3
+
+; 870 :
+; 871 : if (append == APPEND_STATUS_CREATEAFTER)
+
+ 00064 83 ff 01 cmp edi, 1
+ 00067 75 11 jne SHORT $LN8@zipOpen3
+
+; 872 : ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);
+
+ 00069 53 push ebx
+ 0006a 53 push ebx
+ 0006b 8d 57 01 lea edx, DWORD PTR [edi+1]
+ 0006e 8d 44 24 18 lea eax, DWORD PTR _ziinit$[esp+65824]
+ 00072 e8 00 00 00 00 call _call_zseek64
+ 00077 83 c4 08 add esp, 8
+$LN8@zipOpen3:
+
+; 873 :
+; 874 : ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);
+
+ 0007a 8b ce mov ecx, esi
+ 0007c 8d 44 24 10 lea eax, DWORD PTR _ziinit$[esp+65816]
+ 00080 e8 00 00 00 00 call _call_ztell64
+ 00085 89 84 24 f8 00
+ 01 00 mov DWORD PTR _ziinit$[esp+131584], eax
+
+; 875 : ziinit.in_opened_file_inzip = 0;
+; 876 : ziinit.ci.stream_initialised = 0;
+; 877 : ziinit.number_entry = 0;
+; 878 : ziinit.add_position_when_writting_offset = 0;
+; 879 : init_linkedlist(&(ziinit.central_dir));
+
+ 0008c 8d 44 24 40 lea eax, DWORD PTR _ziinit$[esp+65864]
+ 00090 89 94 24 fc 00
+ 01 00 mov DWORD PTR _ziinit$[esp+131588], edx
+ 00097 89 5c 24 48 mov DWORD PTR _ziinit$[esp+65872], ebx
+ 0009b 89 9c 24 88 00
+ 00 00 mov DWORD PTR _ziinit$[esp+65936], ebx
+ 000a2 89 9c 24 08 01
+ 01 00 mov DWORD PTR _ziinit$[esp+131600], ebx
+ 000a9 89 9c 24 0c 01
+ 01 00 mov DWORD PTR _ziinit$[esp+131604], ebx
+ 000b0 89 9c 24 00 01
+ 01 00 mov DWORD PTR _ziinit$[esp+131592], ebx
+ 000b7 89 9c 24 04 01
+ 01 00 mov DWORD PTR _ziinit$[esp+131596], ebx
+ 000be e8 00 00 00 00 call _init_linkedlist
+
+; 880 :
+; 881 :
+; 882 :
+; 883 : zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));
+
+ 000c3 68 08 01 01 00 push 65800 ; 00010108H
+ 000c8 e8 00 00 00 00 call _malloc
+ 000cd 8b f0 mov esi, eax
+ 000cf 83 c4 04 add esp, 4
+
+; 884 : if (zi==NULL)
+
+ 000d2 3b f3 cmp esi, ebx
+ 000d4 75 1c jne SHORT $LN7@zipOpen3
+
+; 885 : {
+; 886 : ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);
+
+ 000d6 8b 44 24 3c mov eax, DWORD PTR _ziinit$[esp+65860]
+ 000da 8b 4c 24 2c mov ecx, DWORD PTR _ziinit$[esp+65844]
+ 000de 50 push eax
+ 000df 51 push ecx
+ 000e0 ff 54 24 2c call DWORD PTR _ziinit$[esp+65844]
+ 000e4 83 c4 08 add esp, 8
+$LN15@zipOpen3:
+
+; 887 : return NULL;
+
+ 000e7 33 c0 xor eax, eax
+
+; 916 : return (zipFile)zi;
+; 917 : }
+; 918 : }
+
+ 000e9 5f pop edi
+ 000ea 5e pop esi
+ 000eb 5b pop ebx
+ 000ec 8b e5 mov esp, ebp
+ 000ee 5d pop ebp
+ 000ef c2 0c 00 ret 12 ; 0000000cH
+$LN7@zipOpen3:
+
+; 888 : }
+; 889 :
+; 890 : /* now we add file in a zipfile */
+; 891 : # ifndef NO_ADDFILEINEXISTINGZIP
+; 892 : ziinit.globalcomment = NULL;
+
+ 000f2 33 c9 xor ecx, ecx
+ 000f4 89 8c 24 10 01
+ 01 00 mov DWORD PTR _ziinit$[esp+131608], ecx
+
+; 893 : if (append == APPEND_STATUS_ADDINZIP)
+
+ 000fb 83 ff 02 cmp edi, 2
+ 000fe 75 12 jne SHORT $LN14@zipOpen3
+
+; 894 : {
+; 895 : // Read and Cache Central Directory Records
+; 896 : err = LoadCentralDirectoryRecord(&ziinit);
+
+ 00100 8d 7c 24 10 lea edi, DWORD PTR _ziinit$[esp+65816]
+ 00104 e8 00 00 00 00 call _LoadCentralDirectoryRecord
+ 00109 8b 8c 24 10 01
+ 01 00 mov ecx, DWORD PTR _ziinit$[esp+131608]
+ 00110 eb 02 jmp SHORT $LN6@zipOpen3
+$LN14@zipOpen3:
+ 00112 8b c1 mov eax, ecx
+$LN6@zipOpen3:
+
+; 897 : }
+; 898 :
+; 899 : if (globalcomment)
+
+ 00114 8b 55 10 mov edx, DWORD PTR _globalcomment$[ebp]
+ 00117 3b d3 cmp edx, ebx
+ 00119 74 02 je SHORT $LN5@zipOpen3
+
+; 900 : {
+; 901 : *globalcomment = ziinit.globalcomment;
+
+ 0011b 89 0a mov DWORD PTR [edx], ecx
+$LN5@zipOpen3:
+
+; 902 : }
+; 903 : # endif /* !NO_ADDFILEINEXISTINGZIP*/
+; 904 :
+; 905 : if (err != ZIP_OK)
+
+ 0011d 3b c3 cmp eax, ebx
+ 0011f 74 21 je SHORT $LN4@zipOpen3
+
+; 906 : {
+; 907 : # ifndef NO_ADDFILEINEXISTINGZIP
+; 908 : TRYFREE(ziinit.globalcomment);
+
+ 00121 3b cb cmp ecx, ebx
+ 00123 74 09 je SHORT $LN3@zipOpen3
+ 00125 51 push ecx
+ 00126 e8 00 00 00 00 call _free
+ 0012b 83 c4 04 add esp, 4
+$LN3@zipOpen3:
+
+; 909 : # endif /* !NO_ADDFILEINEXISTINGZIP*/
+; 910 : TRYFREE(zi);
+
+ 0012e 56 push esi
+ 0012f e8 00 00 00 00 call _free
+ 00134 83 c4 04 add esp, 4
+
+; 911 : return NULL;
+
+ 00137 33 c0 xor eax, eax
+
+; 916 : return (zipFile)zi;
+; 917 : }
+; 918 : }
+
+ 00139 5f pop edi
+ 0013a 5e pop esi
+ 0013b 5b pop ebx
+ 0013c 8b e5 mov esp, ebp
+ 0013e 5d pop ebp
+ 0013f c2 0c 00 ret 12 ; 0000000cH
+$LN4@zipOpen3:
+
+; 912 : }
+; 913 : else
+; 914 : {
+; 915 : *zi = ziinit;
+
+ 00142 68 08 01 01 00 push 65800 ; 00010108H
+ 00147 8d 54 24 14 lea edx, DWORD PTR _ziinit$[esp+65820]
+ 0014b 52 push edx
+ 0014c 56 push esi
+ 0014d e8 00 00 00 00 call _memcpy
+ 00152 83 c4 0c add esp, 12 ; 0000000cH
+
+; 916 : return (zipFile)zi;
+; 917 : }
+; 918 : }
+
+ 00155 5f pop edi
+ 00156 8b c6 mov eax, esi
+ 00158 5e pop esi
+ 00159 5b pop ebx
+ 0015a 8b e5 mov esp, ebp
+ 0015c 5d pop ebp
+ 0015d c2 0c 00 ret 12 ; 0000000cH
+_zipOpen3@16 ENDP
+PUBLIC _zipCloseFileInZip@4
+; Function compile flags: /Ogtp
+; COMDAT _zipCloseFileInZip@4
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_zipCloseFileInZip@4 PROC ; COMDAT
+
+; 1751 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 1752 : return zipCloseFileInZipRaw (file,0,0);
+
+ 00003 8b 45 08 mov eax, DWORD PTR _file$[ebp]
+ 00006 6a 00 push 0
+ 00008 6a 00 push 0
+ 0000a 50 push eax
+ 0000b e8 00 00 00 00 call _zipCloseFileInZipRaw@12
+
+; 1753 : }
+
+ 00010 5d pop ebp
+ 00011 c2 04 00 ret 4
+_zipCloseFileInZip@4 ENDP
+_TEXT ENDS
+PUBLIC _zipOpenNewFileInZip4_64@76
+; Function compile flags: /Ogtp
+; COMDAT _zipOpenNewFileInZip4_64@76
+_TEXT SEGMENT
+_size_comment$ = -20 ; size = 4
+tv878 = -16 ; size = 4
+_size_filename$ = -16 ; size = 4
+_bufHead$83356 = -12 ; size = 12
+_file$ = 8 ; size = 4
+_filename$ = 12 ; size = 4
+_zipfi$ = 16 ; size = 4
+_extrafield_local$ = 20 ; size = 4
+_size_extrafield_local$ = 24 ; size = 4
+_extrafield_global$ = 28 ; size = 4
+_size_extrafield_global$ = 32 ; size = 4
+_comment$ = 36 ; size = 4
+_method$ = 40 ; size = 4
+_level$ = 44 ; size = 4
+_raw$ = 48 ; size = 4
+_windowBits$ = 52 ; size = 4
+_memLevel$ = 56 ; size = 4
+_strategy$ = 60 ; size = 4
+_password$ = 64 ; size = 4
+_crcForCrypting$ = 68 ; size = 4
+_versionMadeBy$ = 72 ; size = 4
+_flagBase$ = 76 ; size = 4
+_zip64$ = 80 ; size = 4
+_zipOpenNewFileInZip4_64@76 PROC ; COMDAT
+
+; 1062 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 e4 f8 and esp, -8 ; fffffff8H
+ 00006 83 ec 14 sub esp, 20 ; 00000014H
+ 00009 53 push ebx
+
+; 1063 : zip64_internal* zi;
+; 1064 : uInt size_filename;
+; 1065 : uInt size_comment;
+; 1066 : uInt i;
+; 1067 : int err = ZIP_OK;
+; 1068 :
+; 1069 : # ifdef NOCRYPT
+; 1070 : (crcForCrypting);
+; 1071 : if (password != NULL)
+; 1072 : return ZIP_PARAMERROR;
+; 1073 : # endif
+; 1074 :
+; 1075 : if (file == NULL)
+
+ 0000a 8b 5d 08 mov ebx, DWORD PTR _file$[ebp]
+ 0000d 56 push esi
+ 0000e 57 push edi
+ 0000f 33 ff xor edi, edi
+ 00011 3b df cmp ebx, edi
+ 00013 75 0e jne SHORT $LN41@zipOpenNew
+$LN64@zipOpenNew:
+
+; 1076 : return ZIP_PARAMERROR;
+
+ 00015 b8 9a ff ff ff mov eax, -102 ; ffffff9aH
+
+; 1263 : }
+
+ 0001a 5f pop edi
+ 0001b 5e pop esi
+ 0001c 5b pop ebx
+ 0001d 8b e5 mov esp, ebp
+ 0001f 5d pop ebp
+ 00020 c2 4c 00 ret 76 ; 0000004cH
+$LN41@zipOpenNew:
+
+; 1077 :
+; 1078 : #ifdef HAVE_BZIP2
+; 1079 : if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED))
+; 1080 : return ZIP_PARAMERROR;
+; 1081 : #else
+; 1082 : if ((method!=0) && (method!=Z_DEFLATED))
+
+ 00023 8b 45 28 mov eax, DWORD PTR _method$[ebp]
+ 00026 3b c7 cmp eax, edi
+ 00028 74 05 je SHORT $LN40@zipOpenNew
+ 0002a 83 f8 08 cmp eax, 8
+
+; 1083 : return ZIP_PARAMERROR;
+
+ 0002d 75 e6 jne SHORT $LN64@zipOpenNew
+$LN40@zipOpenNew:
+
+; 1084 : #endif
+; 1085 :
+; 1086 : zi = (zip64_internal*)file;
+; 1087 :
+; 1088 : if (zi->in_opened_file_inzip == 1)
+
+ 0002f 83 7b 38 01 cmp DWORD PTR [ebx+56], 1
+ 00033 75 0e jne SHORT $LN38@zipOpenNew
+
+; 1089 : {
+; 1090 : err = zipCloseFileInZip (file);
+
+ 00035 53 push ebx
+ 00036 e8 00 00 00 00 call _zipCloseFileInZip@4
+
+; 1091 : if (err != ZIP_OK)
+
+ 0003b 3b c7 cmp eax, edi
+
+; 1092 : return err;
+
+ 0003d 0f 85 7d 04 00
+ 00 jne $LN42@zipOpenNew
+$LN38@zipOpenNew:
+
+; 1093 : }
+; 1094 :
+; 1095 : if (filename==NULL)
+
+ 00043 39 7d 0c cmp DWORD PTR _filename$[ebp], edi
+ 00046 75 07 jne SHORT $LN37@zipOpenNew
+
+; 1096 : filename="-";
+
+ 00048 c7 45 0c 00 00
+ 00 00 mov DWORD PTR _filename$[ebp], OFFSET ??_C@_01JOAMLHOP@?9?$AA@
+$LN37@zipOpenNew:
+
+; 1097 :
+; 1098 : if (comment==NULL)
+
+ 0004f 8b 45 24 mov eax, DWORD PTR _comment$[ebp]
+ 00052 3b c7 cmp eax, edi
+ 00054 75 06 jne SHORT $LN36@zipOpenNew
+
+; 1099 : size_comment = 0;
+
+ 00056 89 7c 24 0c mov DWORD PTR _size_comment$[esp+32], edi
+
+; 1100 : else
+
+ 0005a eb 11 jmp SHORT $LN35@zipOpenNew
+$LN36@zipOpenNew:
+
+; 1101 : size_comment = (uInt)strlen(comment);
+
+ 0005c 8d 50 01 lea edx, DWORD PTR [eax+1]
+ 0005f 90 npad 1
+$LL52@zipOpenNew:
+ 00060 8a 08 mov cl, BYTE PTR [eax]
+ 00062 40 inc eax
+ 00063 84 c9 test cl, cl
+ 00065 75 f9 jne SHORT $LL52@zipOpenNew
+ 00067 2b c2 sub eax, edx
+ 00069 89 44 24 0c mov DWORD PTR _size_comment$[esp+32], eax
+$LN35@zipOpenNew:
+
+; 1102 :
+; 1103 : size_filename = (uInt)strlen(filename);
+
+ 0006d 8b 45 0c mov eax, DWORD PTR _filename$[ebp]
+ 00070 8d 50 01 lea edx, DWORD PTR [eax+1]
+$LL53@zipOpenNew:
+ 00073 8a 08 mov cl, BYTE PTR [eax]
+ 00075 40 inc eax
+ 00076 84 c9 test cl, cl
+ 00078 75 f9 jne SHORT $LL53@zipOpenNew
+ 0007a 2b c2 sub eax, edx
+
+; 1104 :
+; 1105 : if (zipfi == NULL)
+
+ 0007c 8b 55 10 mov edx, DWORD PTR _zipfi$[ebp]
+ 0007f 8b f0 mov esi, eax
+ 00081 89 74 24 10 mov DWORD PTR _size_filename$[esp+32], esi
+ 00085 3b d7 cmp edx, edi
+ 00087 75 08 jne SHORT $LN34@zipOpenNew
+
+; 1106 : zi->ci.dosDate = 0;
+
+ 00089 89 bb a4 00 01
+ 00 mov DWORD PTR [ebx+65700], edi
+
+; 1107 : else
+
+ 0008f eb 12 jmp SHORT $LN31@zipOpenNew
+$LN34@zipOpenNew:
+
+; 1108 : {
+; 1109 : if (zipfi->dosDate != 0)
+
+ 00091 8b 42 18 mov eax, DWORD PTR [edx+24]
+ 00094 3b c7 cmp eax, edi
+
+; 1110 : zi->ci.dosDate = zipfi->dosDate;
+; 1111 : else
+
+ 00096 75 05 jne SHORT $LN61@zipOpenNew
+
+; 1112 : zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);
+
+ 00098 e8 00 00 00 00 call _zip64local_TmzDateToDosDate
+$LN61@zipOpenNew:
+ 0009d 89 83 a4 00 01
+ 00 mov DWORD PTR [ebx+65700], eax
+$LN31@zipOpenNew:
+
+; 1113 : }
+; 1114 :
+; 1115 : zi->ci.flag = flagBase;
+; 1116 : if ((level==8) || (level==9))
+
+ 000a3 8b 4d 2c mov ecx, DWORD PTR _level$[ebp]
+ 000a6 8b 45 4c mov eax, DWORD PTR _flagBase$[ebp]
+ 000a9 89 83 98 00 00
+ 00 mov DWORD PTR [ebx+152], eax
+ 000af 83 f9 08 cmp ecx, 8
+ 000b2 74 05 je SHORT $LN29@zipOpenNew
+ 000b4 83 f9 09 cmp ecx, 9
+ 000b7 75 09 jne SHORT $LN30@zipOpenNew
+$LN29@zipOpenNew:
+
+; 1117 : zi->ci.flag |= 2;
+
+ 000b9 83 c8 02 or eax, 2
+ 000bc 89 83 98 00 00
+ 00 mov DWORD PTR [ebx+152], eax
+$LN30@zipOpenNew:
+
+; 1118 : if (level==2)
+
+ 000c2 83 f9 02 cmp ecx, 2
+ 000c5 75 09 jne SHORT $LN28@zipOpenNew
+
+; 1119 : zi->ci.flag |= 4;
+
+ 000c7 83 8b 98 00 00
+ 00 04 or DWORD PTR [ebx+152], 4
+
+; 1120 : if (level==1)
+
+ 000ce eb 0c jmp SHORT $LN27@zipOpenNew
+$LN28@zipOpenNew:
+ 000d0 83 f9 01 cmp ecx, 1
+ 000d3 75 07 jne SHORT $LN27@zipOpenNew
+
+; 1121 : zi->ci.flag |= 6;
+
+ 000d5 83 8b 98 00 00
+ 00 06 or DWORD PTR [ebx+152], 6
+$LN27@zipOpenNew:
+
+; 1122 : if (password != NULL)
+
+ 000dc 39 7d 40 cmp DWORD PTR _password$[ebp], edi
+ 000df 74 07 je SHORT $LN26@zipOpenNew
+
+; 1123 : zi->ci.flag |= 1;
+
+ 000e1 83 8b 98 00 00
+ 00 01 or DWORD PTR [ebx+152], 1
+$LN26@zipOpenNew:
+
+; 1124 :
+; 1125 : zi->ci.crc32 = 0;
+; 1126 : zi->ci.method = method;
+
+ 000e8 8b 45 28 mov eax, DWORD PTR _method$[ebp]
+
+; 1127 : zi->ci.encrypt = 0;
+; 1128 : zi->ci.stream_initialised = 0;
+; 1129 : zi->ci.pos_in_buffered_data = 0;
+; 1130 : zi->ci.raw = raw;
+
+ 000eb 8b 4d 30 mov ecx, DWORD PTR _raw$[ebp]
+ 000ee 89 83 9c 00 00
+ 00 mov DWORD PTR [ebx+156], eax
+ 000f4 89 8b a0 00 00
+ 00 mov DWORD PTR [ebx+160], ecx
+
+; 1131 : zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ 000fa 8b 4b 2c mov ecx, DWORD PTR [ebx+44]
+ 000fd 8b c3 mov eax, ebx
+ 000ff 89 bb a8 00 01
+ 00 mov DWORD PTR [ebx+65704], edi
+ 00105 89 bb ac 00 01
+ 00 mov DWORD PTR [ebx+65708], edi
+ 0010b 89 7b 78 mov DWORD PTR [ebx+120], edi
+ 0010e 89 7b 7c mov DWORD PTR [ebx+124], edi
+ 00111 e8 00 00 00 00 call _call_ztell64
+ 00116 89 83 80 00 00
+ 00 mov DWORD PTR [ebx+128], eax
+ 0011c 89 93 84 00 00
+ 00 mov DWORD PTR [ebx+132], edx
+
+; 1132 :
+; 1133 : zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;
+
+ 00122 8b 54 24 0c mov edx, DWORD PTR _size_comment$[esp+32]
+ 00126 8d 04 16 lea eax, DWORD PTR [esi+edx]
+ 00129 8b 75 20 mov esi, DWORD PTR _size_extrafield_global$[ebp]
+ 0012c 8d 44 30 2e lea eax, DWORD PTR [eax+esi+46]
+ 00130 89 83 90 00 00
+ 00 mov DWORD PTR [ebx+144], eax
+
+; 1134 : zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data
+; 1135 :
+; 1136 : zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);
+
+ 00136 83 c0 20 add eax, 32 ; 00000020H
+ 00139 50 push eax
+ 0013a c7 83 94 00 00
+ 00 20 00 00 00 mov DWORD PTR [ebx+148], 32 ; 00000020H
+ 00144 e8 00 00 00 00 call _malloc
+ 00149 83 c4 04 add esp, 4
+
+; 1137 :
+; 1138 : zi->ci.size_centralExtra = size_extrafield_global;
+; 1139 : zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
+
+ 0014c 57 push edi
+ 0014d 89 b3 8c 00 00
+ 00 mov DWORD PTR [ebx+140], esi
+ 00153 68 50 4b 01 02 push 33639248 ; 02014b50H
+ 00158 be 04 00 00 00 mov esi, 4
+ 0015d 8b f8 mov edi, eax
+ 0015f 89 83 88 00 00
+ 00 mov DWORD PTR [ebx+136], eax
+ 00165 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1140 : /* version info */
+; 1141 : zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2);
+
+ 0016a 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00170 8b 4d 48 mov ecx, DWORD PTR _versionMadeBy$[ebp]
+ 00173 6a 00 push 0
+ 00175 03 fe add edi, esi
+ 00177 51 push ecx
+ 00178 be 02 00 00 00 mov esi, 2
+ 0017d e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1142 : zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
+
+ 00182 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00188 6a 00 push 0
+ 0018a 6a 14 push 20 ; 00000014H
+ 0018c 83 c7 06 add edi, 6
+ 0018f e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1143 : zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
+
+ 00194 8b 93 98 00 00
+ 00 mov edx, DWORD PTR [ebx+152]
+ 0019a 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001a0 6a 00 push 0
+ 001a2 52 push edx
+ 001a3 83 c7 08 add edi, 8
+ 001a6 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1144 : zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
+
+ 001ab 8b 83 9c 00 00
+ 00 mov eax, DWORD PTR [ebx+156]
+ 001b1 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001b7 6a 00 push 0
+ 001b9 50 push eax
+ 001ba 83 c7 0a add edi, 10 ; 0000000aH
+ 001bd e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1145 : zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
+
+ 001c2 8b 8b a4 00 01
+ 00 mov ecx, DWORD PTR [ebx+65700]
+ 001c8 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001ce 6a 00 push 0
+ 001d0 51 push ecx
+ 001d1 83 c7 0c add edi, 12 ; 0000000cH
+ 001d4 be 04 00 00 00 mov esi, 4
+ 001d9 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1146 : zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
+
+ 001de 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001e4 6a 00 push 0
+ 001e6 6a 00 push 0
+ 001e8 83 c7 10 add edi, 16 ; 00000010H
+ 001eb e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1147 : zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
+
+ 001f0 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 001f6 6a 00 push 0
+ 001f8 6a 00 push 0
+ 001fa 83 c7 14 add edi, 20 ; 00000014H
+ 001fd e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1148 : zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
+
+ 00202 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00208 83 c4 40 add esp, 64 ; 00000040H
+ 0020b 6a 00 push 0
+ 0020d 6a 00 push 0
+ 0020f 83 c7 18 add edi, 24 ; 00000018H
+ 00212 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1149 : zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
+
+ 00217 8b 54 24 18 mov edx, DWORD PTR _size_filename$[esp+40]
+ 0021b 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00221 6a 00 push 0
+ 00223 52 push edx
+ 00224 83 c7 1c add edi, 28 ; 0000001cH
+ 00227 be 02 00 00 00 mov esi, 2
+ 0022c e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1150 : zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
+
+ 00231 8b 45 20 mov eax, DWORD PTR _size_extrafield_global$[ebp]
+ 00234 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 0023a 6a 00 push 0
+ 0023c 50 push eax
+ 0023d 83 c7 1e add edi, 30 ; 0000001eH
+ 00240 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1151 : zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
+
+ 00245 8b 4c 24 24 mov ecx, DWORD PTR _size_comment$[esp+56]
+ 00249 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 0024f 6a 00 push 0
+ 00251 51 push ecx
+ 00252 83 c7 20 add edi, 32 ; 00000020H
+ 00255 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1152 : zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
+
+ 0025a 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00260 6a 00 push 0
+ 00262 6a 00 push 0
+ 00264 83 c7 22 add edi, 34 ; 00000022H
+ 00267 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1153 :
+; 1154 : if (zipfi==NULL)
+; 1155 : zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
+
+ 0026c 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 00272 8b 45 10 mov eax, DWORD PTR _zipfi$[ebp]
+ 00275 83 c4 28 add esp, 40 ; 00000028H
+ 00278 83 c7 24 add edi, 36 ; 00000024H
+ 0027b 6a 00 push 0
+ 0027d 85 c0 test eax, eax
+ 0027f 75 0f jne SHORT $LN25@zipOpenNew
+ 00281 50 push eax
+ 00282 e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 00287 83 c4 08 add esp, 8
+
+; 1158 :
+; 1159 : if (zipfi==NULL)
+; 1160 : zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
+
+ 0028a 6a 00 push 0
+ 0028c 6a 00 push 0
+
+; 1161 : else
+
+ 0028e eb 15 jmp SHORT $LN62@zipOpenNew
+$LN25@zipOpenNew:
+
+; 1156 : else
+; 1157 : zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
+
+ 00290 8b 50 1c mov edx, DWORD PTR [eax+28]
+ 00293 52 push edx
+ 00294 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1162 : zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
+
+ 00299 8b 45 10 mov eax, DWORD PTR _zipfi$[ebp]
+ 0029c 8b 48 20 mov ecx, DWORD PTR [eax+32]
+ 0029f 83 c4 08 add esp, 8
+ 002a2 6a 00 push 0
+ 002a4 51 push ecx
+$LN62@zipOpenNew:
+ 002a5 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 002ab be 04 00 00 00 mov esi, 4
+ 002b0 83 c7 26 add edi, 38 ; 00000026H
+ 002b3 e8 00 00 00 00 call _zip64local_putValue_inmemory
+ 002b8 83 c4 08 add esp, 8
+
+; 1163 :
+; 1164 : if(zi->ci.pos_local_header >= 0xffffffff)
+
+ 002bb 83 bb 84 00 00
+ 00 00 cmp DWORD PTR [ebx+132], 0
+ 002c2 77 09 ja SHORT $LN54@zipOpenNew
+ 002c4 83 bb 80 00 00
+ 00 ff cmp DWORD PTR [ebx+128], -1
+ 002cb 72 06 jb SHORT $LN21@zipOpenNew
+$LN54@zipOpenNew:
+
+; 1165 : zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4);
+
+ 002cd 6a 00 push 0
+ 002cf 6a ff push -1
+
+; 1166 : else
+
+ 002d1 eb 16 jmp SHORT $LN63@zipOpenNew
+$LN21@zipOpenNew:
+
+; 1167 : zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset,4);
+
+ 002d3 8b 93 80 00 00
+ 00 mov edx, DWORD PTR [ebx+128]
+ 002d9 33 c0 xor eax, eax
+ 002db 2b 93 f0 00 01
+ 00 sub edx, DWORD PTR [ebx+65776]
+ 002e1 1b 83 f4 00 01
+ 00 sbb eax, DWORD PTR [ebx+65780]
+ 002e7 50 push eax
+ 002e8 52 push edx
+$LN63@zipOpenNew:
+ 002e9 8b bb 88 00 00
+ 00 mov edi, DWORD PTR [ebx+136]
+ 002ef be 04 00 00 00 mov esi, 4
+ 002f4 83 c7 2a add edi, 42 ; 0000002aH
+ 002f7 e8 00 00 00 00 call _zip64local_putValue_inmemory
+
+; 1168 :
+; 1169 : for (i=0;i<size_filename;i++)
+
+ 002fc 8b 74 24 18 mov esi, DWORD PTR _size_filename$[esp+40]
+ 00300 33 c9 xor ecx, ecx
+ 00302 83 c4 08 add esp, 8
+ 00305 33 c0 xor eax, eax
+ 00307 3b f1 cmp esi, ecx
+ 00309 76 22 jbe SHORT $LN17@zipOpenNew
+ 0030b eb 03 8d 49 00 npad 5
+$LL19@zipOpenNew:
+
+; 1170 : *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
+
+ 00310 8b 7d 0c mov edi, DWORD PTR _filename$[ebp]
+ 00313 8b 93 88 00 00
+ 00 mov edx, DWORD PTR [ebx+136]
+ 00319 89 4c 24 10 mov DWORD PTR tv878[esp+32], ecx
+ 0031d 8a 0c 38 mov cl, BYTE PTR [eax+edi]
+ 00320 88 4c 02 2e mov BYTE PTR [edx+eax+46], cl
+ 00324 8b 4c 24 10 mov ecx, DWORD PTR tv878[esp+32]
+ 00328 40 inc eax
+ 00329 3b c6 cmp eax, esi
+ 0032b 72 e3 jb SHORT $LL19@zipOpenNew
+$LN17@zipOpenNew:
+
+; 1171 :
+; 1172 : for (i=0;i<size_extrafield_global;i++)
+
+ 0032d 8b 7d 20 mov edi, DWORD PTR _size_extrafield_global$[ebp]
+ 00330 33 c0 xor eax, eax
+ 00332 3b f9 cmp edi, ecx
+ 00334 76 19 jbe SHORT $LN14@zipOpenNew
+$LN16@zipOpenNew:
+
+; 1173 : *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
+; 1174 : *(((const char*)extrafield_global)+i);
+
+ 00336 8b 8b 88 00 00
+ 00 mov ecx, DWORD PTR [ebx+136]
+ 0033c 8b 55 1c mov edx, DWORD PTR _extrafield_global$[ebp]
+ 0033f 8a 14 10 mov dl, BYTE PTR [eax+edx]
+ 00342 03 c8 add ecx, eax
+ 00344 40 inc eax
+ 00345 88 54 31 2e mov BYTE PTR [ecx+esi+46], dl
+ 00349 3b c7 cmp eax, edi
+ 0034b 72 e9 jb SHORT $LN16@zipOpenNew
+
+; 1171 :
+; 1172 : for (i=0;i<size_extrafield_global;i++)
+
+ 0034d 33 c9 xor ecx, ecx
+$LN14@zipOpenNew:
+
+; 1175 :
+; 1176 : for (i=0;i<size_comment;i++)
+
+ 0034f 33 c0 xor eax, eax
+ 00351 39 4c 24 0c cmp DWORD PTR _size_comment$[esp+32], ecx
+ 00355 76 26 jbe SHORT $LN11@zipOpenNew
+ 00357 eb 07 8d a4 24
+ 00 00 00 00 npad 9
+$LL13@zipOpenNew:
+
+; 1177 : *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
+; 1178 : size_extrafield_global+i) = *(comment+i);
+
+ 00360 8b 8b 88 00 00
+ 00 mov ecx, DWORD PTR [ebx+136]
+ 00366 8b 55 24 mov edx, DWORD PTR _comment$[ebp]
+ 00369 8a 14 10 mov dl, BYTE PTR [eax+edx]
+ 0036c 03 c8 add ecx, eax
+ 0036e 03 ce add ecx, esi
+ 00370 40 inc eax
+ 00371 88 54 39 2e mov BYTE PTR [ecx+edi+46], dl
+ 00375 3b 44 24 0c cmp eax, DWORD PTR _size_comment$[esp+32]
+ 00379 72 e5 jb SHORT $LL13@zipOpenNew
+
+; 1175 :
+; 1176 : for (i=0;i<size_comment;i++)
+
+ 0037b 33 c9 xor ecx, ecx
+$LN11@zipOpenNew:
+
+; 1179 : if (zi->ci.central_header == NULL)
+
+ 0037d 39 8b 88 00 00
+ 00 cmp DWORD PTR [ebx+136], ecx
+ 00383 75 0e jne SHORT $LN10@zipOpenNew
+
+; 1180 : return ZIP_INTERNALERROR;
+
+ 00385 b8 98 ff ff ff mov eax, -104 ; ffffff98H
+
+; 1263 : }
+
+ 0038a 5f pop edi
+ 0038b 5e pop esi
+ 0038c 5b pop ebx
+ 0038d 8b e5 mov esp, ebp
+ 0038f 5d pop ebp
+ 00390 c2 4c 00 ret 76 ; 0000004cH
+$LN10@zipOpenNew:
+
+; 1181 :
+; 1182 : zi->ci.zip64 = zip64;
+
+ 00393 8b 45 50 mov eax, DWORD PTR _zip64$[ebp]
+
+; 1183 : zi->ci.totalCompressedData = 0;
+; 1184 : zi->ci.totalUncompressedData = 0;
+; 1185 : zi->ci.pos_zip64extrainfo = 0;
+; 1186 :
+; 1187 : err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local);
+
+ 00396 8b 55 18 mov edx, DWORD PTR _size_extrafield_local$[ebp]
+ 00399 89 8b c0 00 01
+ 00 mov DWORD PTR [ebx+65728], ecx
+ 0039f 89 8b c4 00 01
+ 00 mov DWORD PTR [ebx+65732], ecx
+ 003a5 89 8b c8 00 01
+ 00 mov DWORD PTR [ebx+65736], ecx
+ 003ab 89 8b cc 00 01
+ 00 mov DWORD PTR [ebx+65740], ecx
+ 003b1 89 8b b8 00 01
+ 00 mov DWORD PTR [ebx+65720], ecx
+ 003b7 89 8b bc 00 01
+ 00 mov DWORD PTR [ebx+65724], ecx
+ 003bd 8b 4d 14 mov ecx, DWORD PTR _extrafield_local$[ebp]
+ 003c0 51 push ecx
+ 003c1 89 83 b0 00 01
+ 00 mov DWORD PTR [ebx+65712], eax
+ 003c7 8b 45 0c mov eax, DWORD PTR _filename$[ebp]
+ 003ca 52 push edx
+ 003cb 50 push eax
+ 003cc 8b c3 mov eax, ebx
+ 003ce e8 00 00 00 00 call _Write_LocalFileHeader
+
+; 1188 :
+; 1189 : #ifdef HAVE_BZIP2
+; 1190 : zi->ci.bstream.avail_in = (uInt)0;
+; 1191 : zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+; 1192 : zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+; 1193 : zi->ci.bstream.total_in_hi32 = 0;
+; 1194 : zi->ci.bstream.total_in_lo32 = 0;
+; 1195 : zi->ci.bstream.total_out_hi32 = 0;
+; 1196 : zi->ci.bstream.total_out_lo32 = 0;
+; 1197 : #endif
+; 1198 :
+; 1199 : zi->ci.stream.avail_in = (uInt)0;
+
+ 003d3 33 f6 xor esi, esi
+ 003d5 8b f8 mov edi, eax
+ 003d7 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1200 : zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+; 1201 : zi->ci.stream.next_out = zi->ci.buffered_data;
+
+ 003da 8d 8b a4 00 00
+ 00 lea ecx, DWORD PTR [ebx+164]
+ 003e0 89 73 44 mov DWORD PTR [ebx+68], esi
+ 003e3 c7 43 50 00 00
+ 01 00 mov DWORD PTR [ebx+80], 65536 ; 00010000H
+ 003ea 89 4b 4c mov DWORD PTR [ebx+76], ecx
+
+; 1202 : zi->ci.stream.total_in = 0;
+
+ 003ed 89 73 48 mov DWORD PTR [ebx+72], esi
+
+; 1203 : zi->ci.stream.total_out = 0;
+
+ 003f0 89 73 54 mov DWORD PTR [ebx+84], esi
+
+; 1204 : zi->ci.stream.data_type = Z_BINARY;
+
+ 003f3 89 73 6c mov DWORD PTR [ebx+108], esi
+
+; 1205 :
+; 1206 : #ifdef HAVE_BZIP2
+; 1207 : if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+; 1208 : #else
+; 1209 : if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+
+ 003f6 3b fe cmp edi, esi
+ 003f8 75 4f jne SHORT $LN6@zipOpenNew
+ 003fa 83 bb 9c 00 00
+ 00 08 cmp DWORD PTR [ebx+156], 8
+ 00401 75 46 jne SHORT $LN6@zipOpenNew
+ 00403 39 b3 a0 00 00
+ 00 cmp DWORD PTR [ebx+160], esi
+ 00409 75 3e jne SHORT $LN6@zipOpenNew
+
+; 1210 : #endif
+; 1211 : {
+; 1212 : if(zi->ci.method == Z_DEFLATED)
+; 1213 : {
+; 1214 : zi->ci.stream.zalloc = (alloc_func)0;
+; 1215 : zi->ci.stream.zfree = (free_func)0;
+; 1216 : zi->ci.stream.opaque = (voidpf)0;
+; 1217 :
+; 1218 : if (windowBits>0)
+
+ 0040b 8b 45 34 mov eax, DWORD PTR _windowBits$[ebp]
+ 0040e 89 73 60 mov DWORD PTR [ebx+96], esi
+ 00411 89 73 64 mov DWORD PTR [ebx+100], esi
+ 00414 89 73 68 mov DWORD PTR [ebx+104], esi
+ 00417 3b c6 cmp eax, esi
+ 00419 7e 02 jle SHORT $LN7@zipOpenNew
+
+; 1219 : windowBits = -windowBits;
+
+ 0041b f7 d8 neg eax
+$LN7@zipOpenNew:
+
+; 1220 :
+; 1221 : err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);
+
+ 0041d 8b 55 3c mov edx, DWORD PTR _strategy$[ebp]
+ 00420 8b 4d 38 mov ecx, DWORD PTR _memLevel$[ebp]
+ 00423 6a 38 push 56 ; 00000038H
+ 00425 68 00 00 00 00 push OFFSET ??_C@_05IAIEPMAK@1?42?48?$AA@
+ 0042a 52 push edx
+ 0042b 8b 55 2c mov edx, DWORD PTR _level$[ebp]
+ 0042e 51 push ecx
+ 0042f 50 push eax
+ 00430 6a 08 push 8
+ 00432 52 push edx
+ 00433 8d 43 40 lea eax, DWORD PTR [ebx+64]
+ 00436 50 push eax
+ 00437 e8 00 00 00 00 call _deflateInit2_@32
+ 0043c 8b f8 mov edi, eax
+
+; 1222 :
+; 1223 : if (err==Z_OK)
+
+ 0043e 3b fe cmp edi, esi
+ 00440 75 07 jne SHORT $LN6@zipOpenNew
+
+; 1224 : zi->ci.stream_initialised = Z_DEFLATED;
+
+ 00442 c7 43 78 08 00
+ 00 00 mov DWORD PTR [ebx+120], 8
+$LN6@zipOpenNew:
+
+; 1225 : }
+; 1226 : else if(zi->ci.method == Z_BZIP2ED)
+; 1227 : {
+; 1228 : #ifdef HAVE_BZIP2
+; 1229 : // Init BZip stuff here
+; 1230 : zi->ci.bstream.bzalloc = 0;
+; 1231 : zi->ci.bstream.bzfree = 0;
+; 1232 : zi->ci.bstream.opaque = (voidpf)0;
+; 1233 :
+; 1234 : err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35);
+; 1235 : if(err == BZ_OK)
+; 1236 : zi->ci.stream_initialised = Z_BZIP2ED;
+; 1237 : #endif
+; 1238 : }
+; 1239 :
+; 1240 : }
+; 1241 :
+; 1242 : # ifndef NOCRYPT
+; 1243 : zi->ci.crypt_header_size = 0;
+
+ 00449 89 b3 e0 00 01
+ 00 mov DWORD PTR [ebx+65760], esi
+
+; 1244 : if ((err==Z_OK) && (password != NULL))
+
+ 0044f 3b fe cmp edi, esi
+ 00451 75 6b jne SHORT $LN1@zipOpenNew
+ 00453 8b 55 40 mov edx, DWORD PTR _password$[ebp]
+ 00456 3b d6 cmp edx, esi
+ 00458 74 5d je SHORT $LN51@zipOpenNew
+
+; 1245 : {
+; 1246 : unsigned char bufHead[RAND_HEAD_LEN];
+; 1247 : unsigned int sizeHead;
+; 1248 : zi->ci.encrypt = 1;
+
+ 0045a c7 83 ac 00 01
+ 00 01 00 00 00 mov DWORD PTR [ebx+65708], 1
+
+; 1249 : zi->ci.pcrc_32_tab = get_crc_table();
+
+ 00464 e8 00 00 00 00 call _get_crc_table@0
+
+; 1250 : /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
+; 1251 :
+; 1252 : sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
+
+ 00469 8b 4d 44 mov ecx, DWORD PTR _crcForCrypting$[ebp]
+ 0046c 51 push ecx
+ 0046d 8d 74 24 18 lea esi, DWORD PTR _bufHead$83356[esp+36]
+ 00471 56 push esi
+ 00472 8d 8b d0 00 01
+ 00 lea ecx, DWORD PTR [ebx+65744]
+ 00478 52 push edx
+ 00479 89 83 dc 00 01
+ 00 mov DWORD PTR [ebx+65756], eax
+ 0047f e8 00 00 00 00 call _crypthead
+
+; 1253 : zi->ci.crypt_header_size = sizeHead;
+; 1254 :
+; 1255 : if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
+
+ 00484 8b 4b 1c mov ecx, DWORD PTR [ebx+28]
+ 00487 83 c4 0c add esp, 12 ; 0000000cH
+ 0048a 8b f0 mov esi, eax
+ 0048c 8b 43 2c mov eax, DWORD PTR [ebx+44]
+ 0048f 56 push esi
+ 00490 8d 54 24 18 lea edx, DWORD PTR _bufHead$83356[esp+36]
+ 00494 52 push edx
+ 00495 8b 53 08 mov edx, DWORD PTR [ebx+8]
+ 00498 50 push eax
+ 00499 51 push ecx
+ 0049a 89 b3 e0 00 01
+ 00 mov DWORD PTR [ebx+65760], esi
+ 004a0 ff d2 call edx
+ 004a2 83 c4 10 add esp, 16 ; 00000010H
+ 004a5 3b c6 cmp eax, esi
+ 004a7 74 0e je SHORT $LN51@zipOpenNew
+
+; 1256 : err = ZIP_ERRNO;
+
+ 004a9 83 cf ff or edi, -1
+
+; 1262 : return err;
+
+ 004ac 8b c7 mov eax, edi
+
+; 1263 : }
+
+ 004ae 5f pop edi
+ 004af 5e pop esi
+ 004b0 5b pop ebx
+ 004b1 8b e5 mov esp, ebp
+ 004b3 5d pop ebp
+ 004b4 c2 4c 00 ret 76 ; 0000004cH
+$LN51@zipOpenNew:
+
+; 1257 : }
+; 1258 : # endif
+; 1259 :
+; 1260 : if (err==Z_OK)
+; 1261 : zi->in_opened_file_inzip = 1;
+
+ 004b7 c7 43 38 01 00
+ 00 00 mov DWORD PTR [ebx+56], 1
+$LN1@zipOpenNew:
+
+; 1262 : return err;
+
+ 004be 8b c7 mov eax, edi
+$LN42@zipOpenNew:
+
+; 1263 : }
+
+ 004c0 5f pop edi
+ 004c1 5e pop esi
+ 004c2 5b pop ebx
+ 004c3 8b e5 mov esp, ebp
+ 004c5 5d pop ebp
+ 004c6 c2 4c 00 ret 76 ; 0000004cH
+_zipOpenNewFileInZip4_64@76 ENDP
+_TEXT ENDS
+PUBLIC _zipOpen64@8
+; Function compile flags: /Ogtp
+; COMDAT _zipOpen64@8
+_TEXT SEGMENT
+_pathname$ = 8 ; size = 4
+_append$ = 12 ; size = 4
+_zipOpen64@8 PROC ; COMDAT
+
+; 954 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 955 : return zipOpen3(pathname,append,NULL,NULL);
+
+ 00003 8b 45 0c mov eax, DWORD PTR _append$[ebp]
+ 00006 8b 4d 08 mov ecx, DWORD PTR _pathname$[ebp]
+ 00009 6a 00 push 0
+ 0000b 50 push eax
+ 0000c 51 push ecx
+ 0000d 33 c9 xor ecx, ecx
+ 0000f e8 00 00 00 00 call _zipOpen3@16
+
+; 956 : }
+
+ 00014 5d pop ebp
+ 00015 c2 08 00 ret 8
+_zipOpen64@8 ENDP
+_TEXT ENDS
+PUBLIC _zipOpen@8
+; Function compile flags: /Ogtp
+; COMDAT _zipOpen@8
+_TEXT SEGMENT
+_pathname$ = 8 ; size = 4
+_append$ = 12 ; size = 4
+_zipOpen@8 PROC ; COMDAT
+
+; 949 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 950 : return zipOpen3((const void*)pathname,append,NULL,NULL);
+
+ 00003 8b 45 0c mov eax, DWORD PTR _append$[ebp]
+ 00006 8b 4d 08 mov ecx, DWORD PTR _pathname$[ebp]
+ 00009 6a 00 push 0
+ 0000b 50 push eax
+ 0000c 51 push ecx
+ 0000d 33 c9 xor ecx, ecx
+ 0000f e8 00 00 00 00 call _zipOpen3@16
+
+; 951 : }
+
+ 00014 5d pop ebp
+ 00015 c2 08 00 ret 8
+_zipOpen@8 ENDP
+_TEXT ENDS
+PUBLIC _zipOpen2_64@16
+; Function compile flags: /Ogtp
+; COMDAT _zipOpen2_64@16
+_TEXT SEGMENT
+_zlib_filefunc64_32_def_fill$83154 = -44 ; size = 44
+_pathname$ = 8 ; size = 4
+_append$ = 12 ; size = 4
+_globalcomment$ = 16 ; size = 4
+_pzlib_filefunc_def$ = 20 ; size = 4
+_zipOpen2_64@16 PROC ; COMDAT
+
+; 933 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 e4 f8 and esp, -8 ; fffffff8H
+
+; 938 : zlib_filefunc64_32_def_fill.ztell32_file = NULL;
+; 939 : zlib_filefunc64_32_def_fill.zseek32_file = NULL;
+; 940 : return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
+
+ 00006 8b 55 08 mov edx, DWORD PTR _pathname$[ebp]
+ 00009 83 ec 30 sub esp, 48 ; 00000030H
+ 0000c 56 push esi
+ 0000d 8b 75 14 mov esi, DWORD PTR _pzlib_filefunc_def$[ebp]
+ 00010 33 c0 xor eax, eax
+ 00012 57 push edi
+ 00013 3b f0 cmp esi, eax
+ 00015 74 2d je SHORT $LN2@zipOpen2_6
+
+; 934 : if (pzlib_filefunc_def != NULL)
+; 935 : {
+; 936 : zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+; 937 : zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+
+ 00017 b9 08 00 00 00 mov ecx, 8
+ 0001c 8d 7c 24 0c lea edi, DWORD PTR _zlib_filefunc64_32_def_fill$83154[esp+56]
+ 00020 f3 a5 rep movsd
+
+; 938 : zlib_filefunc64_32_def_fill.ztell32_file = NULL;
+; 939 : zlib_filefunc64_32_def_fill.zseek32_file = NULL;
+; 940 : return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
+
+ 00022 8b 4d 0c mov ecx, DWORD PTR _append$[ebp]
+ 00025 89 44 24 30 mov DWORD PTR _zlib_filefunc64_32_def_fill$83154[esp+92], eax
+ 00029 89 44 24 34 mov DWORD PTR _zlib_filefunc64_32_def_fill$83154[esp+96], eax
+ 0002d 8b 45 10 mov eax, DWORD PTR _globalcomment$[ebp]
+ 00030 50 push eax
+ 00031 51 push ecx
+ 00032 8d 4c 24 14 lea ecx, DWORD PTR _zlib_filefunc64_32_def_fill$83154[esp+64]
+
+; 941 : }
+; 942 : else
+; 943 : return zipOpen3(pathname, append, globalcomment, NULL);
+
+ 00036 52 push edx
+ 00037 e8 00 00 00 00 call _zipOpen3@16
+
+; 944 : }
+
+ 0003c 5f pop edi
+ 0003d 5e pop esi
+ 0003e 8b e5 mov esp, ebp
+ 00040 5d pop ebp
+ 00041 c2 10 00 ret 16 ; 00000010H
+$LN2@zipOpen2_6:
+
+; 941 : }
+; 942 : else
+; 943 : return zipOpen3(pathname, append, globalcomment, NULL);
+
+ 00044 8b 45 10 mov eax, DWORD PTR _globalcomment$[ebp]
+ 00047 8b 4d 0c mov ecx, DWORD PTR _append$[ebp]
+ 0004a 50 push eax
+ 0004b 51 push ecx
+ 0004c 33 c9 xor ecx, ecx
+ 0004e 52 push edx
+ 0004f e8 00 00 00 00 call _zipOpen3@16
+
+; 944 : }
+
+ 00054 5f pop edi
+ 00055 5e pop esi
+ 00056 8b e5 mov esp, ebp
+ 00058 5d pop ebp
+ 00059 c2 10 00 ret 16 ; 00000010H
+_zipOpen2_64@16 ENDP
+_TEXT ENDS
+PUBLIC _zipOpen2@16
+; Function compile flags: /Ogtp
+; COMDAT _zipOpen2@16
+_TEXT SEGMENT
+_zlib_filefunc64_32_def_fill$83140 = -44 ; size = 44
+_pathname$ = 8 ; size = 4
+_append$ = 12 ; size = 4
+_globalcomment$ = 16 ; size = 4
+_pzlib_filefunc32_def$ = 20 ; size = 4
+_zipOpen2@16 PROC ; COMDAT
+
+; 921 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 e4 f8 and esp, -8 ; fffffff8H
+
+; 922 : if (pzlib_filefunc32_def != NULL)
+
+ 00006 8b 4d 14 mov ecx, DWORD PTR _pzlib_filefunc32_def$[ebp]
+ 00009 83 ec 30 sub esp, 48 ; 00000030H
+ 0000c 85 c9 test ecx, ecx
+ 0000e 74 24 je SHORT $LN2@zipOpen2
+
+; 923 : {
+; 924 : zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+; 925 : fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
+
+ 00010 8d 44 24 04 lea eax, DWORD PTR _zlib_filefunc64_32_def_fill$83140[esp+48]
+ 00014 e8 00 00 00 00 call _fill_zlib_filefunc64_32_def_from_filefunc32
+
+; 926 : return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
+
+ 00019 8b 45 10 mov eax, DWORD PTR _globalcomment$[ebp]
+ 0001c 8b 4d 0c mov ecx, DWORD PTR _append$[ebp]
+
+; 927 : }
+; 928 : else
+; 929 : return zipOpen3(pathname, append, globalcomment, NULL);
+
+ 0001f 8b 55 08 mov edx, DWORD PTR _pathname$[ebp]
+ 00022 50 push eax
+ 00023 51 push ecx
+ 00024 8d 4c 24 0c lea ecx, DWORD PTR _zlib_filefunc64_32_def_fill$83140[esp+56]
+ 00028 52 push edx
+ 00029 e8 00 00 00 00 call _zipOpen3@16
+
+; 930 : }
+
+ 0002e 8b e5 mov esp, ebp
+ 00030 5d pop ebp
+ 00031 c2 10 00 ret 16 ; 00000010H
+$LN2@zipOpen2:
+
+; 927 : }
+; 928 : else
+; 929 : return zipOpen3(pathname, append, globalcomment, NULL);
+
+ 00034 8b 45 10 mov eax, DWORD PTR _globalcomment$[ebp]
+ 00037 8b 4d 0c mov ecx, DWORD PTR _append$[ebp]
+ 0003a 8b 55 08 mov edx, DWORD PTR _pathname$[ebp]
+ 0003d 50 push eax
+ 0003e 51 push ecx
+ 0003f 33 c9 xor ecx, ecx
+ 00041 52 push edx
+ 00042 e8 00 00 00 00 call _zipOpen3@16
+
+; 930 : }
+
+ 00047 8b e5 mov esp, ebp
+ 00049 5d pop ebp
+ 0004a c2 10 00 ret 16 ; 00000010H
+_zipOpen2@16 ENDP
+PUBLIC _zipClose@8
+; Function compile flags: /Ogtp
+; COMDAT _zipClose@8
+_TEXT SEGMENT
+_size_centraldir$ = -20 ; size = 4
+_centraldir_pos_inzip$ = -16 ; size = 8
+_Zip64EOCDpos$83808 = -8 ; size = 8
+_file$ = 8 ; size = 4
+_global_comment$ = 12 ; size = 4
+_zipClose@8 PROC ; COMDAT
+
+; 1883 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+ 00003 83 e4 f8 and esp, -8 ; fffffff8H
+ 00006 83 ec 14 sub esp, 20 ; 00000014H
+ 00009 53 push ebx
+ 0000a 56 push esi
+ 0000b 57 push edi
+
+; 1884 : zip64_internal* zi;
+; 1885 : int err = 0;
+; 1886 : uLong size_centraldir = 0;
+; 1887 : ZPOS64_T centraldir_pos_inzip;
+; 1888 : ZPOS64_T pos;
+; 1889 :
+; 1890 : if (file == NULL)
+
+ 0000c 8b 7d 08 mov edi, DWORD PTR _file$[ebp]
+ 0000f 33 db xor ebx, ebx
+ 00011 89 5c 24 0c mov DWORD PTR _size_centraldir$[esp+32], ebx
+ 00015 85 ff test edi, edi
+ 00017 75 0c jne SHORT $LN16@zipClose
+
+; 1891 : return ZIP_PARAMERROR;
+
+ 00019 8d 43 9a lea eax, DWORD PTR [ebx-102]
+
+; 1947 :
+; 1948 : return err;
+; 1949 : }
+
+ 0001c 5f pop edi
+ 0001d 5e pop esi
+ 0001e 5b pop ebx
+ 0001f 8b e5 mov esp, ebp
+ 00021 5d pop ebp
+ 00022 c2 08 00 ret 8
+$LN16@zipClose:
+
+; 1892 :
+; 1893 : zi = (zip64_internal*)file;
+; 1894 :
+; 1895 : if (zi->in_opened_file_inzip == 1)
+
+ 00025 83 7f 38 01 cmp DWORD PTR [edi+56], 1
+ 00029 75 08 jne SHORT $LN15@zipClose
+
+; 1896 : {
+; 1897 : err = zipCloseFileInZip (file);
+
+ 0002b 57 push edi
+ 0002c e8 00 00 00 00 call _zipCloseFileInZip@4
+ 00031 8b d8 mov ebx, eax
+$LN15@zipClose:
+
+; 1898 : }
+; 1899 :
+; 1900 : #ifndef NO_ADDFILEINEXISTINGZIP
+; 1901 : if (global_comment==NULL)
+
+ 00033 83 7d 0c 00 cmp DWORD PTR _global_comment$[ebp], 0
+ 00037 75 09 jne SHORT $LN14@zipClose
+
+; 1902 : global_comment = zi->globalcomment;
+
+ 00039 8b 87 00 01 01
+ 00 mov eax, DWORD PTR [edi+65792]
+ 0003f 89 45 0c mov DWORD PTR _global_comment$[ebp], eax
+$LN14@zipClose:
+
+; 1903 : #endif
+; 1904 :
+; 1905 : centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ 00042 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00045 8b c7 mov eax, edi
+ 00047 e8 00 00 00 00 call _call_ztell64
+ 0004c 89 44 24 10 mov DWORD PTR _centraldir_pos_inzip$[esp+32], eax
+ 00050 89 54 24 14 mov DWORD PTR _centraldir_pos_inzip$[esp+36], edx
+
+; 1906 :
+; 1907 : if (err==ZIP_OK)
+
+ 00054 85 db test ebx, ebx
+ 00056 75 3d jne SHORT $LN11@zipClose
+
+; 1908 : {
+; 1909 : linkedlist_datablock_internal* ldi = zi->central_dir.first_block;
+
+ 00058 8b 77 30 mov esi, DWORD PTR [edi+48]
+
+; 1910 : while (ldi!=NULL)
+
+ 0005b 85 f6 test esi, esi
+ 0005d 74 36 je SHORT $LN11@zipClose
+ 0005f 90 npad 1
+$LL12@zipClose:
+
+; 1911 : {
+; 1912 : if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
+
+ 00060 85 db test ebx, ebx
+ 00062 75 24 jne SHORT $LN9@zipClose
+ 00064 8b 46 08 mov eax, DWORD PTR [esi+8]
+ 00067 85 c0 test eax, eax
+ 00069 74 1d je SHORT $LN9@zipClose
+
+; 1913 : {
+; 1914 : if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block)
+
+ 0006b 8b 57 2c mov edx, DWORD PTR [edi+44]
+ 0006e 50 push eax
+ 0006f 8b 47 1c mov eax, DWORD PTR [edi+28]
+ 00072 8d 4e 10 lea ecx, DWORD PTR [esi+16]
+ 00075 51 push ecx
+ 00076 8b 4f 08 mov ecx, DWORD PTR [edi+8]
+ 00079 52 push edx
+ 0007a 50 push eax
+ 0007b ff d1 call ecx
+ 0007d 83 c4 10 add esp, 16 ; 00000010H
+ 00080 3b 46 08 cmp eax, DWORD PTR [esi+8]
+ 00083 74 03 je SHORT $LN9@zipClose
+
+; 1915 : err = ZIP_ERRNO;
+
+ 00085 83 cb ff or ebx, -1
+$LN9@zipClose:
+
+; 1916 : }
+; 1917 :
+; 1918 : size_centraldir += ldi->filled_in_this_block;
+
+ 00088 8b 56 08 mov edx, DWORD PTR [esi+8]
+
+; 1919 : ldi = ldi->next_datablock;
+
+ 0008b 8b 36 mov esi, DWORD PTR [esi]
+ 0008d 01 54 24 0c add DWORD PTR _size_centraldir$[esp+32], edx
+ 00091 85 f6 test esi, esi
+ 00093 75 cb jne SHORT $LL12@zipClose
+$LN11@zipClose:
+
+; 1920 : }
+; 1921 : }
+; 1922 : free_linkedlist(&(zi->central_dir));
+
+ 00095 8d 77 30 lea esi, DWORD PTR [edi+48]
+ 00098 e8 00 00 00 00 call _free_linkedlist
+
+; 1923 :
+; 1924 : pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
+
+ 0009d 8b 74 24 10 mov esi, DWORD PTR _centraldir_pos_inzip$[esp+32]
+ 000a1 8b 44 24 14 mov eax, DWORD PTR _centraldir_pos_inzip$[esp+36]
+ 000a5 8b ce mov ecx, esi
+ 000a7 2b 8f f0 00 01
+ 00 sub ecx, DWORD PTR [edi+65776]
+ 000ad 1b 87 f4 00 01
+ 00 sbb eax, DWORD PTR [edi+65780]
+
+; 1925 : if(pos >= 0xffffffff || zi->number_entry > 0xFFFF)
+
+ 000b3 85 c0 test eax, eax
+ 000b5 77 1c ja SHORT $LN22@zipClose
+ 000b7 72 05 jb SHORT $LN21@zipClose
+ 000b9 83 f9 ff cmp ecx, -1
+ 000bc 73 15 jae SHORT $LN22@zipClose
+$LN21@zipClose:
+ 000be 83 bf fc 00 01
+ 00 00 cmp DWORD PTR [edi+65788], 0
+ 000c5 77 0c ja SHORT $LN22@zipClose
+ 000c7 81 bf f8 00 01
+ 00 ff ff 00 00 cmp DWORD PTR [edi+65784], 65535 ; 0000ffffH
+ 000d1 76 3b jbe SHORT $LN8@zipClose
+$LN22@zipClose:
+
+; 1926 : {
+; 1927 : ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ 000d3 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 000d6 8b c7 mov eax, edi
+ 000d8 e8 00 00 00 00 call _call_ztell64
+
+; 1928 : Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
+
+ 000dd 8b 4c 24 0c mov ecx, DWORD PTR _size_centraldir$[esp+32]
+ 000e1 89 44 24 18 mov DWORD PTR _Zip64EOCDpos$83808[esp+32], eax
+ 000e5 8b 44 24 14 mov eax, DWORD PTR _centraldir_pos_inzip$[esp+36]
+ 000e9 50 push eax
+ 000ea 56 push esi
+ 000eb 51 push ecx
+ 000ec 8b c7 mov eax, edi
+ 000ee 89 54 24 28 mov DWORD PTR _Zip64EOCDpos$83808[esp+48], edx
+ 000f2 e8 00 00 00 00 call _Write_Zip64EndOfCentralDirectoryRecord
+
+; 1929 :
+; 1930 : Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);
+
+ 000f7 8b 54 24 28 mov edx, DWORD PTR _Zip64EOCDpos$83808[esp+48]
+ 000fb 8b 44 24 24 mov eax, DWORD PTR _Zip64EOCDpos$83808[esp+44]
+ 000ff 83 c4 0c add esp, 12 ; 0000000cH
+ 00102 52 push edx
+ 00103 50 push eax
+ 00104 8b c7 mov eax, edi
+ 00106 e8 00 00 00 00 call _Write_Zip64EndOfCentralDirectoryLocator
+ 0010b 83 c4 08 add esp, 8
+$LN8@zipClose:
+
+; 1931 : }
+; 1932 :
+; 1933 : if (err==ZIP_OK)
+
+ 0010e 85 db test ebx, ebx
+ 00110 75 2b jne SHORT $LN5@zipClose
+
+; 1934 : err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
+
+ 00112 8b 4c 24 14 mov ecx, DWORD PTR _centraldir_pos_inzip$[esp+36]
+ 00116 8b 54 24 0c mov edx, DWORD PTR _size_centraldir$[esp+32]
+ 0011a 51 push ecx
+ 0011b 56 push esi
+ 0011c 52 push edx
+ 0011d 8b c7 mov eax, edi
+ 0011f e8 00 00 00 00 call _Write_EndOfCentralDirectoryRecord
+ 00124 8b d8 mov ebx, eax
+ 00126 83 c4 0c add esp, 12 ; 0000000cH
+
+; 1935 :
+; 1936 : if(err == ZIP_OK)
+
+ 00129 85 db test ebx, ebx
+ 0012b 75 10 jne SHORT $LN5@zipClose
+
+; 1937 : err = Write_GlobalComment(zi, global_comment);
+
+ 0012d 8b 45 0c mov eax, DWORD PTR _global_comment$[ebp]
+ 00130 50 push eax
+ 00131 8b c7 mov eax, edi
+ 00133 e8 00 00 00 00 call _Write_GlobalComment
+ 00138 83 c4 04 add esp, 4
+ 0013b 8b d8 mov ebx, eax
+$LN5@zipClose:
+
+; 1938 :
+; 1939 : if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)
+
+ 0013d 8b 4f 2c mov ecx, DWORD PTR [edi+44]
+ 00140 8b 57 1c mov edx, DWORD PTR [edi+28]
+ 00143 8b 47 14 mov eax, DWORD PTR [edi+20]
+ 00146 51 push ecx
+ 00147 52 push edx
+ 00148 ff d0 call eax
+ 0014a 83 c4 08 add esp, 8
+ 0014d 85 c0 test eax, eax
+ 0014f 74 07 je SHORT $LN3@zipClose
+
+; 1940 : if (err == ZIP_OK)
+
+ 00151 85 db test ebx, ebx
+ 00153 75 03 jne SHORT $LN3@zipClose
+
+; 1941 : err = ZIP_ERRNO;
+
+ 00155 83 cb ff or ebx, -1
+$LN3@zipClose:
+
+; 1942 :
+; 1943 : #ifndef NO_ADDFILEINEXISTINGZIP
+; 1944 : TRYFREE(zi->globalcomment);
+
+ 00158 8b 87 00 01 01
+ 00 mov eax, DWORD PTR [edi+65792]
+ 0015e 85 c0 test eax, eax
+ 00160 74 09 je SHORT $LN2@zipClose
+ 00162 50 push eax
+ 00163 e8 00 00 00 00 call _free
+ 00168 83 c4 04 add esp, 4
+$LN2@zipClose:
+
+; 1945 : #endif
+; 1946 : TRYFREE(zi);
+
+ 0016b 57 push edi
+ 0016c e8 00 00 00 00 call _free
+ 00171 83 c4 04 add esp, 4
+
+; 1947 :
+; 1948 : return err;
+; 1949 : }
+
+ 00174 5f pop edi
+ 00175 5e pop esi
+ 00176 8b c3 mov eax, ebx
+ 00178 5b pop ebx
+ 00179 8b e5 mov esp, ebp
+ 0017b 5d pop ebp
+ 0017c c2 08 00 ret 8
+_zipClose@8 ENDP
+_TEXT ENDS
+PUBLIC _zipOpenNewFileInZip@40
+; Function compile flags: /Ogtp
+; COMDAT _zipOpenNewFileInZip@40
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_filename$ = 12 ; size = 4
+_zipfi$ = 16 ; size = 4
+_extrafield_local$ = 20 ; size = 4
+_size_extrafield_local$ = 24 ; size = 4
+_extrafield_global$ = 28 ; size = 4
+_size_extrafield_global$ = 32 ; size = 4
+_comment$ = 36 ; size = 4
+_method$ = 40 ; size = 4
+_level$ = 44 ; size = 4
+_zipOpenNewFileInZip@40 PROC ; COMDAT
+
+; 1354 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 1355 : return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+; 1356 : extrafield_local, size_extrafield_local,
+; 1357 : extrafield_global, size_extrafield_global,
+; 1358 : comment, method, level, 0,
+; 1359 : -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+; 1360 : NULL, 0, VERSIONMADEBY, 0, 0);
+
+ 00003 6a 00 push 0
+ 00005 8b 45 2c mov eax, DWORD PTR _level$[ebp]
+ 00008 6a 00 push 0
+ 0000a 8b 4d 28 mov ecx, DWORD PTR _method$[ebp]
+ 0000d 8b 55 24 mov edx, DWORD PTR _comment$[ebp]
+ 00010 6a 00 push 0
+ 00012 6a 00 push 0
+ 00014 6a 00 push 0
+ 00016 6a 00 push 0
+ 00018 6a 08 push 8
+ 0001a 6a f1 push -15 ; fffffff1H
+ 0001c 6a 00 push 0
+ 0001e 50 push eax
+ 0001f 8b 45 20 mov eax, DWORD PTR _size_extrafield_global$[ebp]
+ 00022 51 push ecx
+ 00023 8b 4d 1c mov ecx, DWORD PTR _extrafield_global$[ebp]
+ 00026 52 push edx
+ 00027 8b 55 18 mov edx, DWORD PTR _size_extrafield_local$[ebp]
+ 0002a 50 push eax
+ 0002b 8b 45 14 mov eax, DWORD PTR _extrafield_local$[ebp]
+ 0002e 51 push ecx
+ 0002f 8b 4d 10 mov ecx, DWORD PTR _zipfi$[ebp]
+ 00032 52 push edx
+ 00033 8b 55 0c mov edx, DWORD PTR _filename$[ebp]
+ 00036 50 push eax
+ 00037 8b 45 08 mov eax, DWORD PTR _file$[ebp]
+ 0003a 51 push ecx
+ 0003b 52 push edx
+ 0003c 50 push eax
+ 0003d e8 00 00 00 00 call _zipOpenNewFileInZip4_64@76
+
+; 1361 : }
+
+ 00042 5d pop ebp
+ 00043 c2 28 00 ret 40 ; 00000028H
+_zipOpenNewFileInZip@40 ENDP
+_TEXT ENDS
+PUBLIC _zipOpenNewFileInZip64@44
+; Function compile flags: /Ogtp
+; COMDAT _zipOpenNewFileInZip64@44
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_filename$ = 12 ; size = 4
+_zipfi$ = 16 ; size = 4
+_extrafield_local$ = 20 ; size = 4
+_size_extrafield_local$ = 24 ; size = 4
+_extrafield_global$ = 28 ; size = 4
+_size_extrafield_global$ = 32 ; size = 4
+_comment$ = 36 ; size = 4
+_method$ = 40 ; size = 4
+_level$ = 44 ; size = 4
+_zip64$ = 48 ; size = 4
+_zipOpenNewFileInZip64@44 PROC ; COMDAT
+
+; 1341 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 1342 : return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+; 1343 : extrafield_local, size_extrafield_local,
+; 1344 : extrafield_global, size_extrafield_global,
+; 1345 : comment, method, level, 0,
+; 1346 : -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+; 1347 : NULL, 0, VERSIONMADEBY, 0, zip64);
+
+ 00003 8b 45 30 mov eax, DWORD PTR _zip64$[ebp]
+ 00006 50 push eax
+ 00007 8b 4d 2c mov ecx, DWORD PTR _level$[ebp]
+ 0000a 6a 00 push 0
+ 0000c 8b 55 28 mov edx, DWORD PTR _method$[ebp]
+ 0000f 8b 45 24 mov eax, DWORD PTR _comment$[ebp]
+ 00012 6a 00 push 0
+ 00014 6a 00 push 0
+ 00016 6a 00 push 0
+ 00018 6a 00 push 0
+ 0001a 6a 08 push 8
+ 0001c 6a f1 push -15 ; fffffff1H
+ 0001e 6a 00 push 0
+ 00020 51 push ecx
+ 00021 8b 4d 20 mov ecx, DWORD PTR _size_extrafield_global$[ebp]
+ 00024 52 push edx
+ 00025 8b 55 1c mov edx, DWORD PTR _extrafield_global$[ebp]
+ 00028 50 push eax
+ 00029 8b 45 18 mov eax, DWORD PTR _size_extrafield_local$[ebp]
+ 0002c 51 push ecx
+ 0002d 8b 4d 14 mov ecx, DWORD PTR _extrafield_local$[ebp]
+ 00030 52 push edx
+ 00031 8b 55 10 mov edx, DWORD PTR _zipfi$[ebp]
+ 00034 50 push eax
+ 00035 8b 45 0c mov eax, DWORD PTR _filename$[ebp]
+ 00038 51 push ecx
+ 00039 8b 4d 08 mov ecx, DWORD PTR _file$[ebp]
+ 0003c 52 push edx
+ 0003d 50 push eax
+ 0003e 51 push ecx
+ 0003f e8 00 00 00 00 call _zipOpenNewFileInZip4_64@76
+
+; 1348 : }
+
+ 00044 5d pop ebp
+ 00045 c2 2c 00 ret 44 ; 0000002cH
+_zipOpenNewFileInZip64@44 ENDP
+_TEXT ENDS
+PUBLIC _zipOpenNewFileInZip2_64@48
+; Function compile flags: /Ogtp
+; COMDAT _zipOpenNewFileInZip2_64@48
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_filename$ = 12 ; size = 4
+_zipfi$ = 16 ; size = 4
+_extrafield_local$ = 20 ; size = 4
+_size_extrafield_local$ = 24 ; size = 4
+_extrafield_global$ = 28 ; size = 4
+_size_extrafield_global$ = 32 ; size = 4
+_comment$ = 36 ; size = 4
+_method$ = 40 ; size = 4
+_level$ = 44 ; size = 4
+_raw$ = 48 ; size = 4
+_zip64$ = 52 ; size = 4
+_zipOpenNewFileInZip2_64@48 PROC ; COMDAT
+
+; 1328 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 1329 : return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+; 1330 : extrafield_local, size_extrafield_local,
+; 1331 : extrafield_global, size_extrafield_global,
+; 1332 : comment, method, level, raw,
+; 1333 : -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+; 1334 : NULL, 0, VERSIONMADEBY, 0, zip64);
+
+ 00003 8b 45 34 mov eax, DWORD PTR _zip64$[ebp]
+ 00006 50 push eax
+ 00007 8b 4d 30 mov ecx, DWORD PTR _raw$[ebp]
+ 0000a 8b 55 2c mov edx, DWORD PTR _level$[ebp]
+ 0000d 6a 00 push 0
+ 0000f 8b 45 28 mov eax, DWORD PTR _method$[ebp]
+ 00012 6a 00 push 0
+ 00014 6a 00 push 0
+ 00016 6a 00 push 0
+ 00018 6a 00 push 0
+ 0001a 6a 08 push 8
+ 0001c 6a f1 push -15 ; fffffff1H
+ 0001e 51 push ecx
+ 0001f 8b 4d 24 mov ecx, DWORD PTR _comment$[ebp]
+ 00022 52 push edx
+ 00023 8b 55 20 mov edx, DWORD PTR _size_extrafield_global$[ebp]
+ 00026 50 push eax
+ 00027 8b 45 1c mov eax, DWORD PTR _extrafield_global$[ebp]
+ 0002a 51 push ecx
+ 0002b 8b 4d 18 mov ecx, DWORD PTR _size_extrafield_local$[ebp]
+ 0002e 52 push edx
+ 0002f 8b 55 14 mov edx, DWORD PTR _extrafield_local$[ebp]
+ 00032 50 push eax
+ 00033 8b 45 10 mov eax, DWORD PTR _zipfi$[ebp]
+ 00036 51 push ecx
+ 00037 8b 4d 0c mov ecx, DWORD PTR _filename$[ebp]
+ 0003a 52 push edx
+ 0003b 8b 55 08 mov edx, DWORD PTR _file$[ebp]
+ 0003e 50 push eax
+ 0003f 51 push ecx
+ 00040 52 push edx
+ 00041 e8 00 00 00 00 call _zipOpenNewFileInZip4_64@76
+
+; 1335 : }
+
+ 00046 5d pop ebp
+ 00047 c2 30 00 ret 48 ; 00000030H
+_zipOpenNewFileInZip2_64@48 ENDP
+_TEXT ENDS
+PUBLIC _zipOpenNewFileInZip2@44
+; Function compile flags: /Ogtp
+; COMDAT _zipOpenNewFileInZip2@44
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_filename$ = 12 ; size = 4
+_zipfi$ = 16 ; size = 4
+_extrafield_local$ = 20 ; size = 4
+_size_extrafield_local$ = 24 ; size = 4
+_extrafield_global$ = 28 ; size = 4
+_size_extrafield_global$ = 32 ; size = 4
+_comment$ = 36 ; size = 4
+_method$ = 40 ; size = 4
+_level$ = 44 ; size = 4
+_raw$ = 48 ; size = 4
+_zipOpenNewFileInZip2@44 PROC ; COMDAT
+
+; 1315 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 1316 : return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+; 1317 : extrafield_local, size_extrafield_local,
+; 1318 : extrafield_global, size_extrafield_global,
+; 1319 : comment, method, level, raw,
+; 1320 : -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+; 1321 : NULL, 0, VERSIONMADEBY, 0, 0);
+
+ 00003 8b 45 30 mov eax, DWORD PTR _raw$[ebp]
+ 00006 6a 00 push 0
+ 00008 8b 4d 2c mov ecx, DWORD PTR _level$[ebp]
+ 0000b 6a 00 push 0
+ 0000d 8b 55 28 mov edx, DWORD PTR _method$[ebp]
+ 00010 6a 00 push 0
+ 00012 6a 00 push 0
+ 00014 6a 00 push 0
+ 00016 6a 00 push 0
+ 00018 6a 08 push 8
+ 0001a 6a f1 push -15 ; fffffff1H
+ 0001c 50 push eax
+ 0001d 8b 45 24 mov eax, DWORD PTR _comment$[ebp]
+ 00020 51 push ecx
+ 00021 8b 4d 20 mov ecx, DWORD PTR _size_extrafield_global$[ebp]
+ 00024 52 push edx
+ 00025 8b 55 1c mov edx, DWORD PTR _extrafield_global$[ebp]
+ 00028 50 push eax
+ 00029 8b 45 18 mov eax, DWORD PTR _size_extrafield_local$[ebp]
+ 0002c 51 push ecx
+ 0002d 8b 4d 14 mov ecx, DWORD PTR _extrafield_local$[ebp]
+ 00030 52 push edx
+ 00031 8b 55 10 mov edx, DWORD PTR _zipfi$[ebp]
+ 00034 50 push eax
+ 00035 8b 45 0c mov eax, DWORD PTR _filename$[ebp]
+ 00038 51 push ecx
+ 00039 8b 4d 08 mov ecx, DWORD PTR _file$[ebp]
+ 0003c 52 push edx
+ 0003d 50 push eax
+ 0003e 51 push ecx
+ 0003f e8 00 00 00 00 call _zipOpenNewFileInZip4_64@76
+
+; 1322 : }
+
+ 00044 5d pop ebp
+ 00045 c2 2c 00 ret 44 ; 0000002cH
+_zipOpenNewFileInZip2@44 ENDP
+_TEXT ENDS
+PUBLIC _zipOpenNewFileInZip3_64@68
+; Function compile flags: /Ogtp
+; COMDAT _zipOpenNewFileInZip3_64@68
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_filename$ = 12 ; size = 4
+_zipfi$ = 16 ; size = 4
+_extrafield_local$ = 20 ; size = 4
+_size_extrafield_local$ = 24 ; size = 4
+_extrafield_global$ = 28 ; size = 4
+_size_extrafield_global$ = 32 ; size = 4
+_comment$ = 36 ; size = 4
+_method$ = 40 ; size = 4
+_level$ = 44 ; size = 4
+_raw$ = 48 ; size = 4
+_windowBits$ = 52 ; size = 4
+_memLevel$ = 56 ; size = 4
+_strategy$ = 60 ; size = 4
+_password$ = 64 ; size = 4
+_crcForCrypting$ = 68 ; size = 4
+_zip64$ = 72 ; size = 4
+_zipOpenNewFileInZip3_64@68 PROC ; COMDAT
+
+; 1302 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 1303 : return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+; 1304 : extrafield_local, size_extrafield_local,
+; 1305 : extrafield_global, size_extrafield_global,
+; 1306 : comment, method, level, raw,
+; 1307 : windowBits, memLevel, strategy,
+; 1308 : password, crcForCrypting, VERSIONMADEBY, 0, zip64);
+
+ 00003 8b 45 48 mov eax, DWORD PTR _zip64$[ebp]
+ 00006 8b 4d 44 mov ecx, DWORD PTR _crcForCrypting$[ebp]
+ 00009 8b 55 40 mov edx, DWORD PTR _password$[ebp]
+ 0000c 50 push eax
+ 0000d 8b 45 3c mov eax, DWORD PTR _strategy$[ebp]
+ 00010 6a 00 push 0
+ 00012 6a 00 push 0
+ 00014 51 push ecx
+ 00015 8b 4d 38 mov ecx, DWORD PTR _memLevel$[ebp]
+ 00018 52 push edx
+ 00019 8b 55 34 mov edx, DWORD PTR _windowBits$[ebp]
+ 0001c 50 push eax
+ 0001d 8b 45 30 mov eax, DWORD PTR _raw$[ebp]
+ 00020 51 push ecx
+ 00021 8b 4d 2c mov ecx, DWORD PTR _level$[ebp]
+ 00024 52 push edx
+ 00025 8b 55 28 mov edx, DWORD PTR _method$[ebp]
+ 00028 50 push eax
+ 00029 8b 45 24 mov eax, DWORD PTR _comment$[ebp]
+ 0002c 51 push ecx
+ 0002d 8b 4d 20 mov ecx, DWORD PTR _size_extrafield_global$[ebp]
+ 00030 52 push edx
+ 00031 8b 55 1c mov edx, DWORD PTR _extrafield_global$[ebp]
+ 00034 50 push eax
+ 00035 8b 45 18 mov eax, DWORD PTR _size_extrafield_local$[ebp]
+ 00038 51 push ecx
+ 00039 8b 4d 14 mov ecx, DWORD PTR _extrafield_local$[ebp]
+ 0003c 52 push edx
+ 0003d 8b 55 10 mov edx, DWORD PTR _zipfi$[ebp]
+ 00040 50 push eax
+ 00041 8b 45 0c mov eax, DWORD PTR _filename$[ebp]
+ 00044 51 push ecx
+ 00045 8b 4d 08 mov ecx, DWORD PTR _file$[ebp]
+ 00048 52 push edx
+ 00049 50 push eax
+ 0004a 51 push ecx
+ 0004b e8 00 00 00 00 call _zipOpenNewFileInZip4_64@76
+
+; 1309 : }
+
+ 00050 5d pop ebp
+ 00051 c2 44 00 ret 68 ; 00000044H
+_zipOpenNewFileInZip3_64@68 ENDP
+_TEXT ENDS
+PUBLIC _zipOpenNewFileInZip3@64
+; Function compile flags: /Ogtp
+; COMDAT _zipOpenNewFileInZip3@64
+_TEXT SEGMENT
+_file$ = 8 ; size = 4
+_filename$ = 12 ; size = 4
+_zipfi$ = 16 ; size = 4
+_extrafield_local$ = 20 ; size = 4
+_size_extrafield_local$ = 24 ; size = 4
+_extrafield_global$ = 28 ; size = 4
+_size_extrafield_global$ = 32 ; size = 4
+_comment$ = 36 ; size = 4
+_method$ = 40 ; size = 4
+_level$ = 44 ; size = 4
+_raw$ = 48 ; size = 4
+_windowBits$ = 52 ; size = 4
+_memLevel$ = 56 ; size = 4
+_strategy$ = 60 ; size = 4
+_password$ = 64 ; size = 4
+_crcForCrypting$ = 68 ; size = 4
+_zipOpenNewFileInZip3@64 PROC ; COMDAT
+
+; 1287 : {
+
+ 00000 55 push ebp
+ 00001 8b ec mov ebp, esp
+
+; 1288 : return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+; 1289 : extrafield_local, size_extrafield_local,
+; 1290 : extrafield_global, size_extrafield_global,
+; 1291 : comment, method, level, raw,
+; 1292 : windowBits, memLevel, strategy,
+; 1293 : password, crcForCrypting, VERSIONMADEBY, 0, 0);
+
+ 00003 8b 45 44 mov eax, DWORD PTR _crcForCrypting$[ebp]
+ 00006 8b 4d 40 mov ecx, DWORD PTR _password$[ebp]
+ 00009 8b 55 3c mov edx, DWORD PTR _strategy$[ebp]
+ 0000c 6a 00 push 0
+ 0000e 6a 00 push 0
+ 00010 6a 00 push 0
+ 00012 50 push eax
+ 00013 8b 45 38 mov eax, DWORD PTR _memLevel$[ebp]
+ 00016 51 push ecx
+ 00017 8b 4d 34 mov ecx, DWORD PTR _windowBits$[ebp]
+ 0001a 52 push edx
+ 0001b 8b 55 30 mov edx, DWORD PTR _raw$[ebp]
+ 0001e 50 push eax
+ 0001f 8b 45 2c mov eax, DWORD PTR _level$[ebp]
+ 00022 51 push ecx
+ 00023 8b 4d 28 mov ecx, DWORD PTR _method$[ebp]
+ 00026 52 push edx
+ 00027 8b 55 24 mov edx, DWORD PTR _comment$[ebp]
+ 0002a 50 push eax
+ 0002b 8b 45 20 mov eax, DWORD PTR _size_extrafield_global$[ebp]
+ 0002e 51 push ecx
+ 0002f 8b 4d 1c mov ecx, DWORD PTR _extrafield_global$[ebp]
+ 00032 52 push edx
+ 00033 8b 55 18 mov edx, DWORD PTR _size_extrafield_local$[ebp]
+ 00036 50 push eax
+ 00037 8b 45 14 mov eax, DWORD PTR _extrafield_local$[ebp]
+ 0003a 51 push ecx
+ 0003b 8b 4d 10 mov ecx, DWORD PTR _zipfi$[ebp]
+ 0003e 52 push edx
+ 0003f 8b 55 0c mov edx, DWORD PTR _filename$[ebp]
+ 00042 50 push eax
+ 00043 8b 45 08 mov eax, DWORD PTR _file$[ebp]
+ 00046 51 push ecx
+ 00047 52 push edx
+ 00048 50 push eax
+ 00049 e8 00 00 00 00 call _zipOpenNewFileInZip4_64@76
+
+; 1294 : }
+
+ 0004e 5d pop ebp
+ 0004f c2 40 00 ret 64 ; 00000040H
+_zipOpenNewFileInZip3@64 ENDP
+END
OSDN Git Service
