; Listing generated by Microsoft (R) Optimizing Compiler Version 19.00.24215.1 

include listing.inc

INCLUDELIB OLDNAMES

PUBLIC	??_C@_01JOAMLHOP@?9?$AA@			; `string'
EXTRN	__imp__time64:PROC
EXTRN	__imp_rand:PROC
EXTRN	__imp_srand:PROC
?calls@?1??crypthead@@9@9 DD 01H DUP (?)		; `crypthead'::`2'::calls
_BSS	ENDS
;	COMDAT ??_C@_01JOAMLHOP@?9?$AA@
CONST	SEGMENT
??_C@_01JOAMLHOP@?9?$AA@ DB '-', 00H			; `string'
PUBLIC	zipClose
PUBLIC	Write_GlobalComment
PUBLIC	Write_EndOfCentralDirectoryRecord
PUBLIC	Write_Zip64EndOfCentralDirectoryRecord
PUBLIC	Write_Zip64EndOfCentralDirectoryLocator
PUBLIC	zipCloseFileInZip
PUBLIC	zipCloseFileInZipRaw64
PUBLIC	zipCloseFileInZipRaw
PUBLIC	zipWriteInFileInZip
PUBLIC	zipOpenNewFileInZip
PUBLIC	zipOpenNewFileInZip64
PUBLIC	zipOpenNewFileInZip2_64
PUBLIC	zipOpenNewFileInZip2
PUBLIC	zipOpenNewFileInZip3_64
PUBLIC	zipOpenNewFileInZip3
PUBLIC	zipOpenNewFileInZip4_64
PUBLIC	Write_LocalFileHeader
PUBLIC	zipOpen64
PUBLIC	zipOpen
PUBLIC	zipOpen2_64
PUBLIC	zipOpen2
PUBLIC	zipOpen3
PUBLIC	LoadCentralDirectoryRecord
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipClose DD imagerel $LN24
	DD	imagerel $LN24+49
	DD	imagerel $unwind$zipClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$zipClose DD imagerel $LN24+49
	DD	imagerel $LN24+54
	DD	imagerel $chain$0$zipClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$zipClose DD imagerel $LN24+54
	DD	imagerel $LN24+87
	DD	imagerel $chain$1$zipClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$zipClose DD imagerel $LN24+87
	DD	imagerel $LN24+253
	DD	imagerel $chain$2$zipClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$zipClose DD imagerel $LN24+253
	DD	imagerel $LN24+305
	DD	imagerel $chain$3$zipClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$zipClose DD imagerel $LN24+305
	DD	imagerel $LN24+328
	DD	imagerel $chain$4$zipClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$5$zipClose DD imagerel $LN24+328
	DD	imagerel $LN24+359
	DD	imagerel $chain$5$zipClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$Write_GlobalComment DD imagerel $LN10
	DD	imagerel $LN10+137
	DD	imagerel $unwind$Write_GlobalComment
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$Write_EndOfCentralDirectoryRecord DD imagerel $LN25
	DD	imagerel $LN25+285
	DD	imagerel $unwind$Write_EndOfCentralDirectoryRecord
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$Write_Zip64EndOfCentralDirectoryRecord DD imagerel $LN13
	DD	imagerel $LN13+301
	DD	imagerel $unwind$Write_Zip64EndOfCentralDirectoryRecord
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$Write_Zip64EndOfCentralDirectoryLocator DD imagerel $LN10
	DD	imagerel $LN10+125
	DD	imagerel $unwind$Write_Zip64EndOfCentralDirectoryLocator
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipCloseFileInZipRaw64 DD imagerel $LN62
	DD	imagerel $LN62+1109
	DD	imagerel $unwind$zipCloseFileInZipRaw64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipWriteInFileInZip DD imagerel $LN29
	DD	imagerel $LN29+57
	DD	imagerel $unwind$zipWriteInFileInZip
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$zipWriteInFileInZip DD imagerel $LN29+57
	DD	imagerel $LN29+207
	DD	imagerel $chain$0$zipWriteInFileInZip
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$zipWriteInFileInZip DD imagerel $LN29+207
	DD	imagerel $LN29+228
	DD	imagerel $chain$1$zipWriteInFileInZip
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$zipWriteInFileInZip DD imagerel $LN29+228
	DD	imagerel $LN29+356
	DD	imagerel $chain$2$zipWriteInFileInZip
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64FlushWriteBuffer DD imagerel zip64FlushWriteBuffer
	DD	imagerel zip64FlushWriteBuffer+22
	DD	imagerel $unwind$zip64FlushWriteBuffer
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$zip64FlushWriteBuffer DD imagerel zip64FlushWriteBuffer+22
	DD	imagerel zip64FlushWriteBuffer+37
	DD	imagerel $chain$0$zip64FlushWriteBuffer
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$zip64FlushWriteBuffer DD imagerel zip64FlushWriteBuffer+37
	DD	imagerel zip64FlushWriteBuffer+118
	DD	imagerel $chain$2$zip64FlushWriteBuffer
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$zip64FlushWriteBuffer DD imagerel zip64FlushWriteBuffer+118
	DD	imagerel zip64FlushWriteBuffer+123
	DD	imagerel $chain$3$zip64FlushWriteBuffer
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$zip64FlushWriteBuffer DD imagerel zip64FlushWriteBuffer+123
	DD	imagerel zip64FlushWriteBuffer+217
	DD	imagerel $chain$4$zip64FlushWriteBuffer
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpenNewFileInZip DD imagerel $LN4
	DD	imagerel $LN4+137
	DD	imagerel $unwind$zipOpenNewFileInZip
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpenNewFileInZip64 DD imagerel $LN4
	DD	imagerel $LN4+144
	DD	imagerel $unwind$zipOpenNewFileInZip64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpenNewFileInZip2_64 DD imagerel $LN4
	DD	imagerel $LN4+151
	DD	imagerel $unwind$zipOpenNewFileInZip2_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpenNewFileInZip2 DD imagerel $LN4
	DD	imagerel $LN4+144
	DD	imagerel $unwind$zipOpenNewFileInZip2
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpenNewFileInZip3_64 DD imagerel $LN4
	DD	imagerel $LN4+179
	DD	imagerel $unwind$zipOpenNewFileInZip3_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpenNewFileInZip3 DD imagerel $LN4
	DD	imagerel $LN4+172
	DD	imagerel $unwind$zipOpenNewFileInZip3
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpenNewFileInZip4_64 DD imagerel $LN72
	DD	imagerel $LN72+39
	DD	imagerel $unwind$zipOpenNewFileInZip4_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$zipOpenNewFileInZip4_64 DD imagerel $LN72+39
	DD	imagerel $LN72+86
	DD	imagerel $chain$0$zipOpenNewFileInZip4_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$zipOpenNewFileInZip4_64 DD imagerel $LN72+86
	DD	imagerel $LN72+105
	DD	imagerel $chain$2$zipOpenNewFileInZip4_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$6$zipOpenNewFileInZip4_64 DD imagerel $LN72+105
	DD	imagerel $LN72+1393
	DD	imagerel $chain$6$zipOpenNewFileInZip4_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$7$zipOpenNewFileInZip4_64 DD imagerel $LN72+1393
	DD	imagerel $LN72+1410
	DD	imagerel $chain$7$zipOpenNewFileInZip4_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$Write_LocalFileHeader DD imagerel $LN36
	DD	imagerel $LN36+593
	DD	imagerel $unwind$Write_LocalFileHeader
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpen2_64 DD imagerel $LN7
	DD	imagerel $LN7+94
	DD	imagerel $unwind$zipOpen2_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpen2 DD imagerel $LN7
	DD	imagerel $LN7+78
	DD	imagerel $unwind$zipOpen2
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zipOpen3 DD imagerel $LN17
	DD	imagerel $LN17+553
	DD	imagerel $unwind$zipOpen3
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$LoadCentralDirectoryRecord DD imagerel $LN58
	DD	imagerel $LN58+920
	DD	imagerel $unwind$LoadCentralDirectoryRecord
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_SearchCentralDir64 DD imagerel zip64local_SearchCentralDir64
	DD	imagerel zip64local_SearchCentralDir64+122
	DD	imagerel $unwind$zip64local_SearchCentralDir64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$zip64local_SearchCentralDir64 DD imagerel zip64local_SearchCentralDir64+122
	DD	imagerel zip64local_SearchCentralDir64+328
	DD	imagerel $chain$2$zip64local_SearchCentralDir64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$zip64local_SearchCentralDir64 DD imagerel zip64local_SearchCentralDir64+328
	DD	imagerel zip64local_SearchCentralDir64+535
	DD	imagerel $chain$3$zip64local_SearchCentralDir64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_SearchCentralDir DD imagerel zip64local_SearchCentralDir
	DD	imagerel zip64local_SearchCentralDir+65
	DD	imagerel $unwind$zip64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$zip64local_SearchCentralDir DD imagerel zip64local_SearchCentralDir+65
	DD	imagerel zip64local_SearchCentralDir+124
	DD	imagerel $chain$0$zip64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$zip64local_SearchCentralDir DD imagerel zip64local_SearchCentralDir+124
	DD	imagerel zip64local_SearchCentralDir+143
	DD	imagerel $chain$3$zip64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$5$zip64local_SearchCentralDir DD imagerel zip64local_SearchCentralDir+143
	DD	imagerel zip64local_SearchCentralDir+338
	DD	imagerel $chain$5$zip64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$6$zip64local_SearchCentralDir DD imagerel zip64local_SearchCentralDir+338
	DD	imagerel zip64local_SearchCentralDir+372
	DD	imagerel $chain$6$zip64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_getLong64 DD imagerel zip64local_getLong64
	DD	imagerel zip64local_getLong64+369
	DD	imagerel $unwind$zip64local_getLong64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_getLong DD imagerel zip64local_getLong
	DD	imagerel zip64local_getLong+205
	DD	imagerel $unwind$zip64local_getLong
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_getShort DD imagerel zip64local_getShort
	DD	imagerel zip64local_getShort+124
	DD	imagerel $unwind$zip64local_getShort
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_getByte DD imagerel zip64local_getByte
	DD	imagerel zip64local_getByte+102
	DD	imagerel $unwind$zip64local_getByte
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_putValue_inmemory DD imagerel zip64local_putValue_inmemory
	DD	imagerel zip64local_putValue_inmemory+70
	DD	imagerel $unwind$zip64local_putValue_inmemory
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$zip64local_putValue DD imagerel zip64local_putValue
	DD	imagerel zip64local_putValue+59
	DD	imagerel $unwind$zip64local_putValue
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$zip64local_putValue DD imagerel zip64local_putValue+59
	DD	imagerel zip64local_putValue+81
	DD	imagerel $chain$0$zip64local_putValue
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$zip64local_putValue DD imagerel zip64local_putValue+81
	DD	imagerel zip64local_putValue+109
	DD	imagerel $chain$1$zip64local_putValue
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$add_data_in_datablock DD imagerel add_data_in_datablock
	DD	imagerel add_data_in_datablock+74
	DD	imagerel $unwind$add_data_in_datablock
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$add_data_in_datablock DD imagerel add_data_in_datablock+74
	DD	imagerel add_data_in_datablock+206
	DD	imagerel $chain$0$add_data_in_datablock
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$add_data_in_datablock DD imagerel add_data_in_datablock+206
	DD	imagerel add_data_in_datablock+213
	DD	imagerel $chain$2$add_data_in_datablock
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$free_linkedlist DD imagerel free_linkedlist
	DD	imagerel free_linkedlist+32
	DD	imagerel $unwind$free_linkedlist
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$free_datablock DD imagerel free_datablock
	DD	imagerel free_datablock+9
	DD	imagerel $unwind$free_datablock
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$free_datablock DD imagerel free_datablock+9
	DD	imagerel free_datablock+38
	DD	imagerel $chain$0$free_datablock
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$free_datablock DD imagerel free_datablock+38
	DD	imagerel free_datablock+43
	DD	imagerel $chain$1$free_datablock
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$allocate_new_datablock DD imagerel allocate_new_datablock
	DD	imagerel allocate_new_datablock+38
	DD	imagerel $unwind$allocate_new_datablock
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$crypthead DD imagerel crypthead
	DD	imagerel crypthead+327
	DD	imagerel $unwind$crypthead
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$init_keys DD imagerel init_keys
	DD	imagerel init_keys+107
	DD	imagerel $unwind$init_keys
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$update_keys DD imagerel update_keys
	DD	imagerel update_keys+93
	DD	imagerel $unwind$update_keys
pdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$update_keys DD 020501H
	DD	013405H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$init_keys DD 060f01H
	DD	07640fH
	DD	06340fH
	DD	0700b320fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$crypthead DD 0c1e01H
	DD	0d741eH
	DD	0c641eH
	DD	0b541eH
	DD	0a341eH
	DD	0f01a521eH
	DD	0d016e018H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$allocate_new_datablock DD 010401H
	DD	04204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$free_datablock DD 021H
	DD	imagerel free_datablock
	DD	imagerel free_datablock+9
	DD	imagerel $unwind$free_datablock
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$free_datablock DD 020521H
	DD	043405H
	DD	imagerel free_datablock
	DD	imagerel free_datablock+9
	DD	imagerel $unwind$free_datablock
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$free_datablock DD 010401H
	DD	04204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$free_linkedlist DD 020601H
	DD	030023206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$add_data_in_datablock DD 020021H
	DD	063400H
	DD	imagerel add_data_in_datablock
	DD	imagerel add_data_in_datablock+74
	DD	imagerel $unwind$add_data_in_datablock
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$add_data_in_datablock DD 020521H
	DD	063405H
	DD	imagerel add_data_in_datablock
	DD	imagerel add_data_in_datablock+74
	DD	imagerel $unwind$add_data_in_datablock
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$add_data_in_datablock DD 060f01H
	DD	08640fH
	DD	07540fH
	DD	0700b320fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$zip64local_putValue DD 021H
	DD	imagerel zip64local_putValue
	DD	imagerel zip64local_putValue+59
	DD	imagerel $unwind$zip64local_putValue
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$zip64local_putValue DD 020521H
	DD	077405H
	DD	imagerel zip64local_putValue
	DD	imagerel zip64local_putValue+59
	DD	imagerel $unwind$zip64local_putValue
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_putValue DD 020601H
	DD	030023206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_putValue_inmemory DD 020501H
	DD	017405H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_getByte DD 060f01H
	DD	08640fH
	DD	07340fH
	DD	0700b320fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_getShort DD 081401H
	DD	086414H
	DD	075414H
	DD	063414H
	DD	070103214H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_getLong DD 081501H
	DD	087415H
	DD	076415H
	DD	063415H
	DD	0e0113215H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_getLong64 DD 081501H
	DD	087415H
	DD	076415H
	DD	063415H
	DD	0e0113215H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$6$zip64local_SearchCentralDir DD 021H
	DD	imagerel zip64local_SearchCentralDir+124
	DD	imagerel zip64local_SearchCentralDir+143
	DD	imagerel $chain$3$zip64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$5$zip64local_SearchCentralDir DD 040a21H
	DD	0d740aH
	DD	0c6405H
	DD	imagerel zip64local_SearchCentralDir+124
	DD	imagerel zip64local_SearchCentralDir+143
	DD	imagerel $chain$3$zip64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$zip64local_SearchCentralDir DD 040521H
	DD	0a5405H
	DD	04f400H
	DD	imagerel zip64local_SearchCentralDir
	DD	imagerel zip64local_SearchCentralDir+65
	DD	imagerel $unwind$zip64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$zip64local_SearchCentralDir DD 020521H
	DD	04f405H
	DD	imagerel zip64local_SearchCentralDir
	DD	imagerel zip64local_SearchCentralDir+65
	DD	imagerel $unwind$zip64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_SearchCentralDir DD 051001H
	DD	0e00c4210H
	DD	0c008d00aH
	DD	03006H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$zip64local_SearchCentralDir64 DD 021H
	DD	imagerel zip64local_SearchCentralDir64
	DD	imagerel zip64local_SearchCentralDir64+122
	DD	imagerel $unwind$zip64local_SearchCentralDir64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$zip64local_SearchCentralDir64 DD 020521H
	DD	055405H
	DD	imagerel zip64local_SearchCentralDir64
	DD	imagerel zip64local_SearchCentralDir64+122
	DD	imagerel $unwind$zip64local_SearchCentralDir64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64local_SearchCentralDir64 DD 0a4f01H
	DD	04744fH
	DD	0c3444H
	DD	0f00a520eH
	DD	0d006e008H
	DD	06002c004H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$LoadCentralDirectoryRecord DD 091401H
	DD	0f00d6214H
	DD	0d009e00bH
	DD	07005c007H
	DD	030036004H
	DD	05002H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpen3 DD 0b2a01H
	DD	02037e42aH
	DD	02036742aH
	DD	02035642aH
	DD	02034342aH
	DD	02032012aH
	DD	05015H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpen2 DD 020901H
	DD	03002f209H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpen2_64 DD 020701H
	DD	0110107H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$Write_LocalFileHeader DD 0a4101H
	DD	085441H
	DD	0a6413H
	DD	093413H
	DD	0f00f3213H
	DD	0700be00dH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$7$zipOpenNewFileInZip4_64 DD 021H
	DD	imagerel $LN72+86
	DD	imagerel $LN72+105
	DD	imagerel $chain$2$zipOpenNewFileInZip4_64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$6$zipOpenNewFileInZip4_64 DD 081d21H
	DD	0ae41dH
	DD	0bd418H
	DD	0116413H
	DD	0105408H
	DD	imagerel $LN72+86
	DD	imagerel $LN72+105
	DD	imagerel $chain$2$zipOpenNewFileInZip4_64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$zipOpenNewFileInZip4_64 DD 020021H
	DD	012c400H
	DD	imagerel $LN72
	DD	imagerel $LN72+39
	DD	imagerel $unwind$zipOpenNewFileInZip4_64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$zipOpenNewFileInZip4_64 DD 020821H
	DD	012c408H
	DD	imagerel $LN72
	DD	imagerel $LN72+39
	DD	imagerel $unwind$zipOpenNewFileInZip4_64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpenNewFileInZip4_64 DD 040d01H
	DD	0f009b20dH
	DD	030067007H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpenNewFileInZip3 DD 020a01H
	DD	015010aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpenNewFileInZip3_64 DD 020a01H
	DD	015010aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpenNewFileInZip2 DD 020a01H
	DD	015010aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpenNewFileInZip2_64 DD 020a01H
	DD	015010aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpenNewFileInZip64 DD 020a01H
	DD	015010aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipOpenNewFileInZip DD 020a01H
	DD	015010aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$zip64FlushWriteBuffer DD 021H
	DD	imagerel zip64FlushWriteBuffer
	DD	imagerel zip64FlushWriteBuffer+22
	DD	imagerel $unwind$zip64FlushWriteBuffer
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$zip64FlushWriteBuffer DD 021H
	DD	imagerel zip64FlushWriteBuffer+22
	DD	imagerel zip64FlushWriteBuffer+37
	DD	imagerel $chain$0$zip64FlushWriteBuffer
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$zip64FlushWriteBuffer DD 040a21H
	DD	08e40aH
	DD	076405H
	DD	imagerel zip64FlushWriteBuffer+22
	DD	imagerel zip64FlushWriteBuffer+37
	DD	imagerel $chain$0$zip64FlushWriteBuffer
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$zip64FlushWriteBuffer DD 020521H
	DD	065405H
	DD	imagerel zip64FlushWriteBuffer
	DD	imagerel zip64FlushWriteBuffer+22
	DD	imagerel $unwind$zip64FlushWriteBuffer
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zip64FlushWriteBuffer DD 040a01H
	DD	09340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$zipWriteInFileInZip DD 020021H
	DD	06e400H
	DD	imagerel $LN29
	DD	imagerel $LN29+57
	DD	imagerel $unwind$zipWriteInFileInZip
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$zipWriteInFileInZip DD 021H
	DD	imagerel $LN29
	DD	imagerel $LN29+57
	DD	imagerel $unwind$zipWriteInFileInZip
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$zipWriteInFileInZip DD 020521H
	DD	06e405H
	DD	imagerel $LN29
	DD	imagerel $LN29+57
	DD	imagerel $unwind$zipWriteInFileInZip
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipWriteInFileInZip DD 081401H
	DD	096414H
	DD	085414H
	DD	073414H
	DD	070103214H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipCloseFileInZipRaw64 DD 0d4f01H
	DD	04f44fH
	DD	0cc44aH
	DD	0b7445H
	DD	0a6440H
	DD	0e007420bH
	DD	05003d005H
	DD	03002H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$Write_Zip64EndOfCentralDirectoryLocator DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$Write_Zip64EndOfCentralDirectoryRecord DD 060f01H
	DD	07640fH
	DD	06340fH
	DD	0700b320fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$Write_EndOfCentralDirectoryRecord DD 060f01H
	DD	07640fH
	DD	06340fH
	DD	0700b320fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$Write_GlobalComment DD 0a1a01H
	DD	09741aH
	DD	08641aH
	DD	07541aH
	DD	06341aH
	DD	0e016321aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$5$zipClose DD 021H
	DD	imagerel $LN24
	DD	imagerel $LN24+49
	DD	imagerel $unwind$zipClose
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$zipClose DD 021H
	DD	imagerel $LN24+49
	DD	imagerel $LN24+54
	DD	imagerel $chain$0$zipClose
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$zipClose DD 021H
	DD	imagerel $LN24+54
	DD	imagerel $LN24+87
	DD	imagerel $chain$1$zipClose
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$zipClose DD 020521H
	DD	083405H
	DD	imagerel $LN24+54
	DD	imagerel $LN24+87
	DD	imagerel $chain$1$zipClose
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$zipClose DD 020521H
	DD	0af405H
	DD	imagerel $LN24+49
	DD	imagerel $LN24+54
	DD	imagerel $chain$0$zipClose
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$zipClose DD 020521H
	DD	09c405H
	DD	imagerel $LN24
	DD	imagerel $LN24+49
	DD	imagerel $unwind$zipClose
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$zipClose DD 060d01H
	DD	0b540dH
	DD	0e009320dH
	DD	060067007H
; Function compile flags: /Ogtpy
; File c:\program files (x86)\windows kits\10\include\10.0.10240.0\ucrt\time.h
;	COMDAT time
_TEXT	SEGMENT
_Time$dead$ = 8
time	PROC						; COMDAT

; 535  :             return _time64(_Time);

  00000	33 c9		 xor	 ecx, ecx
  00002	48 ff 25 00 00
	00 00		 rex_jmp QWORD PTR __imp__time64
time	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\crypt.h
;	COMDAT decrypt_byte
_TEXT	SEGMENT
pkeys$ = 8
pcrc_32_tab$dead$ = 16
decrypt_byte PROC					; COMDAT

; 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 51 08	 mov	 edx, DWORD PTR [rcx+8]
  00003	81 e2 fd ff 00
	00		 and	 edx, 65533		; 0000fffdH
  00009	83 ca 02	 or	 edx, 2

; 42   :     return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);

  0000c	8b c2		 mov	 eax, edx
  0000e	83 f0 01	 xor	 eax, 1
  00011	0f af c2	 imul	 eax, edx
  00014	c1 e8 08	 shr	 eax, 8
  00017	0f b6 c0	 movzx	 eax, al

; 43   : }

  0001a	c3		 ret	 0
decrypt_byte ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\crypt.h
;	COMDAT update_keys
_TEXT	SEGMENT
pkeys$ = 8
pcrc_32_tab$ = 16
c$ = 24
update_keys PROC					; COMDAT

; 49   : {

  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx

; 50   :     (*(pkeys+0)) = CRC32((*(pkeys+0)), c);

  00005	44 8b 11	 mov	 r10d, DWORD PTR [rcx]
  00008	48 8b d9	 mov	 rbx, rcx
  0000b	4c 8b da	 mov	 r11, rdx
  0000e	45 8b ca	 mov	 r9d, r10d
  00011	41 8b c0	 mov	 eax, r8d
  00014	41 c1 ea 08	 shr	 r10d, 8
  00018	4c 33 c8	 xor	 r9, rax
  0001b	41 0f b6 c1	 movzx	 eax, r9b
  0001f	44 8b 0c 82	 mov	 r9d, DWORD PTR [rdx+rax*4]

; 51   :     (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
; 52   :     (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
; 53   :     {
; 54   :       register int keyshift = (int)((*(pkeys+1)) >> 24);
; 55   :       (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);

  00023	8b 53 08	 mov	 edx, DWORD PTR [rbx+8]
  00026	45 33 ca	 xor	 r9d, r10d
  00029	44 89 09	 mov	 DWORD PTR [rcx], r9d
  0002c	41 0f b6 c1	 movzx	 eax, r9b
  00030	03 41 04	 add	 eax, DWORD PTR [rcx+4]
  00033	69 c8 05 84 08
	08		 imul	 ecx, eax, 134775813	; 08088405H
  00039	ff c1		 inc	 ecx
  0003b	89 4b 04	 mov	 DWORD PTR [rbx+4], ecx
  0003e	48 c1 e9 18	 shr	 rcx, 24
  00042	48 33 ca	 xor	 rcx, rdx
  00045	c1 ea 08	 shr	 edx, 8
  00048	0f b6 c1	 movzx	 eax, cl
  0004b	41 8b 04 83	 mov	 eax, DWORD PTR [r11+rax*4]
  0004f	33 c2		 xor	 eax, edx
  00051	89 43 08	 mov	 DWORD PTR [rbx+8], eax

; 56   :     }
; 57   :     return c;

  00054	41 8b c0	 mov	 eax, r8d

; 58   : }

  00057	48 8b 5c 24 08	 mov	 rbx, QWORD PTR [rsp+8]
  0005c	c3		 ret	 0
update_keys ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\crypt.h
;	COMDAT init_keys
_TEXT	SEGMENT
passwd$ = 48
pkeys$ = 56
pcrc_32_tab$ = 64
init_keys PROC						; COMDAT

; 66   : {

  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	57		 push	 rdi
  0000b	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 67   :     *(pkeys+0) = 305419896L;

  0000f	c7 02 78 56 34
	12		 mov	 DWORD PTR [rdx], 305419896 ; 12345678H
  00015	49 8b f0	 mov	 rsi, r8

; 68   :     *(pkeys+1) = 591751049L;

  00018	c7 42 04 89 67
	45 23		 mov	 DWORD PTR [rdx+4], 591751049 ; 23456789H
  0001f	48 8b fa	 mov	 rdi, rdx

; 69   :     *(pkeys+2) = 878082192L;

  00022	c7 42 08 90 78
	56 34		 mov	 DWORD PTR [rdx+8], 878082192 ; 34567890H
  00029	48 8b d9	 mov	 rbx, rcx

; 70   :     while (*passwd != '\0') {

  0002c	0f b6 01	 movzx	 eax, BYTE PTR [rcx]
  0002f	84 c0		 test	 al, al
  00031	74 28		 je	 SHORT $LN3@init_keys
  00033	0f 1f 40 00 66
	0f 1f 84 00 00
	00 00 00	 npad	 13
$LL2@init_keys:

; 71   :         update_keys(pkeys,pcrc_32_tab,(int)*passwd);

  00040	44 0f be c0	 movsx	 r8d, al
  00044	48 8b d6	 mov	 rdx, rsi
  00047	48 8b cf	 mov	 rcx, rdi
  0004a	e8 00 00 00 00	 call	 update_keys
  0004f	0f b6 43 01	 movzx	 eax, BYTE PTR [rbx+1]

; 72   :         passwd++;

  00053	48 8d 5b 01	 lea	 rbx, QWORD PTR [rbx+1]
  00057	84 c0		 test	 al, al
  00059	75 e5		 jne	 SHORT $LL2@init_keys
$LN3@init_keys:

; 73   :     }
; 74   : }

  0005b	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00060	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00065	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00069	5f		 pop	 rdi
  0006a	c3		 ret	 0
init_keys ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\crypt.h
; File c:\program files (x86)\windows kits\10\include\10.0.10240.0\ucrt\time.h
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\crypt.h
;	COMDAT crypthead
_TEXT	SEGMENT
header$ = 32
passwd$ = 80
buf$ = 88
bufSize$dead$ = 96
pkeys$ = 104
pcrc_32_tab$ = 112
crcForCrypting$ = 120
crypthead PROC						; COMDAT

; 96   : {

  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 6c 24 10	 mov	 QWORD PTR [rsp+16], rbp
  0000a	48 89 74 24 18	 mov	 QWORD PTR [rsp+24], rsi
  0000f	48 89 7c 24 20	 mov	 QWORD PTR [rsp+32], rdi
  00014	41 55		 push	 r13
  00016	41 56		 push	 r14
  00018	41 57		 push	 r15
  0001a	48 83 ec 30	 sub	 rsp, 48			; 00000030H

; 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)

  0001e	8b 05 00 00 00
	00		 mov	 eax, DWORD PTR ?calls@?1??crypthead@@9@9
  00024	49 8b d9	 mov	 rbx, r9
  00027	ff c0		 inc	 eax
  00029	4c 8b ea	 mov	 r13, rdx
  0002c	89 05 00 00 00
	00		 mov	 DWORD PTR ?calls@?1??crypthead@@9@9, eax
  00032	4c 8b f9	 mov	 r15, rcx
  00035	83 f8 01	 cmp	 eax, 1
  00038	75 15		 jne	 SHORT $LN9@crypthead
; File c:\program files (x86)\windows kits\10\include\10.0.10240.0\ucrt\time.h

; 535  :             return _time64(_Time);

  0003a	33 c9		 xor	 ecx, ecx
  0003c	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__time64
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\crypt.h

; 112  :         srand((unsigned)(time(NULL) ^ ZCR_SEED2));

  00042	35 4e e6 40 bb	 xor	 eax, -1153374642	; bb40e64eH
  00047	8b c8		 mov	 ecx, eax
  00049	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_srand
$LN9@crypthead:

; 113  :     }
; 114  :     init_keys(passwd, pkeys, pcrc_32_tab);

  0004f	4c 8b 74 24 70	 mov	 r14, QWORD PTR pcrc_32_tab$[rsp]
  00054	48 8b d3	 mov	 rdx, rbx
  00057	4d 8b c6	 mov	 r8, r14
  0005a	49 8b cf	 mov	 rcx, r15
  0005d	e8 00 00 00 00	 call	 init_keys

; 115  :     for (n = 0; n < RAND_HEAD_LEN-2; n++)

  00062	33 ed		 xor	 ebp, ebp
  00064	8b f5		 mov	 esi, ebp
$LL4@crypthead:

; 116  :     {
; 117  :         c = (rand() >> 7) & 0xff;

  00066	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_rand
  0006c	c1 f8 07	 sar	 eax, 7

; 118  :         header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);

  0006f	48 8b cb	 mov	 rcx, rbx
  00072	44 0f b6 c0	 movzx	 r8d, al
  00076	e8 00 00 00 00	 call	 decrypt_byte
  0007b	49 8b d6	 mov	 rdx, r14
  0007e	8b f8		 mov	 edi, eax
  00080	e8 00 00 00 00	 call	 update_keys
  00085	44 32 c7	 xor	 r8b, dil
  00088	44 88 44 34 20	 mov	 BYTE PTR header$[rsp+rsi], r8b
  0008d	48 ff c6	 inc	 rsi
  00090	48 83 fe 0a	 cmp	 rsi, 10
  00094	7c d0		 jl	 SHORT $LL4@crypthead

; 119  :     }
; 120  :     /* Encrypt random header (last two bytes is high word of crc) */
; 121  :     init_keys(passwd, pkeys, pcrc_32_tab);

  00096	4d 8b c6	 mov	 r8, r14
  00099	48 8b d3	 mov	 rdx, rbx
  0009c	49 8b cf	 mov	 rcx, r15
  0009f	e8 00 00 00 00	 call	 init_keys

; 122  :     for (n = 0; n < RAND_HEAD_LEN-2; n++)

  000a4	48 8d 44 24 20	 lea	 rax, QWORD PTR header$[rsp]
  000a9	4d 8b fd	 mov	 r15, r13
  000ac	4c 2b f8	 sub	 r15, rax
  000af	90		 npad	 1
$LL7@crypthead:

; 123  :     {
; 124  :         buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);

  000b0	48 8b cb	 mov	 rcx, rbx
  000b3	e8 00 00 00 00	 call	 decrypt_byte
  000b8	48 8d 74 24 20	 lea	 rsi, QWORD PTR header$[rsp]
  000bd	49 8b d6	 mov	 rdx, r14
  000c0	48 03 f5	 add	 rsi, rbp
  000c3	8b f8		 mov	 edi, eax
  000c5	44 0f b6 06	 movzx	 r8d, BYTE PTR [rsi]
  000c9	e8 00 00 00 00	 call	 update_keys
  000ce	44 32 c7	 xor	 r8b, dil
  000d1	48 ff c5	 inc	 rbp
  000d4	45 88 04 37	 mov	 BYTE PTR [r15+rsi], r8b
  000d8	48 83 fd 0a	 cmp	 rbp, 10
  000dc	7c d2		 jl	 SHORT $LL7@crypthead

; 125  :     }
; 126  :     buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);

  000de	48 8b cb	 mov	 rcx, rbx
  000e1	e8 00 00 00 00	 call	 decrypt_byte
  000e6	8b 6c 24 78	 mov	 ebp, DWORD PTR crcForCrypting$[rsp]
  000ea	49 8b d6	 mov	 rdx, r14
  000ed	8b fd		 mov	 edi, ebp
  000ef	8b f0		 mov	 esi, eax
  000f1	c1 ef 10	 shr	 edi, 16
  000f4	44 0f b6 c7	 movzx	 r8d, dil
  000f8	e8 00 00 00 00	 call	 update_keys
  000fd	40 32 fe	 xor	 dil, sil

; 127  :     buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);

  00100	48 8b cb	 mov	 rcx, rbx
  00103	41 88 7d 0a	 mov	 BYTE PTR [r13+10], dil
  00107	e8 00 00 00 00	 call	 decrypt_byte
  0010c	c1 ed 18	 shr	 ebp, 24
  0010f	49 8b d6	 mov	 rdx, r14
  00112	44 8b c5	 mov	 r8d, ebp
  00115	8b f8		 mov	 edi, eax
  00117	e8 00 00 00 00	 call	 update_keys

; 128  :     return n;
; 129  : }

  0011c	48 8b 5c 24 50	 mov	 rbx, QWORD PTR [rsp+80]
  00121	40 32 ef	 xor	 bpl, dil
  00124	48 8b 74 24 60	 mov	 rsi, QWORD PTR [rsp+96]
  00129	b8 0c 00 00 00	 mov	 eax, 12
  0012e	48 8b 7c 24 68	 mov	 rdi, QWORD PTR [rsp+104]
  00133	41 88 6d 0b	 mov	 BYTE PTR [r13+11], bpl
  00137	48 8b 6c 24 58	 mov	 rbp, QWORD PTR [rsp+88]
  0013c	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00140	41 5f		 pop	 r15
  00142	41 5e		 pop	 r14
  00144	41 5d		 pop	 r13
  00146	c3		 ret	 0
crypthead ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT allocate_new_datablock
_TEXT	SEGMENT
allocate_new_datablock PROC				; COMDAT

; 190  : {

  00000	48 83 ec 28	 sub	 rsp, 40			; 00000028H

; 191  :     linkedlist_datablock_internal* ldi;
; 192  :     ldi = (linkedlist_datablock_internal*)

  00004	b9 08 10 00 00	 mov	 ecx, 4104		; 00001008H
  00009	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc

; 193  :                  ALLOC(sizeof(linkedlist_datablock_internal));
; 194  :     if (ldi!=NULL)

  0000f	48 85 c0	 test	 rax, rax
  00012	74 0d		 je	 SHORT $LN4@allocate_n

; 195  :     {
; 196  :         ldi->next_datablock = NULL ;

  00014	33 c9		 xor	 ecx, ecx

; 197  :         ldi->filled_in_this_block = 0 ;
; 198  :         ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;

  00016	48 c7 40 08 f0
	0f 00 00	 mov	 QWORD PTR [rax+8], 4080	; 00000ff0H
  0001e	48 89 08	 mov	 QWORD PTR [rax], rcx
$LN4@allocate_n:

; 199  :     }
; 200  :     return ldi;
; 201  : }

  00021	48 83 c4 28	 add	 rsp, 40			; 00000028H
  00025	c3		 ret	 0
allocate_new_datablock ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT free_datablock
_TEXT	SEGMENT
ldi$ = 48
free_datablock PROC					; COMDAT

; 204  : {

  00000	48 83 ec 28	 sub	 rsp, 40			; 00000028H

; 205  :     while (ldi!=NULL)

  00004	48 85 c9	 test	 rcx, rcx
  00007	74 1d		 je	 SHORT $LN3@free_datab
  00009	48 89 5c 24 20	 mov	 QWORD PTR [rsp+32], rbx
  0000e	66 90		 npad	 2
$LL2@free_datab:

; 206  :     {
; 207  :         linkedlist_datablock_internal* ldinext = ldi->next_datablock;

  00010	48 8b 19	 mov	 rbx, QWORD PTR [rcx]

; 208  :         TRYFREE(ldi);

  00013	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free

; 209  :         ldi = ldinext;

  00019	48 8b cb	 mov	 rcx, rbx
  0001c	48 85 db	 test	 rbx, rbx
  0001f	75 ef		 jne	 SHORT $LL2@free_datab
  00021	48 8b 5c 24 20	 mov	 rbx, QWORD PTR [rsp+32]
$LN3@free_datab:

; 210  :     }
; 211  : }

  00026	48 83 c4 28	 add	 rsp, 40			; 00000028H
  0002a	c3		 ret	 0
free_datablock ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT init_linkedlist
_TEXT	SEGMENT
ll$ = 8
init_linkedlist PROC					; COMDAT

; 215  :     ll->first_block = ll->last_block = NULL;

  00000	33 c0		 xor	 eax, eax
  00002	48 89 41 08	 mov	 QWORD PTR [rcx+8], rax
  00006	48 89 01	 mov	 QWORD PTR [rcx], rax

; 216  : }

  00009	c3		 ret	 0
init_linkedlist ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT free_linkedlist
_TEXT	SEGMENT
ll$ = 48
free_linkedlist PROC					; COMDAT

; 219  : {

  00000	40 53		 push	 rbx
  00002	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  00006	48 8b d9	 mov	 rbx, rcx

; 220  :     free_datablock(ll->first_block);

  00009	48 8b 09	 mov	 rcx, QWORD PTR [rcx]
  0000c	e8 00 00 00 00	 call	 free_datablock

; 221  :     ll->first_block = ll->last_block = NULL;

  00011	33 c0		 xor	 eax, eax
  00013	48 89 43 08	 mov	 QWORD PTR [rbx+8], rax
  00017	48 89 03	 mov	 QWORD PTR [rbx], rax

; 222  : }

  0001a	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0001e	5b		 pop	 rbx
  0001f	c3		 ret	 0
free_linkedlist ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT add_data_in_datablock
_TEXT	SEGMENT
ll$ = 48
buf$ = 56
len$ = 64
add_data_in_datablock PROC				; COMDAT

; 226  : {

  00000	48 89 6c 24 10	 mov	 QWORD PTR [rsp+16], rbp
  00005	48 89 74 24 18	 mov	 QWORD PTR [rsp+24], rsi
  0000a	57		 push	 rdi
  0000b	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000f	41 8b f8	 mov	 edi, r8d
  00012	48 8b ea	 mov	 rbp, rdx
  00015	48 8b f1	 mov	 rsi, rcx

; 227  :     linkedlist_datablock_internal* ldi;
; 228  :     const unsigned char* from_copy;
; 229  : 
; 230  :     if (ll==NULL)

  00018	48 85 c9	 test	 rcx, rcx
  0001b	75 15		 jne	 SHORT $LN7@add_data_i
$LN26@add_data_i:

; 231  :         return ZIP_INTERNALERROR;

  0001d	b8 98 ff ff ff	 mov	 eax, -104		; ffffffffffffff98H

; 274  : }

  00022	48 8b 6c 24 38	 mov	 rbp, QWORD PTR [rsp+56]
  00027	48 8b 74 24 40	 mov	 rsi, QWORD PTR [rsp+64]
  0002c	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00030	5f		 pop	 rdi
  00031	c3		 ret	 0
$LN7@add_data_i:

; 232  : 
; 233  :     if (ll->last_block == NULL)

  00032	48 83 79 08 00	 cmp	 QWORD PTR [rcx+8], 0
  00037	75 11		 jne	 SHORT $LN9@add_data_i

; 234  :     {
; 235  :         ll->first_block = ll->last_block = allocate_new_datablock();

  00039	e8 00 00 00 00	 call	 allocate_new_datablock
  0003e	48 89 46 08	 mov	 QWORD PTR [rsi+8], rax
  00042	48 89 06	 mov	 QWORD PTR [rsi], rax

; 236  :         if (ll->first_block == NULL)

  00045	48 85 c0	 test	 rax, rax
  00048	74 d3		 je	 SHORT $LN26@add_data_i
$LN9@add_data_i:
  0004a	48 89 5c 24 30	 mov	 QWORD PTR [rsp+48], rbx

; 237  :             return ZIP_INTERNALERROR;
; 238  :     }
; 239  : 
; 240  :     ldi = ll->last_block;

  0004f	48 8b 5e 08	 mov	 rbx, QWORD PTR [rsi+8]

; 241  :     from_copy = (unsigned char*)buf;
; 242  : 
; 243  :     while (len>0)

  00053	85 ff		 test	 edi, edi
  00055	74 60		 je	 SHORT $LN24@add_data_i
$LL2@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)

  00057	83 7b 08 00	 cmp	 DWORD PTR [rbx+8], 0
  0005b	75 14		 jne	 SHORT $LN10@add_data_i

; 250  :         {
; 251  :             ldi->next_datablock = allocate_new_datablock();

  0005d	e8 00 00 00 00	 call	 allocate_new_datablock
  00062	48 89 03	 mov	 QWORD PTR [rbx], rax

; 252  :             if (ldi->next_datablock == NULL)

  00065	48 85 c0	 test	 rax, rax
  00068	74 64		 je	 SHORT $LN17@add_data_i

; 254  :             ldi = ldi->next_datablock ;

  0006a	48 8b d8	 mov	 rbx, rax

; 255  :             ll->last_block = ldi;

  0006d	48 89 46 08	 mov	 QWORD PTR [rsi+8], rax
$LN10@add_data_i:

; 256  :         }
; 257  : 
; 258  :         if (ldi->avail_in_this_block < len)

  00071	39 7b 08	 cmp	 DWORD PTR [rbx+8], edi
  00074	44 8b c7	 mov	 r8d, edi

; 259  :             copy_this = (uInt)ldi->avail_in_this_block;
; 260  :         else
; 261  :             copy_this = (uInt)len;
; 262  : 
; 263  :         to_copy = &(ldi->data[ldi->filled_in_this_block]);

  00077	8b 43 0c	 mov	 eax, DWORD PTR [rbx+12]
  0007a	44 0f 42 43 08	 cmovb	 r8d, DWORD PTR [rbx+8]

; 264  : 
; 265  :         for (i=0;i<copy_this;i++)

  0007f	45 85 c0	 test	 r8d, r8d
  00082	74 20		 je	 SHORT $LN5@add_data_i
  00084	48 8d 4b 14	 lea	 rcx, QWORD PTR [rbx+20]
  00088	45 8b c8	 mov	 r9d, r8d
  0008b	48 03 c8	 add	 rcx, rax
  0008e	48 8b d5	 mov	 rdx, rbp
$LL6@add_data_i:

; 266  :             *(to_copy+i)=*(from_copy+i);

  00091	0f b6 02	 movzx	 eax, BYTE PTR [rdx]
  00094	48 8d 52 01	 lea	 rdx, QWORD PTR [rdx+1]
  00098	88 01		 mov	 BYTE PTR [rcx], al
  0009a	48 8d 49 01	 lea	 rcx, QWORD PTR [rcx+1]
  0009e	49 83 e9 01	 sub	 r9, 1
  000a2	75 ed		 jne	 SHORT $LL6@add_data_i
$LN5@add_data_i:

; 267  : 
; 268  :         ldi->filled_in_this_block += copy_this;

  000a4	44 01 43 0c	 add	 DWORD PTR [rbx+12], r8d

; 269  :         ldi->avail_in_this_block -= copy_this;

  000a8	44 29 43 08	 sub	 DWORD PTR [rbx+8], r8d

; 270  :         from_copy += copy_this ;

  000ac	41 8b c0	 mov	 eax, r8d
  000af	48 03 e8	 add	 rbp, rax

; 271  :         len -= copy_this;

  000b2	41 2b f8	 sub	 edi, r8d
  000b5	75 a0		 jne	 SHORT $LL2@add_data_i
$LN24@add_data_i:

; 272  :     }
; 273  :     return ZIP_OK;

  000b7	33 c0		 xor	 eax, eax
$LN25@add_data_i:
  000b9	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]

; 274  : }

  000be	48 8b 6c 24 38	 mov	 rbp, QWORD PTR [rsp+56]
  000c3	48 8b 74 24 40	 mov	 rsi, QWORD PTR [rsp+64]
  000c8	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000cc	5f		 pop	 rdi
  000cd	c3		 ret	 0
$LN17@add_data_i:

; 253  :                 return ZIP_INTERNALERROR;

  000ce	b8 98 ff ff ff	 mov	 eax, -104		; ffffffffffffff98H
  000d3	eb e4		 jmp	 SHORT $LN25@add_data_i
add_data_in_datablock ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_putValue
_TEXT	SEGMENT
buf$ = 48
pzlib_filefunc_def$ = 48
filestream$ = 56
x$ = 64
nbByte$ = 72
zip64local_putValue PROC				; COMDAT

; 288  : {

  00000	40 53		 push	 rbx
  00002	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 289  :     unsigned char buf[8];
; 290  :     int n;
; 291  :     for (n = 0; n < nbByte; n++)

  00006	33 c0		 xor	 eax, eax
  00008	49 63 d9	 movsxd	 rbx, r9d
  0000b	4c 8b d1	 mov	 r10, rcx
  0000e	48 8b cb	 mov	 rcx, rbx
  00011	45 85 c9	 test	 r9d, r9d
  00014	7e 1b		 jle	 SHORT $LN3@zip64local
  00016	66 66 0f 1f 84
	00 00 00 00 00	 npad	 10
$LL16@zip64local:

; 292  :     {
; 293  :         buf[n] = (unsigned char)(x & 0xff);

  00020	44 88 44 04 30	 mov	 BYTE PTR buf$[rsp+rax], r8b
  00025	48 ff c0	 inc	 rax

; 294  :         x >>= 8;

  00028	49 c1 e8 08	 shr	 r8, 8
  0002c	48 3b c1	 cmp	 rax, rcx
  0002f	7c ef		 jl	 SHORT $LL16@zip64local
$LN3@zip64local:

; 295  :     }
; 296  :     if (x != 0)

  00031	4d 85 c0	 test	 r8, r8
  00034	74 1b		 je	 SHORT $LN6@zip64local

; 297  :       {     /* data overflow - hack for ZIP64 (X Roche) */
; 298  :       for (n = 0; n < nbByte; n++)

  00036	45 85 c9	 test	 r9d, r9d
  00039	7e 16		 jle	 SHORT $LN6@zip64local

; 299  :         {
; 300  :           buf[n] = 0xff;

  0003b	48 89 7c 24 38	 mov	 QWORD PTR [rsp+56], rdi
  00040	b8 ff 00 00 00	 mov	 eax, 255		; 000000ffH
  00045	48 8d 7c 24 30	 lea	 rdi, QWORD PTR buf$[rsp]
  0004a	f3 aa		 rep stosb
  0004c	48 8b 7c 24 38	 mov	 rdi, QWORD PTR [rsp+56]
$LN6@zip64local:

; 301  :         }
; 302  :       }
; 303  : 
; 304  :     if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)

  00051	49 8b 4a 38	 mov	 rcx, QWORD PTR [r10+56]
  00055	4c 8d 44 24 30	 lea	 r8, QWORD PTR buf$[rsp]
  0005a	44 8b cb	 mov	 r9d, ebx
  0005d	41 ff 52 10	 call	 QWORD PTR [r10+16]
  00061	2b c3		 sub	 eax, ebx
  00063	f7 d8		 neg	 eax
  00065	1b c0		 sbb	 eax, eax

; 305  :         return ZIP_ERRNO;
; 306  :     else
; 307  :         return ZIP_OK;
; 308  : }

  00067	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0006b	5b		 pop	 rbx
  0006c	c3		 ret	 0
zip64local_putValue ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_putValue_inmemory
_TEXT	SEGMENT
dest$ = 8
x$ = 16
nbByte$ = 24
zip64local_putValue_inmemory PROC			; COMDAT

; 312  : {

  00000	48 89 7c 24 08	 mov	 QWORD PTR [rsp+8], rdi

; 313  :     unsigned char* buf=(unsigned char*)dest;
; 314  :     int n;
; 315  :     for (n = 0; n < nbByte; n++) {

  00005	33 c0		 xor	 eax, eax
  00007	48 8b f9	 mov	 rdi, rcx
  0000a	49 63 c8	 movsxd	 rcx, r8d
  0000d	45 85 c0	 test	 r8d, r8d
  00010	7e 1d		 jle	 SHORT $LN3@zip64local
  00012	0f 1f 40 00 66
	66 0f 1f 84 00
	00 00 00 00	 npad	 14
$LL14@zip64local:

; 316  :         buf[n] = (unsigned char)(x & 0xff);

  00020	88 14 38	 mov	 BYTE PTR [rax+rdi], dl
  00023	48 ff c0	 inc	 rax

; 317  :         x >>= 8;

  00026	48 c1 ea 08	 shr	 rdx, 8
  0002a	48 3b c1	 cmp	 rax, rcx
  0002d	7c f1		 jl	 SHORT $LL14@zip64local
$LN3@zip64local:

; 318  :     }
; 319  : 
; 320  :     if (x != 0)

  0002f	48 85 d2	 test	 rdx, rdx
  00032	74 0c		 je	 SHORT $LN6@zip64local

; 321  :     {     /* data overflow - hack for ZIP64 */
; 322  :        for (n = 0; n < nbByte; n++)

  00034	45 85 c0	 test	 r8d, r8d
  00037	7e 07		 jle	 SHORT $LN6@zip64local

; 323  :        {
; 324  :           buf[n] = 0xff;

  00039	b8 ff 00 00 00	 mov	 eax, 255		; 000000ffH
  0003e	f3 aa		 rep stosb
$LN6@zip64local:

; 325  :        }
; 326  :     }
; 327  : }

  00040	48 8b 7c 24 08	 mov	 rdi, QWORD PTR [rsp+8]
  00045	c3		 ret	 0
zip64local_putValue_inmemory ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_TmzDateToDosDate
_TEXT	SEGMENT
ptm$ = 8
zip64local_TmzDateToDosDate PROC			; COMDAT

; 334  :     uLong year = (uLong)ptm->tm_year;

  00000	8b 51 14	 mov	 edx, DWORD PTR [rcx+20]
  00003	4c 8b c1	 mov	 r8, rcx

; 335  :     if (year>=1980)

  00006	81 fa bc 07 00
	00		 cmp	 edx, 1980		; 000007bcH
  0000c	72 08		 jb	 SHORT $LN2@zip64local

; 336  :         year-=1980;

  0000e	81 c2 44 f8 ff
	ff		 add	 edx, -1980		; fffff844H
  00014	eb 08		 jmp	 SHORT $LN4@zip64local
$LN2@zip64local:

; 337  :     else if (year>=80)

  00016	83 fa 50	 cmp	 edx, 80			; 00000050H
  00019	72 03		 jb	 SHORT $LN4@zip64local

; 338  :         year-=80;

  0001b	83 c2 b0	 add	 edx, -80		; ffffffb0H
$LN4@zip64local:

; 339  :     return

  0001e	8b 41 08	 mov	 eax, DWORD PTR [rcx+8]
  00021	c1 e0 06	 shl	 eax, 6
  00024	03 41 04	 add	 eax, DWORD PTR [rcx+4]
  00027	8b 09		 mov	 ecx, DWORD PTR [rcx]
  00029	c1 e2 04	 shl	 edx, 4
  0002c	d1 e9		 shr	 ecx, 1
  0002e	c1 e0 05	 shl	 eax, 5
  00031	03 c1		 add	 eax, ecx
  00033	41 8b 48 10	 mov	 ecx, DWORD PTR [r8+16]
  00037	ff c1		 inc	 ecx
  00039	03 d1		 add	 edx, ecx
  0003b	c1 e2 05	 shl	 edx, 5
  0003e	41 03 50 0c	 add	 edx, DWORD PTR [r8+12]
  00042	c1 e2 10	 shl	 edx, 16
  00045	0b c2		 or	 eax, edx

; 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));
; 342  : }

  00047	c3		 ret	 0
zip64local_TmzDateToDosDate ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_getByte
_TEXT	SEGMENT
c$ = 48
pzlib_filefunc_def$ = 48
filestream$ = 56
pi$ = 64
zip64local_getByte PROC					; COMDAT

; 350  : {

  00000	48 89 5c 24 10	 mov	 QWORD PTR [rsp+16], rbx
  00005	48 89 74 24 18	 mov	 QWORD PTR [rsp+24], rsi
  0000a	57		 push	 rdi
  0000b	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000f	48 8b d9	 mov	 rbx, rcx
  00012	49 8b f8	 mov	 rdi, r8

; 351  :     unsigned char c;
; 352  :     int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);

  00015	48 8b 49 38	 mov	 rcx, QWORD PTR [rcx+56]
  00019	4c 8d 44 24 30	 lea	 r8, QWORD PTR c$[rsp]
  0001e	41 b9 01 00 00
	00		 mov	 r9d, 1
  00024	48 8b f2	 mov	 rsi, rdx
  00027	ff 53 08	 call	 QWORD PTR [rbx+8]

; 353  :     if (err==1)

  0002a	83 f8 01	 cmp	 eax, 1
  0002d	75 19		 jne	 SHORT $LN2@zip64local

; 354  :     {
; 355  :         *pi = (int)c;

  0002f	0f b6 44 24 30	 movzx	 eax, BYTE PTR c$[rsp]
  00034	89 07		 mov	 DWORD PTR [rdi], eax

; 356  :         return ZIP_OK;

  00036	33 c0		 xor	 eax, eax

; 361  :             return ZIP_ERRNO;
; 362  :         else
; 363  :             return ZIP_EOF;
; 364  :     }
; 365  : }

  00038	48 8b 5c 24 38	 mov	 rbx, QWORD PTR [rsp+56]
  0003d	48 8b 74 24 40	 mov	 rsi, QWORD PTR [rsp+64]
  00042	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00046	5f		 pop	 rdi
  00047	c3		 ret	 0
$LN2@zip64local:

; 357  :     }
; 358  :     else
; 359  :     {
; 360  :         if (ZERROR64(*pzlib_filefunc_def,filestream))

  00048	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  0004c	48 8b d6	 mov	 rdx, rsi
  0004f	ff 53 30	 call	 QWORD PTR [rbx+48]

; 361  :             return ZIP_ERRNO;
; 362  :         else
; 363  :             return ZIP_EOF;
; 364  :     }
; 365  : }

  00052	48 8b 5c 24 38	 mov	 rbx, QWORD PTR [rsp+56]
  00057	f7 d8		 neg	 eax
  00059	48 8b 74 24 40	 mov	 rsi, QWORD PTR [rsp+64]
  0005e	1b c0		 sbb	 eax, eax
  00060	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00064	5f		 pop	 rdi
  00065	c3		 ret	 0
zip64local_getByte ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_getShort
_TEXT	SEGMENT
pzlib_filefunc_def$ = 48
filestream$ = 56
pX$ = 64
i$ = 72
zip64local_getShort PROC				; COMDAT

; 374  : {

  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 6c 24 10	 mov	 QWORD PTR [rsp+16], rbp
  0000a	48 89 74 24 18	 mov	 QWORD PTR [rsp+24], rsi
  0000f	57		 push	 rdi
  00010	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  00014	49 8b d8	 mov	 rbx, r8

; 375  :     uLong x ;
; 376  :     int i = 0;

  00017	c7 44 24 48 00
	00 00 00	 mov	 DWORD PTR i$[rsp], 0

; 377  :     int err;
; 378  : 
; 379  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  0001f	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00024	48 8b fa	 mov	 rdi, rdx
  00027	48 8b f1	 mov	 rsi, rcx
  0002a	e8 00 00 00 00	 call	 zip64local_getByte

; 380  :     x = (uLong)i;

  0002f	8b 6c 24 48	 mov	 ebp, DWORD PTR i$[rsp]
  00033	44 8b c8	 mov	 r9d, eax

; 381  : 
; 382  :     if (err==ZIP_OK)

  00036	85 c0		 test	 eax, eax
  00038	75 24		 jne	 SHORT $LN3@zip64local

; 383  :         err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  0003a	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  0003f	48 8b d7	 mov	 rdx, rdi
  00042	48 8b ce	 mov	 rcx, rsi
  00045	e8 00 00 00 00	 call	 zip64local_getByte
  0004a	44 8b c8	 mov	 r9d, eax

; 385  : 
; 386  :     if (err==ZIP_OK)

  0004d	85 c0		 test	 eax, eax
  0004f	75 0d		 jne	 SHORT $LN3@zip64local

; 384  :     x += ((uLong)i)<<8;

  00051	8b 44 24 48	 mov	 eax, DWORD PTR i$[rsp]
  00055	c1 e0 08	 shl	 eax, 8
  00058	03 c5		 add	 eax, ebp

; 387  :         *pX = x;

  0005a	89 03		 mov	 DWORD PTR [rbx], eax
  0005c	eb 06		 jmp	 SHORT $LN6@zip64local
$LN3@zip64local:

; 388  :     else
; 389  :         *pX = 0;

  0005e	c7 03 00 00 00
	00		 mov	 DWORD PTR [rbx], 0
$LN6@zip64local:

; 390  :     return err;
; 391  : }

  00064	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00069	41 8b c1	 mov	 eax, r9d
  0006c	48 8b 6c 24 38	 mov	 rbp, QWORD PTR [rsp+56]
  00071	48 8b 74 24 40	 mov	 rsi, QWORD PTR [rsp+64]
  00076	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0007a	5f		 pop	 rdi
  0007b	c3		 ret	 0
zip64local_getShort ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_getLong
_TEXT	SEGMENT
pzlib_filefunc_def$ = 48
filestream$ = 56
pX$ = 64
i$ = 72
zip64local_getLong PROC					; COMDAT

; 396  : {

  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	48 89 7c 24 18	 mov	 QWORD PTR [rsp+24], rdi
  0000f	41 56		 push	 r14
  00011	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  00015	4d 8b f0	 mov	 r14, r8

; 397  :     uLong x ;
; 398  :     int i = 0;

  00018	c7 44 24 48 00
	00 00 00	 mov	 DWORD PTR i$[rsp], 0

; 399  :     int err;
; 400  : 
; 401  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  00020	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00025	48 8b fa	 mov	 rdi, rdx
  00028	48 8b f1	 mov	 rsi, rcx
  0002b	e8 00 00 00 00	 call	 zip64local_getByte

; 402  :     x = (uLong)i;

  00030	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00035	41 8b da	 mov	 ebx, r10d
  00038	44 8b c8	 mov	 r9d, eax

; 403  : 
; 404  :     if (err==ZIP_OK)

  0003b	85 c0		 test	 eax, eax
  0003d	75 18		 jne	 SHORT $LN2@zip64local

; 405  :         err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  0003f	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00044	48 8b d7	 mov	 rdx, rdi
  00047	48 8b ce	 mov	 rcx, rsi
  0004a	e8 00 00 00 00	 call	 zip64local_getByte
  0004f	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00054	44 8b c8	 mov	 r9d, eax
$LN2@zip64local:

; 406  :     x += ((uLong)i)<<8;

  00057	41 8b c2	 mov	 eax, r10d
  0005a	c1 e0 08	 shl	 eax, 8
  0005d	03 d8		 add	 ebx, eax

; 407  : 
; 408  :     if (err==ZIP_OK)

  0005f	45 85 c9	 test	 r9d, r9d
  00062	75 18		 jne	 SHORT $LN3@zip64local

; 409  :         err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  00064	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00069	48 8b d7	 mov	 rdx, rdi
  0006c	48 8b ce	 mov	 rcx, rsi
  0006f	e8 00 00 00 00	 call	 zip64local_getByte
  00074	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00079	44 8b c8	 mov	 r9d, eax
$LN3@zip64local:

; 410  :     x += ((uLong)i)<<16;

  0007c	41 c1 e2 10	 shl	 r10d, 16
  00080	41 03 da	 add	 ebx, r10d

; 411  : 
; 412  :     if (err==ZIP_OK)

  00083	45 85 c9	 test	 r9d, r9d
  00086	75 25		 jne	 SHORT $LN5@zip64local

; 413  :         err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  00088	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  0008d	48 8b d7	 mov	 rdx, rdi
  00090	48 8b ce	 mov	 rcx, rsi
  00093	e8 00 00 00 00	 call	 zip64local_getByte
  00098	44 8b c8	 mov	 r9d, eax

; 415  : 
; 416  :     if (err==ZIP_OK)

  0009b	85 c0		 test	 eax, eax
  0009d	75 0e		 jne	 SHORT $LN5@zip64local

; 414  :     x += ((uLong)i)<<24;

  0009f	8b 44 24 48	 mov	 eax, DWORD PTR i$[rsp]
  000a3	c1 e0 18	 shl	 eax, 24
  000a6	03 c3		 add	 eax, ebx

; 417  :         *pX = x;

  000a8	41 89 06	 mov	 DWORD PTR [r14], eax
  000ab	eb 07		 jmp	 SHORT $LN8@zip64local
$LN5@zip64local:

; 418  :     else
; 419  :         *pX = 0;

  000ad	41 c7 06 00 00
	00 00		 mov	 DWORD PTR [r14], 0
$LN8@zip64local:

; 420  :     return err;
; 421  : }

  000b4	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  000b9	41 8b c1	 mov	 eax, r9d
  000bc	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  000c1	48 8b 7c 24 40	 mov	 rdi, QWORD PTR [rsp+64]
  000c6	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000ca	41 5e		 pop	 r14
  000cc	c3		 ret	 0
zip64local_getLong ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_getLong64
_TEXT	SEGMENT
pzlib_filefunc_def$ = 48
filestream$ = 56
pX$ = 64
i$ = 72
zip64local_getLong64 PROC				; COMDAT

; 427  : {

  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	48 89 7c 24 18	 mov	 QWORD PTR [rsp+24], rdi
  0000f	41 56		 push	 r14
  00011	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  00015	4d 8b f0	 mov	 r14, r8

; 428  :   ZPOS64_T x;
; 429  :   int i = 0;

  00018	c7 44 24 48 00
	00 00 00	 mov	 DWORD PTR i$[rsp], 0

; 430  :   int err;
; 431  : 
; 432  :   err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  00020	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00025	48 8b fa	 mov	 rdi, rdx
  00028	48 8b f1	 mov	 rsi, rcx
  0002b	e8 00 00 00 00	 call	 zip64local_getByte

; 433  :   x = (ZPOS64_T)i;

  00030	4c 63 54 24 48	 movsxd	 r10, DWORD PTR i$[rsp]
  00035	44 8b c8	 mov	 r9d, eax
  00038	49 8b da	 mov	 rbx, r10

; 434  : 
; 435  :   if (err==ZIP_OK)

  0003b	85 c0		 test	 eax, eax
  0003d	75 18		 jne	 SHORT $LN2@zip64local

; 436  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  0003f	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00044	48 8b d7	 mov	 rdx, rdi
  00047	48 8b ce	 mov	 rcx, rsi
  0004a	e8 00 00 00 00	 call	 zip64local_getByte
  0004f	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00054	44 8b c8	 mov	 r9d, eax
$LN2@zip64local:

; 437  :   x += ((ZPOS64_T)i)<<8;

  00057	49 63 c2	 movsxd	 rax, r10d
  0005a	48 c1 e0 08	 shl	 rax, 8
  0005e	48 03 d8	 add	 rbx, rax

; 438  : 
; 439  :   if (err==ZIP_OK)

  00061	45 85 c9	 test	 r9d, r9d
  00064	75 18		 jne	 SHORT $LN3@zip64local

; 440  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  00066	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  0006b	48 8b d7	 mov	 rdx, rdi
  0006e	48 8b ce	 mov	 rcx, rsi
  00071	e8 00 00 00 00	 call	 zip64local_getByte
  00076	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  0007b	44 8b c8	 mov	 r9d, eax
$LN3@zip64local:

; 441  :   x += ((ZPOS64_T)i)<<16;

  0007e	49 63 c2	 movsxd	 rax, r10d
  00081	48 c1 e0 10	 shl	 rax, 16
  00085	48 03 d8	 add	 rbx, rax

; 442  : 
; 443  :   if (err==ZIP_OK)

  00088	45 85 c9	 test	 r9d, r9d
  0008b	75 18		 jne	 SHORT $LN4@zip64local

; 444  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  0008d	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00092	48 8b d7	 mov	 rdx, rdi
  00095	48 8b ce	 mov	 rcx, rsi
  00098	e8 00 00 00 00	 call	 zip64local_getByte
  0009d	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  000a2	44 8b c8	 mov	 r9d, eax
$LN4@zip64local:

; 445  :   x += ((ZPOS64_T)i)<<24;

  000a5	49 63 c2	 movsxd	 rax, r10d
  000a8	48 c1 e0 18	 shl	 rax, 24
  000ac	48 03 d8	 add	 rbx, rax

; 446  : 
; 447  :   if (err==ZIP_OK)

  000af	45 85 c9	 test	 r9d, r9d
  000b2	75 18		 jne	 SHORT $LN5@zip64local

; 448  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  000b4	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  000b9	48 8b d7	 mov	 rdx, rdi
  000bc	48 8b ce	 mov	 rcx, rsi
  000bf	e8 00 00 00 00	 call	 zip64local_getByte
  000c4	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  000c9	44 8b c8	 mov	 r9d, eax
$LN5@zip64local:

; 449  :   x += ((ZPOS64_T)i)<<32;

  000cc	49 63 c2	 movsxd	 rax, r10d
  000cf	48 c1 e0 20	 shl	 rax, 32			; 00000020H
  000d3	48 03 d8	 add	 rbx, rax

; 450  : 
; 451  :   if (err==ZIP_OK)

  000d6	45 85 c9	 test	 r9d, r9d
  000d9	75 18		 jne	 SHORT $LN6@zip64local

; 452  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  000db	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  000e0	48 8b d7	 mov	 rdx, rdi
  000e3	48 8b ce	 mov	 rcx, rsi
  000e6	e8 00 00 00 00	 call	 zip64local_getByte
  000eb	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  000f0	44 8b c8	 mov	 r9d, eax
$LN6@zip64local:

; 453  :   x += ((ZPOS64_T)i)<<40;

  000f3	49 63 c2	 movsxd	 rax, r10d
  000f6	48 c1 e0 28	 shl	 rax, 40			; 00000028H
  000fa	48 03 d8	 add	 rbx, rax

; 454  : 
; 455  :   if (err==ZIP_OK)

  000fd	45 85 c9	 test	 r9d, r9d
  00100	75 18		 jne	 SHORT $LN7@zip64local

; 456  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  00102	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  00107	48 8b d7	 mov	 rdx, rdi
  0010a	48 8b ce	 mov	 rcx, rsi
  0010d	e8 00 00 00 00	 call	 zip64local_getByte
  00112	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00117	44 8b c8	 mov	 r9d, eax
$LN7@zip64local:

; 457  :   x += ((ZPOS64_T)i)<<48;

  0011a	49 63 c2	 movsxd	 rax, r10d
  0011d	48 c1 e0 30	 shl	 rax, 48			; 00000030H
  00121	48 03 d8	 add	 rbx, rax

; 458  : 
; 459  :   if (err==ZIP_OK)

  00124	45 85 c9	 test	 r9d, r9d
  00127	75 28		 jne	 SHORT $LN9@zip64local

; 460  :     err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);

  00129	4c 8d 44 24 48	 lea	 r8, QWORD PTR i$[rsp]
  0012e	48 8b d7	 mov	 rdx, rdi
  00131	48 8b ce	 mov	 rcx, rsi
  00134	e8 00 00 00 00	 call	 zip64local_getByte
  00139	44 8b c8	 mov	 r9d, eax

; 462  : 
; 463  :   if (err==ZIP_OK)

  0013c	85 c0		 test	 eax, eax
  0013e	75 11		 jne	 SHORT $LN9@zip64local

; 461  :   x += ((ZPOS64_T)i)<<56;

  00140	48 63 44 24 48	 movsxd	 rax, DWORD PTR i$[rsp]
  00145	48 c1 e0 38	 shl	 rax, 56			; 00000038H
  00149	48 03 c3	 add	 rax, rbx

; 464  :     *pX = x;

  0014c	49 89 06	 mov	 QWORD PTR [r14], rax
  0014f	eb 07		 jmp	 SHORT $LN12@zip64local
$LN9@zip64local:

; 465  :   else
; 466  :     *pX = 0;

  00151	49 c7 06 00 00
	00 00		 mov	 QWORD PTR [r14], 0
$LN12@zip64local:

; 467  : 
; 468  :   return err;
; 469  : }

  00158	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0015d	41 8b c1	 mov	 eax, r9d
  00160	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00165	48 8b 7c 24 40	 mov	 rdi, QWORD PTR [rsp+64]
  0016a	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0016e	41 5e		 pop	 r14
  00170	c3		 ret	 0
zip64local_getLong64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_SearchCentralDir
_TEXT	SEGMENT
pzlib_filefunc_def$ = 80
filestream$ = 88
zip64local_SearchCentralDir PROC			; COMDAT

; 481  : {

  00000	48 89 54 24 10	 mov	 QWORD PTR [rsp+16], rdx
  00005	53		 push	 rbx
  00006	41 54		 push	 r12
  00008	41 55		 push	 r13
  0000a	41 56		 push	 r14
  0000c	48 83 ec 28	 sub	 rsp, 40			; 00000028H

; 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;

  00010	45 33 e4	 xor	 r12d, r12d

; 487  : 
; 488  :   if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)

  00013	45 33 c0	 xor	 r8d, r8d
  00016	48 8b da	 mov	 rbx, rdx
  00019	4c 8b e9	 mov	 r13, rcx
  0001c	41 be ff ff 00
	00		 mov	 r14d, 65535		; 0000ffffH
  00022	45 8d 4c 24 02	 lea	 r9d, QWORD PTR [r12+2]
  00027	e8 00 00 00 00	 call	 call_zseek64
  0002c	85 c0		 test	 eax, eax
  0002e	74 0e		 je	 SHORT $LN7@zip64local

; 489  :     return 0;

  00030	33 c0		 xor	 eax, eax

; 534  : }

  00032	48 83 c4 28	 add	 rsp, 40			; 00000028H
  00036	41 5e		 pop	 r14
  00038	41 5d		 pop	 r13
  0003a	41 5c		 pop	 r12
  0003c	5b		 pop	 rbx
  0003d	c3		 ret	 0
$LN7@zip64local:

; 490  : 
; 491  : 
; 492  :   uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);

  0003e	48 8b d3	 mov	 rdx, rbx
  00041	4c 89 7c 24 20	 mov	 QWORD PTR [rsp+32], r15
  00046	49 8b cd	 mov	 rcx, r13
  00049	e8 00 00 00 00	 call	 call_ztell64

; 493  : 
; 494  :   if (uMaxBack>uSizeFile)

  0004e	49 3b c6	 cmp	 rax, r14

; 495  :     uMaxBack = uSizeFile;
; 496  : 
; 497  :   buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);

  00051	b9 04 04 00 00	 mov	 ecx, 1028		; 00000404H
  00056	4c 8b f8	 mov	 r15, rax
  00059	4c 0f 42 f0	 cmovb	 r14, rax
  0005d	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc
  00063	48 8b d8	 mov	 rbx, rax

; 498  :   if (buf==NULL)

  00066	48 85 c0	 test	 rax, rax
  00069	75 11		 jne	 SHORT $LN9@zip64local
  0006b	4c 8b 7c 24 20	 mov	 r15, QWORD PTR [rsp+32]

; 534  : }

  00070	48 83 c4 28	 add	 rsp, 40			; 00000028H
  00074	41 5e		 pop	 r14
  00076	41 5d		 pop	 r13
  00078	41 5c		 pop	 r12
  0007a	5b		 pop	 rbx
  0007b	c3		 ret	 0
$LN9@zip64local:
  0007c	48 89 6c 24 50	 mov	 QWORD PTR [rsp+80], rbp

; 499  :     return 0;
; 500  : 
; 501  :   uBackRead = 4;

  00081	bd 04 00 00 00	 mov	 ebp, 4

; 502  :   while (uBackRead<uMaxBack)

  00086	49 3b ee	 cmp	 rbp, r14
  00089	0f 83 c3 00 00
	00		 jae	 $LN33@zip64local
  0008f	48 89 74 24 60	 mov	 QWORD PTR [rsp+96], rsi
  00094	48 89 7c 24 68	 mov	 QWORD PTR [rsp+104], rdi
  00099	0f 1f 80 00 00
	00 00		 npad	 7
$LL2@zip64local:

; 503  :   {
; 504  :     uLong uReadSize;
; 505  :     ZPOS64_T uReadPos ;
; 506  :     int i;
; 507  :     if (uBackRead+BUFREADCOMMENT>uMaxBack)

  000a0	48 8d 85 00 04
	00 00		 lea	 rax, QWORD PTR [rbp+1024]

; 508  :       uBackRead = uMaxBack;
; 509  :     else
; 510  :       uBackRead+=BUFREADCOMMENT;
; 511  :     uReadPos = uSizeFile-uBackRead ;

  000a7	49 8b f7	 mov	 rsi, r15
  000aa	49 3b c6	 cmp	 rax, r14
  000ad	48 8b e8	 mov	 rbp, rax

; 512  : 
; 513  :     uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?

  000b0	49 8b c7	 mov	 rax, r15
  000b3	49 0f 47 ee	 cmova	 rbp, r14
  000b7	48 2b f5	 sub	 rsi, rbp
  000ba	48 2b c6	 sub	 rax, rsi
  000bd	48 3d 04 04 00
	00		 cmp	 rax, 1028		; 00000404H
  000c3	76 07		 jbe	 SHORT $LN18@zip64local
  000c5	bf 04 04 00 00	 mov	 edi, 1028		; 00000404H
  000ca	eb 05		 jmp	 SHORT $LN19@zip64local
$LN18@zip64local:
  000cc	41 8b ff	 mov	 edi, r15d
  000cf	2b fe		 sub	 edi, esi
$LN19@zip64local:

; 514  :       (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
; 515  :     if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)

  000d1	48 8b 54 24 58	 mov	 rdx, QWORD PTR filestream$[rsp]
  000d6	45 33 c9	 xor	 r9d, r9d
  000d9	4c 8b c6	 mov	 r8, rsi
  000dc	49 8b cd	 mov	 rcx, r13
  000df	e8 00 00 00 00	 call	 call_zseek64
  000e4	85 c0		 test	 eax, eax
  000e6	75 60		 jne	 SHORT $LN36@zip64local

; 516  :       break;
; 517  : 
; 518  :     if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)

  000e8	48 8b 54 24 58	 mov	 rdx, QWORD PTR filestream$[rsp]
  000ed	44 8b cf	 mov	 r9d, edi
  000f0	49 8b 4d 38	 mov	 rcx, QWORD PTR [r13+56]
  000f4	4c 8b c3	 mov	 r8, rbx
  000f7	41 ff 55 08	 call	 QWORD PTR [r13+8]
  000fb	3b c7		 cmp	 eax, edi
  000fd	75 49		 jne	 SHORT $LN36@zip64local

; 519  :       break;
; 520  : 
; 521  :     for (i=(int)uReadSize-3; (i--)>0;)

  000ff	8d 4f fd	 lea	 ecx, DWORD PTR [rdi-3]
  00102	48 63 c1	 movsxd	 rax, ecx
  00105	85 c9		 test	 ecx, ecx
  00107	7e 36		 jle	 SHORT $LN32@zip64local
  00109	0f 1f 80 00 00
	00 00		 npad	 7
$LL4@zip64local:
  00110	48 ff c8	 dec	 rax
  00113	ff c9		 dec	 ecx

; 522  :       if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
; 523  :         ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))

  00115	80 3c 18 50	 cmp	 BYTE PTR [rax+rbx], 80	; 00000050H
  00119	75 15		 jne	 SHORT $LN14@zip64local
  0011b	80 7c 18 01 4b	 cmp	 BYTE PTR [rax+rbx+1], 75 ; 0000004bH
  00120	75 0e		 jne	 SHORT $LN14@zip64local
  00122	80 7c 18 02 05	 cmp	 BYTE PTR [rax+rbx+2], 5
  00127	75 07		 jne	 SHORT $LN14@zip64local
  00129	80 7c 18 03 06	 cmp	 BYTE PTR [rax+rbx+3], 6
  0012e	74 07		 je	 SHORT $LN22@zip64local
$LN14@zip64local:

; 519  :       break;
; 520  : 
; 521  :     for (i=(int)uReadSize-3; (i--)>0;)

  00130	48 85 c0	 test	 rax, rax
  00133	7f db		 jg	 SHORT $LL4@zip64local
  00135	eb 08		 jmp	 SHORT $LN32@zip64local
$LN22@zip64local:

; 524  :       {
; 525  :         uPosFound = uReadPos+i;

  00137	4c 63 e1	 movsxd	 r12, ecx
  0013a	4c 03 e6	 add	 r12, rsi

; 526  :         break;
; 527  :       }
; 528  : 
; 529  :       if (uPosFound!=0)

  0013d	75 09		 jne	 SHORT $LN36@zip64local
$LN32@zip64local:

; 502  :   while (uBackRead<uMaxBack)

  0013f	49 3b ee	 cmp	 rbp, r14
  00142	0f 82 58 ff ff
	ff		 jb	 $LL2@zip64local
$LN36@zip64local:
  00148	48 8b 7c 24 68	 mov	 rdi, QWORD PTR [rsp+104]
  0014d	48 8b 74 24 60	 mov	 rsi, QWORD PTR [rsp+96]
$LN33@zip64local:

; 530  :         break;
; 531  :   }
; 532  :   TRYFREE(buf);

  00152	48 8b cb	 mov	 rcx, rbx
  00155	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free
  0015b	48 8b 6c 24 50	 mov	 rbp, QWORD PTR [rsp+80]

; 533  :   return uPosFound;

  00160	49 8b c4	 mov	 rax, r12
  00163	4c 8b 7c 24 20	 mov	 r15, QWORD PTR [rsp+32]

; 534  : }

  00168	48 83 c4 28	 add	 rsp, 40			; 00000028H
  0016c	41 5e		 pop	 r14
  0016e	41 5d		 pop	 r13
  00170	41 5c		 pop	 r12
  00172	5b		 pop	 rbx
  00173	c3		 ret	 0
zip64local_SearchCentralDir ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64local_SearchCentralDir64
_TEXT	SEGMENT
pzlib_filefunc_def$ = 96
filestream$ = 104
uSizeFile$1$ = 112
uL$ = 112
relativeOffset$ = 120
zip64local_SearchCentralDir64 PROC			; COMDAT

; 543  : {

  00000	40 56		 push	 rsi
  00002	41 54		 push	 r12
  00004	41 55		 push	 r13
  00006	41 56		 push	 r14
  00008	41 57		 push	 r15
  0000a	48 83 ec 30	 sub	 rsp, 48			; 00000030H

; 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;

  0000e	33 f6		 xor	 esi, esi

; 549  :   uLong uL;
; 550  :   ZPOS64_T relativeOffset;
; 551  : 
; 552  :   if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)

  00010	45 33 c0	 xor	 r8d, r8d
  00013	4c 8b fa	 mov	 r15, rdx
  00016	4c 8b f1	 mov	 r14, rcx
  00019	41 bc ff ff 00
	00		 mov	 r12d, 65535		; 0000ffffH
  0001f	44 8b ee	 mov	 r13d, esi
  00022	44 8d 4e 02	 lea	 r9d, QWORD PTR [rsi+2]
  00026	e8 00 00 00 00	 call	 call_zseek64
  0002b	85 c0		 test	 eax, eax
  0002d	74 10		 je	 SHORT $LN7@zip64local

; 553  :     return 0;

  0002f	33 c0		 xor	 eax, eax

; 635  :     return 0;
; 636  : 
; 637  :   return relativeOffset;
; 638  : }

  00031	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00035	41 5f		 pop	 r15
  00037	41 5e		 pop	 r14
  00039	41 5d		 pop	 r13
  0003b	41 5c		 pop	 r12
  0003d	5e		 pop	 rsi
  0003e	c3		 ret	 0
$LN7@zip64local:
  0003f	48 89 5c 24 60	 mov	 QWORD PTR [rsp+96], rbx

; 554  : 
; 555  :   uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);

  00044	49 8b d7	 mov	 rdx, r15
  00047	49 8b ce	 mov	 rcx, r14
  0004a	48 89 7c 24 20	 mov	 QWORD PTR [rsp+32], rdi
  0004f	e8 00 00 00 00	 call	 call_ztell64

; 556  : 
; 557  :   if (uMaxBack>uSizeFile)

  00054	49 3b c4	 cmp	 rax, r12
  00057	48 89 44 24 70	 mov	 QWORD PTR uSizeFile$1$[rsp], rax

; 558  :     uMaxBack = uSizeFile;
; 559  : 
; 560  :   buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);

  0005c	b9 04 04 00 00	 mov	 ecx, 1028		; 00000404H
  00061	48 8b f8	 mov	 rdi, rax
  00064	4c 0f 42 e0	 cmovb	 r12, rax
  00068	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc
  0006e	48 8b d8	 mov	 rbx, rax

; 561  :   if (buf==NULL)

  00071	48 85 c0	 test	 rax, rax
  00074	0f 84 72 01 00
	00		 je	 $LN47@zip64local

; 562  :     return 0;
; 563  : 
; 564  :   uBackRead = 4;

  0007a	48 89 6c 24 28	 mov	 QWORD PTR [rsp+40], rbp
  0007f	bd 04 00 00 00	 mov	 ebp, 4

; 565  :   while (uBackRead<uMaxBack)

  00084	49 3b ec	 cmp	 rbp, r12
  00087	0f 83 a4 00 00
	00		 jae	 $LN34@zip64local
  0008d	0f 1f 00	 npad	 3
$LL2@zip64local:

; 566  :   {
; 567  :     uLong uReadSize;
; 568  :     ZPOS64_T uReadPos;
; 569  :     int i;
; 570  :     if (uBackRead+BUFREADCOMMENT>uMaxBack)

  00090	48 8d 85 00 04
	00 00		 lea	 rax, QWORD PTR [rbp+1024]

; 571  :       uBackRead = uMaxBack;
; 572  :     else
; 573  :       uBackRead+=BUFREADCOMMENT;
; 574  :     uReadPos = uSizeFile-uBackRead ;

  00097	48 8b f7	 mov	 rsi, rdi
  0009a	49 3b c4	 cmp	 rax, r12
  0009d	48 8b e8	 mov	 rbp, rax

; 575  : 
; 576  :     uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?

  000a0	48 8b c7	 mov	 rax, rdi
  000a3	49 0f 47 ec	 cmova	 rbp, r12
  000a7	48 2b f5	 sub	 rsi, rbp
  000aa	48 2b c6	 sub	 rax, rsi
  000ad	48 3d 04 04 00
	00		 cmp	 rax, 1028		; 00000404H
  000b3	76 07		 jbe	 SHORT $LN29@zip64local
  000b5	bf 04 04 00 00	 mov	 edi, 1028		; 00000404H
  000ba	eb 02		 jmp	 SHORT $LN30@zip64local
$LN29@zip64local:
  000bc	2b fe		 sub	 edi, esi
$LN30@zip64local:

; 577  :       (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
; 578  :     if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)

  000be	45 33 c9	 xor	 r9d, r9d
  000c1	4c 8b c6	 mov	 r8, rsi
  000c4	49 8b d7	 mov	 rdx, r15
  000c7	49 8b ce	 mov	 rcx, r14
  000ca	e8 00 00 00 00	 call	 call_zseek64
  000cf	85 c0		 test	 eax, eax
  000d1	75 5c		 jne	 SHORT $LN44@zip64local

; 579  :       break;
; 580  : 
; 581  :     if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)

  000d3	49 8b 4e 38	 mov	 rcx, QWORD PTR [r14+56]
  000d7	44 8b cf	 mov	 r9d, edi
  000da	4c 8b c3	 mov	 r8, rbx
  000dd	49 8b d7	 mov	 rdx, r15
  000e0	41 ff 56 08	 call	 QWORD PTR [r14+8]
  000e4	3b c7		 cmp	 eax, edi
  000e6	75 47		 jne	 SHORT $LN44@zip64local

; 582  :       break;
; 583  : 
; 584  :     for (i=(int)uReadSize-3; (i--)>0;)

  000e8	8d 4f fd	 lea	 ecx, DWORD PTR [rdi-3]
  000eb	48 63 c1	 movsxd	 rax, ecx
  000ee	85 c9		 test	 ecx, ecx
  000f0	7e 2f		 jle	 SHORT $LN43@zip64local
$LL4@zip64local:
  000f2	48 ff c8	 dec	 rax
  000f5	ff c9		 dec	 ecx

; 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))

  000f7	80 3c 18 50	 cmp	 BYTE PTR [rax+rbx], 80	; 00000050H
  000fb	75 15		 jne	 SHORT $LN14@zip64local
  000fd	80 7c 18 01 4b	 cmp	 BYTE PTR [rax+rbx+1], 75 ; 0000004bH
  00102	75 0e		 jne	 SHORT $LN14@zip64local
  00104	80 7c 18 02 06	 cmp	 BYTE PTR [rax+rbx+2], 6
  00109	75 07		 jne	 SHORT $LN14@zip64local
  0010b	80 7c 18 03 07	 cmp	 BYTE PTR [rax+rbx+3], 7
  00110	74 07		 je	 SHORT $LN33@zip64local
$LN14@zip64local:

; 582  :       break;
; 583  : 
; 584  :     for (i=(int)uReadSize-3; (i--)>0;)

  00112	48 85 c0	 test	 rax, rax
  00115	7f db		 jg	 SHORT $LL4@zip64local
  00117	eb 08		 jmp	 SHORT $LN43@zip64local
$LN33@zip64local:

; 588  :       {
; 589  :         uPosFound = uReadPos+i;

  00119	4c 63 e9	 movsxd	 r13, ecx
  0011c	4c 03 ee	 add	 r13, rsi

; 590  :         break;
; 591  :       }
; 592  :     }
; 593  : 
; 594  :       if (uPosFound!=0)

  0011f	75 0e		 jne	 SHORT $LN44@zip64local
$LN43@zip64local:

; 565  :   while (uBackRead<uMaxBack)

  00121	48 8b 7c 24 70	 mov	 rdi, QWORD PTR uSizeFile$1$[rsp]
  00126	49 3b ec	 cmp	 rbp, r12
  00129	0f 82 61 ff ff
	ff		 jb	 $LL2@zip64local
$LN44@zip64local:
  0012f	33 f6		 xor	 esi, esi
$LN34@zip64local:

; 595  :         break;
; 596  :   }
; 597  : 
; 598  :   TRYFREE(buf);

  00131	48 8b cb	 mov	 rcx, rbx
  00134	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free
  0013a	48 8b 6c 24 28	 mov	 rbp, QWORD PTR [rsp+40]

; 599  :   if (uPosFound == 0)

  0013f	4d 85 ed	 test	 r13, r13
  00142	0f 84 a4 00 00
	00		 je	 $LN47@zip64local

; 600  :     return 0;
; 601  : 
; 602  :   /* Zip64 end of central directory locator */
; 603  :   if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)

  00148	45 33 c9	 xor	 r9d, r9d
  0014b	4d 8b c5	 mov	 r8, r13
  0014e	49 8b d7	 mov	 rdx, r15
  00151	49 8b ce	 mov	 rcx, r14
  00154	e8 00 00 00 00	 call	 call_zseek64
  00159	85 c0		 test	 eax, eax
  0015b	0f 85 8b 00 00
	00		 jne	 $LN47@zip64local

; 604  :     return 0;
; 605  : 
; 606  :   /* the signature, already checked */
; 607  :   if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)

  00161	4c 8d 44 24 70	 lea	 r8, QWORD PTR uL$[rsp]
  00166	49 8b d7	 mov	 rdx, r15
  00169	49 8b ce	 mov	 rcx, r14
  0016c	e8 00 00 00 00	 call	 zip64local_getLong
  00171	85 c0		 test	 eax, eax
  00173	75 77		 jne	 SHORT $LN47@zip64local

; 608  :     return 0;
; 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)

  00175	4c 8d 44 24 70	 lea	 r8, QWORD PTR uL$[rsp]
  0017a	49 8b d7	 mov	 rdx, r15
  0017d	49 8b ce	 mov	 rcx, r14
  00180	e8 00 00 00 00	 call	 zip64local_getLong
  00185	85 c0		 test	 eax, eax
  00187	75 63		 jne	 SHORT $LN47@zip64local

; 612  :     return 0;
; 613  :   if (uL != 0)

  00189	39 44 24 70	 cmp	 DWORD PTR uL$[rsp], eax
  0018d	75 5d		 jne	 SHORT $LN47@zip64local

; 614  :     return 0;
; 615  : 
; 616  :   /* relative offset of the zip64 end of central directory record */
; 617  :   if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK)

  0018f	4c 8d 44 24 78	 lea	 r8, QWORD PTR relativeOffset$[rsp]
  00194	49 8b d7	 mov	 rdx, r15
  00197	49 8b ce	 mov	 rcx, r14
  0019a	e8 00 00 00 00	 call	 zip64local_getLong64
  0019f	85 c0		 test	 eax, eax
  001a1	75 49		 jne	 SHORT $LN47@zip64local

; 618  :     return 0;
; 619  : 
; 620  :   /* total number of disks */
; 621  :   if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)

  001a3	4c 8d 44 24 70	 lea	 r8, QWORD PTR uL$[rsp]
  001a8	49 8b d7	 mov	 rdx, r15
  001ab	49 8b ce	 mov	 rcx, r14
  001ae	e8 00 00 00 00	 call	 zip64local_getLong
  001b3	85 c0		 test	 eax, eax
  001b5	75 35		 jne	 SHORT $LN47@zip64local

; 622  :     return 0;
; 623  :   if (uL != 1)

  001b7	83 7c 24 70 01	 cmp	 DWORD PTR uL$[rsp], 1
  001bc	75 2e		 jne	 SHORT $LN47@zip64local

; 624  :     return 0;
; 625  : 
; 626  :   /* Goto Zip64 end of central directory record */
; 627  :   if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)

  001be	48 8b 5c 24 78	 mov	 rbx, QWORD PTR relativeOffset$[rsp]
  001c3	45 33 c9	 xor	 r9d, r9d
  001c6	4c 8b c3	 mov	 r8, rbx
  001c9	49 8b d7	 mov	 rdx, r15
  001cc	49 8b ce	 mov	 rcx, r14
  001cf	e8 00 00 00 00	 call	 call_zseek64
  001d4	85 c0		 test	 eax, eax
  001d6	75 14		 jne	 SHORT $LN47@zip64local

; 628  :     return 0;
; 629  : 
; 630  :   /* the signature */
; 631  :   if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)

  001d8	4c 8d 44 24 70	 lea	 r8, QWORD PTR uL$[rsp]
  001dd	49 8b d7	 mov	 rdx, r15
  001e0	49 8b ce	 mov	 rcx, r14
  001e3	e8 00 00 00 00	 call	 zip64local_getLong
  001e8	85 c0		 test	 eax, eax
  001ea	74 04		 je	 SHORT $LN26@zip64local
$LN47@zip64local:

; 632  :     return 0;

  001ec	33 c0		 xor	 eax, eax
  001ee	eb 0f		 jmp	 SHORT $LN46@zip64local
$LN26@zip64local:

; 633  : 
; 634  :   if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'

  001f0	81 7c 24 70 50
	4b 06 06	 cmp	 DWORD PTR uL$[rsp], 101075792 ; 06064b50H
  001f8	48 0f 45 de	 cmovne	 rbx, rsi
  001fc	48 8b c3	 mov	 rax, rbx
$LN46@zip64local:
  001ff	48 8b 5c 24 60	 mov	 rbx, QWORD PTR [rsp+96]
  00204	48 8b 7c 24 20	 mov	 rdi, QWORD PTR [rsp+32]

; 635  :     return 0;
; 636  : 
; 637  :   return relativeOffset;
; 638  : }

  00209	48 83 c4 30	 add	 rsp, 48			; 00000030H
  0020d	41 5f		 pop	 r15
  0020f	41 5e		 pop	 r14
  00211	41 5d		 pop	 r13
  00213	41 5c		 pop	 r12
  00215	5e		 pop	 rsi
  00216	c3		 ret	 0
zip64local_SearchCentralDir64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT LoadCentralDirectoryRecord
_TEXT	SEGMENT
number_entry$ = 32
tv389 = 128
size_comment$ = 128
size_central_dir$ = 128
number_entry_CD$ = 128
VersionNeeded$ = 128
VersionMadeBy$ = 128
sizeEndOfCentralDirectory$1 = 128
uL$ = 128
pziinit$ = 128
offset_central_dir$ = 136
number_disk_with_CD$ = 136
number_disk$ = 144
number_entry_CD$1$ = 152
LoadCentralDirectoryRecord PROC				; COMDAT

; 641  : {

$LN58:
  00000	40 55		 push	 rbp
  00002	53		 push	 rbx
  00003	56		 push	 rsi
  00004	57		 push	 rdi
  00005	41 54		 push	 r12
  00007	41 55		 push	 r13
  00009	41 56		 push	 r14
  0000b	41 57		 push	 r15
  0000d	48 8b ec	 mov	 rbp, rsp
  00010	48 83 ec 38	 sub	 rsp, 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);

  00014	48 8b 51 58	 mov	 rdx, QWORD PTR [rcx+88]
  00018	48 8b d9	 mov	 rbx, rcx
  0001b	33 f6		 xor	 esi, esi
  0001d	e8 00 00 00 00	 call	 zip64local_SearchCentralDir64

; 666  :   if(central_pos > 0)
; 667  :   {
; 668  :     hasZIP64Record = 1;
; 669  :   }
; 670  :   else if(central_pos == 0)
; 671  :   {
; 672  :     central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream);

  00022	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00026	4c 8b e0	 mov	 r12, rax
  00029	48 8b cb	 mov	 rcx, rbx
  0002c	48 85 c0	 test	 rax, rax
  0002f	0f 85 19 01 00
	00		 jne	 $LN54@LoadCentra
  00035	e8 00 00 00 00	 call	 zip64local_SearchCentralDir

; 733  :   }
; 734  :   else
; 735  :   {
; 736  :     // Read End of central Directory info
; 737  :     if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)

  0003a	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0003e	45 33 c9	 xor	 r9d, r9d
  00041	4c 8b c0	 mov	 r8, rax
  00044	48 8b cb	 mov	 rcx, rbx
  00047	4c 8b e0	 mov	 r12, rax
  0004a	e8 00 00 00 00	 call	 call_zseek64

; 738  :       err=ZIP_ERRNO;
; 739  : 
; 740  :     /* the signature, already checked */
; 741  :     if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)

  0004f	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00053	4c 8d 45 48	 lea	 r8, QWORD PTR uL$[rbp-56]
  00057	41 83 cf ff	 or	 r15d, -1
  0005b	8b fe		 mov	 edi, esi
  0005d	85 c0		 test	 eax, eax
  0005f	48 8b cb	 mov	 rcx, rbx
  00062	41 0f 45 ff	 cmovne	 edi, r15d
  00066	e8 00 00 00 00	 call	 zip64local_getLong

; 742  :       err=ZIP_ERRNO;
; 743  : 
; 744  :     /* number of this disk */
; 745  :     if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)

  0006b	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0006f	4c 8d 45 58	 lea	 r8, QWORD PTR number_disk$[rbp-56]
  00073	85 c0		 test	 eax, eax
  00075	48 8b cb	 mov	 rcx, rbx
  00078	41 0f 45 ff	 cmovne	 edi, r15d
  0007c	e8 00 00 00 00	 call	 zip64local_getShort

; 746  :       err=ZIP_ERRNO;
; 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)

  00081	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00085	4c 8d 45 50	 lea	 r8, QWORD PTR number_disk_with_CD$[rbp-56]
  00089	85 c0		 test	 eax, eax
  0008b	48 8b cb	 mov	 rcx, rbx
  0008e	41 0f 45 ff	 cmovne	 edi, r15d
  00092	e8 00 00 00 00	 call	 zip64local_getShort

; 750  :       err=ZIP_ERRNO;
; 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)

  00097	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0009b	4c 8d 45 48	 lea	 r8, QWORD PTR uL$[rbp-56]
  0009f	85 c0		 test	 eax, eax
  000a1	48 8b cb	 mov	 rcx, rbx
  000a4	44 8b ee	 mov	 r13d, esi
  000a7	41 0f 45 ff	 cmovne	 edi, r15d
  000ab	e8 00 00 00 00	 call	 zip64local_getShort
  000b0	85 c0		 test	 eax, eax
  000b2	74 05		 je	 SHORT $LN26@LoadCentra

; 755  :       err=ZIP_ERRNO;

  000b4	41 8b ff	 mov	 edi, r15d
  000b7	eb 04		 jmp	 SHORT $LN27@LoadCentra
$LN26@LoadCentra:

; 756  :     else
; 757  :       number_entry = uL;

  000b9	44 8b 6d 48	 mov	 r13d, DWORD PTR uL$[rbp-56]
$LN27@LoadCentra:

; 758  : 
; 759  :     /* total number of entries in the central dir */
; 760  :     number_entry_CD = 0;
; 761  :     if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)

  000bd	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000c1	4c 8d 45 48	 lea	 r8, QWORD PTR uL$[rbp-56]
  000c5	48 8b cb	 mov	 rcx, rbx
  000c8	48 89 75 60	 mov	 QWORD PTR number_entry_CD$1$[rbp-56], rsi
  000cc	4c 8b f6	 mov	 r14, rsi
  000cf	e8 00 00 00 00	 call	 zip64local_getShort
  000d4	85 c0		 test	 eax, eax
  000d6	74 05		 je	 SHORT $LN28@LoadCentra

; 762  :       err=ZIP_ERRNO;

  000d8	41 8b ff	 mov	 edi, r15d
  000db	eb 08		 jmp	 SHORT $LN29@LoadCentra
$LN28@LoadCentra:

; 763  :     else
; 764  :       number_entry_CD = uL;

  000dd	44 8b 75 48	 mov	 r14d, DWORD PTR uL$[rbp-56]
  000e1	4c 89 75 60	 mov	 QWORD PTR number_entry_CD$1$[rbp-56], r14
$LN29@LoadCentra:

; 765  : 
; 766  :     if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))

  000e5	4d 3b f5	 cmp	 r14, r13
  000e8	75 0a		 jne	 SHORT $LN31@LoadCentra
  000ea	39 75 50	 cmp	 DWORD PTR number_disk_with_CD$[rbp-56], esi
  000ed	75 05		 jne	 SHORT $LN31@LoadCentra
  000ef	39 75 58	 cmp	 DWORD PTR number_disk$[rbp-56], esi
  000f2	74 05		 je	 SHORT $LN30@LoadCentra
$LN31@LoadCentra:

; 767  :       err=ZIP_BADZIPFILE;

  000f4	bf 99 ff ff ff	 mov	 edi, -103		; ffffffffffffff99H
$LN30@LoadCentra:

; 768  : 
; 769  :     /* size of the central directory */
; 770  :     size_central_dir = 0;
; 771  :     if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)

  000f9	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000fd	4c 8d 45 48	 lea	 r8, QWORD PTR uL$[rbp-56]
  00101	48 8b cb	 mov	 rcx, rbx
  00104	4c 8b f6	 mov	 r14, rsi
  00107	e8 00 00 00 00	 call	 zip64local_getLong
  0010c	85 c0		 test	 eax, eax
  0010e	74 05		 je	 SHORT $LN32@LoadCentra

; 772  :       err=ZIP_ERRNO;

  00110	41 8b ff	 mov	 edi, r15d
  00113	eb 04		 jmp	 SHORT $LN33@LoadCentra
$LN32@LoadCentra:

; 773  :     else
; 774  :       size_central_dir = uL;

  00115	44 8b 75 48	 mov	 r14d, DWORD PTR uL$[rbp-56]
$LN33@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)

  00119	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0011d	4c 8d 45 48	 lea	 r8, QWORD PTR uL$[rbp-56]
  00121	48 8b cb	 mov	 rcx, rbx
  00124	e8 00 00 00 00	 call	 zip64local_getLong
  00129	85 c0		 test	 eax, eax
  0012b	74 05		 je	 SHORT $LN34@LoadCentra

; 779  :       err=ZIP_ERRNO;

  0012d	41 8b ff	 mov	 edi, r15d
  00130	eb 03		 jmp	 SHORT $LN35@LoadCentra
$LN34@LoadCentra:

; 780  :     else
; 781  :       offset_central_dir = uL;

  00132	8b 75 48	 mov	 esi, DWORD PTR uL$[rbp-56]
$LN35@LoadCentra:

; 782  : 
; 783  : 
; 784  :     /* zipfile global comment length */
; 785  :     if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK)

  00135	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00139	4c 8d 45 48	 lea	 r8, QWORD PTR size_comment$[rbp-56]
  0013d	48 8b cb	 mov	 rcx, rbx
  00140	e8 00 00 00 00	 call	 zip64local_getShort
  00145	44 8b 6d 48	 mov	 r13d, DWORD PTR size_comment$[rbp-56]
  00149	e9 15 01 00 00	 jmp	 $LN56@LoadCentra
$LN54@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)

  0014e	45 33 c9	 xor	 r9d, r9d
  00151	4c 8b c0	 mov	 r8, rax
  00154	e8 00 00 00 00	 call	 call_zseek64

; 684  :       err=ZIP_ERRNO;
; 685  : 
; 686  :     /* the signature, already checked */
; 687  :     if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)

  00159	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0015d	4c 8d 45 48	 lea	 r8, QWORD PTR uL$[rbp-56]
  00161	41 83 cf ff	 or	 r15d, -1
  00165	8b fe		 mov	 edi, esi
  00167	85 c0		 test	 eax, eax
  00169	48 8b cb	 mov	 rcx, rbx
  0016c	41 0f 45 ff	 cmovne	 edi, r15d
  00170	e8 00 00 00 00	 call	 zip64local_getLong

; 688  :       err=ZIP_ERRNO;
; 689  : 
; 690  :     /* size of zip64 end of central directory record */
; 691  :     if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK)

  00175	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00179	4c 8d 45 48	 lea	 r8, QWORD PTR sizeEndOfCentralDirectory$1[rbp-56]
  0017d	85 c0		 test	 eax, eax
  0017f	48 8b cb	 mov	 rcx, rbx
  00182	41 0f 45 ff	 cmovne	 edi, r15d
  00186	e8 00 00 00 00	 call	 zip64local_getLong64

; 692  :       err=ZIP_ERRNO;
; 693  : 
; 694  :     /* version made by */
; 695  :     if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK)

  0018b	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0018f	4c 8d 45 48	 lea	 r8, QWORD PTR VersionMadeBy$[rbp-56]
  00193	85 c0		 test	 eax, eax
  00195	48 8b cb	 mov	 rcx, rbx
  00198	41 0f 45 ff	 cmovne	 edi, r15d
  0019c	e8 00 00 00 00	 call	 zip64local_getShort

; 696  :       err=ZIP_ERRNO;
; 697  : 
; 698  :     /* version needed to extract */
; 699  :     if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK)

  001a1	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001a5	4c 8d 45 48	 lea	 r8, QWORD PTR VersionNeeded$[rbp-56]
  001a9	85 c0		 test	 eax, eax
  001ab	48 8b cb	 mov	 rcx, rbx
  001ae	41 0f 45 ff	 cmovne	 edi, r15d
  001b2	e8 00 00 00 00	 call	 zip64local_getShort

; 700  :       err=ZIP_ERRNO;
; 701  : 
; 702  :     /* number of this disk */
; 703  :     if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)

  001b7	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001bb	4c 8d 45 58	 lea	 r8, QWORD PTR number_disk$[rbp-56]
  001bf	85 c0		 test	 eax, eax
  001c1	48 8b cb	 mov	 rcx, rbx
  001c4	41 0f 45 ff	 cmovne	 edi, r15d
  001c8	e8 00 00 00 00	 call	 zip64local_getLong

; 704  :       err=ZIP_ERRNO;
; 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)

  001cd	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001d1	4c 8d 45 50	 lea	 r8, QWORD PTR number_disk_with_CD$[rbp-56]
  001d5	85 c0		 test	 eax, eax
  001d7	48 8b cb	 mov	 rcx, rbx
  001da	41 0f 45 ff	 cmovne	 edi, r15d
  001de	e8 00 00 00 00	 call	 zip64local_getLong

; 708  :       err=ZIP_ERRNO;
; 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)

  001e3	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001e7	4c 8d 45 e8	 lea	 r8, QWORD PTR number_entry$[rbp-56]
  001eb	85 c0		 test	 eax, eax
  001ed	48 8b cb	 mov	 rcx, rbx
  001f0	41 0f 45 ff	 cmovne	 edi, r15d
  001f4	e8 00 00 00 00	 call	 zip64local_getLong64

; 712  :       err=ZIP_ERRNO;
; 713  : 
; 714  :     /* total number of entries in the central directory */
; 715  :     if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK)

  001f9	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001fd	4c 8d 45 48	 lea	 r8, QWORD PTR number_entry_CD$[rbp-56]
  00201	85 c0		 test	 eax, eax
  00203	48 8b cb	 mov	 rcx, rbx
  00206	41 0f 45 ff	 cmovne	 edi, r15d
  0020a	e8 00 00 00 00	 call	 zip64local_getLong64
  0020f	85 c0		 test	 eax, eax

; 716  :       err=ZIP_ERRNO;
; 717  : 
; 718  :     if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))

  00211	48 8b 45 48	 mov	 rax, QWORD PTR number_entry_CD$[rbp-56]
  00215	48 89 45 60	 mov	 QWORD PTR number_entry_CD$1$[rbp-56], rax
  00219	41 0f 45 ff	 cmovne	 edi, r15d
  0021d	48 3b 45 e8	 cmp	 rax, QWORD PTR number_entry$[rbp-56]
  00221	75 0a		 jne	 SHORT $LN19@LoadCentra
  00223	39 75 50	 cmp	 DWORD PTR number_disk_with_CD$[rbp-56], esi
  00226	75 05		 jne	 SHORT $LN19@LoadCentra
  00228	39 75 58	 cmp	 DWORD PTR number_disk$[rbp-56], esi
  0022b	74 05		 je	 SHORT $LN18@LoadCentra
$LN19@LoadCentra:

; 719  :       err=ZIP_BADZIPFILE;

  0022d	bf 99 ff ff ff	 mov	 edi, -103		; ffffffffffffff99H
$LN18@LoadCentra:

; 720  : 
; 721  :     /* size of the central directory */
; 722  :     if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK)

  00232	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00236	4c 8d 45 48	 lea	 r8, QWORD PTR size_central_dir$[rbp-56]
  0023a	48 8b cb	 mov	 rcx, rbx
  0023d	e8 00 00 00 00	 call	 zip64local_getLong64

; 723  :       err=ZIP_ERRNO;
; 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)

  00242	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00246	4c 8d 45 50	 lea	 r8, QWORD PTR offset_central_dir$[rbp-56]
  0024a	85 c0		 test	 eax, eax
  0024c	48 8b cb	 mov	 rcx, rbx
  0024f	41 0f 45 ff	 cmovne	 edi, r15d
  00253	e8 00 00 00 00	 call	 zip64local_getLong64

; 728  :       err=ZIP_ERRNO;
; 729  : 
; 730  :     // TODO..
; 731  :     // read the comment from the standard central header.
; 732  :     size_comment = 0;

  00258	4c 8b 75 48	 mov	 r14, QWORD PTR size_central_dir$[rbp-56]
  0025c	44 8b ee	 mov	 r13d, esi
  0025f	48 8b 75 50	 mov	 rsi, QWORD PTR offset_central_dir$[rbp-56]
$LN56@LoadCentra:

; 786  :       err=ZIP_ERRNO;
; 787  :   }
; 788  : 
; 789  :   if ((central_pos<offset_central_dir+size_central_dir) &&

  00263	85 c0		 test	 eax, eax
  00265	4a 8d 04 36	 lea	 rax, QWORD PTR [rsi+r14]
  00269	41 0f 45 ff	 cmovne	 edi, r15d
  0026d	4c 3b e0	 cmp	 r12, rax
  00270	0f 82 03 01 00
	00		 jb	 $LN52@LoadCentra

; 790  :     (err==ZIP_OK))
; 791  :     err=ZIP_BADZIPFILE;
; 792  : 
; 793  :   if (err!=ZIP_OK)

  00276	85 ff		 test	 edi, edi
  00278	0f 85 fb 00 00
	00		 jne	 $LN52@LoadCentra

; 797  :   }
; 798  : 
; 799  :   if (size_comment>0)

  0027e	45 85 ed	 test	 r13d, r13d
  00281	74 34		 je	 SHORT $LN40@LoadCentra

; 800  :   {
; 801  :     pziinit->globalcomment = (char*)ALLOC(size_comment+1);

  00283	41 8d 4d 01	 lea	 ecx, DWORD PTR [r13+1]
  00287	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc
  0028d	48 89 83 60 01
	01 00		 mov	 QWORD PTR [rbx+65888], rax

; 802  :     if (pziinit->globalcomment)

  00294	48 85 c0	 test	 rax, rax
  00297	74 1e		 je	 SHORT $LN40@LoadCentra

; 803  :     {
; 804  :       size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment);

  00299	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0029d	45 8b cd	 mov	 r9d, r13d
  002a0	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  002a4	4c 8b c0	 mov	 r8, rax
  002a7	ff 53 08	 call	 QWORD PTR [rbx+8]

; 805  :       pziinit->globalcomment[size_comment]=0;

  002aa	8b c8		 mov	 ecx, eax
  002ac	48 8b 83 60 01
	01 00		 mov	 rax, QWORD PTR [rbx+65888]
  002b3	40 88 3c 01	 mov	 BYTE PTR [rcx+rax], dil
$LN40@LoadCentra:

; 806  :     }
; 807  :   }
; 808  : 
; 809  :   byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);

  002b7	4c 2b e6	 sub	 r12, rsi

; 810  :   pziinit->add_position_when_writing_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);

  002ba	b9 f0 0f 00 00	 mov	 ecx, 4080		; 00000ff0H
  002bf	4d 2b e6	 sub	 r12, r14
  002c2	4c 89 a3 50 01
	01 00		 mov	 QWORD PTR [rbx+65872], r12
  002c9	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc

; 816  :     if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)

  002cf	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  002d3	49 03 f4	 add	 rsi, r12
  002d6	4c 8b c6	 mov	 r8, rsi
  002d9	48 89 75 48	 mov	 QWORD PTR tv389[rbp-56], rsi
  002dd	45 33 c9	 xor	 r9d, r9d
  002e0	48 8b cb	 mov	 rcx, rbx
  002e3	4c 8b e8	 mov	 r13, rax
  002e6	e8 00 00 00 00	 call	 call_zseek64
  002eb	85 c0		 test	 eax, eax
  002ed	41 0f 45 ff	 cmovne	 edi, r15d

; 817  :       err=ZIP_ERRNO;
; 818  : 
; 819  :     while ((size_central_dir_to_read>0) && (err==ZIP_OK))

  002f1	4d 85 f6	 test	 r14, r14
  002f4	74 47		 je	 SHORT $LN3@LoadCentra
$LL2@LoadCentra:
  002f6	85 ff		 test	 edi, edi
  002f8	75 3f		 jne	 SHORT $LN55@LoadCentra

; 820  :     {
; 821  :       ZPOS64_T read_this = SIZEDATA_INDATABLOCK;
; 822  :       if (read_this > size_central_dir_to_read)
; 823  :         read_this = size_central_dir_to_read;
; 824  : 
; 825  :       if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this)

  002fa	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  002fe	be f0 0f 00 00	 mov	 esi, 4080		; 00000ff0H
  00303	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  00307	4c 3b f6	 cmp	 r14, rsi
  0030a	4d 8b c5	 mov	 r8, r13
  0030d	49 0f 42 f6	 cmovb	 rsi, r14
  00311	44 8b ce	 mov	 r9d, esi
  00314	ff 53 08	 call	 QWORD PTR [rbx+8]
  00317	8b c0		 mov	 eax, eax
  00319	48 3b c6	 cmp	 rax, rsi
  0031c	74 05		 je	 SHORT $LN53@LoadCentra

; 826  :         err=ZIP_ERRNO;

  0031e	41 8b ff	 mov	 edi, r15d

; 827  : 
; 828  :       if (err==ZIP_OK)

  00321	eb 11		 jmp	 SHORT $LN44@LoadCentra
$LN53@LoadCentra:

; 829  :         err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);

  00323	48 8d 4b 60	 lea	 rcx, QWORD PTR [rbx+96]
  00327	44 8b c6	 mov	 r8d, esi
  0032a	49 8b d5	 mov	 rdx, r13
  0032d	e8 00 00 00 00	 call	 add_data_in_datablock
  00332	8b f8		 mov	 edi, eax
$LN44@LoadCentra:

; 830  : 
; 831  :       size_central_dir_to_read-=read_this;

  00334	4c 2b f6	 sub	 r14, rsi

; 817  :       err=ZIP_ERRNO;
; 818  : 
; 819  :     while ((size_central_dir_to_read>0) && (err==ZIP_OK))

  00337	75 bd		 jne	 SHORT $LL2@LoadCentra
$LN55@LoadCentra:
  00339	48 8b 75 48	 mov	 rsi, QWORD PTR tv389[rbp-56]
$LN3@LoadCentra:

; 832  :     }
; 833  :     TRYFREE(buf_read);

  0033d	4d 85 ed	 test	 r13, r13
  00340	74 09		 je	 SHORT $LN45@LoadCentra
  00342	49 8b cd	 mov	 rcx, r13
  00345	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free
$LN45@LoadCentra:

; 834  :   }
; 835  :   pziinit->begin_pos = byte_before_the_zipfile;
; 836  :   pziinit->number_entry = number_entry_CD;

  0034b	48 8b 45 60	 mov	 rax, QWORD PTR number_entry_CD$1$[rbp-56]

; 837  : 
; 838  :   if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)

  0034f	45 33 c9	 xor	 r9d, r9d
  00352	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00356	4c 8b c6	 mov	 r8, rsi
  00359	48 8b cb	 mov	 rcx, rbx
  0035c	48 89 83 58 01
	01 00		 mov	 QWORD PTR [rbx+65880], rax
  00363	4c 89 a3 48 01
	01 00		 mov	 QWORD PTR [rbx+65864], r12
  0036a	e8 00 00 00 00	 call	 call_zseek64
  0036f	85 c0		 test	 eax, eax
  00371	41 0f 45 ff	 cmovne	 edi, r15d

; 839  :     err=ZIP_ERRNO;
; 840  : 
; 841  :   return err;

  00375	8b c7		 mov	 eax, edi
  00377	eb 0e		 jmp	 SHORT $LN1@LoadCentra
$LN52@LoadCentra:

; 794  :   {
; 795  :     ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);

  00379	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0037d	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  00381	ff 53 28	 call	 QWORD PTR [rbx+40]

; 796  :     return ZIP_ERRNO;

  00384	41 8b c7	 mov	 eax, r15d
$LN1@LoadCentra:

; 842  : }

  00387	48 83 c4 38	 add	 rsp, 56			; 00000038H
  0038b	41 5f		 pop	 r15
  0038d	41 5e		 pop	 r14
  0038f	41 5d		 pop	 r13
  00391	41 5c		 pop	 r12
  00393	5f		 pop	 rdi
  00394	5e		 pop	 rsi
  00395	5b		 pop	 rbx
  00396	5d		 pop	 rbp
  00397	c3		 ret	 0
LoadCentralDirectoryRecord ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpen3
_TEXT	SEGMENT
ziinit$ = 32
pathname$ = 65952
append$ = 65960
globalcomment$ = 65968
pzlib_filefunc64_32_def$ = 65976
zipOpen3 PROC						; COMDAT

; 850  : {

$LN17:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	48 89 7c 24 18	 mov	 QWORD PTR [rsp+24], rdi
  0000f	4c 89 74 24 20	 mov	 QWORD PTR [rsp+32], r14
  00014	55		 push	 rbp
  00015	48 8d ac 24 70
	ff fe ff	 lea	 rbp, QWORD PTR [rsp-65680]
  0001d	b8 90 01 01 00	 mov	 eax, 65936		; 00010190H
  00022	e8 00 00 00 00	 call	 __chkstk
  00027	48 2b e0	 sub	 rsp, rax

; 851  :     zip64_internal ziinit;
; 852  :     zip64_internal* zi;
; 853  :     int err=ZIP_OK;

  0002a	33 db		 xor	 ebx, ebx
  0002c	8b f2		 mov	 esi, edx

; 854  : 
; 855  :     ziinit.z_filefunc.zseek32_file = NULL;

  0002e	48 89 5c 24 70	 mov	 QWORD PTR ziinit$[rsp+80], rbx
  00033	4d 8b f0	 mov	 r14, r8

; 856  :     ziinit.z_filefunc.ztell32_file = NULL;

  00036	48 89 5c 24 68	 mov	 QWORD PTR ziinit$[rsp+72], rbx
  0003b	48 8b d1	 mov	 rdx, rcx

; 857  :     if (pzlib_filefunc64_32_def==NULL)

  0003e	4d 85 c9	 test	 r9, r9
  00041	75 0c		 jne	 SHORT $LN2@zipOpen3

; 858  :         fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);

  00043	48 8d 4c 24 20	 lea	 rcx, QWORD PTR ziinit$[rsp]
  00048	e8 00 00 00 00	 call	 fill_fopen64_filefunc
  0004d	eb 3d		 jmp	 SHORT $LN3@zipOpen3
$LN2@zipOpen3:

; 859  :     else
; 860  :         ziinit.z_filefunc = *pzlib_filefunc64_32_def;

  0004f	41 0f 28 01	 movaps	 xmm0, XMMWORD PTR [r9]
  00053	41 0f 28 49 10	 movaps	 xmm1, XMMWORD PTR [r9+16]
  00058	0f 29 44 24 20	 movaps	 XMMWORD PTR ziinit$[rsp], xmm0
  0005d	41 0f 28 41 20	 movaps	 xmm0, XMMWORD PTR [r9+32]
  00062	0f 29 4c 24 30	 movaps	 XMMWORD PTR ziinit$[rsp+16], xmm1
  00067	41 0f 28 49 30	 movaps	 xmm1, XMMWORD PTR [r9+48]
  0006c	0f 29 44 24 40	 movaps	 XMMWORD PTR ziinit$[rsp+32], xmm0
  00071	41 0f 28 41 40	 movaps	 xmm0, XMMWORD PTR [r9+64]
  00076	0f 29 4c 24 50	 movaps	 XMMWORD PTR ziinit$[rsp+48], xmm1
  0007b	f2 41 0f 10 49
	50		 movsd	 xmm1, QWORD PTR [r9+80]
  00081	0f 29 44 24 60	 movaps	 XMMWORD PTR ziinit$[rsp+64], xmm0
  00086	f2 0f 11 4c 24
	70		 movsd	 QWORD PTR ziinit$[rsp+80], xmm1
$LN3@zipOpen3:

; 861  : 
; 862  :     ziinit.filestream = ZOPEN64(ziinit.z_filefunc,

  0008c	b8 0b 00 00 00	 mov	 eax, 11
  00091	48 8d 4c 24 20	 lea	 rcx, QWORD PTR ziinit$[rsp]
  00096	41 b8 07 00 00
	00		 mov	 r8d, 7
  0009c	85 f6		 test	 esi, esi
  0009e	44 0f 44 c0	 cmove	 r8d, eax
  000a2	e8 00 00 00 00	 call	 call_zopen64
  000a7	48 89 44 24 78	 mov	 QWORD PTR ziinit$[rsp+88], rax
  000ac	48 8b f8	 mov	 rdi, rax

; 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));
; 867  : 
; 868  :     if (ziinit.filestream == NULL)

  000af	48 85 c0	 test	 rax, rax
  000b2	74 6b		 je	 SHORT $LN15@zipOpen3

; 869  :         return NULL;
; 870  : 
; 871  :     if (append == APPEND_STATUS_CREATEAFTER)

  000b4	83 fe 01	 cmp	 esi, 1
  000b7	75 14		 jne	 SHORT $LN5@zipOpen3

; 872  :         ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);

  000b9	44 8d 4e 01	 lea	 r9d, QWORD PTR [rsi+1]
  000bd	45 33 c0	 xor	 r8d, r8d
  000c0	48 8b d0	 mov	 rdx, rax
  000c3	48 8d 4c 24 20	 lea	 rcx, QWORD PTR ziinit$[rsp]
  000c8	e8 00 00 00 00	 call	 call_zseek64
$LN5@zipOpen3:

; 873  : 
; 874  :     ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);

  000cd	48 8b d7	 mov	 rdx, rdi
  000d0	48 8d 4c 24 20	 lea	 rcx, QWORD PTR ziinit$[rsp]
  000d5	e8 00 00 00 00	 call	 call_ztell64

; 875  :     ziinit.in_opened_file_inzip = 0;
; 876  :     ziinit.ci.stream_initialised = 0;
; 877  :     ziinit.number_entry = 0;
; 878  :     ziinit.add_position_when_writing_offset = 0;
; 879  :     init_linkedlist(&(ziinit.central_dir));

  000da	48 8d 4d 80	 lea	 rcx, QWORD PTR ziinit$[rbp-160]
  000de	48 89 85 68 00
	01 00		 mov	 QWORD PTR ziinit$[rbp+65608], rax
  000e5	89 5d 90	 mov	 DWORD PTR ziinit$[rbp-144], ebx
  000e8	89 5d f0	 mov	 DWORD PTR ziinit$[rbp-48], ebx
  000eb	48 89 9d 78 00
	01 00		 mov	 QWORD PTR ziinit$[rbp+65624], rbx
  000f2	48 89 9d 70 00
	01 00		 mov	 QWORD PTR ziinit$[rbp+65616], rbx
  000f9	e8 00 00 00 00	 call	 init_linkedlist

; 880  : 
; 881  : 
; 882  : 
; 883  :     zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));

  000fe	b9 68 01 01 00	 mov	 ecx, 65896		; 00010168H
  00103	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc
  00109	48 8b f8	 mov	 rdi, rax

; 884  :     if (zi==NULL)

  0010c	48 85 c0	 test	 rax, rax
  0010f	75 15		 jne	 SHORT $LN6@zipOpen3

; 885  :     {
; 886  :         ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);

  00111	48 8b 54 24 78	 mov	 rdx, QWORD PTR ziinit$[rsp+88]
  00116	48 8b 4c 24 58	 mov	 rcx, QWORD PTR ziinit$[rsp+56]
  0011b	ff 54 24 48	 call	 QWORD PTR ziinit$[rsp+40]
$LN15@zipOpen3:

; 887  :         return NULL;

  0011f	33 c0		 xor	 eax, eax
  00121	e9 e6 00 00 00	 jmp	 $LN10@zipOpen3
$LN6@zipOpen3:

; 888  :     }
; 889  : 
; 890  :     /* now we add file in a zipfile */
; 891  : #    ifndef NO_ADDFILEINEXISTINGZIP
; 892  :     ziinit.globalcomment = NULL;

  00126	48 89 9d 80 00
	01 00		 mov	 QWORD PTR ziinit$[rbp+65632], rbx
  0012d	48 8b cb	 mov	 rcx, rbx

; 893  :     if (append == APPEND_STATUS_ADDINZIP)

  00130	83 fe 02	 cmp	 esi, 2
  00133	75 13		 jne	 SHORT $LN7@zipOpen3

; 894  :     {
; 895  :       // Read and Cache Central Directory Records
; 896  :       err = LoadCentralDirectoryRecord(&ziinit);

  00135	48 8d 4c 24 20	 lea	 rcx, QWORD PTR ziinit$[rsp]
  0013a	e8 00 00 00 00	 call	 LoadCentralDirectoryRecord
  0013f	48 8b 8d 80 00
	01 00		 mov	 rcx, QWORD PTR ziinit$[rbp+65632]
  00146	8b d8		 mov	 ebx, eax
$LN7@zipOpen3:

; 897  :     }
; 898  : 
; 899  :     if (globalcomment)

  00148	4d 85 f6	 test	 r14, r14
  0014b	74 03		 je	 SHORT $LN8@zipOpen3

; 900  :     {
; 901  :       *globalcomment = ziinit.globalcomment;

  0014d	49 89 0e	 mov	 QWORD PTR [r14], rcx
$LN8@zipOpen3:

; 902  :     }
; 903  : #    endif /* !NO_ADDFILEINEXISTINGZIP*/
; 904  : 
; 905  :     if (err != ZIP_OK)

  00150	85 db		 test	 ebx, ebx
  00152	74 1b		 je	 SHORT $LN9@zipOpen3

; 906  :     {
; 907  : #    ifndef NO_ADDFILEINEXISTINGZIP
; 908  :         TRYFREE(ziinit.globalcomment);

  00154	48 85 c9	 test	 rcx, rcx
  00157	74 06		 je	 SHORT $LN11@zipOpen3
  00159	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free
$LN11@zipOpen3:

; 909  : #    endif /* !NO_ADDFILEINEXISTINGZIP*/
; 910  :         TRYFREE(zi);

  0015f	48 8b cf	 mov	 rcx, rdi
  00162	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free

; 911  :         return NULL;

  00168	33 c0		 xor	 eax, eax
  0016a	e9 9d 00 00 00	 jmp	 $LN10@zipOpen3
$LN9@zipOpen3:

; 912  :     }
; 913  :     else
; 914  :     {
; 915  :         *zi = ziinit;

  0016f	48 8b cf	 mov	 rcx, rdi
  00172	48 8d 44 24 20	 lea	 rax, QWORD PTR ziinit$[rsp]
  00177	ba 02 02 00 00	 mov	 edx, 514		; 00000202H
  0017c	0f 1f 40 00	 npad	 4
$LL14@zipOpen3:
  00180	48 8d 89 80 00
	00 00		 lea	 rcx, QWORD PTR [rcx+128]
  00187	0f 10 00	 movups	 xmm0, XMMWORD PTR [rax]
  0018a	0f 10 48 10	 movups	 xmm1, XMMWORD PTR [rax+16]
  0018e	48 8d 80 80 00
	00 00		 lea	 rax, QWORD PTR [rax+128]
  00195	0f 11 41 80	 movups	 XMMWORD PTR [rcx-128], xmm0
  00199	0f 10 40 a0	 movups	 xmm0, XMMWORD PTR [rax-96]
  0019d	0f 11 49 90	 movups	 XMMWORD PTR [rcx-112], xmm1
  001a1	0f 10 48 b0	 movups	 xmm1, XMMWORD PTR [rax-80]
  001a5	0f 11 41 a0	 movups	 XMMWORD PTR [rcx-96], xmm0
  001a9	0f 10 40 c0	 movups	 xmm0, XMMWORD PTR [rax-64]
  001ad	0f 11 49 b0	 movups	 XMMWORD PTR [rcx-80], xmm1
  001b1	0f 10 48 d0	 movups	 xmm1, XMMWORD PTR [rax-48]
  001b5	0f 11 41 c0	 movups	 XMMWORD PTR [rcx-64], xmm0
  001b9	0f 10 40 e0	 movups	 xmm0, XMMWORD PTR [rax-32]
  001bd	0f 11 49 d0	 movups	 XMMWORD PTR [rcx-48], xmm1
  001c1	0f 10 48 f0	 movups	 xmm1, XMMWORD PTR [rax-16]
  001c5	0f 11 41 e0	 movups	 XMMWORD PTR [rcx-32], xmm0
  001c9	0f 11 49 f0	 movups	 XMMWORD PTR [rcx-16], xmm1
  001cd	48 83 ea 01	 sub	 rdx, 1
  001d1	75 ad		 jne	 SHORT $LL14@zipOpen3
  001d3	0f 10 00	 movups	 xmm0, XMMWORD PTR [rax]
  001d6	0f 10 48 10	 movups	 xmm1, XMMWORD PTR [rax+16]
  001da	0f 11 01	 movups	 XMMWORD PTR [rcx], xmm0
  001dd	0f 10 40 20	 movups	 xmm0, XMMWORD PTR [rax+32]
  001e1	0f 11 49 10	 movups	 XMMWORD PTR [rcx+16], xmm1
  001e5	0f 10 48 30	 movups	 xmm1, XMMWORD PTR [rax+48]
  001e9	0f 11 41 20	 movups	 XMMWORD PTR [rcx+32], xmm0
  001ed	0f 10 40 40	 movups	 xmm0, XMMWORD PTR [rax+64]
  001f1	0f 11 49 30	 movups	 XMMWORD PTR [rcx+48], xmm1
  001f5	0f 10 48 50	 movups	 xmm1, XMMWORD PTR [rax+80]
  001f9	48 8b 40 60	 mov	 rax, QWORD PTR [rax+96]
  001fd	0f 11 41 40	 movups	 XMMWORD PTR [rcx+64], xmm0
  00201	0f 11 49 50	 movups	 XMMWORD PTR [rcx+80], xmm1
  00205	48 89 41 60	 mov	 QWORD PTR [rcx+96], rax

; 916  :         return (zipFile)zi;

  00209	48 8b c7	 mov	 rax, rdi
$LN10@zipOpen3:

; 917  :     }
; 918  : }

  0020c	4c 8d 9c 24 90
	01 01 00	 lea	 r11, QWORD PTR [rsp+65936]
  00214	49 8b 5b 10	 mov	 rbx, QWORD PTR [r11+16]
  00218	49 8b 73 18	 mov	 rsi, QWORD PTR [r11+24]
  0021c	49 8b 7b 20	 mov	 rdi, QWORD PTR [r11+32]
  00220	4d 8b 73 28	 mov	 r14, QWORD PTR [r11+40]
  00224	49 8b e3	 mov	 rsp, r11
  00227	5d		 pop	 rbp
  00228	c3		 ret	 0
zipOpen3 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpen2
_TEXT	SEGMENT
zlib_filefunc64_32_def_fill$1 = 32
pathname$ = 144
append$ = 152
globalcomment$ = 160
pzlib_filefunc32_def$ = 168
zipOpen2 PROC						; COMDAT

; 921  : {

$LN7:
  00000	40 53		 push	 rbx
  00002	48 81 ec 80 00
	00 00		 sub	 rsp, 128		; 00000080H
  00009	4d 8b d0	 mov	 r10, r8
  0000c	44 8b da	 mov	 r11d, edx
  0000f	48 8b d9	 mov	 rbx, rcx

; 922  :     if (pzlib_filefunc32_def != NULL)

  00012	4d 85 c9	 test	 r9, r9
  00015	74 29		 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);

  00017	49 8b d1	 mov	 rdx, r9
  0001a	48 8d 4c 24 20	 lea	 rcx, QWORD PTR zlib_filefunc64_32_def_fill$1[rsp]
  0001f	e8 00 00 00 00	 call	 fill_zlib_filefunc64_32_def_from_filefunc32

; 926  :         return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);

  00024	4d 8b c2	 mov	 r8, r10
  00027	4c 8d 4c 24 20	 lea	 r9, QWORD PTR zlib_filefunc64_32_def_fill$1[rsp]
  0002c	41 8b d3	 mov	 edx, r11d
  0002f	48 8b cb	 mov	 rcx, rbx

; 927  :     }
; 928  :     else
; 929  :         return zipOpen3(pathname, append, globalcomment, NULL);

  00032	e8 00 00 00 00	 call	 zipOpen3

; 930  : }

  00037	48 81 c4 80 00
	00 00		 add	 rsp, 128		; 00000080H
  0003e	5b		 pop	 rbx
  0003f	c3		 ret	 0
$LN2@zipOpen2:

; 927  :     }
; 928  :     else
; 929  :         return zipOpen3(pathname, append, globalcomment, NULL);

  00040	e8 00 00 00 00	 call	 zipOpen3

; 930  : }

  00045	48 81 c4 80 00
	00 00		 add	 rsp, 128		; 00000080H
  0004c	5b		 pop	 rbx
  0004d	c3		 ret	 0
zipOpen2 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpen2_64
_TEXT	SEGMENT
zlib_filefunc64_32_def_fill$1 = 32
pathname$ = 144
append$ = 152
globalcomment$ = 160
pzlib_filefunc_def$ = 168
zipOpen2_64 PROC					; COMDAT

; 933  : {

$LN7:
  00000	48 81 ec 88 00
	00 00		 sub	 rsp, 136		; 00000088H

; 934  :     if (pzlib_filefunc_def != NULL)

  00007	4d 85 c9	 test	 r9, r9
  0000a	74 45		 je	 SHORT $LN2@zipOpen2_6

; 935  :     {
; 936  :         zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
; 937  :         zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;

  0000c	41 0f 10 01	 movups	 xmm0, XMMWORD PTR [r9]

; 938  :         zlib_filefunc64_32_def_fill.ztell32_file = NULL;

  00010	33 c0		 xor	 eax, eax
  00012	41 0f 10 49 10	 movups	 xmm1, XMMWORD PTR [r9+16]
  00017	48 89 44 24 68	 mov	 QWORD PTR zlib_filefunc64_32_def_fill$1[rsp+72], rax
  0001c	0f 29 44 24 20	 movaps	 XMMWORD PTR zlib_filefunc64_32_def_fill$1[rsp], xmm0
  00021	41 0f 10 41 20	 movups	 xmm0, XMMWORD PTR [r9+32]

; 939  :         zlib_filefunc64_32_def_fill.zseek32_file = NULL;

  00026	48 89 44 24 70	 mov	 QWORD PTR zlib_filefunc64_32_def_fill$1[rsp+80], rax
  0002b	0f 29 4c 24 30	 movaps	 XMMWORD PTR zlib_filefunc64_32_def_fill$1[rsp+16], xmm1
  00030	41 0f 10 49 30	 movups	 xmm1, XMMWORD PTR [r9+48]

; 940  :         return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);

  00035	4c 8d 4c 24 20	 lea	 r9, QWORD PTR zlib_filefunc64_32_def_fill$1[rsp]
  0003a	0f 29 44 24 40	 movaps	 XMMWORD PTR zlib_filefunc64_32_def_fill$1[rsp+32], xmm0
  0003f	0f 29 4c 24 50	 movaps	 XMMWORD PTR zlib_filefunc64_32_def_fill$1[rsp+48], xmm1

; 941  :     }
; 942  :     else
; 943  :         return zipOpen3(pathname, append, globalcomment, NULL);

  00044	e8 00 00 00 00	 call	 zipOpen3

; 944  : }

  00049	48 81 c4 88 00
	00 00		 add	 rsp, 136		; 00000088H
  00050	c3		 ret	 0
$LN2@zipOpen2_6:

; 941  :     }
; 942  :     else
; 943  :         return zipOpen3(pathname, append, globalcomment, NULL);

  00051	e8 00 00 00 00	 call	 zipOpen3

; 944  : }

  00056	48 81 c4 88 00
	00 00		 add	 rsp, 136		; 00000088H
  0005d	c3		 ret	 0
zipOpen2_64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpen
_TEXT	SEGMENT
pathname$ = 8
append$ = 16
zipOpen	PROC						; COMDAT

; 950  :     return zipOpen3((const void*)pathname,append,NULL,NULL);

  00000	45 33 c9	 xor	 r9d, r9d
  00003	45 33 c0	 xor	 r8d, r8d
  00006	e9 00 00 00 00	 jmp	 zipOpen3
zipOpen	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpen64
_TEXT	SEGMENT
pathname$ = 8
append$ = 16
zipOpen64 PROC						; COMDAT

; 955  :     return zipOpen3(pathname,append,NULL,NULL);

  00000	45 33 c9	 xor	 r9d, r9d
  00003	45 33 c0	 xor	 r8d, r8d
  00006	e9 00 00 00 00	 jmp	 zipOpen3
zipOpen64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT Write_LocalFileHeader
_TEXT	SEGMENT
zi$ = 64
filename$ = 72
size_extrafield_local$ = 80
extrafield_local$ = 88
Write_LocalFileHeader PROC				; COMDAT

; 959  : {

$LN36:
  00000	48 89 5c 24 10	 mov	 QWORD PTR [rsp+16], rbx
  00005	48 89 74 24 18	 mov	 QWORD PTR [rsp+24], rsi
  0000a	57		 push	 rdi
  0000b	41 56		 push	 r14
  0000d	41 57		 push	 r15
  0000f	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  00013	4d 8b f9	 mov	 r15, r9
  00016	45 8b f0	 mov	 r14d, r8d
  00019	48 8b f2	 mov	 rsi, rdx
  0001c	48 8b d9	 mov	 rbx, rcx

; 960  :   /* write the local header */
; 961  :   int err;
; 962  :   uInt size_filename = (uInt)strlen(filename);

  0001f	48 83 cf ff	 or	 rdi, -1
$LL26@Write_Loca:
  00023	48 ff c7	 inc	 rdi
  00026	80 3c 3a 00	 cmp	 BYTE PTR [rdx+rdi], 0
  0002a	75 f7		 jne	 SHORT $LL26@Write_Loca

; 963  :   uInt size_extrafield = size_extrafield_local;
; 964  : 
; 965  :   err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4);

  0002c	48 8b 51 58	 mov	 rdx, QWORD PTR [rcx+88]
  00030	41 b9 04 00 00
	00		 mov	 r9d, 4
  00036	41 b8 50 4b 03
	04		 mov	 r8d, 67324752		; 04034b50H
  0003c	48 89 6c 24 40	 mov	 QWORD PTR [rsp+64], rbp
  00041	e8 00 00 00 00	 call	 zip64local_putValue

; 966  : 
; 967  :   if (err==ZIP_OK)

  00046	85 c0		 test	 eax, eax
  00048	0f 85 ea 01 00
	00		 jne	 $LN29@Write_Loca

; 968  :   {
; 969  :     if(zi->ci.zip64)
; 970  :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */

  0004e	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  00052	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00056	44 8d 40 2d	 lea	 r8d, QWORD PTR [rax+45]
  0005a	48 8b cb	 mov	 rcx, rbx
  0005d	39 83 0c 01 01
	00		 cmp	 DWORD PTR [rbx+65804], eax
  00063	75 04		 jne	 SHORT $LN31@Write_Loca

; 971  :     else
; 972  :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */

  00065	44 8d 40 14	 lea	 r8d, QWORD PTR [rax+20]
$LN31@Write_Loca:
  00069	e8 00 00 00 00	 call	 zip64local_putValue

; 973  :   }
; 974  : 
; 975  :   if (err==ZIP_OK)

  0006e	85 c0		 test	 eax, eax
  00070	0f 85 c2 01 00
	00		 jne	 $LN29@Write_Loca

; 976  :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);

  00076	44 8b 83 f4 00
	00 00		 mov	 r8d, DWORD PTR [rbx+244]
  0007d	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  00081	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00085	48 8b cb	 mov	 rcx, rbx
  00088	e8 00 00 00 00	 call	 zip64local_putValue

; 977  : 
; 978  :   if (err==ZIP_OK)

  0008d	85 c0		 test	 eax, eax
  0008f	0f 85 a3 01 00
	00		 jne	 $LN29@Write_Loca

; 979  :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);

  00095	44 8b 83 f8 00
	00 00		 mov	 r8d, DWORD PTR [rbx+248]
  0009c	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  000a0	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000a4	48 8b cb	 mov	 rcx, rbx
  000a7	e8 00 00 00 00	 call	 zip64local_putValue

; 980  : 
; 981  :   if (err==ZIP_OK)

  000ac	85 c0		 test	 eax, eax
  000ae	0f 85 84 01 00
	00		 jne	 $LN29@Write_Loca

; 982  :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);

  000b4	44 8b 83 00 01
	01 00		 mov	 r8d, DWORD PTR [rbx+65792]
  000bb	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  000bf	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000c3	48 8b cb	 mov	 rcx, rbx
  000c6	e8 00 00 00 00	 call	 zip64local_putValue

; 983  : 
; 984  :   // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
; 985  :   if (err==ZIP_OK)

  000cb	85 c0		 test	 eax, eax
  000cd	0f 85 65 01 00
	00		 jne	 $LN29@Write_Loca

; 986  :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */

  000d3	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000d7	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  000db	45 33 c0	 xor	 r8d, r8d
  000de	48 8b cb	 mov	 rcx, rbx
  000e1	e8 00 00 00 00	 call	 zip64local_putValue

; 987  :   if (err==ZIP_OK)

  000e6	85 c0		 test	 eax, eax
  000e8	0f 85 4a 01 00
	00		 jne	 $LN29@Write_Loca

; 988  :   {
; 989  :     if(zi->ci.zip64)
; 990  :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */

  000ee	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  000f2	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000f6	bd ff ff ff ff	 mov	 ebp, -1			; ffffffffH
  000fb	48 8b cb	 mov	 rcx, rbx
  000fe	39 83 0c 01 01
	00		 cmp	 DWORD PTR [rbx+65804], eax
  00104	74 05		 je	 SHORT $LN10@Write_Loca
  00106	44 8b c5	 mov	 r8d, ebp
  00109	eb 03		 jmp	 SHORT $LN32@Write_Loca
$LN10@Write_Loca:

; 991  :     else
; 992  :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */

  0010b	45 33 c0	 xor	 r8d, r8d
$LN32@Write_Loca:
  0010e	e8 00 00 00 00	 call	 zip64local_putValue

; 993  :   }
; 994  :   if (err==ZIP_OK)

  00113	85 c0		 test	 eax, eax
  00115	0f 85 1d 01 00
	00		 jne	 $LN29@Write_Loca

; 995  :   {
; 996  :     if(zi->ci.zip64)
; 997  :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */

  0011b	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  0011f	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00123	48 8b cb	 mov	 rcx, rbx
  00126	39 83 0c 01 01
	00		 cmp	 DWORD PTR [rbx+65804], eax
  0012c	74 05		 je	 SHORT $LN13@Write_Loca
  0012e	4c 8b c5	 mov	 r8, rbp
  00131	eb 03		 jmp	 SHORT $LN33@Write_Loca
$LN13@Write_Loca:

; 998  :     else
; 999  :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */

  00133	45 33 c0	 xor	 r8d, r8d
$LN33@Write_Loca:
  00136	e8 00 00 00 00	 call	 zip64local_putValue

; 1000 :   }
; 1001 : 
; 1002 :   if (err==ZIP_OK)

  0013b	85 c0		 test	 eax, eax
  0013d	0f 85 f5 00 00
	00		 jne	 $LN29@Write_Loca

; 1003 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);

  00143	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00147	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  0014b	44 8b c7	 mov	 r8d, edi
  0014e	48 8b cb	 mov	 rcx, rbx
  00151	e8 00 00 00 00	 call	 zip64local_putValue

; 1004 : 
; 1005 :   if(zi->ci.zip64)
; 1006 :   {
; 1007 :     size_extrafield += 20;
; 1008 :   }
; 1009 : 
; 1010 :   if (err==ZIP_OK)

  00156	85 c0		 test	 eax, eax
  00158	0f 85 da 00 00
	00		 jne	 $LN29@Write_Loca

; 1011 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2);

  0015e	39 83 0c 01 01
	00		 cmp	 DWORD PTR [rbx+65804], eax
  00164	45 8d 46 14	 lea	 r8d, DWORD PTR [r14+20]
  00168	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0016c	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  00170	45 0f 44 c6	 cmove	 r8d, r14d
  00174	48 8b cb	 mov	 rcx, rbx
  00177	e8 00 00 00 00	 call	 zip64local_putValue
  0017c	8b e8		 mov	 ebp, eax

; 1012 : 
; 1013 :   if ((err==ZIP_OK) && (size_filename > 0))

  0017e	85 c0		 test	 eax, eax
  00180	0f 85 b2 00 00
	00		 jne	 $LN29@Write_Loca
  00186	85 ff		 test	 edi, edi
  00188	74 1d		 je	 SHORT $LN24@Write_Loca

; 1014 :   {
; 1015 :     if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)

  0018a	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0018e	44 8b cf	 mov	 r9d, edi
  00191	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  00195	4c 8b c6	 mov	 r8, rsi
  00198	ff 53 10	 call	 QWORD PTR [rbx+16]
  0019b	3b c7		 cmp	 eax, edi
  0019d	74 08		 je	 SHORT $LN24@Write_Loca
$LN34@Write_Loca:

; 1042 :   }
; 1043 : 
; 1044 :   return err;

  0019f	83 c8 ff	 or	 eax, -1

; 1016 :       err = ZIP_ERRNO;
; 1017 :   }
; 1018 : 
; 1019 :   if ((err==ZIP_OK) && (size_extrafield_local > 0))

  001a2	e9 91 00 00 00	 jmp	 $LN29@Write_Loca
$LN24@Write_Loca:
  001a7	45 85 f6	 test	 r14d, r14d
  001aa	74 16		 je	 SHORT $LN25@Write_Loca

; 1020 :   {
; 1021 :     if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)

  001ac	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001b0	45 8b ce	 mov	 r9d, r14d
  001b3	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  001b7	4d 8b c7	 mov	 r8, r15
  001ba	ff 53 10	 call	 QWORD PTR [rbx+16]
  001bd	41 3b c6	 cmp	 eax, r14d
  001c0	75 dd		 jne	 SHORT $LN34@Write_Loca
$LN25@Write_Loca:

; 1022 :       err = ZIP_ERRNO;
; 1023 :   }
; 1024 : 
; 1025 : 
; 1026 :   if ((err==ZIP_OK) && (zi->ci.zip64))

  001c2	83 bb 0c 01 01
	00 00		 cmp	 DWORD PTR [rbx+65804], 0
  001c9	74 6b		 je	 SHORT $LN27@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);

  001cb	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001cf	48 8b cb	 mov	 rcx, rbx
  001d2	e8 00 00 00 00	 call	 call_ztell64

; 1036 : 
; 1037 :       err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2);

  001d7	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001db	41 b9 02 00 00
	00		 mov	 r9d, 2
  001e1	48 8b cb	 mov	 rcx, rbx
  001e4	48 89 83 10 01
	01 00		 mov	 QWORD PTR [rbx+65808], rax
  001eb	45 8d 41 ff	 lea	 r8d, QWORD PTR [r9-1]
  001ef	e8 00 00 00 00	 call	 zip64local_putValue

; 1038 :       err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2);

  001f4	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  001f8	41 b9 02 00 00
	00		 mov	 r9d, 2
  001fe	48 8b cb	 mov	 rcx, rbx
  00201	45 8d 41 0e	 lea	 r8d, QWORD PTR [r9+14]
  00205	e8 00 00 00 00	 call	 zip64local_putValue

; 1039 : 
; 1040 :       err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);

  0020a	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0020e	41 b9 08 00 00
	00		 mov	 r9d, 8
  00214	45 33 c0	 xor	 r8d, r8d
  00217	48 8b cb	 mov	 rcx, rbx
  0021a	e8 00 00 00 00	 call	 zip64local_putValue

; 1041 :       err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);

  0021f	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00223	41 b9 08 00 00
	00		 mov	 r9d, 8
  00229	45 33 c0	 xor	 r8d, r8d
  0022c	48 8b cb	 mov	 rcx, rbx
  0022f	e8 00 00 00 00	 call	 zip64local_putValue
  00234	eb 02		 jmp	 SHORT $LN29@Write_Loca
$LN27@Write_Loca:

; 1042 :   }
; 1043 : 
; 1044 :   return err;

  00236	8b c5		 mov	 eax, ebp
$LN29@Write_Loca:
  00238	48 8b 6c 24 40	 mov	 rbp, QWORD PTR [rsp+64]

; 1045 : }

  0023d	48 8b 5c 24 48	 mov	 rbx, QWORD PTR [rsp+72]
  00242	48 8b 74 24 50	 mov	 rsi, QWORD PTR [rsp+80]
  00247	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0024b	41 5f		 pop	 r15
  0024d	41 5e		 pop	 r14
  0024f	5f		 pop	 rdi
  00250	c3		 ret	 0
Write_LocalFileHeader ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpenNewFileInZip4_64
_TEXT	SEGMENT
bufHead$1 = 64
file$ = 128
filename$ = 136
zipfi$ = 144
extrafield_local$ = 152
size_extrafield_local$ = 160
extrafield_global$ = 168
size_extrafield_global$ = 176
comment$ = 184
method$ = 192
level$ = 200
raw$ = 208
windowBits$ = 216
memLevel$ = 224
strategy$ = 232
password$ = 240
crcForCrypting$ = 248
versionMadeBy$ = 256
flagBase$ = 264
zip64$ = 272
zipOpenNewFileInZip4_64 PROC				; COMDAT

; 1062 : {

$LN72:
  00000	4c 89 4c 24 20	 mov	 QWORD PTR [rsp+32], r9
  00005	53		 push	 rbx
  00006	57		 push	 rdi
  00007	41 57		 push	 r15
  00009	48 83 ec 60	 sub	 rsp, 96			; 00000060H
  0000d	4d 8b f8	 mov	 r15, r8
  00010	48 8b fa	 mov	 rdi, rdx
  00013	48 8b d9	 mov	 rbx, rcx

; 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)

  00016	48 85 c9	 test	 rcx, rcx
  00019	75 0c		 jne	 SHORT $LN11@zipOpenNew

; 1076 :         return ZIP_PARAMERROR;

  0001b	8d 41 9a	 lea	 eax, QWORD PTR [rcx-102]

; 1263 : }

  0001e	48 83 c4 60	 add	 rsp, 96			; 00000060H
  00022	41 5f		 pop	 r15
  00024	5f		 pop	 rdi
  00025	5b		 pop	 rbx
  00026	c3		 ret	 0
$LN11@zipOpenNew:
  00027	4c 89 a4 24 90
	00 00 00	 mov	 QWORD PTR [rsp+144], r12
  0002f	44 8b a4 24 c0
	00 00 00	 mov	 r12d, DWORD PTR method$[rsp]
  00037	41 f7 c4 f7 ff
	ff ff		 test	 r12d, -9		; fffffff7H
  0003e	74 16		 je	 SHORT $LN12@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))
; 1083 :       return ZIP_PARAMERROR;

  00040	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH
  00045	4c 8b a4 24 90
	00 00 00	 mov	 r12, QWORD PTR [rsp+144]

; 1263 : }

  0004d	48 83 c4 60	 add	 rsp, 96			; 00000060H
  00051	41 5f		 pop	 r15
  00053	5f		 pop	 rdi
  00054	5b		 pop	 rbx
  00055	c3		 ret	 0
$LN12@zipOpenNew:

; 1084 : #endif
; 1085 : 
; 1086 :     zi = (zip64_internal*)file;
; 1087 : 
; 1088 :     if (zi->in_opened_file_inzip == 1)

  00056	83 79 70 01	 cmp	 DWORD PTR [rcx+112], 1
  0005a	75 0d		 jne	 SHORT $LN14@zipOpenNew

; 1089 :     {
; 1090 :         err = zipCloseFileInZip (file);

  0005c	e8 00 00 00 00	 call	 zipCloseFileInZip

; 1091 :         if (err != ZIP_OK)

  00061	85 c0		 test	 eax, eax
  00063	0f 85 08 05 00
	00		 jne	 $LN63@zipOpenNew
$LN14@zipOpenNew:
  00069	48 89 ac 24 80
	00 00 00	 mov	 QWORD PTR [rsp+128], rbp
  00071	48 85 ff	 test	 rdi, rdi
  00074	48 89 b4 24 88
	00 00 00	 mov	 QWORD PTR [rsp+136], rsi
  0007c	4c 89 6c 24 58	 mov	 QWORD PTR [rsp+88], r13
  00081	4c 89 74 24 50	 mov	 QWORD PTR [rsp+80], r14
  00086	4c 8d 35 00 00
	00 00		 lea	 r14, OFFSET FLAT:??_C@_01JOAMLHOP@?9?$AA@
  0008d	4c 0f 45 f7	 cmovne	 r14, rdi

; 1092 :             return err;
; 1093 :     }
; 1094 : 
; 1095 :     if (filename==NULL)
; 1096 :         filename="-";
; 1097 : 
; 1098 :     if (comment==NULL)

  00091	48 8b bc 24 b8
	00 00 00	 mov	 rdi, QWORD PTR comment$[rsp]
  00099	45 33 c9	 xor	 r9d, r9d
  0009c	48 85 ff	 test	 rdi, rdi
  0009f	75 05		 jne	 SHORT $LN16@zipOpenNew

; 1099 :         size_comment = 0;

  000a1	41 8b f1	 mov	 esi, r9d
  000a4	eb 13		 jmp	 SHORT $LN17@zipOpenNew
$LN16@zipOpenNew:

; 1100 :     else
; 1101 :         size_comment = (uInt)strlen(comment);

  000a6	48 83 ce ff	 or	 rsi, -1
  000aa	66 0f 1f 44 00
	00		 npad	 6
$LL61@zipOpenNew:
  000b0	48 ff c6	 inc	 rsi
  000b3	44 38 0c 37	 cmp	 BYTE PTR [rdi+rsi], r9b
  000b7	75 f7		 jne	 SHORT $LL61@zipOpenNew
$LN17@zipOpenNew:

; 1102 : 
; 1103 :     size_filename = (uInt)strlen(filename);

  000b9	48 83 cd ff	 or	 rbp, -1
  000bd	0f 1f 00	 npad	 3
$LL60@zipOpenNew:
  000c0	48 ff c5	 inc	 rbp
  000c3	45 38 0c 2e	 cmp	 BYTE PTR [r14+rbp], r9b
  000c7	75 f7		 jne	 SHORT $LL60@zipOpenNew

; 1104 : 
; 1105 :     if (zipfi == NULL)

  000c9	4d 85 ff	 test	 r15, r15
  000cc	75 09		 jne	 SHORT $LN18@zipOpenNew

; 1106 :         zi->ci.dosDate = 0;

  000ce	44 89 8b 00 01
	01 00		 mov	 DWORD PTR [rbx+65792], r9d
  000d5	eb 16		 jmp	 SHORT $LN21@zipOpenNew
$LN18@zipOpenNew:

; 1107 :     else
; 1108 :     {
; 1109 :         if (zipfi->dosDate != 0)

  000d7	41 8b 47 18	 mov	 eax, DWORD PTR [r15+24]
  000db	85 c0		 test	 eax, eax
  000dd	75 08		 jne	 SHORT $LN68@zipOpenNew

; 1110 :             zi->ci.dosDate = zipfi->dosDate;
; 1111 :         else
; 1112 :           zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);

  000df	49 8b cf	 mov	 rcx, r15
  000e2	e8 00 00 00 00	 call	 zip64local_TmzDateToDosDate
$LN68@zipOpenNew:
  000e7	89 83 00 01 01
	00		 mov	 DWORD PTR [rbx+65792], eax
$LN21@zipOpenNew:
  000ed	44 8b ac 24 c8
	00 00 00	 mov	 r13d, DWORD PTR level$[rsp]

; 1113 :     }
; 1114 : 
; 1115 :     zi->ci.flag = flagBase;

  000f5	8b 8c 24 08 01
	00 00		 mov	 ecx, DWORD PTR flagBase$[rsp]
  000fc	89 8b f4 00 00
	00		 mov	 DWORD PTR [rbx+244], ecx
  00102	41 8d 45 f8	 lea	 eax, DWORD PTR [r13-8]
  00106	83 f8 01	 cmp	 eax, 1
  00109	77 09		 ja	 SHORT $LN22@zipOpenNew

; 1116 :     if ((level==8) || (level==9))
; 1117 :       zi->ci.flag |= 2;

  0010b	83 c9 02	 or	 ecx, 2
  0010e	89 8b f4 00 00
	00		 mov	 DWORD PTR [rbx+244], ecx
$LN22@zipOpenNew:

; 1118 :     if (level==2)

  00114	41 83 fd 02	 cmp	 r13d, 2
  00118	75 09		 jne	 SHORT $LN24@zipOpenNew

; 1119 :       zi->ci.flag |= 4;

  0011a	83 8b f4 00 00
	00 04		 or	 DWORD PTR [rbx+244], 4

; 1120 :     if (level==1)

  00121	eb 0d		 jmp	 SHORT $LN25@zipOpenNew
$LN24@zipOpenNew:
  00123	41 83 fd 01	 cmp	 r13d, 1
  00127	75 07		 jne	 SHORT $LN25@zipOpenNew

; 1121 :       zi->ci.flag |= 6;

  00129	83 8b f4 00 00
	00 06		 or	 DWORD PTR [rbx+244], 6
$LN25@zipOpenNew:

; 1122 :     if (password != NULL)

  00130	4c 39 8c 24 f0
	00 00 00	 cmp	 QWORD PTR password$[rsp], r9
  00138	74 07		 je	 SHORT $LN26@zipOpenNew

; 1123 :       zi->ci.flag |= 1;

  0013a	83 8b f4 00 00
	00 01		 or	 DWORD PTR [rbx+244], 1
$LN26@zipOpenNew:

; 1124 : 
; 1125 :     zi->ci.crc32 = 0;
; 1126 :     zi->ci.method = method;
; 1127 :     zi->ci.encrypt = 0;
; 1128 :     zi->ci.stream_initialised = 0;
; 1129 :     zi->ci.pos_in_buffered_data = 0;
; 1130 :     zi->ci.raw = raw;

  00141	8b 84 24 d0 00
	00 00		 mov	 eax, DWORD PTR raw$[rsp]

; 1131 :     zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);

  00148	48 8b cb	 mov	 rcx, rbx
  0014b	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0014f	89 83 fc 00 00
	00		 mov	 DWORD PTR [rbx+252], eax
  00155	4c 89 8b 04 01
	01 00		 mov	 QWORD PTR [rbx+65796], r9
  0015c	44 89 a3 f8 00
	00 00		 mov	 DWORD PTR [rbx+248], r12d
  00163	4c 89 8b d0 00
	00 00		 mov	 QWORD PTR [rbx+208], r9
  0016a	e8 00 00 00 00	 call	 call_ztell64

; 1132 : 
; 1133 :     zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;

  0016f	44 8b a4 24 b0
	00 00 00	 mov	 r12d, DWORD PTR size_extrafield_global$[rsp]
  00177	48 89 83 d8 00
	00 00		 mov	 QWORD PTR [rbx+216], rax
  0017e	8d 46 2e	 lea	 eax, DWORD PTR [rsi+46]
  00181	03 c5		 add	 eax, ebp

; 1134 :     zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data

  00183	c7 83 f0 00 00
	00 20 00 00 00	 mov	 DWORD PTR [rbx+240], 32	; 00000020H
  0018d	41 03 c4	 add	 eax, r12d
  00190	89 83 ec 00 00
	00		 mov	 DWORD PTR [rbx+236], eax

; 1135 : 
; 1136 :     zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);

  00196	8d 48 20	 lea	 ecx, DWORD PTR [rax+32]
  00199	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc

; 1137 : 
; 1138 :     zi->ci.size_centralExtra = size_extrafield_global;
; 1139 :     zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);

  0019f	ba 50 4b 01 02	 mov	 edx, 33639248		; 02014b50H
  001a4	44 89 a3 e8 00
	00 00		 mov	 DWORD PTR [rbx+232], r12d
  001ab	48 8b c8	 mov	 rcx, rax
  001ae	48 89 83 e0 00
	00 00		 mov	 QWORD PTR [rbx+224], rax
  001b5	41 b8 04 00 00
	00		 mov	 r8d, 4
  001bb	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1140 :     /* version info */
; 1141 :     zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2);

  001c0	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  001c7	8b 94 24 00 01
	00 00		 mov	 edx, DWORD PTR versionMadeBy$[rsp]
  001ce	49 03 c8	 add	 rcx, r8
  001d1	41 b8 02 00 00
	00		 mov	 r8d, 2
  001d7	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1142 :     zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);

  001dc	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  001e3	41 8d 50 12	 lea	 edx, QWORD PTR [r8+18]
  001e7	48 83 c1 06	 add	 rcx, 6
  001eb	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1143 :     zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);

  001f0	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  001f7	8b 93 f4 00 00
	00		 mov	 edx, DWORD PTR [rbx+244]
  001fd	48 83 c1 08	 add	 rcx, 8
  00201	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1144 :     zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);

  00206	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  0020d	8b 93 f8 00 00
	00		 mov	 edx, DWORD PTR [rbx+248]
  00213	48 83 c1 0a	 add	 rcx, 10
  00217	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1145 :     zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);

  0021c	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00223	41 b8 04 00 00
	00		 mov	 r8d, 4
  00229	8b 93 00 01 01
	00		 mov	 edx, DWORD PTR [rbx+65792]
  0022f	48 83 c1 0c	 add	 rcx, 12
  00233	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1146 :     zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/

  00238	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  0023f	33 d2		 xor	 edx, edx
  00241	48 83 c1 10	 add	 rcx, 16
  00245	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1147 :     zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/

  0024a	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00251	33 d2		 xor	 edx, edx
  00253	48 83 c1 14	 add	 rcx, 20
  00257	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1148 :     zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/

  0025c	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00263	33 d2		 xor	 edx, edx
  00265	48 83 c1 18	 add	 rcx, 24
  00269	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1149 :     zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);

  0026e	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00275	41 b8 02 00 00
	00		 mov	 r8d, 2
  0027b	48 83 c1 1c	 add	 rcx, 28
  0027f	8b d5		 mov	 edx, ebp
  00281	44 8b d5	 mov	 r10d, ebp
  00284	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1150 :     zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);

  00289	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00290	41 8b d4	 mov	 edx, r12d
  00293	48 83 c1 1e	 add	 rcx, 30
  00297	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1151 :     zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);

  0029c	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  002a3	48 83 c1 20	 add	 rcx, 32			; 00000020H
  002a7	8b d6		 mov	 edx, esi
  002a9	44 8b de	 mov	 r11d, esi
  002ac	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1152 :     zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/

  002b1	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  002b8	33 d2		 xor	 edx, edx
  002ba	48 83 c1 22	 add	 rcx, 34			; 00000022H
  002be	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);

  002c3	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  002ca	48 83 c1 24	 add	 rcx, 36			; 00000024H
  002ce	4d 85 ff	 test	 r15, r15
  002d1	75 0b		 jne	 SHORT $LN27@zipOpenNew
  002d3	33 d2		 xor	 edx, edx
  002d5	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1158 : 
; 1159 :     if (zipfi==NULL)
; 1160 :         zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);

  002da	33 d2		 xor	 edx, edx
  002dc	eb 0d		 jmp	 SHORT $LN69@zipOpenNew
$LN27@zipOpenNew:

; 1156 :     else
; 1157 :         zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);

  002de	41 8b 57 1c	 mov	 edx, DWORD PTR [r15+28]
  002e2	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1161 :     else
; 1162 :         zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);

  002e7	41 8b 57 20	 mov	 edx, DWORD PTR [r15+32]
$LN69@zipOpenNew:
  002eb	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  002f2	41 b8 04 00 00
	00		 mov	 r8d, 4
  002f8	48 83 c1 26	 add	 rcx, 38			; 00000026H
  002fc	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1163 : 
; 1164 :     if(zi->ci.pos_local_header >= 0xffffffff)
; 1165 :       zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4);

  00301	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00308	ba ff ff ff ff	 mov	 edx, -1			; ffffffffH
  0030d	48 83 c1 2a	 add	 rcx, 42			; 0000002aH
  00311	48 39 93 d8 00
	00 00		 cmp	 QWORD PTR [rbx+216], rdx
  00318	73 0d		 jae	 SHORT $LN70@zipOpenNew

; 1166 :     else
; 1167 :       zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writing_offset,4);

  0031a	8b 93 d8 00 00
	00		 mov	 edx, DWORD PTR [rbx+216]
  00320	48 2b 93 50 01
	01 00		 sub	 rdx, QWORD PTR [rbx+65872]
$LN70@zipOpenNew:
  00327	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1168 : 
; 1169 :     for (i=0;i<size_filename;i++)

  0032c	85 ed		 test	 ebp, ebp
  0032e	74 2f		 je	 SHORT $LN62@zipOpenNew
  00330	33 ed		 xor	 ebp, ebp
  00332	4d 8b c6	 mov	 r8, r14
  00335	8b d5		 mov	 edx, ebp
  00337	4d 8b ca	 mov	 r9, r10
  0033a	66 0f 1f 44 00
	00		 npad	 6
$LL4@zipOpenNew:

; 1170 :         *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);

  00340	41 0f b6 00	 movzx	 eax, BYTE PTR [r8]
  00344	48 8d 52 01	 lea	 rdx, QWORD PTR [rdx+1]
  00348	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  0034f	4d 8d 40 01	 lea	 r8, QWORD PTR [r8+1]
  00353	88 44 11 2d	 mov	 BYTE PTR [rcx+rdx+45], al
  00357	49 83 e9 01	 sub	 r9, 1
  0035b	75 e3		 jne	 SHORT $LL4@zipOpenNew
  0035d	eb 02		 jmp	 SHORT $LN3@zipOpenNew
$LN62@zipOpenNew:
  0035f	33 ed		 xor	 ebp, ebp
$LN3@zipOpenNew:

; 1171 : 
; 1172 :     for (i=0;i<size_extrafield_global;i++)

  00361	83 bc 24 b0 00
	00 00 00	 cmp	 DWORD PTR size_extrafield_global$[rsp], 0
  00369	76 35		 jbe	 SHORT $LN6@zipOpenNew
  0036b	4c 8b 84 24 a8
	00 00 00	 mov	 r8, QWORD PTR extrafield_global$[rsp]
  00373	48 8b d5	 mov	 rdx, rbp
  00376	4d 8b cc	 mov	 r9, r12
  00379	0f 1f 80 00 00
	00 00		 npad	 7
$LL7@zipOpenNew:

; 1173 :         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =

  00380	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00387	48 8d 52 01	 lea	 rdx, QWORD PTR [rdx+1]
  0038b	41 0f b6 00	 movzx	 eax, BYTE PTR [r8]
  0038f	4d 8d 40 01	 lea	 r8, QWORD PTR [r8+1]
  00393	49 03 ca	 add	 rcx, r10
  00396	88 44 11 2d	 mov	 BYTE PTR [rcx+rdx+45], al
  0039a	49 83 e9 01	 sub	 r9, 1
  0039e	75 e0		 jne	 SHORT $LL7@zipOpenNew
$LN6@zipOpenNew:

; 1174 :               *(((const char*)extrafield_global)+i);
; 1175 : 
; 1176 :     for (i=0;i<size_comment;i++)

  003a0	85 f6		 test	 esi, esi
  003a2	74 2c		 je	 SHORT $LN9@zipOpenNew
  003a4	48 8b d5	 mov	 rdx, rbp
  003a7	66 0f 1f 84 00
	00 00 00 00	 npad	 9
$LL10@zipOpenNew:

; 1177 :         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
; 1178 :               size_extrafield_global+i) = *(comment+i);

  003b0	0f b6 07	 movzx	 eax, BYTE PTR [rdi]
  003b3	4b 8d 0c 14	 lea	 rcx, QWORD PTR [r12+r10]
  003b7	48 03 8b e0 00
	00 00		 add	 rcx, QWORD PTR [rbx+224]
  003be	48 8d 52 01	 lea	 rdx, QWORD PTR [rdx+1]
  003c2	48 8d 7f 01	 lea	 rdi, QWORD PTR [rdi+1]
  003c6	88 44 11 2d	 mov	 BYTE PTR [rcx+rdx+45], al
  003ca	49 83 eb 01	 sub	 r11, 1
  003ce	75 e0		 jne	 SHORT $LL10@zipOpenNew
$LN9@zipOpenNew:

; 1179 :     if (zi->ci.central_header == NULL)

  003d0	48 83 bb e0 00
	00 00 00	 cmp	 QWORD PTR [rbx+224], 0
  003d8	75 0a		 jne	 SHORT $LN33@zipOpenNew

; 1180 :         return ZIP_INTERNALERROR;

  003da	b8 98 ff ff ff	 mov	 eax, -104		; ffffffffffffff98H
  003df	e9 73 01 00 00	 jmp	 $LN67@zipOpenNew
$LN33@zipOpenNew:

; 1181 : 
; 1182 :     zi->ci.zip64 = zip64;

  003e4	8b 84 24 10 01
	00 00		 mov	 eax, DWORD PTR zip64$[rsp]

; 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);

  003eb	49 8b d6	 mov	 rdx, r14
  003ee	4c 8b 8c 24 98
	00 00 00	 mov	 r9, QWORD PTR extrafield_local$[rsp]
  003f6	48 8b cb	 mov	 rcx, rbx
  003f9	44 8b 84 24 a0
	00 00 00	 mov	 r8d, DWORD PTR size_extrafield_local$[rsp]
  00401	89 83 0c 01 01
	00		 mov	 DWORD PTR [rbx+65804], eax
  00407	48 89 ab 18 01
	01 00		 mov	 QWORD PTR [rbx+65816], rbp
  0040e	48 89 ab 20 01
	01 00		 mov	 QWORD PTR [rbx+65824], rbp
  00415	48 89 ab 10 01
	01 00		 mov	 QWORD PTR [rbx+65808], rbp
  0041c	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;

  00421	48 c7 83 80 00
	00 00 00 00 00
	00		 mov	 QWORD PTR [rbx+128], 0

; 1200 :     zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
; 1201 :     zi->ci.stream.next_out = zi->ci.buffered_data;

  0042c	48 8d 8b 00 01
	00 00		 lea	 rcx, QWORD PTR [rbx+256]
  00433	48 89 8b 88 00
	00 00		 mov	 QWORD PTR [rbx+136], rcx
  0043a	8b f0		 mov	 esi, eax
  0043c	48 c7 83 90 00
	00 00 00 00 01
	00		 mov	 QWORD PTR [rbx+144], 65536 ; 00010000H

; 1202 :     zi->ci.stream.total_in = 0;
; 1203 :     zi->ci.stream.total_out = 0;
; 1204 :     zi->ci.stream.data_type = Z_BINARY;

  00447	89 ab c0 00 00
	00		 mov	 DWORD PTR [rbx+192], ebp

; 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))

  0044d	85 c0		 test	 eax, eax
  0044f	0f 85 84 00 00
	00		 jne	 $LN38@zipOpenNew
  00455	83 bb f8 00 00
	00 08		 cmp	 DWORD PTR [rbx+248], 8
  0045c	75 7b		 jne	 SHORT $LN38@zipOpenNew
  0045e	39 83 fc 00 00
	00		 cmp	 DWORD PTR [rbx+252], eax
  00464	75 73		 jne	 SHORT $LN38@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)
; 1219 :               windowBits = -windowBits;
; 1220 : 
; 1221 :           err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);

  00466	8b 84 24 d8 00
	00 00		 mov	 eax, DWORD PTR windowBits$[rsp]
  0046d	48 8d 4b 78	 lea	 rcx, QWORD PTR [rbx+120]
  00471	99		 cdq
  00472	c7 44 24 38 58
	00 00 00	 mov	 DWORD PTR [rsp+56], 88	; 00000058H
  0047a	44 8b c8	 mov	 r9d, eax
  0047d	48 89 ab a8 00
	00 00		 mov	 QWORD PTR [rbx+168], rbp
  00484	44 33 ca	 xor	 r9d, edx
  00487	48 89 ab b0 00
	00 00		 mov	 QWORD PTR [rbx+176], rbp
  0048e	48 8d 05 00 00
	00 00		 lea	 rax, OFFSET FLAT:??_C@_06CJNJFBNP@1?42?411?$AA@
  00495	48 89 ab b8 00
	00 00		 mov	 QWORD PTR [rbx+184], rbp
  0049c	48 89 44 24 30	 mov	 QWORD PTR [rsp+48], rax
  004a1	44 8d 46 08	 lea	 r8d, QWORD PTR [rsi+8]
  004a5	8b 84 24 e8 00
	00 00		 mov	 eax, DWORD PTR strategy$[rsp]
  004ac	44 2b ca	 sub	 r9d, edx
  004af	89 44 24 28	 mov	 DWORD PTR [rsp+40], eax
  004b3	41 f7 d9	 neg	 r9d
  004b6	8b 84 24 e0 00
	00 00		 mov	 eax, DWORD PTR memLevel$[rsp]
  004bd	41 8b d5	 mov	 edx, r13d
  004c0	89 44 24 20	 mov	 DWORD PTR [rsp+32], eax
  004c4	e8 00 00 00 00	 call	 deflateInit2_
  004c9	8b f0		 mov	 esi, eax

; 1222 : 
; 1223 :           if (err==Z_OK)

  004cb	85 c0		 test	 eax, eax
  004cd	75 0a		 jne	 SHORT $LN38@zipOpenNew

; 1224 :               zi->ci.stream_initialised = Z_DEFLATED;

  004cf	c7 83 d0 00 00
	00 08 00 00 00	 mov	 DWORD PTR [rbx+208], 8
$LN38@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;

  004d9	89 ab 40 01 01
	00		 mov	 DWORD PTR [rbx+65856], ebp

; 1244 :     if ((err==Z_OK) && (password != NULL))

  004df	85 f6		 test	 esi, esi
  004e1	75 72		 jne	 SHORT $LN42@zipOpenNew
  004e3	48 8b bc 24 f0
	00 00 00	 mov	 rdi, QWORD PTR password$[rsp]
  004eb	48 85 ff	 test	 rdi, rdi
  004ee	74 5e		 je	 SHORT $LN57@zipOpenNew

; 1245 :     {
; 1246 :         unsigned char bufHead[RAND_HEAD_LEN];
; 1247 :         unsigned int sizeHead;
; 1248 :         zi->ci.encrypt = 1;

  004f0	c7 83 08 01 01
	00 01 00 00 00	 mov	 DWORD PTR [rbx+65800], 1

; 1249 :         zi->ci.pcrc_32_tab = get_crc_table();

  004fa	e8 00 00 00 00	 call	 get_crc_table

; 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);

  004ff	8b 94 24 f8 00
	00 00		 mov	 edx, DWORD PTR crcForCrypting$[rsp]
  00506	4c 8d 8b 28 01
	01 00		 lea	 r9, QWORD PTR [rbx+65832]
  0050d	89 54 24 28	 mov	 DWORD PTR [rsp+40], edx
  00511	48 8b cf	 mov	 rcx, rdi
  00514	48 8d 54 24 40	 lea	 rdx, QWORD PTR bufHead$1[rsp]
  00519	48 89 83 38 01
	01 00		 mov	 QWORD PTR [rbx+65848], rax
  00520	48 89 44 24 20	 mov	 QWORD PTR [rsp+32], rax
  00525	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)

  0052a	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0052e	4c 8d 44 24 40	 lea	 r8, QWORD PTR bufHead$1[rsp]
  00533	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  00537	44 8b c8	 mov	 r9d, eax
  0053a	8b f8		 mov	 edi, eax
  0053c	89 83 40 01 01
	00		 mov	 DWORD PTR [rbx+65856], eax
  00542	ff 53 10	 call	 QWORD PTR [rbx+16]
  00545	3b c7		 cmp	 eax, edi
  00547	74 05		 je	 SHORT $LN57@zipOpenNew

; 1256 :                 err = ZIP_ERRNO;

  00549	83 ce ff	 or	 esi, -1

; 1257 :     }
; 1258 : #    endif
; 1259 : 
; 1260 :     if (err==Z_OK)

  0054c	eb 07		 jmp	 SHORT $LN42@zipOpenNew
$LN57@zipOpenNew:

; 1261 :         zi->in_opened_file_inzip = 1;

  0054e	c7 43 70 01 00
	00 00		 mov	 DWORD PTR [rbx+112], 1
$LN42@zipOpenNew:

; 1262 :     return err;

  00555	8b c6		 mov	 eax, esi
$LN67@zipOpenNew:
  00557	4c 8b 6c 24 58	 mov	 r13, QWORD PTR [rsp+88]
  0055c	48 8b ac 24 80
	00 00 00	 mov	 rbp, QWORD PTR [rsp+128]
  00564	48 8b b4 24 88
	00 00 00	 mov	 rsi, QWORD PTR [rsp+136]
  0056c	4c 8b 74 24 50	 mov	 r14, QWORD PTR [rsp+80]
$LN63@zipOpenNew:
  00571	4c 8b a4 24 90
	00 00 00	 mov	 r12, QWORD PTR [rsp+144]

; 1263 : }

  00579	48 83 c4 60	 add	 rsp, 96			; 00000060H
  0057d	41 5f		 pop	 r15
  0057f	5f		 pop	 rdi
  00580	5b		 pop	 rbx
  00581	c3		 ret	 0
zipOpenNewFileInZip4_64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpenNewFileInZip3
_TEXT	SEGMENT
file$ = 176
filename$ = 184
zipfi$ = 192
extrafield_local$ = 200
size_extrafield_local$ = 208
extrafield_global$ = 216
size_extrafield_global$ = 224
comment$ = 232
method$ = 240
level$ = 248
raw$ = 256
windowBits$ = 264
memLevel$ = 272
strategy$ = 280
password$ = 288
crcForCrypting$ = 296
zipOpenNewFileInZip3 PROC				; COMDAT

; 1287 : {

$LN4:
  00000	4c 8b dc	 mov	 r11, rsp
  00003	48 81 ec a8 00
	00 00		 sub	 rsp, 168		; 000000a8H

; 1288 :     return zipOpenNewFileInZip4_64 (file, filename, zipfi,

  0000a	33 c0		 xor	 eax, eax
  0000c	41 89 43 e8	 mov	 DWORD PTR [r11-24], eax
  00010	41 89 43 e0	 mov	 DWORD PTR [r11-32], eax
  00014	41 89 43 d8	 mov	 DWORD PTR [r11-40], eax
  00018	8b 84 24 28 01
	00 00		 mov	 eax, DWORD PTR crcForCrypting$[rsp]
  0001f	89 44 24 78	 mov	 DWORD PTR [rsp+120], eax
  00023	48 8b 84 24 20
	01 00 00	 mov	 rax, QWORD PTR password$[rsp]
  0002b	49 89 43 c8	 mov	 QWORD PTR [r11-56], rax
  0002f	8b 84 24 18 01
	00 00		 mov	 eax, DWORD PTR strategy$[rsp]
  00036	89 44 24 68	 mov	 DWORD PTR [rsp+104], eax
  0003a	8b 84 24 10 01
	00 00		 mov	 eax, DWORD PTR memLevel$[rsp]
  00041	89 44 24 60	 mov	 DWORD PTR [rsp+96], eax
  00045	8b 84 24 08 01
	00 00		 mov	 eax, DWORD PTR windowBits$[rsp]
  0004c	89 44 24 58	 mov	 DWORD PTR [rsp+88], eax
  00050	8b 84 24 00 01
	00 00		 mov	 eax, DWORD PTR raw$[rsp]
  00057	89 44 24 50	 mov	 DWORD PTR [rsp+80], eax
  0005b	8b 84 24 f8 00
	00 00		 mov	 eax, DWORD PTR level$[rsp]
  00062	89 44 24 48	 mov	 DWORD PTR [rsp+72], eax
  00066	8b 84 24 f0 00
	00 00		 mov	 eax, DWORD PTR method$[rsp]
  0006d	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  00071	48 8b 84 24 e8
	00 00 00	 mov	 rax, QWORD PTR comment$[rsp]
  00079	49 89 43 90	 mov	 QWORD PTR [r11-112], rax
  0007d	8b 84 24 e0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_global$[rsp]
  00084	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  00088	48 8b 84 24 d8
	00 00 00	 mov	 rax, QWORD PTR extrafield_global$[rsp]
  00090	49 89 43 80	 mov	 QWORD PTR [r11-128], rax
  00094	8b 84 24 d0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_local$[rsp]
  0009b	89 44 24 20	 mov	 DWORD PTR [rsp+32], eax
  0009f	e8 00 00 00 00	 call	 zipOpenNewFileInZip4_64

; 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);
; 1294 : }

  000a4	48 81 c4 a8 00
	00 00		 add	 rsp, 168		; 000000a8H
  000ab	c3		 ret	 0
zipOpenNewFileInZip3 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpenNewFileInZip3_64
_TEXT	SEGMENT
file$ = 176
filename$ = 184
zipfi$ = 192
extrafield_local$ = 200
size_extrafield_local$ = 208
extrafield_global$ = 216
size_extrafield_global$ = 224
comment$ = 232
method$ = 240
level$ = 248
raw$ = 256
windowBits$ = 264
memLevel$ = 272
strategy$ = 280
password$ = 288
crcForCrypting$ = 296
zip64$ = 304
zipOpenNewFileInZip3_64 PROC				; COMDAT

; 1302 : {

$LN4:
  00000	4c 8b dc	 mov	 r11, rsp
  00003	48 81 ec a8 00
	00 00		 sub	 rsp, 168		; 000000a8H

; 1303 :     return zipOpenNewFileInZip4_64 (file, filename, zipfi,

  0000a	8b 84 24 30 01
	00 00		 mov	 eax, DWORD PTR zip64$[rsp]
  00011	41 89 43 e8	 mov	 DWORD PTR [r11-24], eax
  00015	33 c0		 xor	 eax, eax
  00017	41 89 43 e0	 mov	 DWORD PTR [r11-32], eax
  0001b	41 89 43 d8	 mov	 DWORD PTR [r11-40], eax
  0001f	8b 84 24 28 01
	00 00		 mov	 eax, DWORD PTR crcForCrypting$[rsp]
  00026	89 44 24 78	 mov	 DWORD PTR [rsp+120], eax
  0002a	48 8b 84 24 20
	01 00 00	 mov	 rax, QWORD PTR password$[rsp]
  00032	49 89 43 c8	 mov	 QWORD PTR [r11-56], rax
  00036	8b 84 24 18 01
	00 00		 mov	 eax, DWORD PTR strategy$[rsp]
  0003d	89 44 24 68	 mov	 DWORD PTR [rsp+104], eax
  00041	8b 84 24 10 01
	00 00		 mov	 eax, DWORD PTR memLevel$[rsp]
  00048	89 44 24 60	 mov	 DWORD PTR [rsp+96], eax
  0004c	8b 84 24 08 01
	00 00		 mov	 eax, DWORD PTR windowBits$[rsp]
  00053	89 44 24 58	 mov	 DWORD PTR [rsp+88], eax
  00057	8b 84 24 00 01
	00 00		 mov	 eax, DWORD PTR raw$[rsp]
  0005e	89 44 24 50	 mov	 DWORD PTR [rsp+80], eax
  00062	8b 84 24 f8 00
	00 00		 mov	 eax, DWORD PTR level$[rsp]
  00069	89 44 24 48	 mov	 DWORD PTR [rsp+72], eax
  0006d	8b 84 24 f0 00
	00 00		 mov	 eax, DWORD PTR method$[rsp]
  00074	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  00078	48 8b 84 24 e8
	00 00 00	 mov	 rax, QWORD PTR comment$[rsp]
  00080	49 89 43 90	 mov	 QWORD PTR [r11-112], rax
  00084	8b 84 24 e0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_global$[rsp]
  0008b	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  0008f	48 8b 84 24 d8
	00 00 00	 mov	 rax, QWORD PTR extrafield_global$[rsp]
  00097	49 89 43 80	 mov	 QWORD PTR [r11-128], rax
  0009b	8b 84 24 d0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_local$[rsp]
  000a2	89 44 24 20	 mov	 DWORD PTR [rsp+32], eax
  000a6	e8 00 00 00 00	 call	 zipOpenNewFileInZip4_64

; 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);
; 1309 : }

  000ab	48 81 c4 a8 00
	00 00		 add	 rsp, 168		; 000000a8H
  000b2	c3		 ret	 0
zipOpenNewFileInZip3_64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpenNewFileInZip2
_TEXT	SEGMENT
file$ = 176
filename$ = 184
zipfi$ = 192
extrafield_local$ = 200
size_extrafield_local$ = 208
extrafield_global$ = 216
size_extrafield_global$ = 224
comment$ = 232
method$ = 240
level$ = 248
raw$ = 256
zipOpenNewFileInZip2 PROC				; COMDAT

; 1315 : {

$LN4:
  00000	4c 8b dc	 mov	 r11, rsp
  00003	48 81 ec a8 00
	00 00		 sub	 rsp, 168		; 000000a8H

; 1316 :     return zipOpenNewFileInZip4_64 (file, filename, zipfi,

  0000a	33 c0		 xor	 eax, eax
  0000c	41 89 43 e8	 mov	 DWORD PTR [r11-24], eax
  00010	41 89 43 e0	 mov	 DWORD PTR [r11-32], eax
  00014	41 89 43 d8	 mov	 DWORD PTR [r11-40], eax
  00018	89 44 24 78	 mov	 DWORD PTR [rsp+120], eax
  0001c	49 89 43 c8	 mov	 QWORD PTR [r11-56], rax
  00020	89 44 24 68	 mov	 DWORD PTR [rsp+104], eax
  00024	8b 84 24 00 01
	00 00		 mov	 eax, DWORD PTR raw$[rsp]
  0002b	c7 44 24 60 08
	00 00 00	 mov	 DWORD PTR [rsp+96], 8
  00033	c7 44 24 58 f1
	ff ff ff	 mov	 DWORD PTR [rsp+88], -15
  0003b	89 44 24 50	 mov	 DWORD PTR [rsp+80], eax
  0003f	8b 84 24 f8 00
	00 00		 mov	 eax, DWORD PTR level$[rsp]
  00046	89 44 24 48	 mov	 DWORD PTR [rsp+72], eax
  0004a	8b 84 24 f0 00
	00 00		 mov	 eax, DWORD PTR method$[rsp]
  00051	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  00055	48 8b 84 24 e8
	00 00 00	 mov	 rax, QWORD PTR comment$[rsp]
  0005d	49 89 43 90	 mov	 QWORD PTR [r11-112], rax
  00061	8b 84 24 e0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_global$[rsp]
  00068	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  0006c	48 8b 84 24 d8
	00 00 00	 mov	 rax, QWORD PTR extrafield_global$[rsp]
  00074	49 89 43 80	 mov	 QWORD PTR [r11-128], rax
  00078	8b 84 24 d0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_local$[rsp]
  0007f	89 44 24 20	 mov	 DWORD PTR [rsp+32], eax
  00083	e8 00 00 00 00	 call	 zipOpenNewFileInZip4_64

; 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);
; 1322 : }

  00088	48 81 c4 a8 00
	00 00		 add	 rsp, 168		; 000000a8H
  0008f	c3		 ret	 0
zipOpenNewFileInZip2 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpenNewFileInZip2_64
_TEXT	SEGMENT
file$ = 176
filename$ = 184
zipfi$ = 192
extrafield_local$ = 200
size_extrafield_local$ = 208
extrafield_global$ = 216
size_extrafield_global$ = 224
comment$ = 232
method$ = 240
level$ = 248
raw$ = 256
zip64$ = 264
zipOpenNewFileInZip2_64 PROC				; COMDAT

; 1328 : {

$LN4:
  00000	4c 8b dc	 mov	 r11, rsp
  00003	48 81 ec a8 00
	00 00		 sub	 rsp, 168		; 000000a8H

; 1329 :     return zipOpenNewFileInZip4_64 (file, filename, zipfi,

  0000a	8b 84 24 08 01
	00 00		 mov	 eax, DWORD PTR zip64$[rsp]
  00011	41 89 43 e8	 mov	 DWORD PTR [r11-24], eax
  00015	33 c0		 xor	 eax, eax
  00017	41 89 43 e0	 mov	 DWORD PTR [r11-32], eax
  0001b	41 89 43 d8	 mov	 DWORD PTR [r11-40], eax
  0001f	89 44 24 78	 mov	 DWORD PTR [rsp+120], eax
  00023	49 89 43 c8	 mov	 QWORD PTR [r11-56], rax
  00027	89 44 24 68	 mov	 DWORD PTR [rsp+104], eax
  0002b	8b 84 24 00 01
	00 00		 mov	 eax, DWORD PTR raw$[rsp]
  00032	c7 44 24 60 08
	00 00 00	 mov	 DWORD PTR [rsp+96], 8
  0003a	c7 44 24 58 f1
	ff ff ff	 mov	 DWORD PTR [rsp+88], -15
  00042	89 44 24 50	 mov	 DWORD PTR [rsp+80], eax
  00046	8b 84 24 f8 00
	00 00		 mov	 eax, DWORD PTR level$[rsp]
  0004d	89 44 24 48	 mov	 DWORD PTR [rsp+72], eax
  00051	8b 84 24 f0 00
	00 00		 mov	 eax, DWORD PTR method$[rsp]
  00058	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  0005c	48 8b 84 24 e8
	00 00 00	 mov	 rax, QWORD PTR comment$[rsp]
  00064	49 89 43 90	 mov	 QWORD PTR [r11-112], rax
  00068	8b 84 24 e0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_global$[rsp]
  0006f	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  00073	48 8b 84 24 d8
	00 00 00	 mov	 rax, QWORD PTR extrafield_global$[rsp]
  0007b	49 89 43 80	 mov	 QWORD PTR [r11-128], rax
  0007f	8b 84 24 d0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_local$[rsp]
  00086	89 44 24 20	 mov	 DWORD PTR [rsp+32], eax
  0008a	e8 00 00 00 00	 call	 zipOpenNewFileInZip4_64

; 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);
; 1335 : }

  0008f	48 81 c4 a8 00
	00 00		 add	 rsp, 168		; 000000a8H
  00096	c3		 ret	 0
zipOpenNewFileInZip2_64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpenNewFileInZip64
_TEXT	SEGMENT
file$ = 176
filename$ = 184
zipfi$ = 192
extrafield_local$ = 200
size_extrafield_local$ = 208
extrafield_global$ = 216
size_extrafield_global$ = 224
comment$ = 232
method$ = 240
level$ = 248
zip64$ = 256
zipOpenNewFileInZip64 PROC				; COMDAT

; 1341 : {

$LN4:
  00000	4c 8b dc	 mov	 r11, rsp
  00003	48 81 ec a8 00
	00 00		 sub	 rsp, 168		; 000000a8H

; 1342 :     return zipOpenNewFileInZip4_64 (file, filename, zipfi,

  0000a	8b 84 24 00 01
	00 00		 mov	 eax, DWORD PTR zip64$[rsp]
  00011	41 89 43 e8	 mov	 DWORD PTR [r11-24], eax
  00015	33 c0		 xor	 eax, eax
  00017	41 89 43 e0	 mov	 DWORD PTR [r11-32], eax
  0001b	41 89 43 d8	 mov	 DWORD PTR [r11-40], eax
  0001f	89 44 24 78	 mov	 DWORD PTR [rsp+120], eax
  00023	49 89 43 c8	 mov	 QWORD PTR [r11-56], rax
  00027	89 44 24 68	 mov	 DWORD PTR [rsp+104], eax
  0002b	c7 44 24 60 08
	00 00 00	 mov	 DWORD PTR [rsp+96], 8
  00033	c7 44 24 58 f1
	ff ff ff	 mov	 DWORD PTR [rsp+88], -15
  0003b	89 44 24 50	 mov	 DWORD PTR [rsp+80], eax
  0003f	8b 84 24 f8 00
	00 00		 mov	 eax, DWORD PTR level$[rsp]
  00046	89 44 24 48	 mov	 DWORD PTR [rsp+72], eax
  0004a	8b 84 24 f0 00
	00 00		 mov	 eax, DWORD PTR method$[rsp]
  00051	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  00055	48 8b 84 24 e8
	00 00 00	 mov	 rax, QWORD PTR comment$[rsp]
  0005d	49 89 43 90	 mov	 QWORD PTR [r11-112], rax
  00061	8b 84 24 e0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_global$[rsp]
  00068	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  0006c	48 8b 84 24 d8
	00 00 00	 mov	 rax, QWORD PTR extrafield_global$[rsp]
  00074	49 89 43 80	 mov	 QWORD PTR [r11-128], rax
  00078	8b 84 24 d0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_local$[rsp]
  0007f	89 44 24 20	 mov	 DWORD PTR [rsp+32], eax
  00083	e8 00 00 00 00	 call	 zipOpenNewFileInZip4_64

; 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);
; 1348 : }

  00088	48 81 c4 a8 00
	00 00		 add	 rsp, 168		; 000000a8H
  0008f	c3		 ret	 0
zipOpenNewFileInZip64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipOpenNewFileInZip
_TEXT	SEGMENT
file$ = 176
filename$ = 184
zipfi$ = 192
extrafield_local$ = 200
size_extrafield_local$ = 208
extrafield_global$ = 216
size_extrafield_global$ = 224
comment$ = 232
method$ = 240
level$ = 248
zipOpenNewFileInZip PROC				; COMDAT

; 1354 : {

$LN4:
  00000	4c 8b dc	 mov	 r11, rsp
  00003	48 81 ec a8 00
	00 00		 sub	 rsp, 168		; 000000a8H

; 1355 :     return zipOpenNewFileInZip4_64 (file, filename, zipfi,

  0000a	33 c0		 xor	 eax, eax
  0000c	41 89 43 e8	 mov	 DWORD PTR [r11-24], eax
  00010	41 89 43 e0	 mov	 DWORD PTR [r11-32], eax
  00014	41 89 43 d8	 mov	 DWORD PTR [r11-40], eax
  00018	89 44 24 78	 mov	 DWORD PTR [rsp+120], eax
  0001c	49 89 43 c8	 mov	 QWORD PTR [r11-56], rax
  00020	89 44 24 68	 mov	 DWORD PTR [rsp+104], eax
  00024	c7 44 24 60 08
	00 00 00	 mov	 DWORD PTR [rsp+96], 8
  0002c	c7 44 24 58 f1
	ff ff ff	 mov	 DWORD PTR [rsp+88], -15
  00034	89 44 24 50	 mov	 DWORD PTR [rsp+80], eax
  00038	8b 84 24 f8 00
	00 00		 mov	 eax, DWORD PTR level$[rsp]
  0003f	89 44 24 48	 mov	 DWORD PTR [rsp+72], eax
  00043	8b 84 24 f0 00
	00 00		 mov	 eax, DWORD PTR method$[rsp]
  0004a	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  0004e	48 8b 84 24 e8
	00 00 00	 mov	 rax, QWORD PTR comment$[rsp]
  00056	49 89 43 90	 mov	 QWORD PTR [r11-112], rax
  0005a	8b 84 24 e0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_global$[rsp]
  00061	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  00065	48 8b 84 24 d8
	00 00 00	 mov	 rax, QWORD PTR extrafield_global$[rsp]
  0006d	49 89 43 80	 mov	 QWORD PTR [r11-128], rax
  00071	8b 84 24 d0 00
	00 00		 mov	 eax, DWORD PTR size_extrafield_local$[rsp]
  00078	89 44 24 20	 mov	 DWORD PTR [rsp+32], eax
  0007c	e8 00 00 00 00	 call	 zipOpenNewFileInZip4_64

; 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);
; 1361 : }

  00081	48 81 c4 a8 00
	00 00		 add	 rsp, 168		; 000000a8H
  00088	c3		 ret	 0
zipOpenNewFileInZip ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zip64FlushWriteBuffer
_TEXT	SEGMENT
zi$ = 48
zip64FlushWriteBuffer PROC				; COMDAT

; 1364 : {

  00000	48 89 5c 24 20	 mov	 QWORD PTR [rsp+32], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 1365 :     int err=ZIP_OK;
; 1366 : 
; 1367 :     if (zi->ci.encrypt != 0)

  0000a	83 b9 08 01 01
	00 00		 cmp	 DWORD PTR [rcx+65800], 0
  00011	48 8b d9	 mov	 rbx, rcx
  00014	74 65		 je	 SHORT $LN3@zip64Flush

; 1368 :     {
; 1369 : #ifndef NOCRYPT
; 1370 :         uInt i;
; 1371 :         int t;
; 1372 :         for (i=0;i<zi->ci.pos_in_buffered_data;i++)

  00016	48 89 6c 24 30	 mov	 QWORD PTR [rsp+48], rbp
  0001b	33 ed		 xor	 ebp, ebp
  0001d	39 a9 d4 00 00
	00		 cmp	 DWORD PTR [rcx+212], ebp
  00023	76 51		 jbe	 SHORT $LN12@zip64Flush
  00025	48 89 74 24 38	 mov	 QWORD PTR [rsp+56], rsi
  0002a	4c 89 74 24 40	 mov	 QWORD PTR [rsp+64], r14
  0002f	90		 npad	 1
$LL4@zip64Flush:

; 1373 :             zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);

  00030	48 8d 8b 28 01
	01 00		 lea	 rcx, QWORD PTR [rbx+65832]
  00037	e8 00 00 00 00	 call	 decrypt_byte
  0003c	48 8b 93 38 01
	01 00		 mov	 rdx, QWORD PTR [rbx+65848]
  00043	48 8d 8b 28 01
	01 00		 lea	 rcx, QWORD PTR [rbx+65832]
  0004a	44 0f b6 84 1d
	00 01 00 00	 movzx	 r8d, BYTE PTR [rbp+rbx+256]
  00053	8b f0		 mov	 esi, eax
  00055	e8 00 00 00 00	 call	 update_keys
  0005a	40 30 b4 1d 00
	01 00 00	 xor	 BYTE PTR [rbp+rbx+256], sil
  00062	ff c5		 inc	 ebp
  00064	3b ab d4 00 00
	00		 cmp	 ebp, DWORD PTR [rbx+212]
  0006a	72 c4		 jb	 SHORT $LL4@zip64Flush
  0006c	4c 8b 74 24 40	 mov	 r14, QWORD PTR [rsp+64]
  00071	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
$LN12@zip64Flush:
  00076	48 8b 6c 24 30	 mov	 rbp, QWORD PTR [rsp+48]
$LN3@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)

  0007b	44 8b 8b d4 00
	00 00		 mov	 r9d, DWORD PTR [rbx+212]
  00082	4c 8d 83 00 01
	00 00		 lea	 r8, QWORD PTR [rbx+256]
  00089	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0008d	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  00091	8b bb d4 00 00
	00		 mov	 edi, DWORD PTR [rbx+212]
  00097	ff 53 10	 call	 QWORD PTR [rbx+16]
  0009a	83 c9 ff	 or	 ecx, -1

; 1378 :       err = ZIP_ERRNO;
; 1379 : 
; 1380 :     zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;
; 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;
; 1393 :       zi->ci.stream.total_in = 0;
; 1394 :     }
; 1395 : 
; 1396 : 
; 1397 :     zi->ci.pos_in_buffered_data = 0;

  0009d	c7 83 d4 00 00
	00 00 00 00 00	 mov	 DWORD PTR [rbx+212], 0
  000a7	33 d2		 xor	 edx, edx
  000a9	3b c7		 cmp	 eax, edi
  000ab	0f 45 d1	 cmovne	 edx, ecx
  000ae	8b 8b 84 00 00
	00		 mov	 ecx, DWORD PTR [rbx+132]
  000b4	48 01 bb 18 01
	01 00		 add	 QWORD PTR [rbx+65816], rdi

; 1398 : 
; 1399 :     return err;

  000bb	8b c2		 mov	 eax, edx
  000bd	48 01 8b 20 01
	01 00		 add	 QWORD PTR [rbx+65824], rcx
  000c4	c7 83 84 00 00
	00 00 00 00 00	 mov	 DWORD PTR [rbx+132], 0

; 1400 : }

  000ce	48 8b 5c 24 48	 mov	 rbx, QWORD PTR [rsp+72]
  000d3	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000d7	5f		 pop	 rdi
  000d8	c3		 ret	 0
zip64FlushWriteBuffer ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipWriteInFileInZip
_TEXT	SEGMENT
file$ = 48
buf$ = 56
len$ = 64
zipWriteInFileInZip PROC				; COMDAT

; 1403 : {

$LN29:
  00000	48 89 5c 24 10	 mov	 QWORD PTR [rsp+16], rbx
  00005	48 89 6c 24 18	 mov	 QWORD PTR [rsp+24], rbp
  0000a	48 89 74 24 20	 mov	 QWORD PTR [rsp+32], rsi
  0000f	57		 push	 rdi
  00010	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 1404 :     zip64_internal* zi;
; 1405 :     int err=ZIP_OK;

  00014	33 f6		 xor	 esi, esi
  00016	41 8b f8	 mov	 edi, r8d
  00019	48 8b ea	 mov	 rbp, rdx
  0001c	48 8b d9	 mov	 rbx, rcx

; 1406 : 
; 1407 :     if (file == NULL)

  0001f	48 85 c9	 test	 rcx, rcx
  00022	75 0a		 jne	 SHORT $LN7@zipWriteIn
$LN27@zipWriteIn:

; 1408 :         return ZIP_PARAMERROR;

  00024	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH
  00029	e9 a1 00 00 00	 jmp	 $LN1@zipWriteIn
$LN7@zipWriteIn:

; 1409 :     zi = (zip64_internal*)file;
; 1410 : 
; 1411 :     if (zi->in_opened_file_inzip == 0)

  0002e	39 71 70	 cmp	 DWORD PTR [rcx+112], esi
  00031	74 f1		 je	 SHORT $LN27@zipWriteIn

; 1412 :         return ZIP_PARAMERROR;
; 1413 : 
; 1414 :     zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len);

  00033	8b 89 04 01 01
	00		 mov	 ecx, DWORD PTR [rcx+65796]
  00039	4c 89 74 24 30	 mov	 QWORD PTR [rsp+48], r14
  0003e	e8 00 00 00 00	 call	 crc32

; 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;

  00043	48 89 6b 78	 mov	 QWORD PTR [rbx+120], rbp

; 1454 :       zi->ci.stream.avail_in = len;

  00047	83 cd ff	 or	 ebp, -1
  0004a	89 83 04 01 01
	00		 mov	 DWORD PTR [rbx+65796], eax
  00050	89 bb 80 00 00
	00		 mov	 DWORD PTR [rbx+128], edi
$LL2@zipWriteIn:

; 1455 : 
; 1456 :       while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))

  00056	83 bb 80 00 00
	00 00		 cmp	 DWORD PTR [rbx+128], 0
  0005d	76 69		 jbe	 SHORT $LN26@zipWriteIn

; 1457 :       {
; 1458 :           if (zi->ci.stream.avail_out == 0)

  0005f	83 bb 90 00 00
	00 00		 cmp	 DWORD PTR [rbx+144], 0
  00066	75 26		 jne	 SHORT $LN9@zipWriteIn

; 1459 :           {
; 1460 :               if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)

  00068	48 8b cb	 mov	 rcx, rbx
  0006b	e8 00 00 00 00	 call	 zip64FlushWriteBuffer
  00070	83 f8 ff	 cmp	 eax, -1

; 1461 :                   err = ZIP_ERRNO;
; 1462 :               zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;

  00073	c7 83 90 00 00
	00 00 00 01 00	 mov	 DWORD PTR [rbx+144], 65536 ; 00010000H

; 1463 :               zi->ci.stream.next_out = zi->ci.buffered_data;

  0007d	48 8d 83 00 01
	00 00		 lea	 rax, QWORD PTR [rbx+256]
  00084	0f 44 f5	 cmove	 esi, ebp
  00087	48 89 83 88 00
	00 00		 mov	 QWORD PTR [rbx+136], rax
$LN9@zipWriteIn:

; 1464 :           }
; 1465 : 
; 1466 : 
; 1467 :           if(err != ZIP_OK)

  0008e	85 f6		 test	 esi, esi
  00090	75 36		 jne	 SHORT $LN26@zipWriteIn

; 1468 :               break;
; 1469 : 
; 1470 :           if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))

  00092	83 bb f8 00 00
	00 08		 cmp	 DWORD PTR [rbx+248], 8
  00099	75 49		 jne	 SHORT $LN12@zipWriteIn
  0009b	39 b3 fc 00 00
	00		 cmp	 DWORD PTR [rbx+252], esi
  000a1	75 41		 jne	 SHORT $LN12@zipWriteIn

; 1471 :           {
; 1472 :               uLong uTotalOutBefore = zi->ci.stream.total_out;

  000a3	8b bb 94 00 00
	00		 mov	 edi, DWORD PTR [rbx+148]

; 1473 :               err=deflate(&zi->ci.stream,  Z_NO_FLUSH);

  000a9	48 8d 4b 78	 lea	 rcx, QWORD PTR [rbx+120]
  000ad	33 d2		 xor	 edx, edx
  000af	e8 00 00 00 00	 call	 deflate

; 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) ;

  000b4	8b 8b 94 00 00
	00		 mov	 ecx, DWORD PTR [rbx+148]
  000ba	8b f0		 mov	 esi, eax
  000bc	2b cf		 sub	 ecx, edi
  000be	01 8b d4 00 00
	00		 add	 DWORD PTR [rbx+212], ecx
  000c4	85 c0		 test	 eax, eax
  000c6	74 8e		 je	 SHORT $LL2@zipWriteIn
$LN26@zipWriteIn:
  000c8	4c 8b 74 24 30	 mov	 r14, QWORD PTR [rsp+48]

; 1501 :               }
; 1502 :           }
; 1503 :       }// while(...)
; 1504 :     }
; 1505 : 
; 1506 :     return err;

  000cd	8b c6		 mov	 eax, esi
$LN1@zipWriteIn:

; 1507 : }

  000cf	48 8b 5c 24 38	 mov	 rbx, QWORD PTR [rsp+56]
  000d4	48 8b 6c 24 40	 mov	 rbp, QWORD PTR [rsp+64]
  000d9	48 8b 74 24 48	 mov	 rsi, QWORD PTR [rsp+72]
  000de	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000e2	5f		 pop	 rdi
  000e3	c3		 ret	 0
$LN12@zipWriteIn:

; 1481 :           }
; 1482 :           else
; 1483 :           {
; 1484 :               uInt copy_this,i;
; 1485 :               if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)

  000e4	44 8b 83 90 00
	00 00		 mov	 r8d, DWORD PTR [rbx+144]
  000eb	8b 83 80 00 00
	00		 mov	 eax, DWORD PTR [rbx+128]
  000f1	41 3b c0	 cmp	 eax, r8d
  000f4	44 0f 42 c0	 cmovb	 r8d, eax

; 1486 :                   copy_this = zi->ci.stream.avail_in;
; 1487 :               else
; 1488 :                   copy_this = zi->ci.stream.avail_out;
; 1489 : 
; 1490 :               for (i = 0; i < copy_this; i++)

  000f8	45 85 c0	 test	 r8d, r8d
  000fb	74 31		 je	 SHORT $LN5@zipWriteIn
  000fd	33 d2		 xor	 edx, edx
  000ff	45 8b c8	 mov	 r9d, r8d
  00102	0f 1f 40 00 66
	66 0f 1f 84 00
	00 00 00 00	 npad	 14
$LL6@zipWriteIn:

; 1491 :                   *(((char*)zi->ci.stream.next_out)+i) =

  00110	48 8b 43 78	 mov	 rax, QWORD PTR [rbx+120]
  00114	48 8d 52 01	 lea	 rdx, QWORD PTR [rdx+1]
  00118	48 8b 8b 88 00
	00 00		 mov	 rcx, QWORD PTR [rbx+136]
  0011f	0f b6 44 02 ff	 movzx	 eax, BYTE PTR [rdx+rax-1]
  00124	88 44 0a ff	 mov	 BYTE PTR [rdx+rcx-1], al
  00128	49 83 e9 01	 sub	 r9, 1
  0012c	75 e2		 jne	 SHORT $LL6@zipWriteIn
$LN5@zipWriteIn:

; 1492 :                       *(((const char*)zi->ci.stream.next_in)+i);
; 1493 :               {
; 1494 :                   zi->ci.stream.avail_in -= copy_this;

  0012e	44 29 83 80 00
	00 00		 sub	 DWORD PTR [rbx+128], r8d

; 1495 :                   zi->ci.stream.avail_out-= copy_this;

  00135	44 29 83 90 00
	00 00		 sub	 DWORD PTR [rbx+144], r8d

; 1496 :                   zi->ci.stream.next_in+= copy_this;
; 1497 :                   zi->ci.stream.next_out+= copy_this;
; 1498 :                   zi->ci.stream.total_in+= copy_this;

  0013c	44 01 83 84 00
	00 00		 add	 DWORD PTR [rbx+132], r8d

; 1499 :                   zi->ci.stream.total_out+= copy_this;

  00143	44 01 83 94 00
	00 00		 add	 DWORD PTR [rbx+148], r8d
  0014a	41 8b c0	 mov	 eax, r8d
  0014d	48 01 43 78	 add	 QWORD PTR [rbx+120], rax
  00151	48 01 83 88 00
	00 00		 add	 QWORD PTR [rbx+136], rax

; 1500 :                   zi->ci.pos_in_buffered_data += copy_this;

  00158	44 01 83 d4 00
	00 00		 add	 DWORD PTR [rbx+212], r8d
  0015f	e9 f2 fe ff ff	 jmp	 $LL2@zipWriteIn
zipWriteInFileInZip ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipCloseFileInZipRaw
_TEXT	SEGMENT
file$ = 8
uncompressed_size$ = 16
crc32$ = 24
zipCloseFileInZipRaw PROC				; COMDAT

; 1511 :     return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);

  00000	8b d2		 mov	 edx, edx
  00002	e9 00 00 00 00	 jmp	 zipCloseFileInZipRaw64
zipCloseFileInZipRaw ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipCloseFileInZipRaw64
_TEXT	SEGMENT
file$ = 80
uncompressed_size$ = 88
crc32$ = 96
zipCloseFileInZipRaw64 PROC				; COMDAT

; 1515 : {

$LN62:
  00000	40 53		 push	 rbx
  00002	55		 push	 rbp
  00003	41 55		 push	 r13
  00005	41 56		 push	 r14
  00007	48 83 ec 28	 sub	 rsp, 40			; 00000028H

; 1516 :     zip64_internal* zi;
; 1517 :     ZPOS64_T compressed_size;
; 1518 :     uLong invalidValue = 0xffffffff;
; 1519 :     short datasize = 0;
; 1520 :     int err=ZIP_OK;

  0000b	45 33 ed	 xor	 r13d, r13d
  0000e	45 8b f0	 mov	 r14d, r8d
  00011	48 8b ea	 mov	 rbp, rdx
  00014	48 8b d9	 mov	 rbx, rcx
  00017	41 8b c5	 mov	 eax, r13d

; 1521 : 
; 1522 :     if (file == NULL)

  0001a	48 85 c9	 test	 rcx, rcx
  0001d	75 10		 jne	 SHORT $LN4@zipCloseFi
$LN60@zipCloseFi:

; 1523 :         return ZIP_PARAMERROR;

  0001f	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1748 : }

  00024	48 83 c4 28	 add	 rsp, 40			; 00000028H
  00028	41 5e		 pop	 r14
  0002a	41 5d		 pop	 r13
  0002c	5d		 pop	 rbp
  0002d	5b		 pop	 rbx
  0002e	c3		 ret	 0
$LN4@zipCloseFi:

; 1524 :     zi = (zip64_internal*)file;
; 1525 : 
; 1526 :     if (zi->in_opened_file_inzip == 0)

  0002f	39 41 70	 cmp	 DWORD PTR [rcx+112], eax
  00032	74 eb		 je	 SHORT $LN60@zipCloseFi

; 1527 :         return ZIP_PARAMERROR;
; 1528 :     zi->ci.stream.avail_in = 0;
; 1529 : 
; 1530 :     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))

  00034	83 b9 f8 00 00
	00 08		 cmp	 DWORD PTR [rcx+248], 8
  0003b	48 89 74 24 50	 mov	 QWORD PTR [rsp+80], rsi
  00040	48 89 7c 24 58	 mov	 QWORD PTR [rsp+88], rdi
  00045	4c 89 64 24 60	 mov	 QWORD PTR [rsp+96], r12
  0004a	4c 89 7c 24 20	 mov	 QWORD PTR [rsp+32], r15
  0004f	44 89 a9 80 00
	00 00		 mov	 DWORD PTR [rcx+128], r13d
  00056	75 57		 jne	 SHORT $LN3@zipCloseFi
  00058	39 81 fc 00 00
	00		 cmp	 DWORD PTR [rcx+252], eax
  0005e	75 4f		 jne	 SHORT $LN3@zipCloseFi
$LL2@zipCloseFi:

; 1531 :                 {
; 1532 :                         while (err==ZIP_OK)
; 1533 :                         {
; 1534 :                                 uLong uTotalOutBefore;
; 1535 :                                 if (zi->ci.stream.avail_out == 0)

  00060	44 39 ab 90 00
	00 00		 cmp	 DWORD PTR [rbx+144], r13d
  00067	75 20		 jne	 SHORT $LN8@zipCloseFi

; 1536 :                                 {
; 1537 :                                         if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)

  00069	48 8b cb	 mov	 rcx, rbx
  0006c	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;

  00071	48 8d 83 00 01
	00 00		 lea	 rax, QWORD PTR [rbx+256]
  00078	c7 83 90 00 00
	00 00 00 01 00	 mov	 DWORD PTR [rbx+144], 65536 ; 00010000H
  00082	48 89 83 88 00
	00 00		 mov	 QWORD PTR [rbx+136], rax
$LN8@zipCloseFi:

; 1541 :                                 }
; 1542 :                                 uTotalOutBefore = zi->ci.stream.total_out;

  00089	8b bb 94 00 00
	00		 mov	 edi, DWORD PTR [rbx+148]

; 1543 :                                 err=deflate(&zi->ci.stream,  Z_FINISH);

  0008f	48 8d 4b 78	 lea	 rcx, QWORD PTR [rbx+120]
  00093	ba 04 00 00 00	 mov	 edx, 4
  00098	e8 00 00 00 00	 call	 deflate

; 1544 :                                 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;

  0009d	8b 8b 94 00 00
	00		 mov	 ecx, DWORD PTR [rbx+148]
  000a3	2b cf		 sub	 ecx, edi
  000a5	01 8b d4 00 00
	00		 add	 DWORD PTR [rbx+212], ecx
  000ab	85 c0		 test	 eax, eax
  000ad	74 b1		 je	 SHORT $LL2@zipCloseFi
$LN3@zipCloseFi:
  000af	83 f8 01	 cmp	 eax, 1
  000b2	41 8b cd	 mov	 ecx, r13d
  000b5	0f 45 c8	 cmovne	 ecx, eax

; 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)
; 1575 :         err=ZIP_OK; /* this is normal */
; 1576 : 
; 1577 :     if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))

  000b8	83 ce ff	 or	 esi, -1
  000bb	8b f9		 mov	 edi, ecx
  000bd	44 39 ab d4 00
	00 00		 cmp	 DWORD PTR [rbx+212], r13d
  000c4	76 14		 jbe	 SHORT $LN13@zipCloseFi
  000c6	85 c9		 test	 ecx, ecx
  000c8	75 10		 jne	 SHORT $LN13@zipCloseFi

; 1578 :                 {
; 1579 :         if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO)

  000ca	48 8b cb	 mov	 rcx, rbx
  000cd	41 8b fd	 mov	 edi, r13d
  000d0	e8 00 00 00 00	 call	 zip64FlushWriteBuffer
  000d5	3b c6		 cmp	 eax, esi
  000d7	0f 44 fe	 cmove	 edi, esi
$LN13@zipCloseFi:

; 1580 :             err = ZIP_ERRNO;
; 1581 :                 }
; 1582 : 
; 1583 :     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))

  000da	83 bb f8 00 00
	00 08		 cmp	 DWORD PTR [rbx+248], 8
  000e1	75 1e		 jne	 SHORT $LN14@zipCloseFi
  000e3	44 39 ab fc 00
	00 00		 cmp	 DWORD PTR [rbx+252], r13d
  000ea	75 2c		 jne	 SHORT $LN16@zipCloseFi

; 1584 :     {
; 1585 :         int tmp_err = deflateEnd(&zi->ci.stream);

  000ec	48 8d 4b 78	 lea	 rcx, QWORD PTR [rbx+120]
  000f0	e8 00 00 00 00	 call	 deflateEnd

; 1586 :         if (err == ZIP_OK)

  000f5	85 ff		 test	 edi, edi

; 1587 :             err = tmp_err;
; 1588 :         zi->ci.stream_initialised = 0;

  000f7	44 89 ab d0 00
	00 00		 mov	 DWORD PTR [rbx+208], r13d
  000fe	0f 44 f8	 cmove	 edi, eax
$LN14@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)

  00101	44 39 ab fc 00
	00 00		 cmp	 DWORD PTR [rbx+252], r13d
  00108	75 0e		 jne	 SHORT $LN16@zipCloseFi

; 1601 :     {
; 1602 :         crc32 = (uLong)zi->ci.crc32;

  0010a	44 8b b3 04 01
	01 00		 mov	 r14d, DWORD PTR [rbx+65796]

; 1603 :         uncompressed_size = zi->ci.totalUncompressedData;

  00111	48 8b ab 20 01
	01 00		 mov	 rbp, QWORD PTR [rbx+65824]
$LN16@zipCloseFi:

; 1604 :     }
; 1605 :     compressed_size = zi->ci.totalCompressedData;
; 1606 : 
; 1607 : #    ifndef NOCRYPT
; 1608 :     compressed_size += zi->ci.crypt_header_size;

  00118	48 63 b3 40 01
	01 00		 movsxd	 rsi, DWORD PTR [rbx+65856]

; 1609 : #    endif
; 1610 : 
; 1611 :     // update Current Item crc and sizes,
; 1612 :     if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)

  0011f	41 bc ff ff ff
	ff		 mov	 r12d, -1		; ffffffffH
  00125	48 03 b3 18 01
	01 00		 add	 rsi, QWORD PTR [rbx+65816]
  0012c	49 3b f4	 cmp	 rsi, r12
  0012f	73 0e		 jae	 SHORT $LN18@zipCloseFi
  00131	49 3b ec	 cmp	 rbp, r12
  00134	73 09		 jae	 SHORT $LN18@zipCloseFi
  00136	4c 39 a3 d8 00
	00 00		 cmp	 QWORD PTR [rbx+216], r12
  0013d	72 2d		 jb	 SHORT $LN17@zipCloseFi
$LN18@zipCloseFi:

; 1613 :     {
; 1614 :       /*version Made by*/
; 1615 :       zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2);

  0013f	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00146	ba 2d 00 00 00	 mov	 edx, 45			; 0000002dH
  0014b	48 83 c1 04	 add	 rcx, 4
  0014f	44 8d 42 d5	 lea	 r8d, QWORD PTR [rdx-43]
  00153	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1616 :       /*version needed*/
; 1617 :       zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2);

  00158	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  0015f	41 8d 50 2b	 lea	 edx, QWORD PTR [r8+43]
  00163	48 83 c1 06	 add	 rcx, 6
  00167	e8 00 00 00 00	 call	 zip64local_putValue_inmemory
$LN17@zipCloseFi:

; 1618 : 
; 1619 :     }
; 1620 : 
; 1621 :     zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/

  0016c	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00173	41 b8 04 00 00
	00		 mov	 r8d, 4
  00179	48 83 c1 10	 add	 rcx, 16
  0017d	41 8b d6	 mov	 edx, r14d
  00180	45 8b fe	 mov	 r15d, r14d
  00183	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1622 : 
; 1623 : 
; 1624 :     if(compressed_size >= 0xffffffff)
; 1625 :       zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/

  00188	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  0018f	49 8b d4	 mov	 rdx, r12
  00192	48 83 c1 14	 add	 rcx, 20
  00196	49 3b f4	 cmp	 rsi, r12
  00199	73 03		 jae	 SHORT $LN58@zipCloseFi

; 1626 :     else
; 1627 :       zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/

  0019b	48 8b d6	 mov	 rdx, rsi
$LN58@zipCloseFi:
  0019e	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1628 : 
; 1629 :     /// set internal file attributes field
; 1630 :     if (zi->ci.stream.data_type == Z_ASCII)

  001a3	83 bb c0 00 00
	00 01		 cmp	 DWORD PTR [rbx+192], 1
  001aa	75 19		 jne	 SHORT $LN21@zipCloseFi

; 1631 :         zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);

  001ac	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  001b3	ba 01 00 00 00	 mov	 edx, 1
  001b8	48 83 c1 24	 add	 rcx, 36			; 00000024H
  001bc	44 8d 42 01	 lea	 r8d, QWORD PTR [rdx+1]
  001c0	e8 00 00 00 00	 call	 zip64local_putValue_inmemory
$LN21@zipCloseFi:

; 1632 : 
; 1633 :     if(uncompressed_size >= 0xffffffff)
; 1634 :       zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/

  001c5	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  001cc	41 b8 04 00 00
	00		 mov	 r8d, 4
  001d2	48 83 c1 18	 add	 rcx, 24
  001d6	49 8b d4	 mov	 rdx, r12
  001d9	49 3b ec	 cmp	 rbp, r12
  001dc	73 03		 jae	 SHORT $LN59@zipCloseFi

; 1635 :     else
; 1636 :       zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/

  001de	48 8b d5	 mov	 rdx, rbp
$LN59@zipCloseFi:
  001e1	e8 00 00 00 00	 call	 zip64local_putValue_inmemory
  001e6	49 3b ec	 cmp	 rbp, r12
  001e9	b8 08 00 00 00	 mov	 eax, 8
  001ee	66 41 0f 42 c5	 cmovb	 ax, r13w
  001f3	49 3b f4	 cmp	 rsi, r12
  001f6	8d 48 08	 lea	 ecx, DWORD PTR [rax+8]
  001f9	66 0f 42 c8	 cmovb	 cx, ax
  001fd	4c 39 a3 d8 00
	00 00		 cmp	 QWORD PTR [rbx+216], r12
  00204	44 8d 51 08	 lea	 r10d, DWORD PTR [rcx+8]
  00208	66 44 0f 42 d1	 cmovb	 r10w, cx
  0020d	66 45 85 d2	 test	 r10w, r10w

; 1637 : 
; 1638 :     // Add ZIP64 extra info field for uncompressed size
; 1639 :     if(uncompressed_size >= 0xffffffff)
; 1640 :       datasize += 8;
; 1641 : 
; 1642 :     // Add ZIP64 extra info field for compressed size
; 1643 :     if(compressed_size >= 0xffffffff)
; 1644 :       datasize += 8;
; 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)
; 1648 :       datasize += 8;
; 1649 : 
; 1650 :     if(datasize > 0)

  00211	0f 84 d4 00 00
	00		 je	 $LN27@zipCloseFi

; 1651 :     {
; 1652 :       char* p = NULL;
; 1653 : 
; 1654 :       if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)

  00217	41 0f b7 c2	 movzx	 eax, r10w
  0021b	83 c0 04	 add	 eax, 4
  0021e	3b 83 f0 00 00
	00		 cmp	 eax, DWORD PTR [rbx+240]
  00224	76 0a		 jbe	 SHORT $LN28@zipCloseFi

; 1655 :       {
; 1656 :         // we can not write more data to the buffer that we have room for.
; 1657 :         return ZIP_BADZIPFILE;

  00226	b8 99 ff ff ff	 mov	 eax, -103		; ffffffffffffff99H
  0022b	e9 06 02 00 00	 jmp	 $LN56@zipCloseFi
$LN28@zipCloseFi:

; 1658 :       }
; 1659 : 
; 1660 :       p = zi->ci.central_header + zi->ci.size_centralheader;

  00230	44 8b 8b ec 00
	00 00		 mov	 r9d, DWORD PTR [rbx+236]

; 1661 : 
; 1662 :       // Add Extra Information Header for 'ZIP64 information'
; 1663 :       zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID

  00237	ba 01 00 00 00	 mov	 edx, 1
  0023c	4c 03 8b e0 00
	00 00		 add	 r9, QWORD PTR [rbx+224]
  00243	49 8b c9	 mov	 rcx, r9
  00246	44 8d 42 01	 lea	 r8d, QWORD PTR [rdx+1]
  0024a	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1664 :       p += 2;
; 1665 :       zip64local_putValue_inmemory(p, datasize, 2); // DataSize

  0024f	41 0f b7 d2	 movzx	 edx, r10w
  00253	49 8d 49 02	 lea	 rcx, QWORD PTR [r9+2]
  00257	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1666 :       p += 2;

  0025c	49 83 c1 04	 add	 r9, 4

; 1667 : 
; 1668 :       if(uncompressed_size >= 0xffffffff)

  00260	49 3b ec	 cmp	 rbp, r12
  00263	72 14		 jb	 SHORT $LN29@zipCloseFi

; 1669 :       {
; 1670 :         zip64local_putValue_inmemory(p, uncompressed_size, 8);

  00265	41 b8 08 00 00
	00		 mov	 r8d, 8
  0026b	48 8b d5	 mov	 rdx, rbp
  0026e	49 8b c9	 mov	 rcx, r9
  00271	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1671 :         p += 8;

  00276	4d 03 c8	 add	 r9, r8
$LN29@zipCloseFi:

; 1672 :       }
; 1673 : 
; 1674 :       if(compressed_size >= 0xffffffff)

  00279	49 3b f4	 cmp	 rsi, r12
  0027c	72 14		 jb	 SHORT $LN30@zipCloseFi

; 1675 :       {
; 1676 :         zip64local_putValue_inmemory(p, compressed_size, 8);

  0027e	41 b8 08 00 00
	00		 mov	 r8d, 8
  00284	48 8b d6	 mov	 rdx, rsi
  00287	49 8b c9	 mov	 rcx, r9
  0028a	e8 00 00 00 00	 call	 zip64local_putValue_inmemory

; 1677 :         p += 8;

  0028f	4d 03 c8	 add	 r9, r8
$LN30@zipCloseFi:

; 1678 :       }
; 1679 : 
; 1680 :       if(zi->ci.pos_local_header >= 0xffffffff)

  00292	48 8b 93 d8 00
	00 00		 mov	 rdx, QWORD PTR [rbx+216]
  00299	49 3b d4	 cmp	 rdx, r12
  0029c	72 0e		 jb	 SHORT $LN31@zipCloseFi

; 1681 :       {
; 1682 :         zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);

  0029e	41 b8 08 00 00
	00		 mov	 r8d, 8
  002a4	49 8b c9	 mov	 rcx, r9
  002a7	e8 00 00 00 00	 call	 zip64local_putValue_inmemory
$LN31@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;

  002ac	41 0f b7 ca	 movzx	 ecx, r10w
  002b0	b8 fc ff ff ff	 mov	 eax, -4			; fffffffcH
  002b5	2b c1		 sub	 eax, ecx

; 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);

  002b7	41 b8 02 00 00
	00		 mov	 r8d, 2
  002bd	01 83 f0 00 00
	00		 add	 DWORD PTR [rbx+240], eax
  002c3	8d 41 04	 lea	 eax, DWORD PTR [rcx+4]
  002c6	01 83 ec 00 00
	00		 add	 DWORD PTR [rbx+236], eax
  002cc	8d 41 04	 lea	 eax, DWORD PTR [rcx+4]
  002cf	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  002d6	01 83 e8 00 00
	00		 add	 DWORD PTR [rbx+232], eax
  002dc	48 83 c1 1e	 add	 rcx, 30
  002e0	8b 93 e8 00 00
	00		 mov	 edx, DWORD PTR [rbx+232]
  002e6	e8 00 00 00 00	 call	 zip64local_putValue_inmemory
$LN27@zipCloseFi:

; 1695 :     }
; 1696 : 
; 1697 :     if (err==ZIP_OK)

  002eb	85 ff		 test	 edi, edi
  002ed	75 19		 jne	 SHORT $LN32@zipCloseFi

; 1698 :         err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);

  002ef	44 8b 83 ec 00
	00 00		 mov	 r8d, DWORD PTR [rbx+236]
  002f6	48 8d 4b 60	 lea	 rcx, QWORD PTR [rbx+96]
  002fa	48 8b 93 e0 00
	00 00		 mov	 rdx, QWORD PTR [rbx+224]
  00301	e8 00 00 00 00	 call	 add_data_in_datablock
  00306	8b f8		 mov	 edi, eax
$LN32@zipCloseFi:

; 1699 : 
; 1700 :     free(zi->ci.central_header);

  00308	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  0030f	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free

; 1701 : 
; 1702 :     if (err==ZIP_OK)

  00315	85 ff		 test	 edi, edi
  00317	0f 85 0c 01 00
	00		 jne	 $LN46@zipCloseFi

; 1703 :     {
; 1704 :         // Update the LocalFileHeader with the new values.
; 1705 : 
; 1706 :         ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);

  0031d	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00321	48 8b cb	 mov	 rcx, rbx
  00324	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)

  00329	4c 8b 83 d8 00
	00 00		 mov	 r8, QWORD PTR [rbx+216]
  00330	45 33 c9	 xor	 r9d, r9d
  00333	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00337	49 83 c0 0e	 add	 r8, 14
  0033b	48 8b cb	 mov	 rcx, rbx
  0033e	4c 8b f0	 mov	 r14, rax
  00341	e8 00 00 00 00	 call	 call_zseek64
  00346	85 c0		 test	 eax, eax
  00348	74 09		 je	 SHORT $LN52@zipCloseFi

; 1709 :             err = ZIP_ERRNO;

  0034a	41 83 cf ff	 or	 r15d, -1
  0034e	41 8b ff	 mov	 edi, r15d

; 1710 : 
; 1711 :         if (err==ZIP_OK)

  00351	eb 1b		 jmp	 SHORT $LN35@zipCloseFi
$LN52@zipCloseFi:

; 1712 :             err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */

  00353	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00357	41 b9 04 00 00
	00		 mov	 r9d, 4
  0035d	4d 8b c7	 mov	 r8, r15
  00360	48 8b cb	 mov	 rcx, rbx
  00363	e8 00 00 00 00	 call	 zip64local_putValue
  00368	8b f8		 mov	 edi, eax
  0036a	41 83 cf ff	 or	 r15d, -1
$LN35@zipCloseFi:

; 1713 : 
; 1714 :         if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff )

  0036e	49 3b ec	 cmp	 rbp, r12
  00371	73 3d		 jae	 SHORT $LN38@zipCloseFi
  00373	49 3b f4	 cmp	 rsi, r12
  00376	73 38		 jae	 SHORT $LN38@zipCloseFi

; 1730 :         }
; 1731 :         else
; 1732 :         {
; 1733 :           if (err==ZIP_OK) /* compressed size, unknown */

  00378	85 ff		 test	 edi, edi
  0037a	0f 85 91 00 00
	00		 jne	 $LN40@zipCloseFi

; 1734 :               err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);

  00380	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00384	44 8d 4f 04	 lea	 r9d, QWORD PTR [rdi+4]
  00388	4c 8b c6	 mov	 r8, rsi
  0038b	48 8b cb	 mov	 rcx, rbx
  0038e	e8 00 00 00 00	 call	 zip64local_putValue
  00393	8b f8		 mov	 edi, eax

; 1735 : 
; 1736 :           if (err==ZIP_OK) /* uncompressed size, unknown */

  00395	85 c0		 test	 eax, eax
  00397	75 78		 jne	 SHORT $LN40@zipCloseFi

; 1737 :               err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);

  00399	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0039d	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  003a1	4c 8b c5	 mov	 r8, rbp
  003a4	48 8b cb	 mov	 rcx, rbx
  003a7	e8 00 00 00 00	 call	 zip64local_putValue
  003ac	8b f8		 mov	 edi, eax
  003ae	eb 61		 jmp	 SHORT $LN40@zipCloseFi
$LN38@zipCloseFi:

; 1715 :         {
; 1716 :           if(zi->ci.pos_zip64extrainfo > 0)

  003b0	4c 8b 83 10 01
	01 00		 mov	 r8, QWORD PTR [rbx+65808]
  003b7	4d 85 c0	 test	 r8, r8
  003ba	74 50		 je	 SHORT $LN39@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)

  003bc	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  003c0	49 83 c0 04	 add	 r8, 4
  003c4	45 33 c9	 xor	 r9d, r9d
  003c7	48 8b cb	 mov	 rcx, rbx
  003ca	e8 00 00 00 00	 call	 call_zseek64
  003cf	85 c0		 test	 eax, eax
  003d1	74 05		 je	 SHORT $LN41@zipCloseFi

; 1720 :               err = ZIP_ERRNO;

  003d3	41 8b ff	 mov	 edi, r15d

; 1721 : 
; 1722 :             if (err==ZIP_OK) /* compressed size, unknown */

  003d6	eb 39		 jmp	 SHORT $LN40@zipCloseFi
$LN41@zipCloseFi:
  003d8	85 ff		 test	 edi, edi
  003da	75 35		 jne	 SHORT $LN40@zipCloseFi

; 1723 :               err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);

  003dc	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  003e0	44 8d 4f 08	 lea	 r9d, QWORD PTR [rdi+8]
  003e4	4c 8b c5	 mov	 r8, rbp
  003e7	48 8b cb	 mov	 rcx, rbx
  003ea	e8 00 00 00 00	 call	 zip64local_putValue
  003ef	8b f8		 mov	 edi, eax

; 1724 : 
; 1725 :             if (err==ZIP_OK) /* uncompressed size, unknown */

  003f1	85 c0		 test	 eax, eax
  003f3	75 1c		 jne	 SHORT $LN40@zipCloseFi

; 1726 :               err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);

  003f5	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  003f9	44 8d 48 08	 lea	 r9d, QWORD PTR [rax+8]
  003fd	4c 8b c6	 mov	 r8, rsi
  00400	48 8b cb	 mov	 rcx, rbx
  00403	e8 00 00 00 00	 call	 zip64local_putValue
  00408	8b f8		 mov	 edi, eax

; 1727 :           }

  0040a	eb 05		 jmp	 SHORT $LN40@zipCloseFi
$LN39@zipCloseFi:

; 1728 :           else
; 1729 :               err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal

  0040c	bf 99 ff ff ff	 mov	 edi, -103		; ffffffffffffff99H
$LN40@zipCloseFi:

; 1738 :         }
; 1739 : 
; 1740 :         if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)

  00411	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00415	45 33 c9	 xor	 r9d, r9d
  00418	4d 8b c6	 mov	 r8, r14
  0041b	48 8b cb	 mov	 rcx, rbx
  0041e	e8 00 00 00 00	 call	 call_zseek64
  00423	85 c0		 test	 eax, eax
  00425	41 0f 45 ff	 cmovne	 edi, r15d
$LN46@zipCloseFi:

; 1741 :             err = ZIP_ERRNO;
; 1742 :     }
; 1743 : 
; 1744 :     zi->number_entry ++;

  00429	48 ff 83 58 01
	01 00		 inc	 QWORD PTR [rbx+65880]

; 1745 :     zi->in_opened_file_inzip = 0;
; 1746 : 
; 1747 :     return err;

  00430	8b c7		 mov	 eax, edi
  00432	44 89 6b 70	 mov	 DWORD PTR [rbx+112], r13d
$LN56@zipCloseFi:
  00436	4c 8b 64 24 60	 mov	 r12, QWORD PTR [rsp+96]
  0043b	48 8b 7c 24 58	 mov	 rdi, QWORD PTR [rsp+88]
  00440	48 8b 74 24 50	 mov	 rsi, QWORD PTR [rsp+80]
  00445	4c 8b 7c 24 20	 mov	 r15, QWORD PTR [rsp+32]

; 1748 : }

  0044a	48 83 c4 28	 add	 rsp, 40			; 00000028H
  0044e	41 5e		 pop	 r14
  00450	41 5d		 pop	 r13
  00452	5d		 pop	 rbp
  00453	5b		 pop	 rbx
  00454	c3		 ret	 0
zipCloseFileInZipRaw64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipCloseFileInZip
_TEXT	SEGMENT
file$ = 8
zipCloseFileInZip PROC					; COMDAT

; 1752 :     return zipCloseFileInZipRaw (file,0,0);

  00000	45 33 c0	 xor	 r8d, r8d
  00003	33 d2		 xor	 edx, edx
  00005	e9 00 00 00 00	 jmp	 zipCloseFileInZipRaw
zipCloseFileInZip ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT Write_Zip64EndOfCentralDirectoryLocator
_TEXT	SEGMENT
zi$ = 48
zip64eocd_pos_inzip$ = 56
Write_Zip64EndOfCentralDirectoryLocator PROC		; COMDAT

; 1756 : {

$LN10:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000a	48 8b fa	 mov	 rdi, rdx

; 1757 :   int err = ZIP_OK;
; 1758 :   ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset;
; 1759 : 
; 1760 :   err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);

  0000d	41 b9 04 00 00
	00		 mov	 r9d, 4
  00013	48 8b 51 58	 mov	 rdx, QWORD PTR [rcx+88]
  00017	41 b8 50 4b 06
	07		 mov	 r8d, 117853008		; 07064b50H
  0001d	48 2b b9 50 01
	01 00		 sub	 rdi, QWORD PTR [rcx+65872]
  00024	48 8b d9	 mov	 rbx, rcx
  00027	e8 00 00 00 00	 call	 zip64local_putValue

; 1761 : 
; 1762 :   /*num disks*/
; 1763 :     if (err==ZIP_OK) /* number of the disk with the start of the central directory */

  0002c	85 c0		 test	 eax, eax
  0002e	75 42		 jne	 SHORT $LN8@Write_Zip6

; 1764 :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);

  00030	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00034	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  00038	45 33 c0	 xor	 r8d, r8d
  0003b	48 8b cb	 mov	 rcx, rbx
  0003e	e8 00 00 00 00	 call	 zip64local_putValue

; 1765 : 
; 1766 :   /*relative offset*/
; 1767 :     if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */

  00043	85 c0		 test	 eax, eax
  00045	75 2b		 jne	 SHORT $LN8@Write_Zip6

; 1768 :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);

  00047	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0004b	44 8d 48 08	 lea	 r9d, QWORD PTR [rax+8]
  0004f	4c 8b c7	 mov	 r8, rdi
  00052	48 8b cb	 mov	 rcx, rbx
  00055	e8 00 00 00 00	 call	 zip64local_putValue

; 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 */

  0005a	85 c0		 test	 eax, eax
  0005c	75 14		 jne	 SHORT $LN8@Write_Zip6

; 1772 :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);

  0005e	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00062	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  00066	44 8d 40 01	 lea	 r8d, QWORD PTR [rax+1]
  0006a	48 8b cb	 mov	 rcx, rbx
  0006d	e8 00 00 00 00	 call	 zip64local_putValue
$LN8@Write_Zip6:

; 1773 : 
; 1774 :     return err;
; 1775 : }

  00072	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00077	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0007b	5f		 pop	 rdi
  0007c	c3		 ret	 0
Write_Zip64EndOfCentralDirectoryLocator ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT Write_Zip64EndOfCentralDirectoryRecord
_TEXT	SEGMENT
zi$ = 48
size_centraldir$ = 56
centraldir_pos_inzip$ = 64
Write_Zip64EndOfCentralDirectoryRecord PROC		; COMDAT

; 1778 : {

$LN13:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	57		 push	 rdi
  0000b	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000f	49 8b f8	 mov	 rdi, r8
  00012	8b f2		 mov	 esi, edx

; 1779 :   int err = ZIP_OK;
; 1780 : 
; 1781 :   uLong Zip64DataSize = 44;
; 1782 : 
; 1783 :   err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);

  00014	48 8b 51 58	 mov	 rdx, QWORD PTR [rcx+88]
  00018	41 b8 50 4b 06
	06		 mov	 r8d, 101075792		; 06064b50H
  0001e	41 b9 04 00 00
	00		 mov	 r9d, 4
  00024	48 8b d9	 mov	 rbx, rcx
  00027	e8 00 00 00 00	 call	 zip64local_putValue

; 1784 : 
; 1785 :   if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */

  0002c	85 c0		 test	 eax, eax
  0002e	0f 85 e9 00 00
	00		 jne	 $LN10@Write_Zip6

; 1786 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?

  00034	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00038	44 8d 48 08	 lea	 r9d, QWORD PTR [rax+8]
  0003c	44 8d 40 2c	 lea	 r8d, QWORD PTR [rax+44]
  00040	48 8b cb	 mov	 rcx, rbx
  00043	e8 00 00 00 00	 call	 zip64local_putValue

; 1787 : 
; 1788 :   if (err==ZIP_OK) /* version made by */

  00048	85 c0		 test	 eax, eax
  0004a	0f 85 cd 00 00
	00		 jne	 $LN10@Write_Zip6

; 1789 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);

  00050	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00054	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  00058	44 8d 40 2d	 lea	 r8d, QWORD PTR [rax+45]
  0005c	48 8b cb	 mov	 rcx, rbx
  0005f	e8 00 00 00 00	 call	 zip64local_putValue

; 1790 : 
; 1791 :   if (err==ZIP_OK) /* version needed */

  00064	85 c0		 test	 eax, eax
  00066	0f 85 b1 00 00
	00		 jne	 $LN10@Write_Zip6

; 1792 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);

  0006c	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00070	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  00074	44 8d 40 2d	 lea	 r8d, QWORD PTR [rax+45]
  00078	48 8b cb	 mov	 rcx, rbx
  0007b	e8 00 00 00 00	 call	 zip64local_putValue

; 1793 : 
; 1794 :   if (err==ZIP_OK) /* number of this disk */

  00080	85 c0		 test	 eax, eax
  00082	0f 85 95 00 00
	00		 jne	 $LN10@Write_Zip6

; 1795 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);

  00088	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0008c	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  00090	45 33 c0	 xor	 r8d, r8d
  00093	48 8b cb	 mov	 rcx, rbx
  00096	e8 00 00 00 00	 call	 zip64local_putValue

; 1796 : 
; 1797 :   if (err==ZIP_OK) /* number of the disk with the start of the central directory */

  0009b	85 c0		 test	 eax, eax
  0009d	75 7e		 jne	 SHORT $LN10@Write_Zip6

; 1798 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);

  0009f	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000a3	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  000a7	45 33 c0	 xor	 r8d, r8d
  000aa	48 8b cb	 mov	 rcx, rbx
  000ad	e8 00 00 00 00	 call	 zip64local_putValue

; 1799 : 
; 1800 :   if (err==ZIP_OK) /* total number of entries in the central dir on this disk */

  000b2	85 c0		 test	 eax, eax
  000b4	75 67		 jne	 SHORT $LN10@Write_Zip6

; 1801 :     err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);

  000b6	4c 8b 83 58 01
	01 00		 mov	 r8, QWORD PTR [rbx+65880]
  000bd	44 8d 48 08	 lea	 r9d, QWORD PTR [rax+8]
  000c1	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000c5	48 8b cb	 mov	 rcx, rbx
  000c8	e8 00 00 00 00	 call	 zip64local_putValue

; 1802 : 
; 1803 :   if (err==ZIP_OK) /* total number of entries in the central dir */

  000cd	85 c0		 test	 eax, eax
  000cf	75 4c		 jne	 SHORT $LN10@Write_Zip6

; 1804 :     err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);

  000d1	4c 8b 83 58 01
	01 00		 mov	 r8, QWORD PTR [rbx+65880]
  000d8	44 8d 48 08	 lea	 r9d, QWORD PTR [rax+8]
  000dc	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000e0	48 8b cb	 mov	 rcx, rbx
  000e3	e8 00 00 00 00	 call	 zip64local_putValue

; 1805 : 
; 1806 :   if (err==ZIP_OK) /* size of the central directory */

  000e8	85 c0		 test	 eax, eax
  000ea	75 31		 jne	 SHORT $LN10@Write_Zip6

; 1807 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8);

  000ec	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000f0	44 8d 48 08	 lea	 r9d, QWORD PTR [rax+8]
  000f4	44 8b c6	 mov	 r8d, esi
  000f7	48 8b cb	 mov	 rcx, rbx
  000fa	e8 00 00 00 00	 call	 zip64local_putValue

; 1808 : 
; 1809 :   if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */

  000ff	85 c0		 test	 eax, eax
  00101	75 1a		 jne	 SHORT $LN10@Write_Zip6

; 1810 :   {
; 1811 :     ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;

  00103	48 2b bb 50 01
	01 00		 sub	 rdi, QWORD PTR [rbx+65872]

; 1812 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);

  0010a	44 8d 48 08	 lea	 r9d, QWORD PTR [rax+8]
  0010e	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00112	4c 8b c7	 mov	 r8, rdi
  00115	48 8b cb	 mov	 rcx, rbx
  00118	e8 00 00 00 00	 call	 zip64local_putValue
$LN10@Write_Zip6:

; 1813 :   }
; 1814 :   return err;
; 1815 : }

  0011d	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00122	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00127	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0012b	5f		 pop	 rdi
  0012c	c3		 ret	 0
Write_Zip64EndOfCentralDirectoryRecord ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT Write_EndOfCentralDirectoryRecord
_TEXT	SEGMENT
zi$ = 48
size_centraldir$ = 56
centraldir_pos_inzip$ = 64
Write_EndOfCentralDirectoryRecord PROC			; COMDAT

; 1817 : {

$LN25:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	57		 push	 rdi
  0000b	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000f	49 8b f8	 mov	 rdi, r8
  00012	8b f2		 mov	 esi, edx

; 1818 :   int err = ZIP_OK;
; 1819 : 
; 1820 :   /*signature*/
; 1821 :   err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);

  00014	48 8b 51 58	 mov	 rdx, QWORD PTR [rcx+88]
  00018	41 b8 50 4b 05
	06		 mov	 r8d, 101010256		; 06054b50H
  0001e	41 b9 04 00 00
	00		 mov	 r9d, 4
  00024	48 8b d9	 mov	 rbx, rcx
  00027	e8 00 00 00 00	 call	 zip64local_putValue

; 1822 : 
; 1823 :   if (err==ZIP_OK) /* number of this disk */

  0002c	85 c0		 test	 eax, eax
  0002e	0f 85 d9 00 00
	00		 jne	 $LN20@Write_EndO

; 1824 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);

  00034	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00038	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  0003c	45 33 c0	 xor	 r8d, r8d
  0003f	48 8b cb	 mov	 rcx, rbx
  00042	e8 00 00 00 00	 call	 zip64local_putValue

; 1825 : 
; 1826 :   if (err==ZIP_OK) /* number of the disk with the start of the central directory */

  00047	85 c0		 test	 eax, eax
  00049	0f 85 be 00 00
	00		 jne	 $LN20@Write_EndO

; 1827 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);

  0004f	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  00053	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  00057	45 33 c0	 xor	 r8d, r8d
  0005a	48 8b cb	 mov	 rcx, rbx
  0005d	e8 00 00 00 00	 call	 zip64local_putValue

; 1828 : 
; 1829 :   if (err==ZIP_OK) /* total number of entries in the central dir on this disk */

  00062	85 c0		 test	 eax, eax
  00064	0f 85 a3 00 00
	00		 jne	 $LN20@Write_EndO

; 1830 :   {
; 1831 :     {
; 1832 :       if(zi->number_entry >= 0xFFFF)

  0006a	48 81 bb 58 01
	01 00 ff ff 00
	00		 cmp	 QWORD PTR [rbx+65880], 65535 ; 0000ffffH

; 1833 :         err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record

  00075	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  00079	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  0007d	48 8b cb	 mov	 rcx, rbx
  00080	41 b8 ff ff 00
	00		 mov	 r8d, 65535		; 0000ffffH
  00086	73 07		 jae	 SHORT $LN21@Write_EndO

; 1834 :       else
; 1835 :         err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);

  00088	44 8b 83 58 01
	01 00		 mov	 r8d, DWORD PTR [rbx+65880]
$LN21@Write_EndO:
  0008f	e8 00 00 00 00	 call	 zip64local_putValue

; 1836 :     }
; 1837 :   }
; 1838 : 
; 1839 :   if (err==ZIP_OK) /* total number of entries in the central dir */

  00094	85 c0		 test	 eax, eax
  00096	75 75		 jne	 SHORT $LN20@Write_EndO

; 1840 :   {
; 1841 :     if(zi->number_entry >= 0xFFFF)

  00098	48 81 bb 58 01
	01 00 ff ff 00
	00		 cmp	 QWORD PTR [rbx+65880], 65535 ; 0000ffffH

; 1842 :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record

  000a3	44 8d 48 02	 lea	 r9d, QWORD PTR [rax+2]
  000a7	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000ab	48 8b cb	 mov	 rcx, rbx
  000ae	41 b8 ff ff 00
	00		 mov	 r8d, 65535		; 0000ffffH
  000b4	73 07		 jae	 SHORT $LN22@Write_EndO

; 1843 :     else
; 1844 :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);

  000b6	44 8b 83 58 01
	01 00		 mov	 r8d, DWORD PTR [rbx+65880]
$LN22@Write_EndO:
  000bd	e8 00 00 00 00	 call	 zip64local_putValue

; 1845 :   }
; 1846 : 
; 1847 :   if (err==ZIP_OK) /* size of the central directory */

  000c2	85 c0		 test	 eax, eax
  000c4	75 47		 jne	 SHORT $LN20@Write_EndO

; 1848 :     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);

  000c6	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000ca	44 8d 48 04	 lea	 r9d, QWORD PTR [rax+4]
  000ce	4c 8b c6	 mov	 r8, rsi
  000d1	48 8b cb	 mov	 rcx, rbx
  000d4	e8 00 00 00 00	 call	 zip64local_putValue

; 1849 : 
; 1850 :   if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */

  000d9	85 c0		 test	 eax, eax
  000db	75 30		 jne	 SHORT $LN20@Write_EndO

; 1851 :   {
; 1852 :     ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
; 1853 :     if(pos >= 0xffffffff)
; 1854 :     {
; 1855 :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4);

  000dd	48 8b 53 58	 mov	 rdx, QWORD PTR [rbx+88]
  000e1	48 8b c7	 mov	 rax, rdi
  000e4	48 2b 83 50 01
	01 00		 sub	 rax, QWORD PTR [rbx+65872]
  000eb	41 b8 ff ff ff
	ff		 mov	 r8d, -1			; ffffffffH
  000f1	41 b9 04 00 00
	00		 mov	 r9d, 4
  000f7	48 8b cb	 mov	 rcx, rbx
  000fa	49 3b c0	 cmp	 rax, r8
  000fd	73 09		 jae	 SHORT $LN23@Write_EndO

; 1856 :     }
; 1857 :     else
; 1858 :       err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writing_offset),4);

  000ff	2b bb 50 01 01
	00		 sub	 edi, DWORD PTR [rbx+65872]
  00105	44 8b c7	 mov	 r8d, edi
$LN23@Write_EndO:
  00108	e8 00 00 00 00	 call	 zip64local_putValue
$LN20@Write_EndO:

; 1859 :   }
; 1860 : 
; 1861 :    return err;
; 1862 : }

  0010d	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00112	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00117	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0011b	5f		 pop	 rdi
  0011c	c3		 ret	 0
Write_EndOfCentralDirectoryRecord ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT Write_GlobalComment
_TEXT	SEGMENT
zi$ = 48
global_comment$ = 56
Write_GlobalComment PROC				; COMDAT

; 1865 : {

$LN10:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 6c 24 10	 mov	 QWORD PTR [rsp+16], rbp
  0000a	48 89 74 24 18	 mov	 QWORD PTR [rsp+24], rsi
  0000f	48 89 7c 24 20	 mov	 QWORD PTR [rsp+32], rdi
  00014	41 56		 push	 r14
  00016	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 1866 :   int err = ZIP_OK;
; 1867 :   uInt size_global_comment = 0;

  0001a	33 db		 xor	 ebx, ebx

; 1868 : 
; 1869 :   if(global_comment != NULL)

  0001c	49 83 ce ff	 or	 r14, -1
  00020	48 8b fa	 mov	 rdi, rdx
  00023	48 8b e9	 mov	 rbp, rcx
  00026	48 85 d2	 test	 rdx, rdx
  00029	74 0e		 je	 SHORT $LN2@Write_Glob

; 1870 :     size_global_comment = (uInt)strlen(global_comment);

  0002b	49 8b de	 mov	 rbx, r14
  0002e	66 90		 npad	 2
$LL6@Write_Glob:
  00030	48 ff c3	 inc	 rbx
  00033	80 3c 1a 00	 cmp	 BYTE PTR [rdx+rbx], 0
  00037	75 f7		 jne	 SHORT $LL6@Write_Glob
$LN2@Write_Glob:

; 1871 : 
; 1872 :   err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);

  00039	48 8b 51 58	 mov	 rdx, QWORD PTR [rcx+88]
  0003d	41 b9 02 00 00
	00		 mov	 r9d, 2
  00043	44 8b c3	 mov	 r8d, ebx
  00046	e8 00 00 00 00	 call	 zip64local_putValue
  0004b	8b f0		 mov	 esi, eax

; 1873 : 
; 1874 :   if (err == ZIP_OK && size_global_comment > 0)

  0004d	85 c0		 test	 eax, eax
  0004f	75 1d		 jne	 SHORT $LN4@Write_Glob
  00051	85 db		 test	 ebx, ebx
  00053	74 19		 je	 SHORT $LN4@Write_Glob

; 1875 :   {
; 1876 :     if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)

  00055	48 8b 55 58	 mov	 rdx, QWORD PTR [rbp+88]
  00059	44 8b cb	 mov	 r9d, ebx
  0005c	48 8b 4d 38	 mov	 rcx, QWORD PTR [rbp+56]
  00060	4c 8b c7	 mov	 r8, rdi
  00063	ff 55 10	 call	 QWORD PTR [rbp+16]
  00066	3b c3		 cmp	 eax, ebx
  00068	41 0f 45 f6	 cmovne	 esi, r14d

; 1877 :       err = ZIP_ERRNO;
; 1878 :   }
; 1879 :   return err;

  0006c	8b c6		 mov	 eax, esi
$LN4@Write_Glob:

; 1880 : }

  0006e	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00073	48 8b 6c 24 38	 mov	 rbp, QWORD PTR [rsp+56]
  00078	48 8b 74 24 40	 mov	 rsi, QWORD PTR [rsp+64]
  0007d	48 8b 7c 24 48	 mov	 rdi, QWORD PTR [rsp+72]
  00082	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00086	41 5e		 pop	 r14
  00088	c3		 ret	 0
Write_GlobalComment ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\zip.c
;	COMDAT zipClose
_TEXT	SEGMENT
file$ = 64
global_comment$ = 72
zipClose PROC						; COMDAT

; 1883 : {

$LN24:
  00000	48 89 6c 24 20	 mov	 QWORD PTR [rsp+32], rbp
  00005	56		 push	 rsi
  00006	57		 push	 rdi
  00007	41 56		 push	 r14
  00009	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 1884 :     zip64_internal* zi;
; 1885 :     int err = 0;

  0000d	33 f6		 xor	 esi, esi
  0000f	4c 8b f2	 mov	 r14, rdx
  00012	48 8b f9	 mov	 rdi, rcx

; 1886 :     uLong size_centraldir = 0;

  00015	8b ee		 mov	 ebp, esi

; 1887 :     ZPOS64_T centraldir_pos_inzip;
; 1888 :     ZPOS64_T pos;
; 1889 : 
; 1890 :     if (file == NULL)

  00017	48 85 c9	 test	 rcx, rcx
  0001a	75 11		 jne	 SHORT $LN4@zipClose

; 1891 :         return ZIP_PARAMERROR;

  0001c	8d 41 9a	 lea	 eax, QWORD PTR [rcx-102]

; 1947 : 
; 1948 :     return err;
; 1949 : }

  0001f	48 8b 6c 24 58	 mov	 rbp, QWORD PTR [rsp+88]
  00024	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00028	41 5e		 pop	 r14
  0002a	5f		 pop	 rdi
  0002b	5e		 pop	 rsi
  0002c	c3		 ret	 0
$LN4@zipClose:

; 1892 : 
; 1893 :     zi = (zip64_internal*)file;
; 1894 : 
; 1895 :     if (zi->in_opened_file_inzip == 1)

  0002d	83 79 70 01	 cmp	 DWORD PTR [rcx+112], 1
  00031	4c 89 64 24 48	 mov	 QWORD PTR [rsp+72], r12
  00036	4c 89 7c 24 50	 mov	 QWORD PTR [rsp+80], r15
  0003b	75 07		 jne	 SHORT $LN5@zipClose

; 1896 :     {
; 1897 :         err = zipCloseFileInZip (file);

  0003d	e8 00 00 00 00	 call	 zipCloseFileInZip
  00042	8b f0		 mov	 esi, eax
$LN5@zipClose:

; 1898 :     }
; 1899 : 
; 1900 : #ifndef NO_ADDFILEINEXISTINGZIP
; 1901 :     if (global_comment==NULL)

  00044	4d 85 f6	 test	 r14, r14
  00047	75 07		 jne	 SHORT $LN6@zipClose

; 1902 :         global_comment = zi->globalcomment;

  00049	4c 8b b7 60 01
	01 00		 mov	 r14, QWORD PTR [rdi+65888]
$LN6@zipClose:

; 1903 : #endif
; 1904 : 
; 1905 :     centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);

  00050	48 8b 57 58	 mov	 rdx, QWORD PTR [rdi+88]
  00054	48 8b cf	 mov	 rcx, rdi
  00057	48 89 5c 24 40	 mov	 QWORD PTR [rsp+64], rbx
  0005c	e8 00 00 00 00	 call	 call_ztell64

; 1906 : 
; 1907 :     if (err==ZIP_OK)

  00061	41 83 cc ff	 or	 r12d, -1
  00065	4c 8b f8	 mov	 r15, rax
  00068	85 f6		 test	 esi, esi
  0006a	75 37		 jne	 SHORT $LN3@zipClose

; 1908 :     {
; 1909 :         linkedlist_datablock_internal* ldi = zi->central_dir.first_block;

  0006c	48 8b 5f 60	 mov	 rbx, QWORD PTR [rdi+96]

; 1910 :         while (ldi!=NULL)

  00070	48 85 db	 test	 rbx, rbx
  00073	74 2e		 je	 SHORT $LN3@zipClose
$LL2@zipClose:

; 1911 :         {
; 1912 :             if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))

  00075	85 f6		 test	 esi, esi
  00077	75 1f		 jne	 SHORT $LN9@zipClose
  00079	44 8b 4b 0c	 mov	 r9d, DWORD PTR [rbx+12]
  0007d	45 85 c9	 test	 r9d, r9d
  00080	74 16		 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)

  00082	48 8b 57 58	 mov	 rdx, QWORD PTR [rdi+88]
  00086	4c 8d 43 14	 lea	 r8, QWORD PTR [rbx+20]
  0008a	48 8b 4f 38	 mov	 rcx, QWORD PTR [rdi+56]
  0008e	ff 57 10	 call	 QWORD PTR [rdi+16]
  00091	3b 43 0c	 cmp	 eax, DWORD PTR [rbx+12]
  00094	41 0f 45 f4	 cmovne	 esi, r12d
$LN9@zipClose:

; 1915 :                     err = ZIP_ERRNO;
; 1916 :             }
; 1917 : 
; 1918 :             size_centraldir += ldi->filled_in_this_block;

  00098	03 6b 0c	 add	 ebp, DWORD PTR [rbx+12]

; 1919 :             ldi = ldi->next_datablock;

  0009b	48 8b 1b	 mov	 rbx, QWORD PTR [rbx]
  0009e	48 85 db	 test	 rbx, rbx
  000a1	75 d2		 jne	 SHORT $LL2@zipClose
$LN3@zipClose:

; 1920 :         }
; 1921 :     }
; 1922 :     free_linkedlist(&(zi->central_dir));

  000a3	48 8d 4f 60	 lea	 rcx, QWORD PTR [rdi+96]
  000a7	e8 00 00 00 00	 call	 free_linkedlist

; 1923 : 
; 1924 :     pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;

  000ac	49 8b c7	 mov	 rax, r15

; 1925 :     if(pos >= 0xffffffff || zi->number_entry > 0xFFFF)

  000af	b9 ff ff ff ff	 mov	 ecx, -1			; ffffffffH
  000b4	48 2b 87 50 01
	01 00		 sub	 rax, QWORD PTR [rdi+65872]
  000bb	48 3b c1	 cmp	 rax, rcx
  000be	73 0d		 jae	 SHORT $LN11@zipClose
  000c0	48 81 bf 58 01
	01 00 ff ff 00
	00		 cmp	 QWORD PTR [rdi+65880], 65535 ; 0000ffffH
  000cb	76 27		 jbe	 SHORT $LN10@zipClose
$LN11@zipClose:

; 1926 :     {
; 1927 :       ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);

  000cd	48 8b 57 58	 mov	 rdx, QWORD PTR [rdi+88]
  000d1	48 8b cf	 mov	 rcx, rdi
  000d4	e8 00 00 00 00	 call	 call_ztell64

; 1928 :       Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);

  000d9	4d 8b c7	 mov	 r8, r15
  000dc	8b d5		 mov	 edx, ebp
  000de	48 8b cf	 mov	 rcx, rdi
  000e1	48 8b d8	 mov	 rbx, rax
  000e4	e8 00 00 00 00	 call	 Write_Zip64EndOfCentralDirectoryRecord

; 1929 : 
; 1930 :       Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);

  000e9	48 8b d3	 mov	 rdx, rbx
  000ec	48 8b cf	 mov	 rcx, rdi
  000ef	e8 00 00 00 00	 call	 Write_Zip64EndOfCentralDirectoryLocator
$LN10@zipClose:

; 1931 :     }
; 1932 : 
; 1933 :     if (err==ZIP_OK)

  000f4	48 8b 5c 24 40	 mov	 rbx, QWORD PTR [rsp+64]
  000f9	85 f6		 test	 esi, esi
  000fb	75 20		 jne	 SHORT $LN13@zipClose

; 1934 :       err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);

  000fd	4d 8b c7	 mov	 r8, r15
  00100	8b d5		 mov	 edx, ebp
  00102	48 8b cf	 mov	 rcx, rdi
  00105	e8 00 00 00 00	 call	 Write_EndOfCentralDirectoryRecord
  0010a	8b f0		 mov	 esi, eax

; 1935 : 
; 1936 :     if(err == ZIP_OK)

  0010c	85 c0		 test	 eax, eax
  0010e	75 0d		 jne	 SHORT $LN13@zipClose

; 1937 :       err = Write_GlobalComment(zi, global_comment);

  00110	49 8b d6	 mov	 rdx, r14
  00113	48 8b cf	 mov	 rcx, rdi
  00116	e8 00 00 00 00	 call	 Write_GlobalComment
  0011b	8b f0		 mov	 esi, eax
$LN13@zipClose:

; 1938 : 
; 1939 :     if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)

  0011d	48 8b 57 58	 mov	 rdx, QWORD PTR [rdi+88]
  00121	48 8b 4f 38	 mov	 rcx, QWORD PTR [rdi+56]
  00125	ff 57 28	 call	 QWORD PTR [rdi+40]
  00128	4c 8b 7c 24 50	 mov	 r15, QWORD PTR [rsp+80]
  0012d	85 c0		 test	 eax, eax
  0012f	74 06		 je	 SHORT $LN15@zipClose

; 1940 :         if (err == ZIP_OK)

  00131	85 f6		 test	 esi, esi
  00133	41 0f 44 f4	 cmove	 esi, r12d
$LN15@zipClose:

; 1941 :             err = ZIP_ERRNO;
; 1942 : 
; 1943 : #ifndef NO_ADDFILEINEXISTINGZIP
; 1944 :     TRYFREE(zi->globalcomment);

  00137	48 8b 8f 60 01
	01 00		 mov	 rcx, QWORD PTR [rdi+65888]
  0013e	4c 8b 64 24 48	 mov	 r12, QWORD PTR [rsp+72]
  00143	48 85 c9	 test	 rcx, rcx
  00146	74 06		 je	 SHORT $LN16@zipClose
  00148	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free
$LN16@zipClose:

; 1945 : #endif
; 1946 :     TRYFREE(zi);

  0014e	48 8b cf	 mov	 rcx, rdi
  00151	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free

; 1947 : 
; 1948 :     return err;
; 1949 : }

  00157	48 8b 6c 24 58	 mov	 rbp, QWORD PTR [rsp+88]
  0015c	8b c6		 mov	 eax, esi
  0015e	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00162	41 5e		 pop	 r14
  00164	5f		 pop	 rdi
  00165	5e		 pop	 rsi
  00166	c3		 ret	 0
zipClose ENDP
_TEXT	ENDS
END
