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

include listing.inc

INCLUDELIB OLDNAMES

PUBLIC	unz_copyright
	ORG $+13
unz_copyright DB ' unzip 1.01 Copyright 1998-2004 Gilles Vollant - http:/'
	DB	'/www.winimage.com/zLibDll', 00H
PUBLIC	unzGetGlobalComment
PUBLIC	unzCloseCurrentFile
PUBLIC	unzGetLocalExtrafield
PUBLIC	unzeof
PUBLIC	unztell64
PUBLIC	unztell
PUBLIC	unzReadCurrentFile
PUBLIC	unzGetCurrentFileZStreamPos64
PUBLIC	unzOpenCurrentFile2
PUBLIC	unzOpenCurrentFilePassword
PUBLIC	unzOpenCurrentFile
PUBLIC	unzOpenCurrentFile3
PUBLIC	unzGoToFilePos
PUBLIC	unzGoToFilePos64
PUBLIC	unzGetFilePos
PUBLIC	unzGetFilePos64
PUBLIC	unzLocateFile
PUBLIC	unzGoToNextFile
PUBLIC	unzGoToFirstFile
PUBLIC	unzGetCurrentFileInfo
PUBLIC	unzGetCurrentFileInfo64
PUBLIC	unzGetGlobalInfo
PUBLIC	unzGetGlobalInfo64
PUBLIC	unzClose
PUBLIC	unzOpen64
PUBLIC	unzOpen
PUBLIC	unzOpen2_64
PUBLIC	unzOpen2
PUBLIC	unzStringFileNameCompare
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGetGlobalComment DD imagerel $LN12
	DD	imagerel $LN12+160
	DD	imagerel $unwind$unzGetGlobalComment
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzCloseCurrentFile DD imagerel $LN12
	DD	imagerel $LN12+34
	DD	imagerel $unwind$unzCloseCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$unzCloseCurrentFile DD imagerel $LN12+34
	DD	imagerel $LN12+70
	DD	imagerel $chain$0$unzCloseCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$unzCloseCurrentFile DD imagerel $LN12+70
	DD	imagerel $LN12+188
	DD	imagerel $chain$2$unzCloseCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGetLocalExtrafield DD imagerel $LN13
	DD	imagerel $LN13+35
	DD	imagerel $unwind$unzGetLocalExtrafield
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$unzGetLocalExtrafield DD imagerel $LN13+35
	DD	imagerel $LN13+71
	DD	imagerel $chain$0$unzGetLocalExtrafield
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$unzGetLocalExtrafield DD imagerel $LN13+71
	DD	imagerel $LN13+107
	DD	imagerel $chain$2$unzGetLocalExtrafield
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$unzGetLocalExtrafield DD imagerel $LN13+107
	DD	imagerel $LN13+135
	DD	imagerel $chain$4$unzGetLocalExtrafield
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$6$unzGetLocalExtrafield DD imagerel $LN13+135
	DD	imagerel $LN13+187
	DD	imagerel $chain$6$unzGetLocalExtrafield
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$8$unzGetLocalExtrafield DD imagerel $LN13+187
	DD	imagerel $LN13+239
	DD	imagerel $chain$8$unzGetLocalExtrafield
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzReadCurrentFile DD imagerel $LN56
	DD	imagerel $LN56+24
	DD	imagerel $unwind$unzReadCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$unzReadCurrentFile DD imagerel $LN56+24
	DD	imagerel $LN56+56
	DD	imagerel $chain$0$unzReadCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$unzReadCurrentFile DD imagerel $LN56+56
	DD	imagerel $LN56+78
	DD	imagerel $chain$2$unzReadCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$unzReadCurrentFile DD imagerel $LN56+78
	DD	imagerel $LN56+97
	DD	imagerel $chain$4$unzReadCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$12$unzReadCurrentFile DD imagerel $LN56+97
	DD	imagerel $LN56+693
	DD	imagerel $chain$12$unzReadCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$14$unzReadCurrentFile DD imagerel $LN56+693
	DD	imagerel $LN56+702
	DD	imagerel $chain$14$unzReadCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzOpenCurrentFile2 DD imagerel $LN4
	DD	imagerel $LN4+23
	DD	imagerel $unwind$unzOpenCurrentFile2
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzOpenCurrentFilePassword DD imagerel $LN4
	DD	imagerel $LN4+27
	DD	imagerel $unwind$unzOpenCurrentFilePassword
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzOpenCurrentFile DD imagerel $LN4
	DD	imagerel $LN4+31
	DD	imagerel $unwind$unzOpenCurrentFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzOpenCurrentFile3 DD imagerel $LN29
	DD	imagerel $LN29+133
	DD	imagerel $unwind$unzOpenCurrentFile3
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$unzOpenCurrentFile3 DD imagerel $LN29+133
	DD	imagerel $LN29+165
	DD	imagerel $chain$0$unzOpenCurrentFile3
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$unzOpenCurrentFile3 DD imagerel $LN29+165
	DD	imagerel $LN29+537
	DD	imagerel $chain$1$unzOpenCurrentFile3
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$unzOpenCurrentFile3 DD imagerel $LN29+537
	DD	imagerel $LN29+556
	DD	imagerel $chain$2$unzOpenCurrentFile3
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$unzOpenCurrentFile3 DD imagerel $LN29+556
	DD	imagerel $LN29+638
	DD	imagerel $chain$4$unzOpenCurrentFile3
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_CheckCurrentFileCoherencyHeader DD imagerel unz64local_CheckCurrentFileCoherencyHeader
	DD	imagerel unz64local_CheckCurrentFileCoherencyHeader+540
	DD	imagerel $unwind$unz64local_CheckCurrentFileCoherencyHeader
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGoToFilePos DD imagerel $LN5
	DD	imagerel $LN5+49
	DD	imagerel $unwind$unzGoToFilePos
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGoToFilePos64 DD imagerel $LN6
	DD	imagerel $LN6+50
	DD	imagerel $unwind$unzGoToFilePos64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$unzGoToFilePos64 DD imagerel $LN6+50
	DD	imagerel $LN6+114
	DD	imagerel $chain$0$unzGoToFilePos64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$unzGoToFilePos64 DD imagerel $LN6+114
	DD	imagerel $LN6+125
	DD	imagerel $chain$1$unzGoToFilePos64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGetFilePos DD imagerel $LN6
	DD	imagerel $LN6+42
	DD	imagerel $unwind$unzGetFilePos
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzLocateFile DD imagerel $LN24
	DD	imagerel $LN24+98
	DD	imagerel $unwind$unzLocateFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$unzLocateFile DD imagerel $LN24+98
	DD	imagerel $LN24+471
	DD	imagerel $chain$3$unzLocateFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$5$unzLocateFile DD imagerel $LN24+471
	DD	imagerel $LN24+475
	DD	imagerel $chain$5$unzLocateFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGoToNextFile DD imagerel $LN9
	DD	imagerel $LN9+186
	DD	imagerel $unwind$unzGoToNextFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGoToFirstFile DD imagerel $LN5
	DD	imagerel $LN5+118
	DD	imagerel $unwind$unzGoToFirstFile
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGetCurrentFileInfo DD imagerel $LN7
	DD	imagerel $LN7+246
	DD	imagerel $unwind$unzGetCurrentFileInfo
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzGetCurrentFileInfo64 DD imagerel $LN4
	DD	imagerel $LN4+73
	DD	imagerel $unwind$unzGetCurrentFileInfo64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_GetCurrentFileInfoInternal DD imagerel unz64local_GetCurrentFileInfoInternal
	DD	imagerel unz64local_GetCurrentFileInfoInternal+1345
	DD	imagerel $unwind$unz64local_GetCurrentFileInfoInternal
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzClose DD imagerel $LN7
	DD	imagerel $LN7+66
	DD	imagerel $unwind$unzClose
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzOpen2_64 DD imagerel $LN7
	DD	imagerel $LN7+96
	DD	imagerel $unwind$unzOpen2_64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzOpen2 DD imagerel $LN7
	DD	imagerel $LN7+65
	DD	imagerel $unwind$unzOpen2
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unzOpenInternal DD imagerel unzOpenInternal
	DD	imagerel unzOpenInternal+174
	DD	imagerel $unwind$unzOpenInternal
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$unzOpenInternal DD imagerel unzOpenInternal+174
	DD	imagerel unzOpenInternal+874
	DD	imagerel $chain$3$unzOpenInternal
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$unzOpenInternal DD imagerel unzOpenInternal+874
	DD	imagerel unzOpenInternal+1105
	DD	imagerel $chain$4$unzOpenInternal
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_SearchCentralDir64 DD imagerel unz64local_SearchCentralDir64
	DD	imagerel unz64local_SearchCentralDir64+122
	DD	imagerel $unwind$unz64local_SearchCentralDir64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$2$unz64local_SearchCentralDir64 DD imagerel unz64local_SearchCentralDir64+122
	DD	imagerel unz64local_SearchCentralDir64+328
	DD	imagerel $chain$2$unz64local_SearchCentralDir64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$unz64local_SearchCentralDir64 DD imagerel unz64local_SearchCentralDir64+328
	DD	imagerel unz64local_SearchCentralDir64+535
	DD	imagerel $chain$3$unz64local_SearchCentralDir64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_SearchCentralDir DD imagerel unz64local_SearchCentralDir
	DD	imagerel unz64local_SearchCentralDir+65
	DD	imagerel $unwind$unz64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$unz64local_SearchCentralDir DD imagerel unz64local_SearchCentralDir+65
	DD	imagerel unz64local_SearchCentralDir+124
	DD	imagerel $chain$0$unz64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$unz64local_SearchCentralDir DD imagerel unz64local_SearchCentralDir+124
	DD	imagerel unz64local_SearchCentralDir+143
	DD	imagerel $chain$3$unz64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$5$unz64local_SearchCentralDir DD imagerel unz64local_SearchCentralDir+143
	DD	imagerel unz64local_SearchCentralDir+338
	DD	imagerel $chain$5$unz64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$6$unz64local_SearchCentralDir DD imagerel unz64local_SearchCentralDir+338
	DD	imagerel unz64local_SearchCentralDir+372
	DD	imagerel $chain$6$unz64local_SearchCentralDir
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_getLong64 DD imagerel unz64local_getLong64
	DD	imagerel unz64local_getLong64+369
	DD	imagerel $unwind$unz64local_getLong64
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_getLong DD imagerel unz64local_getLong
	DD	imagerel unz64local_getLong+205
	DD	imagerel $unwind$unz64local_getLong
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_getShort DD imagerel unz64local_getShort
	DD	imagerel unz64local_getShort+124
	DD	imagerel $unwind$unz64local_getShort
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$unz64local_getByte DD imagerel unz64local_getByte
	DD	imagerel unz64local_getByte+102
	DD	imagerel $unwind$unz64local_getByte
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_getByte DD 060f01H
	DD	08640fH
	DD	07340fH
	DD	0700b320fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_getShort DD 081401H
	DD	086414H
	DD	075414H
	DD	063414H
	DD	070103214H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_getLong DD 081501H
	DD	087415H
	DD	076415H
	DD	063415H
	DD	0e0113215H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_getLong64 DD 081501H
	DD	087415H
	DD	076415H
	DD	063415H
	DD	0e0113215H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$6$unz64local_SearchCentralDir DD 021H
	DD	imagerel unz64local_SearchCentralDir+124
	DD	imagerel unz64local_SearchCentralDir+143
	DD	imagerel $chain$3$unz64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$5$unz64local_SearchCentralDir DD 040a21H
	DD	0d740aH
	DD	0c6405H
	DD	imagerel unz64local_SearchCentralDir+124
	DD	imagerel unz64local_SearchCentralDir+143
	DD	imagerel $chain$3$unz64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$unz64local_SearchCentralDir DD 040521H
	DD	0a5405H
	DD	04f400H
	DD	imagerel unz64local_SearchCentralDir
	DD	imagerel unz64local_SearchCentralDir+65
	DD	imagerel $unwind$unz64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$unz64local_SearchCentralDir DD 020521H
	DD	04f405H
	DD	imagerel unz64local_SearchCentralDir
	DD	imagerel unz64local_SearchCentralDir+65
	DD	imagerel $unwind$unz64local_SearchCentralDir
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_SearchCentralDir DD 051001H
	DD	0e00c4210H
	DD	0c008d00aH
	DD	03006H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$unz64local_SearchCentralDir64 DD 021H
	DD	imagerel unz64local_SearchCentralDir64
	DD	imagerel unz64local_SearchCentralDir64+122
	DD	imagerel $unwind$unz64local_SearchCentralDir64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$unz64local_SearchCentralDir64 DD 020521H
	DD	055405H
	DD	imagerel unz64local_SearchCentralDir64
	DD	imagerel unz64local_SearchCentralDir64+122
	DD	imagerel $unwind$unz64local_SearchCentralDir64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_SearchCentralDir64 DD 0a4f01H
	DD	04744fH
	DD	0c3444H
	DD	0f00a520eH
	DD	0d006e008H
	DD	06002c004H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$unzOpenInternal DD 020021H
	DD	02af400H
	DD	imagerel unzOpenInternal
	DD	imagerel unzOpenInternal+174
	DD	imagerel $unwind$unzOpenInternal
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$unzOpenInternal DD 041021H
	DD	02af410H
	DD	02be408H
	DD	imagerel unzOpenInternal
	DD	imagerel unzOpenInternal+174
	DD	imagerel $unwind$unzOpenInternal
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzOpenInternal DD 09ab01H
	DD	03174abH
	DD	030349eH
	DD	02c0111H
	DD	06003c005H
	DD	05002H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzOpen2 DD 020701H
	DD	0110107H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzOpen2_64 DD 020701H
	DD	0110107H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzClose DD 020601H
	DD	030023206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_GetCurrentFileInfoInternal DD 0d7101H
	DD	015f471H
	DD	0167469H
	DD	0173461H
	DD	0180123H
	DD	0d015e017H
	DD	06011c013H
	DD	05010H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGetCurrentFileInfo64 DD 010401H
	DD	0a204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGetCurrentFileInfo DD 030901H
	DD	0160109H
	DD	03002H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGoToFirstFile DD 042a01H
	DD	0c342aH
	DD	070029206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGoToNextFile DD 048301H
	DD	0c3483H
	DD	070029206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$5$unzLocateFile DD 080021H
	DD	034f400H
	DD	035e400H
	DD	03cc400H
	DD	03b3400H
	DD	imagerel $LN24
	DD	imagerel $LN24+98
	DD	imagerel $unwind$unzLocateFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$unzLocateFile DD 083f21H
	DD	034f43fH
	DD	035e42bH
	DD	03cc41cH
	DD	03b3408H
	DD	imagerel $LN24
	DD	imagerel $LN24+98
	DD	imagerel $unwind$unzLocateFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzLocateFile DD 050b01H
	DD	036010bH
	DD	060037004H
	DD	05002H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGetFilePos DD 020601H
	DD	030025206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$unzGoToFilePos64 DD 021H
	DD	imagerel $LN6
	DD	imagerel $LN6+50
	DD	imagerel $unwind$unzGoToFilePos64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$unzGoToFilePos64 DD 020521H
	DD	0c3405H
	DD	imagerel $LN6
	DD	imagerel $LN6+50
	DD	imagerel $unwind$unzGoToFilePos64
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGoToFilePos64 DD 020601H
	DD	070029206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGoToFilePos DD 010401H
	DD	06204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unz64local_CheckCurrentFileCoherencyHeader DD 0b6601H
	DD	04d466H
	DD	0e545eH
	DD	0f00a420eH
	DD	0c006e008H
	DD	060037004H
	DD	03002H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$unzOpenCurrentFile3 DD 040021H
	DD	0bf400H
	DD	0a3400H
	DD	imagerel $LN29
	DD	imagerel $LN29+133
	DD	imagerel $unwind$unzOpenCurrentFile3
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$unzOpenCurrentFile3 DD 021H
	DD	imagerel $LN29+133
	DD	imagerel $LN29+165
	DD	imagerel $chain$0$unzOpenCurrentFile3
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$unzOpenCurrentFile3 DD 020521H
	DD	0bf405H
	DD	imagerel $LN29+133
	DD	imagerel $LN29+165
	DD	imagerel $chain$0$unzOpenCurrentFile3
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$unzOpenCurrentFile3 DD 020521H
	DD	0a3405H
	DD	imagerel $LN29
	DD	imagerel $LN29+133
	DD	imagerel $unwind$unzOpenCurrentFile3
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzOpenCurrentFile3 DD 060d01H
	DD	0c540dH
	DD	0e009520dH
	DD	060067007H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzOpenCurrentFile DD 010401H
	DD	06204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzOpenCurrentFilePassword DD 010401H
	DD	06204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzOpenCurrentFile2 DD 010401H
	DD	06204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$14$unzReadCurrentFile DD 0e0021H
	DD	04f400H
	DD	05e400H
	DD	06d400H
	DD	077400H
	DD	0c6400H
	DD	0b5400H
	DD	0a3400H
	DD	imagerel $LN56
	DD	imagerel $LN56+24
	DD	imagerel $unwind$unzReadCurrentFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$12$unzReadCurrentFile DD 0e6921H
	DD	04f469H
	DD	05e464H
	DD	06d45fH
	DD	07745aH
	DD	0c6455H
	DD	0b5450H
	DD	0a3400H
	DD	imagerel $LN56
	DD	imagerel $LN56+24
	DD	imagerel $unwind$unzReadCurrentFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$unzReadCurrentFile DD 020021H
	DD	0a3400H
	DD	imagerel $LN56
	DD	imagerel $LN56+24
	DD	imagerel $unwind$unzReadCurrentFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$unzReadCurrentFile DD 020021H
	DD	0a3400H
	DD	imagerel $LN56
	DD	imagerel $LN56+24
	DD	imagerel $unwind$unzReadCurrentFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$unzReadCurrentFile DD 020521H
	DD	0a3405H
	DD	imagerel $LN56
	DD	imagerel $LN56+24
	DD	imagerel $unwind$unzReadCurrentFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzReadCurrentFile DD 020601H
	DD	0c0027206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$8$unzGetLocalExtrafield DD 020021H
	DD	063400H
	DD	imagerel $LN13
	DD	imagerel $LN13+35
	DD	imagerel $unwind$unzGetLocalExtrafield
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$6$unzGetLocalExtrafield DD 020021H
	DD	063400H
	DD	imagerel $LN13
	DD	imagerel $LN13+35
	DD	imagerel $unwind$unzGetLocalExtrafield
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$unzGetLocalExtrafield DD 020021H
	DD	063400H
	DD	imagerel $LN13
	DD	imagerel $LN13+35
	DD	imagerel $unwind$unzGetLocalExtrafield
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$unzGetLocalExtrafield DD 020021H
	DD	063400H
	DD	imagerel $LN13
	DD	imagerel $LN13+35
	DD	imagerel $unwind$unzGetLocalExtrafield
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$unzGetLocalExtrafield DD 020521H
	DD	063405H
	DD	imagerel $LN13
	DD	imagerel $LN13+35
	DD	imagerel $unwind$unzGetLocalExtrafield
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGetLocalExtrafield DD 040a01H
	DD	07640aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$2$unzCloseCurrentFile DD 020021H
	DD	063400H
	DD	imagerel $LN12
	DD	imagerel $LN12+34
	DD	imagerel $unwind$unzCloseCurrentFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$unzCloseCurrentFile DD 020521H
	DD	063405H
	DD	imagerel $LN12
	DD	imagerel $LN12+34
	DD	imagerel $unwind$unzCloseCurrentFile
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzCloseCurrentFile DD 040a01H
	DD	07640aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$unzGetGlobalComment DD 084301H
	DD	066443H
	DD	08540fH
	DD	07340fH
	DD	0700b320fH
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_getByte
_TEXT	SEGMENT
c$ = 48
pzlib_filefunc_def$ = 48
filestream$ = 56
pi$ = 64
unz64local_getByte PROC					; COMDAT

; 213  : {

  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

; 214  :     unsigned char c;
; 215  :     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]

; 216  :     if (err==1)

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

; 217  :     {
; 218  :         *pi = (int)c;

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

; 219  :         return UNZ_OK;

  00036	33 c0		 xor	 eax, eax

; 224  :             return UNZ_ERRNO;
; 225  :         else
; 226  :             return UNZ_EOF;
; 227  :     }
; 228  : }

  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@unz64local:

; 220  :     }
; 221  :     else
; 222  :     {
; 223  :         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]

; 224  :             return UNZ_ERRNO;
; 225  :         else
; 226  :             return UNZ_EOF;
; 227  :     }
; 228  : }

  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
unz64local_getByte ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_getShort
_TEXT	SEGMENT
pzlib_filefunc_def$ = 48
filestream$ = 56
pX$ = 64
i$ = 72
unz64local_getShort PROC				; COMDAT

; 242  : {

  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

; 243  :     uLong x ;
; 244  :     int i = 0;

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

; 245  :     int err;
; 246  : 
; 247  :     err = unz64local_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	 unz64local_getByte

; 248  :     x = (uLong)i;

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

; 249  : 
; 250  :     if (err==UNZ_OK)

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

; 251  :         err = unz64local_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	 unz64local_getByte
  0004a	44 8b c8	 mov	 r9d, eax

; 253  : 
; 254  :     if (err==UNZ_OK)

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

; 252  :     x |= ((uLong)i)<<8;

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

; 255  :         *pX = x;

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

; 256  :     else
; 257  :         *pX = 0;

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

; 258  :     return err;
; 259  : }

  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
unz64local_getShort ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_getLong
_TEXT	SEGMENT
pzlib_filefunc_def$ = 48
filestream$ = 56
pX$ = 64
i$ = 72
unz64local_getLong PROC					; COMDAT

; 269  : {

  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

; 270  :     uLong x ;
; 271  :     int i = 0;

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

; 272  :     int err;
; 273  : 
; 274  :     err = unz64local_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	 unz64local_getByte

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

; 276  : 
; 277  :     if (err==UNZ_OK)

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

; 278  :         err = unz64local_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	 unz64local_getByte
  0004f	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00054	44 8b c8	 mov	 r9d, eax
$LN2@unz64local:

; 279  :     x |= ((uLong)i)<<8;

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

; 280  : 
; 281  :     if (err==UNZ_OK)

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

; 282  :         err = unz64local_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	 unz64local_getByte
  00074	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00079	44 8b c8	 mov	 r9d, eax
$LN3@unz64local:

; 283  :     x |= ((uLong)i)<<16;

  0007c	41 c1 e2 10	 shl	 r10d, 16
  00080	41 0b da	 or	 ebx, r10d

; 284  : 
; 285  :     if (err==UNZ_OK)

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

; 286  :         err = unz64local_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	 unz64local_getByte
  00098	44 8b c8	 mov	 r9d, eax

; 288  : 
; 289  :     if (err==UNZ_OK)

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

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

; 290  :         *pX = x;

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

; 291  :     else
; 292  :         *pX = 0;

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

; 293  :     return err;
; 294  : }

  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
unz64local_getLong ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_getLong64
_TEXT	SEGMENT
pzlib_filefunc_def$ = 48
filestream$ = 56
pX$ = 64
i$ = 72
unz64local_getLong64 PROC				; COMDAT

; 305  : {

  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

; 306  :     ZPOS64_T x ;
; 307  :     int i = 0;

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

; 308  :     int err;
; 309  : 
; 310  :     err = unz64local_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	 unz64local_getByte

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

; 312  : 
; 313  :     if (err==UNZ_OK)

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

; 314  :         err = unz64local_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	 unz64local_getByte
  0004f	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00054	44 8b c8	 mov	 r9d, eax
$LN2@unz64local:

; 315  :     x |= ((ZPOS64_T)i)<<8;

  00057	49 63 c2	 movsxd	 rax, r10d
  0005a	48 c1 e0 08	 shl	 rax, 8
  0005e	48 0b d8	 or	 rbx, rax

; 316  : 
; 317  :     if (err==UNZ_OK)

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

; 318  :         err = unz64local_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	 unz64local_getByte
  00076	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  0007b	44 8b c8	 mov	 r9d, eax
$LN3@unz64local:

; 319  :     x |= ((ZPOS64_T)i)<<16;

  0007e	49 63 c2	 movsxd	 rax, r10d
  00081	48 c1 e0 10	 shl	 rax, 16
  00085	48 0b d8	 or	 rbx, rax

; 320  : 
; 321  :     if (err==UNZ_OK)

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

; 322  :         err = unz64local_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	 unz64local_getByte
  0009d	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  000a2	44 8b c8	 mov	 r9d, eax
$LN4@unz64local:

; 323  :     x |= ((ZPOS64_T)i)<<24;

  000a5	49 63 c2	 movsxd	 rax, r10d
  000a8	48 c1 e0 18	 shl	 rax, 24
  000ac	48 0b d8	 or	 rbx, rax

; 324  : 
; 325  :     if (err==UNZ_OK)

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

; 326  :         err = unz64local_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	 unz64local_getByte
  000c4	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  000c9	44 8b c8	 mov	 r9d, eax
$LN5@unz64local:

; 327  :     x |= ((ZPOS64_T)i)<<32;

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

; 328  : 
; 329  :     if (err==UNZ_OK)

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

; 330  :         err = unz64local_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	 unz64local_getByte
  000eb	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  000f0	44 8b c8	 mov	 r9d, eax
$LN6@unz64local:

; 331  :     x |= ((ZPOS64_T)i)<<40;

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

; 332  : 
; 333  :     if (err==UNZ_OK)

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

; 334  :         err = unz64local_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	 unz64local_getByte
  00112	44 8b 54 24 48	 mov	 r10d, DWORD PTR i$[rsp]
  00117	44 8b c8	 mov	 r9d, eax
$LN7@unz64local:

; 335  :     x |= ((ZPOS64_T)i)<<48;

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

; 336  : 
; 337  :     if (err==UNZ_OK)

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

; 338  :         err = unz64local_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	 unz64local_getByte
  00139	44 8b c8	 mov	 r9d, eax

; 340  : 
; 341  :     if (err==UNZ_OK)

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

; 339  :     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 0b c3	 or	 rax, rbx

; 342  :         *pX = x;

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

; 343  :     else
; 344  :         *pX = 0;

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

; 345  :     return err;
; 346  : }

  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
unz64local_getLong64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT strcmpcasenosensitive_internal
_TEXT	SEGMENT
fileName1$ = 8
fileName2$ = 16
strcmpcasenosensitive_internal PROC			; COMDAT

; 350  : {

  00000	4c 8b d1	 mov	 r10, rcx

; 367  :     }

  00003	4c 2b d2	 sub	 r10, rdx
  00006	66 66 0f 1f 84
	00 00 00 00 00	 npad	 10
$LL2@strcmpcase:

; 351  :     for (;;)
; 352  :     {
; 353  :         char c1=*(fileName1++);
; 354  :         char c2=*(fileName2++);

  00010	45 0f b6 0c 12	 movzx	 r9d, BYTE PTR [r10+rdx]
  00015	0f b6 02	 movzx	 eax, BYTE PTR [rdx]
  00018	48 8d 52 01	 lea	 rdx, QWORD PTR [rdx+1]

; 355  :         if ((c1>='a') && (c1<='z'))

  0001c	45 8d 41 9f	 lea	 r8d, DWORD PTR [r9-97]
  00020	41 80 f8 19	 cmp	 r8b, 25
  00024	77 04		 ja	 SHORT $LN5@strcmpcase

; 356  :             c1 -= 0x20;

  00026	41 80 c1 e0	 add	 r9b, -32		; ffffffffffffffe0H
$LN5@strcmpcase:

; 357  :         if ((c2>='a') && (c2<='z'))

  0002a	8d 48 9f	 lea	 ecx, DWORD PTR [rax-97]
  0002d	80 f9 19	 cmp	 cl, 25
  00030	77 02		 ja	 SHORT $LN6@strcmpcase

; 358  :             c2 -= 0x20;

  00032	04 e0		 add	 al, -32			; ffffffffffffffe0H
$LN6@strcmpcase:

; 359  :         if (c1=='\0')

  00034	45 84 c9	 test	 r9b, r9b
  00037	74 15		 je	 SHORT $LN14@strcmpcase

; 361  :         if (c2=='\0')

  00039	84 c0		 test	 al, al
  0003b	74 07		 je	 SHORT $LN15@strcmpcase

; 362  :             return 1;
; 363  :         if (c1<c2)

  0003d	44 3a c8	 cmp	 r9b, al
  00040	7c 08		 jl	 SHORT $LN16@strcmpcase

; 365  :         if (c1>c2)

  00042	7e cc		 jle	 SHORT $LL2@strcmpcase
$LN15@strcmpcase:

; 366  :             return 1;

  00044	b8 01 00 00 00	 mov	 eax, 1

; 368  : }

  00049	c3		 ret	 0
$LN16@strcmpcase:

; 364  :             return -1;

  0004a	83 c8 ff	 or	 eax, -1

; 368  : }

  0004d	c3		 ret	 0
$LN14@strcmpcase:

; 360  :             return ((c2=='\0') ? 0 : -1);

  0004e	f6 d8		 neg	 al
  00050	1b c0		 sbb	 eax, eax

; 368  : }

  00052	c3		 ret	 0
strcmpcasenosensitive_internal ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzStringFileNameCompare
_TEXT	SEGMENT
fileName1$ = 8
fileName2$ = 16
iCaseSensitivity$ = 24
unzStringFileNameCompare PROC				; COMDAT

; 394  : {

  00000	45 85 c0	 test	 r8d, r8d
  00003	b8 02 00 00 00	 mov	 eax, 2
  00008	41 0f 45 c0	 cmovne	 eax, r8d

; 395  :     if (iCaseSensitivity==0)
; 396  :         iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
; 397  : 
; 398  :     if (iCaseSensitivity==1)

  0000c	83 f8 01	 cmp	 eax, 1
  0000f	75 1b		 jne	 SHORT $LN3@unzStringF

; 399  :         return strcmp(fileName1,fileName2);

  00011	48 2b d1	 sub	 rdx, rcx
$LL5@unzStringF:
  00014	0f b6 01	 movzx	 eax, BYTE PTR [rcx]
  00017	3a 04 11	 cmp	 al, BYTE PTR [rcx+rdx]
  0001a	75 0a		 jne	 SHORT $LN7@unzStringF
  0001c	48 ff c1	 inc	 rcx
  0001f	84 c0		 test	 al, al
  00021	75 f1		 jne	 SHORT $LL5@unzStringF
  00023	33 c0		 xor	 eax, eax

; 402  : }

  00025	c3		 ret	 0
$LN7@unzStringF:

; 399  :         return strcmp(fileName1,fileName2);

  00026	1b c0		 sbb	 eax, eax
  00028	83 c8 01	 or	 eax, 1

; 402  : }

  0002b	c3		 ret	 0
$LN3@unzStringF:

; 400  : 
; 401  :     return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);

  0002c	e9 00 00 00 00	 jmp	 strcmpcasenosensitive_internal
unzStringFileNameCompare ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_SearchCentralDir
_TEXT	SEGMENT
pzlib_filefunc_def$ = 80
filestream$ = 88
unz64local_SearchCentralDir PROC			; COMDAT

; 414  : {

  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

; 415  :     unsigned char* buf;
; 416  :     ZPOS64_T uSizeFile;
; 417  :     ZPOS64_T uBackRead;
; 418  :     ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
; 419  :     ZPOS64_T uPosFound=0;

  00010	45 33 e4	 xor	 r12d, r12d

; 420  : 
; 421  :     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@unz64local

; 422  :         return 0;

  00030	33 c0		 xor	 eax, eax

; 467  : }

  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@unz64local:

; 423  : 
; 424  : 
; 425  :     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

; 426  : 
; 427  :     if (uMaxBack>uSizeFile)

  0004e	49 3b c6	 cmp	 rax, r14

; 428  :         uMaxBack = uSizeFile;
; 429  : 
; 430  :     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

; 431  :     if (buf==NULL)

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

; 467  : }

  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@unz64local:
  0007c	48 89 6c 24 50	 mov	 QWORD PTR [rsp+80], rbp

; 432  :         return 0;
; 433  : 
; 434  :     uBackRead = 4;

  00081	bd 04 00 00 00	 mov	 ebp, 4

; 435  :     while (uBackRead<uMaxBack)

  00086	49 3b ee	 cmp	 rbp, r14
  00089	0f 83 c3 00 00
	00		 jae	 $LN33@unz64local
  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@unz64local:

; 436  :     {
; 437  :         uLong uReadSize;
; 438  :         ZPOS64_T uReadPos ;
; 439  :         int i;
; 440  :         if (uBackRead+BUFREADCOMMENT>uMaxBack)

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

; 441  :             uBackRead = uMaxBack;
; 442  :         else
; 443  :             uBackRead+=BUFREADCOMMENT;
; 444  :         uReadPos = uSizeFile-uBackRead ;

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

; 445  : 
; 446  :         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@unz64local
  000c5	bf 04 04 00 00	 mov	 edi, 1028		; 00000404H
  000ca	eb 05		 jmp	 SHORT $LN19@unz64local
$LN18@unz64local:
  000cc	41 8b ff	 mov	 edi, r15d
  000cf	2b fe		 sub	 edi, esi
$LN19@unz64local:

; 447  :                      (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
; 448  :         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@unz64local

; 449  :             break;
; 450  : 
; 451  :         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@unz64local

; 452  :             break;
; 453  : 
; 454  :         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@unz64local
  00109	0f 1f 80 00 00
	00 00		 npad	 7
$LL4@unz64local:
  00110	48 ff c8	 dec	 rax
  00113	ff c9		 dec	 ecx

; 455  :             if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
; 456  :                 ((*(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@unz64local
  0011b	80 7c 18 01 4b	 cmp	 BYTE PTR [rax+rbx+1], 75 ; 0000004bH
  00120	75 0e		 jne	 SHORT $LN14@unz64local
  00122	80 7c 18 02 05	 cmp	 BYTE PTR [rax+rbx+2], 5
  00127	75 07		 jne	 SHORT $LN14@unz64local
  00129	80 7c 18 03 06	 cmp	 BYTE PTR [rax+rbx+3], 6
  0012e	74 07		 je	 SHORT $LN22@unz64local
$LN14@unz64local:

; 452  :             break;
; 453  : 
; 454  :         for (i=(int)uReadSize-3; (i--)>0;)

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

; 457  :             {
; 458  :                 uPosFound = uReadPos+i;

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

; 459  :                 break;
; 460  :             }
; 461  : 
; 462  :         if (uPosFound!=0)

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

; 435  :     while (uBackRead<uMaxBack)

  0013f	49 3b ee	 cmp	 rbp, r14
  00142	0f 82 58 ff ff
	ff		 jb	 $LL2@unz64local
$LN36@unz64local:
  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@unz64local:

; 463  :             break;
; 464  :     }
; 465  :     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]

; 466  :     return uPosFound;

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

; 467  : }

  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
unz64local_SearchCentralDir ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_SearchCentralDir64
_TEXT	SEGMENT
pzlib_filefunc_def$ = 96
filestream$ = 104
uSizeFile$1$ = 112
uL$ = 112
relativeOffset$ = 120
unz64local_SearchCentralDir64 PROC			; COMDAT

; 480  : {

  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

; 481  :     unsigned char* buf;
; 482  :     ZPOS64_T uSizeFile;
; 483  :     ZPOS64_T uBackRead;
; 484  :     ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
; 485  :     ZPOS64_T uPosFound=0;

  0000e	33 f6		 xor	 esi, esi

; 486  :     uLong uL;
; 487  :                 ZPOS64_T relativeOffset;
; 488  : 
; 489  :     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@unz64local

; 490  :         return 0;

  0002f	33 c0		 xor	 eax, eax

; 570  :         return 0;
; 571  : 
; 572  :     return relativeOffset;
; 573  : }

  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@unz64local:
  0003f	48 89 5c 24 60	 mov	 QWORD PTR [rsp+96], rbx

; 491  : 
; 492  : 
; 493  :     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

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

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

; 496  :         uMaxBack = uSizeFile;
; 497  : 
; 498  :     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

; 499  :     if (buf==NULL)

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

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

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

; 503  :     while (uBackRead<uMaxBack)

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

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

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

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

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

; 513  : 
; 514  :         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@unz64local
  000b5	bf 04 04 00 00	 mov	 edi, 1028		; 00000404H
  000ba	eb 02		 jmp	 SHORT $LN30@unz64local
$LN29@unz64local:
  000bc	2b fe		 sub	 edi, esi
$LN30@unz64local:

; 515  :                      (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
; 516  :         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@unz64local

; 517  :             break;
; 518  : 
; 519  :         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@unz64local

; 520  :             break;
; 521  : 
; 522  :         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@unz64local
$LL4@unz64local:
  000f2	48 ff c8	 dec	 rax
  000f5	ff c9		 dec	 ecx

; 523  :             if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
; 524  :                 ((*(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@unz64local
  000fd	80 7c 18 01 4b	 cmp	 BYTE PTR [rax+rbx+1], 75 ; 0000004bH
  00102	75 0e		 jne	 SHORT $LN14@unz64local
  00104	80 7c 18 02 06	 cmp	 BYTE PTR [rax+rbx+2], 6
  00109	75 07		 jne	 SHORT $LN14@unz64local
  0010b	80 7c 18 03 07	 cmp	 BYTE PTR [rax+rbx+3], 7
  00110	74 07		 je	 SHORT $LN33@unz64local
$LN14@unz64local:

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

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

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

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

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

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

; 503  :     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@unz64local
$LN44@unz64local:
  0012f	33 f6		 xor	 esi, esi
$LN34@unz64local:

; 531  :             break;
; 532  :     }
; 533  :     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]

; 534  :     if (uPosFound == 0)

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

; 535  :         return 0;
; 536  : 
; 537  :     /* Zip64 end of central directory locator */
; 538  :     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@unz64local

; 539  :         return 0;
; 540  : 
; 541  :     /* the signature, already checked */
; 542  :     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_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	 unz64local_getLong
  00171	85 c0		 test	 eax, eax
  00173	75 77		 jne	 SHORT $LN47@unz64local

; 543  :         return 0;
; 544  : 
; 545  :     /* number of the disk with the start of the zip64 end of  central directory */
; 546  :     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_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	 unz64local_getLong
  00185	85 c0		 test	 eax, eax
  00187	75 63		 jne	 SHORT $LN47@unz64local

; 547  :         return 0;
; 548  :     if (uL != 0)

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

; 549  :         return 0;
; 550  : 
; 551  :     /* relative offset of the zip64 end of central directory record */
; 552  :     if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_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	 unz64local_getLong64
  0019f	85 c0		 test	 eax, eax
  001a1	75 49		 jne	 SHORT $LN47@unz64local

; 553  :         return 0;
; 554  : 
; 555  :     /* total number of disks */
; 556  :     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_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	 unz64local_getLong
  001b3	85 c0		 test	 eax, eax
  001b5	75 35		 jne	 SHORT $LN47@unz64local

; 557  :         return 0;
; 558  :     if (uL != 1)

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

; 559  :         return 0;
; 560  : 
; 561  :     /* Goto end of central directory record */
; 562  :     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@unz64local

; 563  :         return 0;
; 564  : 
; 565  :      /* the signature */
; 566  :     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_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	 unz64local_getLong
  001e8	85 c0		 test	 eax, eax
  001ea	74 04		 je	 SHORT $LN26@unz64local
$LN47@unz64local:

; 567  :         return 0;

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

; 568  : 
; 569  :     if (uL != 0x06064b50)

  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@unz64local:
  001ff	48 8b 5c 24 60	 mov	 rbx, QWORD PTR [rsp+96]
  00204	48 8b 7c 24 20	 mov	 rdi, QWORD PTR [rsp+32]

; 570  :         return 0;
; 571  : 
; 572  :     return relativeOffset;
; 573  : }

  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
unz64local_SearchCentralDir64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpenInternal
_TEXT	SEGMENT
number_disk_with_CD$ = 32
number_disk$ = 36
us$ = 48
path$ = 384
pzlib_filefunc64_32_def$ = 392
is64bitOpenFunction$ = 400
number_entry_CD$ = 408
uS$1 = 408
uL64$2 = 408
uL$ = 408
unzOpenInternal PROC					; COMDAT

; 587  : {

  00000	40 55		 push	 rbp
  00002	56		 push	 rsi
  00003	41 54		 push	 r12
  00005	48 8d 6c 24 a0	 lea	 rbp, QWORD PTR [rsp-96]
  0000a	48 81 ec 60 01
	00 00		 sub	 rsp, 352		; 00000160H

; 588  :     unz64_s us;
; 589  :     unz64_s *s;
; 590  :     ZPOS64_T central_pos;
; 591  :     uLong   uL;
; 592  : 
; 593  :     uLong number_disk;          /* number of the current dist, used for
; 594  :                                    spaning ZIP, unsupported, always 0*/
; 595  :     uLong number_disk_with_CD;  /* number the the disk with central dir, used
; 596  :                                    for spaning ZIP, unsupported, always 0*/
; 597  :     ZPOS64_T number_entry_CD;      /* total number of entries in
; 598  :                                    the central dir
; 599  :                                    (same than number_entry on nospan) */
; 600  : 
; 601  :     int err=UNZ_OK;

  00011	45 33 e4	 xor	 r12d, r12d
  00014	4c 8b c9	 mov	 r9, rcx

; 602  : 
; 603  :     if (unz_copyright[0]!=' ')
; 604  :         return NULL;
; 605  : 
; 606  :     us.z_filefunc.zseek32_file = NULL;

  00017	4c 89 65 80	 mov	 QWORD PTR us$[rbp-176], r12

; 607  :     us.z_filefunc.ztell32_file = NULL;

  0001b	4c 89 64 24 78	 mov	 QWORD PTR us$[rsp+72], r12

; 608  :     if (pzlib_filefunc64_32_def==NULL)

  00020	48 85 d2	 test	 rdx, rdx
  00023	75 0c		 jne	 SHORT $LN3@unzOpenInt

; 609  :         fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);

  00025	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  0002a	e8 00 00 00 00	 call	 fill_fopen64_filefunc
  0002f	eb 36		 jmp	 SHORT $LN4@unzOpenInt
$LN3@unzOpenInt:

; 610  :     else
; 611  :         us.z_filefunc = *pzlib_filefunc64_32_def;

  00031	0f 28 02	 movaps	 xmm0, XMMWORD PTR [rdx]
  00034	0f 28 4a 10	 movaps	 xmm1, XMMWORD PTR [rdx+16]
  00038	0f 29 44 24 30	 movaps	 XMMWORD PTR us$[rsp], xmm0
  0003d	0f 28 42 20	 movaps	 xmm0, XMMWORD PTR [rdx+32]
  00041	0f 29 4c 24 40	 movaps	 XMMWORD PTR us$[rsp+16], xmm1
  00046	0f 28 4a 30	 movaps	 xmm1, XMMWORD PTR [rdx+48]
  0004a	0f 29 44 24 50	 movaps	 XMMWORD PTR us$[rsp+32], xmm0
  0004f	0f 28 42 40	 movaps	 xmm0, XMMWORD PTR [rdx+64]
  00053	0f 29 4c 24 60	 movaps	 XMMWORD PTR us$[rsp+48], xmm1
  00058	f2 0f 10 4a 50	 movsd	 xmm1, QWORD PTR [rdx+80]
  0005d	0f 29 44 24 70	 movaps	 XMMWORD PTR us$[rsp+64], xmm0
  00062	f2 0f 11 4d 80	 movsd	 QWORD PTR us$[rbp-176], xmm1
$LN4@unzOpenInt:

; 612  :     us.is64bitOpenFunction = is64bitOpenFunction;

  00067	44 89 45 88	 mov	 DWORD PTR us$[rbp-168], r8d

; 613  : 
; 614  : 
; 615  : 
; 616  :     us.filestream = ZOPEN64(us.z_filefunc,

  0006b	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00070	41 b8 05 00 00
	00		 mov	 r8d, 5
  00076	49 8b d1	 mov	 rdx, r9
  00079	e8 00 00 00 00	 call	 call_zopen64
  0007e	48 89 45 90	 mov	 QWORD PTR us$[rbp-160], rax
  00082	48 8b f0	 mov	 rsi, rax

; 617  :                                                  path,
; 618  :                                                  ZLIB_FILEFUNC_MODE_READ |
; 619  :                                                  ZLIB_FILEFUNC_MODE_EXISTING);
; 620  :     if (us.filestream==NULL)

  00085	48 85 c0	 test	 rax, rax
  00088	75 0c		 jne	 SHORT $LN5@unzOpenInt

; 762  : }

  0008a	48 81 c4 60 01
	00 00		 add	 rsp, 352		; 00000160H
  00091	41 5c		 pop	 r12
  00093	5e		 pop	 rsi
  00094	5d		 pop	 rbp
  00095	c3		 ret	 0
$LN5@unzOpenInt:
  00096	48 89 9c 24 80
	01 00 00	 mov	 QWORD PTR [rsp+384], rbx

; 621  :         return NULL;
; 622  : 
; 623  :     central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);

  0009e	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  000a3	48 89 bc 24 88
	01 00 00	 mov	 QWORD PTR [rsp+392], rdi
  000ab	48 8b d6	 mov	 rdx, rsi
  000ae	4c 89 b4 24 58
	01 00 00	 mov	 QWORD PTR [rsp+344], r14
  000b6	4c 89 bc 24 50
	01 00 00	 mov	 QWORD PTR [rsp+336], r15
  000be	e8 00 00 00 00	 call	 unz64local_SearchCentralDir64

; 624  :     if (central_pos)
; 625  :     {
; 626  :         uLong uS;
; 627  :         ZPOS64_T uL64;
; 628  : 
; 629  :         us.isZip64 = 1;
; 630  : 
; 631  :         if (ZSEEK64(us.z_filefunc, us.filestream,
; 632  :                                       central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)

  000c3	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  000c8	4c 8b f8	 mov	 r15, rax
  000cb	48 8b d6	 mov	 rdx, rsi
  000ce	48 85 c0	 test	 rax, rax
  000d1	0f 84 3e 01 00
	00		 je	 $LN6@unzOpenInt
  000d7	45 33 c9	 xor	 r9d, r9d
  000da	c7 45 4c 01 00
	00 00		 mov	 DWORD PTR us$[rbp+28], 1
  000e1	4c 8b c0	 mov	 r8, rax
  000e4	e8 00 00 00 00	 call	 call_zseek64
  000e9	41 83 ce ff	 or	 r14d, -1

; 633  :         err=UNZ_ERRNO;
; 634  : 
; 635  :         /* the signature, already checked */
; 636  :         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

  000ed	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uL$[rbp-256]
  000f4	85 c0		 test	 eax, eax
  000f6	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  000fb	41 8b fc	 mov	 edi, r12d
  000fe	48 8b d6	 mov	 rdx, rsi
  00101	41 0f 45 fe	 cmovne	 edi, r14d
  00105	e8 00 00 00 00	 call	 unz64local_getLong
  0010a	85 c0		 test	 eax, eax

; 637  :             err=UNZ_ERRNO;
; 638  : 
; 639  :         /* size of zip64 end of central directory record */
; 640  :         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)

  0010c	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uL64$2[rbp-256]
  00113	48 8b d6	 mov	 rdx, rsi
  00116	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  0011b	41 0f 45 fe	 cmovne	 edi, r14d
  0011f	e8 00 00 00 00	 call	 unz64local_getLong64
  00124	85 c0		 test	 eax, eax

; 641  :             err=UNZ_ERRNO;
; 642  : 
; 643  :         /* version made by */
; 644  :         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)

  00126	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uS$1[rbp-256]
  0012d	48 8b d6	 mov	 rdx, rsi
  00130	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00135	41 0f 45 fe	 cmovne	 edi, r14d
  00139	e8 00 00 00 00	 call	 unz64local_getShort
  0013e	85 c0		 test	 eax, eax

; 645  :             err=UNZ_ERRNO;
; 646  : 
; 647  :         /* version needed to extract */
; 648  :         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)

  00140	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uS$1[rbp-256]
  00147	48 8b d6	 mov	 rdx, rsi
  0014a	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  0014f	41 0f 45 fe	 cmovne	 edi, r14d
  00153	e8 00 00 00 00	 call	 unz64local_getShort
  00158	85 c0		 test	 eax, eax

; 649  :             err=UNZ_ERRNO;
; 650  : 
; 651  :         /* number of this disk */
; 652  :         if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)

  0015a	4c 8d 44 24 24	 lea	 r8, QWORD PTR number_disk$[rsp]
  0015f	48 8b d6	 mov	 rdx, rsi
  00162	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00167	41 0f 45 fe	 cmovne	 edi, r14d
  0016b	e8 00 00 00 00	 call	 unz64local_getLong
  00170	85 c0		 test	 eax, eax

; 653  :             err=UNZ_ERRNO;
; 654  : 
; 655  :         /* number of the disk with the start of the central directory */
; 656  :         if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)

  00172	4c 8d 44 24 20	 lea	 r8, QWORD PTR number_disk_with_CD$[rsp]
  00177	48 8b d6	 mov	 rdx, rsi
  0017a	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  0017f	41 0f 45 fe	 cmovne	 edi, r14d
  00183	e8 00 00 00 00	 call	 unz64local_getLong
  00188	85 c0		 test	 eax, eax

; 657  :             err=UNZ_ERRNO;
; 658  : 
; 659  :         /* total number of entries in the central directory on this disk */
; 660  :         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)

  0018a	4c 8d 45 98	 lea	 r8, QWORD PTR us$[rbp-152]
  0018e	48 8b d6	 mov	 rdx, rsi
  00191	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00196	41 0f 45 fe	 cmovne	 edi, r14d
  0019a	e8 00 00 00 00	 call	 unz64local_getLong64

; 661  :             err=UNZ_ERRNO;
; 662  : 
; 663  :         /* total number of entries in the central directory */
; 664  :         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)

  0019f	48 8b 5d 90	 mov	 rbx, QWORD PTR us$[rbp-160]
  001a3	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR number_entry_CD$[rbp-256]
  001aa	85 c0		 test	 eax, eax
  001ac	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  001b1	48 8b d3	 mov	 rdx, rbx
  001b4	41 0f 45 fe	 cmovne	 edi, r14d
  001b8	e8 00 00 00 00	 call	 unz64local_getLong64
  001bd	85 c0		 test	 eax, eax

; 665  :             err=UNZ_ERRNO;
; 666  : 
; 667  :         if ((number_entry_CD!=us.gi.number_entry) ||
; 668  :             (number_disk_with_CD!=0) ||

  001bf	48 8b 45 98	 mov	 rax, QWORD PTR us$[rbp-152]
  001c3	41 0f 45 fe	 cmovne	 edi, r14d
  001c7	48 39 85 98 00
	00 00		 cmp	 QWORD PTR number_entry_CD$[rbp-256], rax
  001ce	75 0e		 jne	 SHORT $LN18@unzOpenInt
  001d0	44 39 64 24 20	 cmp	 DWORD PTR number_disk_with_CD$[rsp], r12d
  001d5	75 07		 jne	 SHORT $LN18@unzOpenInt
  001d7	44 39 64 24 24	 cmp	 DWORD PTR number_disk$[rsp], r12d
  001dc	74 05		 je	 SHORT $LN17@unzOpenInt
$LN18@unzOpenInt:

; 669  :             (number_disk!=0))
; 670  :             err=UNZ_BADZIPFILE;

  001de	bf 99 ff ff ff	 mov	 edi, -103		; ffffffffffffff99H
$LN17@unzOpenInt:

; 671  : 
; 672  :         /* size of the central directory */
; 673  :         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)

  001e3	4c 8d 45 d0	 lea	 r8, QWORD PTR us$[rbp-96]
  001e7	48 8b d3	 mov	 rdx, rbx
  001ea	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  001ef	e8 00 00 00 00	 call	 unz64local_getLong64

; 674  :             err=UNZ_ERRNO;
; 675  : 
; 676  :         /* offset of start of central directory with respect to the
; 677  :           starting disk number */
; 678  :         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)

  001f4	48 8b 55 90	 mov	 rdx, QWORD PTR us$[rbp-160]
  001f8	4c 8d 45 d8	 lea	 r8, QWORD PTR us$[rbp-88]
  001fc	85 c0		 test	 eax, eax
  001fe	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00203	41 0f 45 fe	 cmovne	 edi, r14d
  00207	e8 00 00 00 00	 call	 unz64local_getLong64

; 679  :             err=UNZ_ERRNO;
; 680  : 
; 681  :         us.gi.size_comment = 0;

  0020c	44 89 65 a0	 mov	 DWORD PTR us$[rbp-144], r12d

; 682  :     }

  00210	e9 32 01 00 00	 jmp	 $LN42@unzOpenInt
$LN6@unzOpenInt:

; 683  :     else
; 684  :     {
; 685  :         central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);

  00215	e8 00 00 00 00	 call	 unz64local_SearchCentralDir

; 686  :         if (central_pos==0)

  0021a	41 83 ce ff	 or	 r14d, -1

; 687  :             err=UNZ_ERRNO;
; 688  : 
; 689  :         us.isZip64 = 0;

  0021e	44 89 65 4c	 mov	 DWORD PTR us$[rbp+28], r12d
  00222	48 85 c0	 test	 rax, rax

; 690  : 
; 691  :         if (ZSEEK64(us.z_filefunc, us.filestream,
; 692  :                                         central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)

  00225	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  0022a	41 8b fc	 mov	 edi, r12d
  0022d	4c 8b c0	 mov	 r8, rax
  00230	41 0f 44 fe	 cmove	 edi, r14d
  00234	48 8b d6	 mov	 rdx, rsi
  00237	45 33 c9	 xor	 r9d, r9d
  0023a	4c 8b f8	 mov	 r15, rax
  0023d	e8 00 00 00 00	 call	 call_zseek64
  00242	85 c0		 test	 eax, eax

; 693  :             err=UNZ_ERRNO;
; 694  : 
; 695  :         /* the signature, already checked */
; 696  :         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

  00244	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uL$[rbp-256]
  0024b	48 8b d6	 mov	 rdx, rsi
  0024e	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00253	41 0f 45 fe	 cmovne	 edi, r14d
  00257	e8 00 00 00 00	 call	 unz64local_getLong
  0025c	85 c0		 test	 eax, eax

; 697  :             err=UNZ_ERRNO;
; 698  : 
; 699  :         /* number of this disk */
; 700  :         if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)

  0025e	4c 8d 44 24 24	 lea	 r8, QWORD PTR number_disk$[rsp]
  00263	48 8b d6	 mov	 rdx, rsi
  00266	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  0026b	41 0f 45 fe	 cmovne	 edi, r14d
  0026f	e8 00 00 00 00	 call	 unz64local_getShort
  00274	85 c0		 test	 eax, eax

; 701  :             err=UNZ_ERRNO;
; 702  : 
; 703  :         /* number of the disk with the start of the central directory */
; 704  :         if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)

  00276	4c 8d 44 24 20	 lea	 r8, QWORD PTR number_disk_with_CD$[rsp]
  0027b	48 8b d6	 mov	 rdx, rsi
  0027e	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00283	41 0f 45 fe	 cmovne	 edi, r14d
  00287	e8 00 00 00 00	 call	 unz64local_getShort
  0028c	85 c0		 test	 eax, eax

; 705  :             err=UNZ_ERRNO;
; 706  : 
; 707  :         /* total number of entries in the central dir on this disk */
; 708  :         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

  0028e	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uL$[rbp-256]
  00295	48 8b d6	 mov	 rdx, rsi
  00298	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  0029d	41 0f 45 fe	 cmovne	 edi, r14d
  002a1	e8 00 00 00 00	 call	 unz64local_getShort

; 709  :             err=UNZ_ERRNO;
; 710  :         us.gi.number_entry = uL;

  002a6	8b 9d 98 00 00
	00		 mov	 ebx, DWORD PTR uL$[rbp-256]

; 711  : 
; 712  :         /* total number of entries in the central dir */
; 713  :         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

  002ac	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uL$[rbp-256]
  002b3	85 c0		 test	 eax, eax
  002b5	48 89 5d 98	 mov	 QWORD PTR us$[rbp-152], rbx
  002b9	48 8b d6	 mov	 rdx, rsi
  002bc	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  002c1	41 0f 45 fe	 cmovne	 edi, r14d
  002c5	e8 00 00 00 00	 call	 unz64local_getShort
  002ca	85 c0		 test	 eax, eax

; 714  :             err=UNZ_ERRNO;
; 715  :         number_entry_CD = uL;

  002cc	8b 85 98 00 00
	00		 mov	 eax, DWORD PTR uL$[rbp-256]
  002d2	41 0f 45 fe	 cmovne	 edi, r14d

; 716  : 
; 717  :         if ((number_entry_CD!=us.gi.number_entry) ||
; 718  :             (number_disk_with_CD!=0) ||

  002d6	48 3b c3	 cmp	 rax, rbx
  002d9	75 0e		 jne	 SHORT $LN29@unzOpenInt
  002db	44 39 64 24 20	 cmp	 DWORD PTR number_disk_with_CD$[rsp], r12d
  002e0	75 07		 jne	 SHORT $LN29@unzOpenInt
  002e2	44 39 64 24 24	 cmp	 DWORD PTR number_disk$[rsp], r12d
  002e7	74 05		 je	 SHORT $LN28@unzOpenInt
$LN29@unzOpenInt:

; 719  :             (number_disk!=0))
; 720  :             err=UNZ_BADZIPFILE;

  002e9	bf 99 ff ff ff	 mov	 edi, -103		; ffffffffffffff99H
$LN28@unzOpenInt:

; 721  : 
; 722  :         /* size of the central directory */
; 723  :         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

  002ee	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uL$[rbp-256]
  002f5	48 8b d6	 mov	 rdx, rsi
  002f8	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  002fd	e8 00 00 00 00	 call	 unz64local_getLong
  00302	85 c0		 test	 eax, eax

; 724  :             err=UNZ_ERRNO;
; 725  :         us.size_central_dir = uL;
; 726  : 
; 727  :         /* offset of start of central directory with respect to the
; 728  :             starting disk number */
; 729  :         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

  00304	4c 8d 85 98 00
	00 00		 lea	 r8, QWORD PTR uL$[rbp-256]
  0030b	8b 85 98 00 00
	00		 mov	 eax, DWORD PTR uL$[rbp-256]
  00311	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00316	48 8b d6	 mov	 rdx, rsi
  00319	48 89 45 d0	 mov	 QWORD PTR us$[rbp-96], rax
  0031d	41 0f 45 fe	 cmovne	 edi, r14d
  00321	e8 00 00 00 00	 call	 unz64local_getLong
  00326	85 c0		 test	 eax, eax

; 730  :             err=UNZ_ERRNO;
; 731  :         us.offset_central_dir = uL;
; 732  : 
; 733  :         /* zipfile comment length */
; 734  :         if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)

  00328	4c 8d 45 a0	 lea	 r8, QWORD PTR us$[rbp-144]
  0032c	8b 85 98 00 00
	00		 mov	 eax, DWORD PTR uL$[rbp-256]
  00332	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  00337	48 8b d6	 mov	 rdx, rsi
  0033a	48 89 45 d8	 mov	 QWORD PTR us$[rbp-88], rax
  0033e	41 0f 45 fe	 cmovne	 edi, r14d
  00342	e8 00 00 00 00	 call	 unz64local_getShort
$LN42@unzOpenInt:

; 735  :             err=UNZ_ERRNO;
; 736  :     }
; 737  : 
; 738  :     if ((central_pos<us.offset_central_dir+us.size_central_dir) &&

  00347	48 8b 4d d8	 mov	 rcx, QWORD PTR us$[rbp-88]
  0034b	85 c0		 test	 eax, eax
  0034d	48 8b 55 d0	 mov	 rdx, QWORD PTR us$[rbp-96]
  00351	41 0f 45 fe	 cmovne	 edi, r14d
  00355	4c 8b b4 24 58
	01 00 00	 mov	 r14, QWORD PTR [rsp+344]
  0035d	48 8d 04 11	 lea	 rax, QWORD PTR [rcx+rdx]
  00361	4c 3b f8	 cmp	 r15, rax
  00364	0f 82 b4 00 00
	00		 jb	 $LN37@unzOpenInt

; 739  :         (err==UNZ_OK))
; 740  :         err=UNZ_BADZIPFILE;
; 741  : 
; 742  :     if (err!=UNZ_OK)

  0036a	85 ff		 test	 edi, edi
  0036c	0f 85 ac 00 00
	00		 jne	 $LN37@unzOpenInt

; 746  :     }
; 747  : 
; 748  :     us.byte_before_the_zipfile = central_pos -

  00372	49 8b c7	 mov	 rax, r15

; 749  :                             (us.offset_central_dir+us.size_central_dir);
; 750  :     us.central_pos = central_pos;

  00375	4c 89 7d c8	 mov	 QWORD PTR us$[rbp-104], r15
  00379	48 2b c1	 sub	 rax, rcx

; 751  :     us.pfile_in_zip_read = NULL;

  0037c	4c 89 65 40	 mov	 QWORD PTR us$[rbp+16], r12
  00380	48 2b c2	 sub	 rax, rdx

; 752  :     us.encrypted = 0;

  00383	44 89 65 48	 mov	 DWORD PTR us$[rbp+24], r12d

; 753  : 
; 754  : 
; 755  :     s=(unz64_s*)ALLOC(sizeof(unz64_s));

  00387	b9 20 01 00 00	 mov	 ecx, 288		; 00000120H
  0038c	48 89 45 a8	 mov	 QWORD PTR us$[rbp-136], rax
  00390	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc
  00396	48 8b d8	 mov	 rbx, rax

; 756  :     if( s != NULL)

  00399	48 85 c0	 test	 rax, rax
  0039c	74 7b		 je	 SHORT $LN35@unzOpenInt

; 757  :     {
; 758  :         *s=us;

  0039e	48 8b d0	 mov	 rdx, rax
  003a1	48 8d 4c 24 30	 lea	 rcx, QWORD PTR us$[rsp]
  003a6	44 8d 47 02	 lea	 r8d, QWORD PTR [rdi+2]
  003aa	66 0f 1f 44 00
	00		 npad	 6
$LL38@unzOpenInt:
  003b0	48 8d 92 80 00
	00 00		 lea	 rdx, QWORD PTR [rdx+128]
  003b7	0f 10 01	 movups	 xmm0, XMMWORD PTR [rcx]
  003ba	0f 10 49 10	 movups	 xmm1, XMMWORD PTR [rcx+16]
  003be	48 8d 89 80 00
	00 00		 lea	 rcx, QWORD PTR [rcx+128]
  003c5	0f 11 42 80	 movups	 XMMWORD PTR [rdx-128], xmm0
  003c9	0f 10 41 a0	 movups	 xmm0, XMMWORD PTR [rcx-96]
  003cd	0f 11 4a 90	 movups	 XMMWORD PTR [rdx-112], xmm1
  003d1	0f 10 49 b0	 movups	 xmm1, XMMWORD PTR [rcx-80]
  003d5	0f 11 42 a0	 movups	 XMMWORD PTR [rdx-96], xmm0
  003d9	0f 10 41 c0	 movups	 xmm0, XMMWORD PTR [rcx-64]
  003dd	0f 11 4a b0	 movups	 XMMWORD PTR [rdx-80], xmm1
  003e1	0f 10 49 d0	 movups	 xmm1, XMMWORD PTR [rcx-48]
  003e5	0f 11 42 c0	 movups	 XMMWORD PTR [rdx-64], xmm0
  003e9	0f 10 41 e0	 movups	 xmm0, XMMWORD PTR [rcx-32]
  003ed	0f 11 4a d0	 movups	 XMMWORD PTR [rdx-48], xmm1
  003f1	0f 10 49 f0	 movups	 xmm1, XMMWORD PTR [rcx-16]
  003f5	0f 11 42 e0	 movups	 XMMWORD PTR [rdx-32], xmm0
  003f9	0f 11 4a f0	 movups	 XMMWORD PTR [rdx-16], xmm1
  003fd	49 83 e8 01	 sub	 r8, 1
  00401	75 ad		 jne	 SHORT $LL38@unzOpenInt
  00403	0f 10 01	 movups	 xmm0, XMMWORD PTR [rcx]
  00406	0f 10 49 10	 movups	 xmm1, XMMWORD PTR [rcx+16]

; 759  :         unzGoToFirstFile((unzFile)s);

  0040a	48 8b cb	 mov	 rcx, rbx
  0040d	0f 11 02	 movups	 XMMWORD PTR [rdx], xmm0
  00410	0f 11 4a 10	 movups	 XMMWORD PTR [rdx+16], xmm1
  00414	e8 00 00 00 00	 call	 unzGoToFirstFile
$LN35@unzOpenInt:

; 760  :     }
; 761  :     return (unzFile)s;

  00419	48 8b c3	 mov	 rax, rbx
  0041c	eb 0f		 jmp	 SHORT $LN41@unzOpenInt
$LN37@unzOpenInt:

; 743  :     {
; 744  :         ZCLOSE64(us.z_filefunc, us.filestream);

  0041e	48 8b 55 90	 mov	 rdx, QWORD PTR us$[rbp-160]
  00422	48 8b 4c 24 68	 mov	 rcx, QWORD PTR us$[rsp+56]
  00427	ff 54 24 58	 call	 QWORD PTR us$[rsp+40]

; 745  :         return NULL;

  0042b	33 c0		 xor	 eax, eax
$LN41@unzOpenInt:
  0042d	48 8b bc 24 88
	01 00 00	 mov	 rdi, QWORD PTR [rsp+392]
  00435	48 8b 9c 24 80
	01 00 00	 mov	 rbx, QWORD PTR [rsp+384]
  0043d	4c 8b bc 24 50
	01 00 00	 mov	 r15, QWORD PTR [rsp+336]

; 762  : }

  00445	48 81 c4 60 01
	00 00		 add	 rsp, 352		; 00000160H
  0044c	41 5c		 pop	 r12
  0044e	5e		 pop	 rsi
  0044f	5d		 pop	 rbp
  00450	c3		 ret	 0
unzOpenInternal ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpen2
_TEXT	SEGMENT
zlib_filefunc64_32_def_fill$1 = 32
path$ = 144
pzlib_filefunc32_def$ = 152
unzOpen2 PROC						; COMDAT

; 767  : {

$LN7:
  00000	48 81 ec 88 00
	00 00		 sub	 rsp, 136		; 00000088H
  00007	4c 8b c9	 mov	 r9, rcx

; 768  :     if (pzlib_filefunc32_def != NULL)

  0000a	48 85 d2	 test	 rdx, rdx
  0000d	74 22		 je	 SHORT $LN2@unzOpen2

; 769  :     {
; 770  :         zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
; 771  :         fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);

  0000f	48 8d 4c 24 20	 lea	 rcx, QWORD PTR zlib_filefunc64_32_def_fill$1[rsp]
  00014	e8 00 00 00 00	 call	 fill_zlib_filefunc64_32_def_from_filefunc32

; 772  :         return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
; 773  :     }
; 774  :     else
; 775  :         return unzOpenInternal(path, NULL, 0);

  00019	45 33 c0	 xor	 r8d, r8d
  0001c	48 8d 54 24 20	 lea	 rdx, QWORD PTR zlib_filefunc64_32_def_fill$1[rsp]
  00021	49 8b c9	 mov	 rcx, r9
  00024	e8 00 00 00 00	 call	 unzOpenInternal

; 776  : }

  00029	48 81 c4 88 00
	00 00		 add	 rsp, 136		; 00000088H
  00030	c3		 ret	 0
$LN2@unzOpen2:

; 772  :         return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
; 773  :     }
; 774  :     else
; 775  :         return unzOpenInternal(path, NULL, 0);

  00031	45 33 c0	 xor	 r8d, r8d
  00034	e8 00 00 00 00	 call	 unzOpenInternal

; 776  : }

  00039	48 81 c4 88 00
	00 00		 add	 rsp, 136		; 00000088H
  00040	c3		 ret	 0
unzOpen2 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpen2_64
_TEXT	SEGMENT
zlib_filefunc64_32_def_fill$1 = 32
path$ = 144
pzlib_filefunc_def$ = 152
unzOpen2_64 PROC					; COMDAT

; 780  : {

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

; 787  :         return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);

  00007	41 b8 01 00 00
	00		 mov	 r8d, 1
  0000d	48 85 d2	 test	 rdx, rdx
  00010	74 41		 je	 SHORT $LN2@unzOpen2_6

; 781  :     if (pzlib_filefunc_def != NULL)
; 782  :     {
; 783  :         zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
; 784  :         zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
; 785  :         zlib_filefunc64_32_def_fill.ztell32_file = NULL;

  00012	0f 10 02	 movups	 xmm0, XMMWORD PTR [rdx]
  00015	33 c0		 xor	 eax, eax
  00017	0f 10 4a 10	 movups	 xmm1, XMMWORD PTR [rdx+16]
  0001b	48 89 44 24 68	 mov	 QWORD PTR zlib_filefunc64_32_def_fill$1[rsp+72], rax
  00020	0f 29 44 24 20	 movaps	 XMMWORD PTR zlib_filefunc64_32_def_fill$1[rsp], xmm0
  00025	0f 10 42 20	 movups	 xmm0, XMMWORD PTR [rdx+32]

; 786  :         zlib_filefunc64_32_def_fill.zseek32_file = NULL;

  00029	48 89 44 24 70	 mov	 QWORD PTR zlib_filefunc64_32_def_fill$1[rsp+80], rax
  0002e	0f 29 4c 24 30	 movaps	 XMMWORD PTR zlib_filefunc64_32_def_fill$1[rsp+16], xmm1
  00033	0f 10 4a 30	 movups	 xmm1, XMMWORD PTR [rdx+48]

; 787  :         return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);

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

; 788  :     }
; 789  :     else
; 790  :         return unzOpenInternal(path, NULL, 1);

  00046	e8 00 00 00 00	 call	 unzOpenInternal

; 791  : }

  0004b	48 81 c4 88 00
	00 00		 add	 rsp, 136		; 00000088H
  00052	c3		 ret	 0
$LN2@unzOpen2_6:

; 788  :     }
; 789  :     else
; 790  :         return unzOpenInternal(path, NULL, 1);

  00053	e8 00 00 00 00	 call	 unzOpenInternal

; 791  : }

  00058	48 81 c4 88 00
	00 00		 add	 rsp, 136		; 00000088H
  0005f	c3		 ret	 0
unzOpen2_64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpen
_TEXT	SEGMENT
path$ = 8
unzOpen	PROC						; COMDAT

; 795  :     return unzOpenInternal(path, NULL, 0);

  00000	45 33 c0	 xor	 r8d, r8d
  00003	33 d2		 xor	 edx, edx
  00005	e9 00 00 00 00	 jmp	 unzOpenInternal
unzOpen	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpen64
_TEXT	SEGMENT
path$ = 8
unzOpen64 PROC						; COMDAT

; 800  :     return unzOpenInternal(path, NULL, 1);

  00000	33 d2		 xor	 edx, edx
  00002	44 8d 42 01	 lea	 r8d, QWORD PTR [rdx+1]
  00006	e9 00 00 00 00	 jmp	 unzOpenInternal
unzOpen64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzClose
_TEXT	SEGMENT
file$ = 48
unzClose PROC						; COMDAT

; 809  : {

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

; 810  :     unz64_s* s;
; 811  :     if (file==NULL)

  00009	48 85 c9	 test	 rcx, rcx
  0000c	75 09		 jne	 SHORT $LN2@unzClose

; 812  :         return UNZ_PARAMERROR;

  0000e	8d 41 9a	 lea	 eax, QWORD PTR [rcx-102]

; 821  : }

  00011	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00015	5b		 pop	 rbx
  00016	c3		 ret	 0
$LN2@unzClose:

; 813  :     s=(unz64_s*)file;
; 814  : 
; 815  :     if (s->pfile_in_zip_read!=NULL)

  00017	48 83 b9 10 01
	00 00 00	 cmp	 QWORD PTR [rcx+272], 0
  0001f	74 05		 je	 SHORT $LN3@unzClose

; 816  :         unzCloseCurrentFile(file);

  00021	e8 00 00 00 00	 call	 unzCloseCurrentFile
$LN3@unzClose:

; 817  : 
; 818  :     ZCLOSE64(s->z_filefunc, s->filestream);

  00026	48 8b 53 60	 mov	 rdx, QWORD PTR [rbx+96]
  0002a	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  0002e	ff 53 28	 call	 QWORD PTR [rbx+40]

; 819  :     TRYFREE(s);

  00031	48 8b cb	 mov	 rcx, rbx
  00034	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free

; 820  :     return UNZ_OK;

  0003a	33 c0		 xor	 eax, eax

; 821  : }

  0003c	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00040	5b		 pop	 rbx
  00041	c3		 ret	 0
unzClose ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetGlobalInfo64
_TEXT	SEGMENT
file$ = 8
pglobal_info$ = 16
unzGetGlobalInfo64 PROC					; COMDAT

; 830  :     unz64_s* s;
; 831  :     if (file==NULL)

  00000	48 85 c9	 test	 rcx, rcx
  00003	75 06		 jne	 SHORT $LN2@unzGetGlob

; 832  :         return UNZ_PARAMERROR;

  00005	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 836  : }

  0000a	c3		 ret	 0
$LN2@unzGetGlob:

; 833  :     s=(unz64_s*)file;
; 834  :     *pglobal_info=s->gi;

  0000b	0f 10 41 68	 movups	 xmm0, XMMWORD PTR [rcx+104]

; 835  :     return UNZ_OK;

  0000f	33 c0		 xor	 eax, eax
  00011	0f 11 02	 movups	 XMMWORD PTR [rdx], xmm0

; 836  : }

  00014	c3		 ret	 0
unzGetGlobalInfo64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetGlobalInfo
_TEXT	SEGMENT
file$ = 8
pglobal_info32$ = 16
unzGetGlobalInfo PROC					; COMDAT

; 840  :     unz64_s* s;
; 841  :     if (file==NULL)

  00000	48 85 c9	 test	 rcx, rcx
  00003	75 06		 jne	 SHORT $LN2@unzGetGlob

; 842  :         return UNZ_PARAMERROR;

  00005	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 848  : }

  0000a	c3		 ret	 0
$LN2@unzGetGlob:

; 843  :     s=(unz64_s*)file;
; 844  :     /* to do : check if number_entry is not truncated */
; 845  :     pglobal_info32->number_entry = (uLong)s->gi.number_entry;

  0000b	8b 41 68	 mov	 eax, DWORD PTR [rcx+104]
  0000e	89 02		 mov	 DWORD PTR [rdx], eax

; 846  :     pglobal_info32->size_comment = s->gi.size_comment;

  00010	8b 41 70	 mov	 eax, DWORD PTR [rcx+112]
  00013	89 42 04	 mov	 DWORD PTR [rdx+4], eax

; 847  :     return UNZ_OK;

  00016	33 c0		 xor	 eax, eax

; 848  : }

  00018	c3		 ret	 0
unzGetGlobalInfo ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_DosDateToTmuDate
_TEXT	SEGMENT
ulDosDate$ = 8
ptm$ = 16
unz64local_DosDateToTmuDate PROC			; COMDAT

; 854  :     ZPOS64_T uDate;
; 855  :     uDate = (ZPOS64_T)(ulDosDate>>16);

  00000	4c 8b c1	 mov	 r8, rcx
  00003	49 c1 e8 10	 shr	 r8, 16

; 856  :     ptm->tm_mday = (uInt)(uDate&0x1f) ;

  00007	41 8b c0	 mov	 eax, r8d
  0000a	83 e0 1f	 and	 eax, 31
  0000d	89 42 0c	 mov	 DWORD PTR [rdx+12], eax

; 857  :     ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;

  00010	49 8b c0	 mov	 rax, r8
  00013	48 c1 e8 05	 shr	 rax, 5
  00017	83 e0 0f	 and	 eax, 15

; 858  :     ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;

  0001a	49 c1 e8 09	 shr	 r8, 9
  0001e	ff c8		 dec	 eax
  00020	41 83 e0 7f	 and	 r8d, 127		; 0000007fH
  00024	89 42 10	 mov	 DWORD PTR [rdx+16], eax
  00027	41 81 c0 bc 07
	00 00		 add	 r8d, 1980		; 000007bcH

; 859  : 
; 860  :     ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);

  0002e	48 8b c1	 mov	 rax, rcx
  00031	44 89 42 14	 mov	 DWORD PTR [rdx+20], r8d
  00035	48 c1 e8 0b	 shr	 rax, 11
  00039	83 e0 1f	 and	 eax, 31
  0003c	89 42 08	 mov	 DWORD PTR [rdx+8], eax

; 861  :     ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;

  0003f	48 8b c1	 mov	 rax, rcx
  00042	48 c1 e8 05	 shr	 rax, 5

; 862  :     ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;

  00046	83 e1 1f	 and	 ecx, 31
  00049	83 e0 3f	 and	 eax, 63			; 0000003fH
  0004c	03 c9		 add	 ecx, ecx
  0004e	89 42 04	 mov	 DWORD PTR [rdx+4], eax
  00051	89 0a		 mov	 DWORD PTR [rdx], ecx

; 863  : }

  00053	c3		 ret	 0
unz64local_DosDateToTmuDate ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_GetCurrentFileInfoInternal
_TEXT	SEGMENT
dataSize$1 = 32
headerId$2 = 36
file_info_internal$ = 40
file_info$ = 48
uL$3 = 144
uSizeRead$1$ = 240
uSizeRead$1$ = 240
lSeek$1$ = 240
uL$ = 240
uMagic$ = 240
file$ = 240
pfile_info$ = 248
pfile_info_internal$ = 256
szFileName$ = 264
fileNameBufferSize$ = 272
extraField$ = 280
extraFieldBufferSize$ = 288
szComment$ = 296
commentBufferSize$ = 304
unz64local_GetCurrentFileInfoInternal PROC		; COMDAT

; 889  : {

  00000	4c 89 4c 24 20	 mov	 QWORD PTR [rsp+32], r9
  00005	4c 89 44 24 18	 mov	 QWORD PTR [rsp+24], r8
  0000a	48 89 54 24 10	 mov	 QWORD PTR [rsp+16], rdx
  0000f	55		 push	 rbp
  00010	56		 push	 rsi
  00011	41 54		 push	 r12
  00013	41 55		 push	 r13
  00015	41 56		 push	 r14
  00017	48 8d 6c 24 f1	 lea	 rbp, QWORD PTR [rsp-15]
  0001c	48 81 ec c0 00
	00 00		 sub	 rsp, 192		; 000000c0H

; 890  :     unz64_s* s;
; 891  :     unz_file_info64 file_info;
; 892  :     unz_file_info64_internal file_info_internal;
; 893  :     int err=UNZ_OK;

  00023	45 33 e4	 xor	 r12d, r12d
  00026	4d 8b f1	 mov	 r14, r9
  00029	4c 8b ea	 mov	 r13, rdx
  0002c	48 8b f1	 mov	 rsi, rcx

; 894  :     uLong uMagic;
; 895  :     long lSeek=0;
; 896  :     uLong uL;
; 897  : 
; 898  :     if (file==NULL)

  0002f	48 85 c9	 test	 rcx, rcx
  00032	75 13		 jne	 SHORT $LN4@unz64local

; 899  :         return UNZ_PARAMERROR;

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

; 1115 : }

  00037	48 81 c4 c0 00
	00 00		 add	 rsp, 192		; 000000c0H
  0003e	41 5e		 pop	 r14
  00040	41 5d		 pop	 r13
  00042	41 5c		 pop	 r12
  00044	5e		 pop	 rsi
  00045	5d		 pop	 rbp
  00046	c3		 ret	 0
$LN4@unz64local:

; 900  :     s=(unz64_s*)file;
; 901  :     if (ZSEEK64(s->z_filefunc, s->filestream,
; 902  :               s->pos_in_central_dir+s->byte_before_the_zipfile,
; 903  :               ZLIB_FILEFUNC_SEEK_SET)!=0)

  00047	4c 8b 81 88 00
	00 00		 mov	 r8, QWORD PTR [rcx+136]
  0004e	45 33 c9	 xor	 r9d, r9d
  00051	4c 03 41 78	 add	 r8, QWORD PTR [rcx+120]
  00055	48 8b 51 60	 mov	 rdx, QWORD PTR [rcx+96]
  00059	48 89 9c 24 b8
	00 00 00	 mov	 QWORD PTR [rsp+184], rbx
  00061	48 89 bc 24 b0
	00 00 00	 mov	 QWORD PTR [rsp+176], rdi
  00069	4c 89 bc 24 a8
	00 00 00	 mov	 QWORD PTR [rsp+168], r15
  00071	e8 00 00 00 00	 call	 call_zseek64
  00076	83 cb ff	 or	 ebx, -1
  00079	85 c0		 test	 eax, eax
  0007b	74 04		 je	 SHORT $LN72@unz64local

; 904  :         err=UNZ_ERRNO;

  0007d	8b fb		 mov	 edi, ebx

; 905  : 
; 906  : 
; 907  :     /* we check the magic */
; 908  :     if (err==UNZ_OK)

  0007f	eb 2a		 jmp	 SHORT $LN9@unz64local
$LN72@unz64local:

; 909  :     {
; 910  :         if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)

  00081	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00085	4c 8d 45 3f	 lea	 r8, QWORD PTR uMagic$[rbp-177]
  00089	48 8b ce	 mov	 rcx, rsi
  0008c	e8 00 00 00 00	 call	 unz64local_getLong
  00091	85 c0		 test	 eax, eax
  00093	74 04		 je	 SHORT $LN7@unz64local

; 911  :             err=UNZ_ERRNO;

  00095	8b fb		 mov	 edi, ebx
  00097	eb 12		 jmp	 SHORT $LN9@unz64local
$LN7@unz64local:

; 912  :         else if (uMagic!=0x02014b50)

  00099	81 7d 3f 50 4b
	01 02		 cmp	 DWORD PTR uMagic$[rbp-177], 33639248 ; 02014b50H
  000a0	41 8b fc	 mov	 edi, r12d
  000a3	b8 99 ff ff ff	 mov	 eax, -103		; ffffffffffffff99H
  000a8	0f 45 f8	 cmovne	 edi, eax
$LN9@unz64local:

; 913  :             err=UNZ_BADZIPFILE;
; 914  :     }
; 915  : 
; 916  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)

  000ab	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  000af	4c 8d 44 24 30	 lea	 r8, QWORD PTR file_info$[rsp]
  000b4	48 8b ce	 mov	 rcx, rsi
  000b7	e8 00 00 00 00	 call	 unz64local_getShort

; 917  :         err=UNZ_ERRNO;
; 918  : 
; 919  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)

  000bc	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  000c0	4c 8d 45 83	 lea	 r8, QWORD PTR file_info$[rbp-173]
  000c4	85 c0		 test	 eax, eax
  000c6	48 8b ce	 mov	 rcx, rsi
  000c9	0f 45 fb	 cmovne	 edi, ebx
  000cc	e8 00 00 00 00	 call	 unz64local_getShort

; 920  :         err=UNZ_ERRNO;
; 921  : 
; 922  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)

  000d1	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  000d5	4c 8d 45 87	 lea	 r8, QWORD PTR file_info$[rbp-169]
  000d9	85 c0		 test	 eax, eax
  000db	48 8b ce	 mov	 rcx, rsi
  000de	0f 45 fb	 cmovne	 edi, ebx
  000e1	e8 00 00 00 00	 call	 unz64local_getShort

; 923  :         err=UNZ_ERRNO;
; 924  : 
; 925  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)

  000e6	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  000ea	4c 8d 45 8b	 lea	 r8, QWORD PTR file_info$[rbp-165]
  000ee	85 c0		 test	 eax, eax
  000f0	48 8b ce	 mov	 rcx, rsi
  000f3	0f 45 fb	 cmovne	 edi, ebx
  000f6	e8 00 00 00 00	 call	 unz64local_getShort

; 926  :         err=UNZ_ERRNO;
; 927  : 
; 928  :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)

  000fb	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  000ff	4c 8d 45 8f	 lea	 r8, QWORD PTR file_info$[rbp-161]
  00103	85 c0		 test	 eax, eax
  00105	48 8b ce	 mov	 rcx, rsi
  00108	0f 45 fb	 cmovne	 edi, ebx
  0010b	e8 00 00 00 00	 call	 unz64local_getLong

; 929  :         err=UNZ_ERRNO;
; 930  : 
; 931  :     unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);

  00110	8b 4d 8f	 mov	 ecx, DWORD PTR file_info$[rbp-161]
  00113	48 8d 55 bf	 lea	 rdx, QWORD PTR file_info$[rbp-113]
  00117	85 c0		 test	 eax, eax
  00119	0f 45 fb	 cmovne	 edi, ebx
  0011c	e8 00 00 00 00	 call	 unz64local_DosDateToTmuDate

; 932  : 
; 933  :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)

  00121	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00125	4c 8d 45 93	 lea	 r8, QWORD PTR file_info$[rbp-157]
  00129	48 8b ce	 mov	 rcx, rsi
  0012c	e8 00 00 00 00	 call	 unz64local_getLong

; 934  :         err=UNZ_ERRNO;
; 935  : 
; 936  :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

  00131	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00135	4c 8d 45 3f	 lea	 r8, QWORD PTR uL$[rbp-177]
  00139	85 c0		 test	 eax, eax
  0013b	48 8b ce	 mov	 rcx, rsi
  0013e	0f 45 fb	 cmovne	 edi, ebx
  00141	e8 00 00 00 00	 call	 unz64local_getLong

; 937  :         err=UNZ_ERRNO;
; 938  :     file_info.compressed_size = uL;
; 939  : 
; 940  :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

  00146	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  0014a	4c 8d 45 3f	 lea	 r8, QWORD PTR uL$[rbp-177]
  0014e	85 c0		 test	 eax, eax
  00150	48 8b ce	 mov	 rcx, rsi
  00153	8b 45 3f	 mov	 eax, DWORD PTR uL$[rbp-177]
  00156	0f 45 fb	 cmovne	 edi, ebx
  00159	48 89 45 97	 mov	 QWORD PTR file_info$[rbp-153], rax
  0015d	e8 00 00 00 00	 call	 unz64local_getLong

; 941  :         err=UNZ_ERRNO;
; 942  :     file_info.uncompressed_size = uL;
; 943  : 
; 944  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)

  00162	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00166	4c 8d 45 a7	 lea	 r8, QWORD PTR file_info$[rbp-137]
  0016a	85 c0		 test	 eax, eax
  0016c	48 8b ce	 mov	 rcx, rsi
  0016f	8b 45 3f	 mov	 eax, DWORD PTR uL$[rbp-177]
  00172	0f 45 fb	 cmovne	 edi, ebx
  00175	48 89 45 9f	 mov	 QWORD PTR file_info$[rbp-145], rax
  00179	e8 00 00 00 00	 call	 unz64local_getShort

; 945  :         err=UNZ_ERRNO;
; 946  : 
; 947  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)

  0017e	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00182	4c 8d 45 ab	 lea	 r8, QWORD PTR file_info$[rbp-133]
  00186	85 c0		 test	 eax, eax
  00188	48 8b ce	 mov	 rcx, rsi
  0018b	0f 45 fb	 cmovne	 edi, ebx
  0018e	e8 00 00 00 00	 call	 unz64local_getShort

; 948  :         err=UNZ_ERRNO;
; 949  : 
; 950  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)

  00193	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00197	4c 8d 45 af	 lea	 r8, QWORD PTR file_info$[rbp-129]
  0019b	85 c0		 test	 eax, eax
  0019d	48 8b ce	 mov	 rcx, rsi
  001a0	0f 45 fb	 cmovne	 edi, ebx
  001a3	e8 00 00 00 00	 call	 unz64local_getShort

; 951  :         err=UNZ_ERRNO;
; 952  : 
; 953  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)

  001a8	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  001ac	4c 8d 45 b3	 lea	 r8, QWORD PTR file_info$[rbp-125]
  001b0	85 c0		 test	 eax, eax
  001b2	48 8b ce	 mov	 rcx, rsi
  001b5	0f 45 fb	 cmovne	 edi, ebx
  001b8	e8 00 00 00 00	 call	 unz64local_getShort

; 954  :         err=UNZ_ERRNO;
; 955  : 
; 956  :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)

  001bd	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  001c1	4c 8d 45 b7	 lea	 r8, QWORD PTR file_info$[rbp-121]
  001c5	85 c0		 test	 eax, eax
  001c7	0f 45 fb	 cmovne	 edi, ebx
  001ca	48 8b ce	 mov	 rcx, rsi
  001cd	e8 00 00 00 00	 call	 unz64local_getShort

; 957  :         err=UNZ_ERRNO;
; 958  : 
; 959  :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)

  001d2	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  001d6	4c 8d 45 bb	 lea	 r8, QWORD PTR file_info$[rbp-117]
  001da	85 c0		 test	 eax, eax
  001dc	48 8b ce	 mov	 rcx, rsi
  001df	0f 45 fb	 cmovne	 edi, ebx
  001e2	e8 00 00 00 00	 call	 unz64local_getLong

; 960  :         err=UNZ_ERRNO;
; 961  : 
; 962  :                 // relative offset of local header
; 963  :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

  001e7	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  001eb	4c 8d 45 3f	 lea	 r8, QWORD PTR uL$[rbp-177]
  001ef	85 c0		 test	 eax, eax
  001f1	48 8b ce	 mov	 rcx, rsi
  001f4	0f 45 fb	 cmovne	 edi, ebx
  001f7	e8 00 00 00 00	 call	 unz64local_getLong

; 964  :         err=UNZ_ERRNO;
; 965  :     file_info_internal.offset_curfile = uL;
; 966  : 
; 967  :     lSeek+=file_info.size_filename;

  001fc	44 8b 7d a7	 mov	 r15d, DWORD PTR file_info$[rbp-137]
  00200	85 c0		 test	 eax, eax
  00202	0f 45 fb	 cmovne	 edi, ebx
  00205	8b 5d 3f	 mov	 ebx, DWORD PTR uL$[rbp-177]
  00208	48 89 5c 24 28	 mov	 QWORD PTR file_info_internal$[rsp], rbx

; 968  :     if ((err==UNZ_OK) && (szFileName!=NULL))

  0020d	85 ff		 test	 edi, edi
  0020f	0f 85 dc 00 00
	00		 jne	 $LN30@unz64local
  00215	4d 85 f6	 test	 r14, r14
  00218	74 45		 je	 SHORT $LN73@unz64local

; 969  :     {
; 970  :         uLong uSizeRead ;
; 971  :         if (file_info.size_filename<fileNameBufferSize)

  0021a	8b 4d 5f	 mov	 ecx, DWORD PTR fileNameBufferSize$[rbp-177]
  0021d	44 3b f9	 cmp	 r15d, ecx
  00220	73 09		 jae	 SHORT $LN26@unz64local

; 972  :         {
; 973  :             *(szFileName+file_info.size_filename)='\0';

  00222	47 88 24 37	 mov	 BYTE PTR [r15+r14], r12b

; 974  :             uSizeRead = file_info.size_filename;

  00226	45 8b f7	 mov	 r14d, r15d

; 975  :         }

  00229	eb 03		 jmp	 SHORT $LN27@unz64local
$LN26@unz64local:

; 976  :         else
; 977  :             uSizeRead = fileNameBufferSize;

  0022b	44 8b f1	 mov	 r14d, ecx
$LN27@unz64local:

; 978  : 
; 979  :         if ((file_info.size_filename>0) && (fileNameBufferSize>0))

  0022e	45 85 ff	 test	 r15d, r15d
  00231	74 21		 je	 SHORT $LN29@unz64local
  00233	85 c9		 test	 ecx, ecx
  00235	74 1d		 je	 SHORT $LN29@unz64local

; 980  :             if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)

  00237	4c 8b 45 57	 mov	 r8, QWORD PTR szFileName$[rbp-177]
  0023b	45 8b ce	 mov	 r9d, r14d
  0023e	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00242	48 8b 4e 38	 mov	 rcx, QWORD PTR [rsi+56]
  00246	ff 56 08	 call	 QWORD PTR [rsi+8]
  00249	41 3b c6	 cmp	 eax, r14d
  0024c	b8 ff ff ff ff	 mov	 eax, -1
  00251	0f 45 f8	 cmovne	 edi, eax
$LN29@unz64local:

; 981  :                 err=UNZ_ERRNO;
; 982  :         lSeek -= uSizeRead;

  00254	45 2b fe	 sub	 r15d, r14d

; 983  :     }
; 984  : 
; 985  :     // Read extrafield
; 986  :     if ((err==UNZ_OK) && (extraField!=NULL))

  00257	85 ff		 test	 edi, edi
  00259	0f 85 92 00 00
	00		 jne	 $LN30@unz64local
$LN73@unz64local:
  0025f	48 8b 55 67	 mov	 rdx, QWORD PTR extraField$[rbp-177]
  00263	48 85 d2	 test	 rdx, rdx
  00266	0f 84 85 00 00
	00		 je	 $LN30@unz64local

; 987  :     {
; 988  :         ZPOS64_T uSizeRead ;
; 989  :         if (file_info.size_file_extra<extraFieldBufferSize)

  0026c	44 8b 75 ab	 mov	 r14d, DWORD PTR file_info$[rbp-133]
  00270	8b 4d 6f	 mov	 ecx, DWORD PTR extraFieldBufferSize$[rbp-177]

; 990  :             uSizeRead = file_info.size_file_extra;

  00273	4c 89 75 3f	 mov	 QWORD PTR uSizeRead$1$[rbp-177], r14
  00277	44 3b f1	 cmp	 r14d, ecx
  0027a	72 04		 jb	 SHORT $LN33@unz64local

; 991  :         else
; 992  :             uSizeRead = extraFieldBufferSize;

  0027c	48 89 4d 3f	 mov	 QWORD PTR uSizeRead$1$[rbp-177], rcx
$LN33@unz64local:

; 993  : 
; 994  :         if (lSeek!=0)

  00280	45 85 ff	 test	 r15d, r15d
  00283	74 28		 je	 SHORT $LN36@unz64local

; 995  :         {
; 996  :             if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)

  00285	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00289	41 b9 01 00 00
	00		 mov	 r9d, 1
  0028f	4d 63 c7	 movsxd	 r8, r15d
  00292	48 8b ce	 mov	 rcx, rsi
  00295	e8 00 00 00 00	 call	 call_zseek64

; 997  :                 lSeek=0;

  0029a	8b 4d 6f	 mov	 ecx, DWORD PTR extraFieldBufferSize$[rbp-177]
  0029d	48 8b 55 67	 mov	 rdx, QWORD PTR extraField$[rbp-177]
  002a1	85 c0		 test	 eax, eax
  002a3	75 05		 jne	 SHORT $LN35@unz64local
  002a5	45 8b fc	 mov	 r15d, r12d
  002a8	eb 03		 jmp	 SHORT $LN36@unz64local
$LN35@unz64local:

; 998  :             else
; 999  :                 err=UNZ_ERRNO;

  002aa	83 cf ff	 or	 edi, -1
$LN36@unz64local:

; 1000 :         }
; 1001 : 
; 1002 :         if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))

  002ad	45 85 f6	 test	 r14d, r14d
  002b0	74 31		 je	 SHORT $LN78@unz64local
  002b2	85 c9		 test	 ecx, ecx
  002b4	74 2d		 je	 SHORT $LN78@unz64local

; 1003 :             if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)

  002b6	44 8b 4d 3f	 mov	 r9d, DWORD PTR uSizeRead$1$[rbp-177]
  002ba	4c 8b c2	 mov	 r8, rdx
  002bd	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  002c1	48 8b 4e 38	 mov	 rcx, QWORD PTR [rsi+56]
  002c5	ff 56 08	 call	 QWORD PTR [rsi+8]
  002c8	48 8b 4d 3f	 mov	 rcx, QWORD PTR uSizeRead$1$[rbp-177]
  002cc	8b c0		 mov	 eax, eax
  002ce	48 3b c1	 cmp	 rax, rcx
  002d1	b8 ff ff ff ff	 mov	 eax, -1
  002d6	0f 45 f8	 cmovne	 edi, eax

; 1004 :                 err=UNZ_ERRNO;
; 1005 : 
; 1006 :         lSeek += file_info.size_file_extra - (uLong)uSizeRead;

  002d9	41 8b c6	 mov	 eax, r14d
  002dc	2b c1		 sub	 eax, ecx
  002de	44 03 f8	 add	 r15d, eax

; 1007 :     }

  002e1	eb 15		 jmp	 SHORT $LN31@unz64local
$LN78@unz64local:
  002e3	48 8b 4d 3f	 mov	 rcx, QWORD PTR uSizeRead$1$[rbp-177]

; 1004 :                 err=UNZ_ERRNO;
; 1005 : 
; 1006 :         lSeek += file_info.size_file_extra - (uLong)uSizeRead;

  002e7	41 8b c6	 mov	 eax, r14d
  002ea	2b c1		 sub	 eax, ecx
  002ec	44 03 f8	 add	 r15d, eax

; 1007 :     }

  002ef	eb 07		 jmp	 SHORT $LN31@unz64local
$LN30@unz64local:

; 1008 :     else
; 1009 :         lSeek += file_info.size_file_extra;

  002f1	44 8b 75 ab	 mov	 r14d, DWORD PTR file_info$[rbp-133]
  002f5	45 03 fe	 add	 r15d, r14d
$LN31@unz64local:

; 1010 : 
; 1011 : 
; 1012 :     if ((err==UNZ_OK) && (file_info.size_file_extra != 0))

  002f8	85 ff		 test	 edi, edi
  002fa	0f 85 17 02 00
	00		 jne	 $LN66@unz64local
  00300	45 85 f6	 test	 r14d, r14d
  00303	0f 84 45 01 00
	00		 je	 $LN74@unz64local

; 1013 :     {
; 1014 :                                 uLong acc = 0;
; 1015 : 
; 1016 :         // since lSeek now points to after the extra field we need to move back
; 1017 :         lSeek -= file_info.size_file_extra;

  00309	45 2b fe	 sub	 r15d, r14d
  0030c	44 89 7d 3f	 mov	 DWORD PTR lSeek$1$[rbp-177], r15d

; 1018 : 
; 1019 :         if (lSeek!=0)

  00310	74 23		 je	 SHORT $LN68@unz64local

; 1020 :         {
; 1021 :             if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)

  00312	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00316	44 8d 4f 01	 lea	 r9d, QWORD PTR [rdi+1]
  0031a	4d 63 c7	 movsxd	 r8, r15d
  0031d	48 8b ce	 mov	 rcx, rsi
  00320	e8 00 00 00 00	 call	 call_zseek64
  00325	85 c0		 test	 eax, eax
  00327	75 09		 jne	 SHORT $LN41@unz64local

; 1022 :                 lSeek=0;

  00329	45 8b fc	 mov	 r15d, r12d
  0032c	44 89 65 3f	 mov	 DWORD PTR lSeek$1$[rbp-177], r12d
  00330	eb 03		 jmp	 SHORT $LN68@unz64local
$LN41@unz64local:

; 1023 :             else
; 1024 :                 err=UNZ_ERRNO;

  00332	83 cf ff	 or	 edi, -1
$LN68@unz64local:

; 1025 :         }
; 1026 : 
; 1027 :         while(acc < file_info.size_file_extra)

  00335	45 85 f6	 test	 r14d, r14d
  00338	0f 84 08 01 00
	00		 je	 $LN3@unz64local
  0033e	41 83 cf ff	 or	 r15d, -1
$LL2@unz64local:

; 1028 :         {
; 1029 :             uLong headerId;
; 1030 :                                                 uLong dataSize;
; 1031 : 
; 1032 :             if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)

  00342	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00346	4c 8d 44 24 24	 lea	 r8, QWORD PTR headerId$2[rsp]
  0034b	48 8b ce	 mov	 rcx, rsi
  0034e	e8 00 00 00 00	 call	 unz64local_getShort

; 1033 :                 err=UNZ_ERRNO;
; 1034 : 
; 1035 :             if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)

  00353	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00357	4c 8d 44 24 20	 lea	 r8, QWORD PTR dataSize$1[rsp]
  0035c	85 c0		 test	 eax, eax
  0035e	48 8b ce	 mov	 rcx, rsi
  00361	41 0f 45 ff	 cmovne	 edi, r15d
  00365	e8 00 00 00 00	 call	 unz64local_getShort

; 1036 :                 err=UNZ_ERRNO;
; 1037 : 
; 1038 :             /* ZIP64 extra fields */
; 1039 :             if (headerId == 0x0001)

  0036a	44 8b 6c 24 20	 mov	 r13d, DWORD PTR dataSize$1[rsp]
  0036f	85 c0		 test	 eax, eax
  00371	41 0f 45 ff	 cmovne	 edi, r15d
  00375	83 7c 24 24 01	 cmp	 DWORD PTR headerId$2[rsp], 1
  0037a	0f 85 93 00 00
	00		 jne	 $LN45@unz64local

; 1040 :             {
; 1041 :                                                         uLong uL;
; 1042 : 
; 1043 :                                                                 if(file_info.uncompressed_size == MAXU32)

  00380	b8 ff ff ff ff	 mov	 eax, -1			; ffffffffH
  00385	48 39 45 9f	 cmp	 QWORD PTR file_info$[rbp-145], rax
  00389	75 1f		 jne	 SHORT $LN48@unz64local

; 1044 :                                                                 {
; 1045 :                                                                         if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)

  0038b	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  0038f	4c 8d 45 9f	 lea	 r8, QWORD PTR file_info$[rbp-145]
  00393	48 8b ce	 mov	 rcx, rsi
  00396	e8 00 00 00 00	 call	 unz64local_getLong64
  0039b	44 8b 75 ab	 mov	 r14d, DWORD PTR file_info$[rbp-133]
  0039f	85 c0		 test	 eax, eax
  003a1	b8 ff ff ff ff	 mov	 eax, -1			; ffffffffH
  003a6	41 0f 45 ff	 cmovne	 edi, r15d
$LN48@unz64local:

; 1046 :                                                                                         err=UNZ_ERRNO;
; 1047 :                                                                 }
; 1048 : 
; 1049 :                                                                 if(file_info.compressed_size == MAXU32)

  003aa	48 39 45 97	 cmp	 QWORD PTR file_info$[rbp-153], rax
  003ae	75 1f		 jne	 SHORT $LN50@unz64local

; 1050 :                                                                 {
; 1051 :                                                                         if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)

  003b0	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  003b4	4c 8d 45 97	 lea	 r8, QWORD PTR file_info$[rbp-153]
  003b8	48 8b ce	 mov	 rcx, rsi
  003bb	e8 00 00 00 00	 call	 unz64local_getLong64
  003c0	44 8b 75 ab	 mov	 r14d, DWORD PTR file_info$[rbp-133]
  003c4	85 c0		 test	 eax, eax
  003c6	b8 ff ff ff ff	 mov	 eax, -1			; ffffffffH
  003cb	41 0f 45 ff	 cmovne	 edi, r15d
$LN50@unz64local:

; 1052 :                                                                                   err=UNZ_ERRNO;
; 1053 :                                                                 }
; 1054 : 
; 1055 :                                                                 if(file_info_internal.offset_curfile == MAXU32)

  003cf	48 3b d8	 cmp	 rbx, rax
  003d2	75 21		 jne	 SHORT $LN52@unz64local

; 1056 :                                                                 {
; 1057 :                                                                         /* Relative Header offset */
; 1058 :                                                                         if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)

  003d4	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  003d8	4c 8d 44 24 28	 lea	 r8, QWORD PTR file_info_internal$[rsp]
  003dd	48 8b ce	 mov	 rcx, rsi
  003e0	e8 00 00 00 00	 call	 unz64local_getLong64
  003e5	48 8b 5c 24 28	 mov	 rbx, QWORD PTR file_info_internal$[rsp]
  003ea	85 c0		 test	 eax, eax
  003ec	b8 ff ff ff ff	 mov	 eax, -1			; ffffffffH
  003f1	41 0f 45 ff	 cmovne	 edi, r15d
$LN52@unz64local:

; 1059 :                                                                                 err=UNZ_ERRNO;
; 1060 :                                                                 }
; 1061 : 
; 1062 :                                                                 if(file_info.disk_num_start == MAXU32)

  003f5	39 45 b3	 cmp	 DWORD PTR file_info$[rbp-125], eax
  003f8	75 34		 jne	 SHORT $LN55@unz64local

; 1063 :                                                                 {
; 1064 :                                                                         /* Disk Start Number */
; 1065 :                                                                         if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

  003fa	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  003fe	4c 8d 45 df	 lea	 r8, QWORD PTR uL$3[rbp-177]
  00402	48 8b ce	 mov	 rcx, rsi
  00405	e8 00 00 00 00	 call	 unz64local_getLong
  0040a	85 c0		 test	 eax, eax
  0040c	74 20		 je	 SHORT $LN55@unz64local

; 1066 :                                                                                 err=UNZ_ERRNO;

  0040e	41 8b ff	 mov	 edi, r15d

; 1067 :                                                                 }
; 1068 : 
; 1069 :             }

  00411	eb 1b		 jmp	 SHORT $LN55@unz64local
$LN45@unz64local:

; 1070 :             else
; 1071 :             {
; 1072 :                 if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)

  00413	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  00417	4d 8b c5	 mov	 r8, r13
  0041a	41 b9 01 00 00
	00		 mov	 r9d, 1
  00420	48 8b ce	 mov	 rcx, rsi
  00423	e8 00 00 00 00	 call	 call_zseek64
  00428	85 c0		 test	 eax, eax
  0042a	41 0f 45 ff	 cmovne	 edi, r15d
$LN55@unz64local:

; 1073 :                     err=UNZ_ERRNO;
; 1074 :             }
; 1075 : 
; 1076 :             acc += 2 + 2 + dataSize;

  0042e	41 83 c4 04	 add	 r12d, 4
  00432	45 03 e5	 add	 r12d, r13d
  00435	45 3b e6	 cmp	 r12d, r14d
  00438	0f 82 04 ff ff
	ff		 jb	 $LL2@unz64local
  0043e	44 8b 7d 3f	 mov	 r15d, DWORD PTR lSeek$1$[rbp-177]
  00442	4c 8b 6d 47	 mov	 r13, QWORD PTR pfile_info$[rbp-177]
$LN3@unz64local:

; 1077 :         }
; 1078 :     }
; 1079 : 
; 1080 :     if ((err==UNZ_OK) && (szComment!=NULL))

  00446	85 ff		 test	 edi, edi
  00448	0f 85 c9 00 00
	00		 jne	 $LN66@unz64local
$LN74@unz64local:
  0044e	48 8b 4d 77	 mov	 rcx, QWORD PTR szComment$[rbp-177]
  00452	48 85 c9	 test	 rcx, rcx
  00455	74 76		 je	 SHORT $LN75@unz64local

; 1081 :     {
; 1082 :         uLong uSizeRead ;
; 1083 :         if (file_info.size_file_comment<commentBufferSize)

  00457	44 8b 75 af	 mov	 r14d, DWORD PTR file_info$[rbp-129]
  0045b	44 8b 65 7f	 mov	 r12d, DWORD PTR commentBufferSize$[rbp-177]
  0045f	45 3b f4	 cmp	 r14d, r12d
  00462	73 0b		 jae	 SHORT $LN58@unz64local

; 1084 :         {
; 1085 :             *(szComment+file_info.size_file_comment)='\0';

  00464	41 c6 04 0e 00	 mov	 BYTE PTR [r14+rcx], 0

; 1086 :             uSizeRead = file_info.size_file_comment;

  00469	44 89 75 3f	 mov	 DWORD PTR uSizeRead$1$[rbp-177], r14d

; 1087 :         }

  0046d	eb 04		 jmp	 SHORT $LN59@unz64local
$LN58@unz64local:

; 1088 :         else
; 1089 :             uSizeRead = commentBufferSize;

  0046f	44 89 65 3f	 mov	 DWORD PTR uSizeRead$1$[rbp-177], r12d
$LN59@unz64local:

; 1090 : 
; 1091 :         if (lSeek!=0)

  00473	45 85 ff	 test	 r15d, r15d
  00476	74 27		 je	 SHORT $LN79@unz64local

; 1092 :         {
; 1093 :             if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)

  00478	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  0047c	41 b9 01 00 00
	00		 mov	 r9d, 1
  00482	4d 63 c7	 movsxd	 r8, r15d
  00485	48 8b ce	 mov	 rcx, rsi
  00488	e8 00 00 00 00	 call	 call_zseek64
  0048d	48 8b 4d 77	 mov	 rcx, QWORD PTR szComment$[rbp-177]
  00491	85 c0		 test	 eax, eax
  00493	41 bf ff ff ff
	ff		 mov	 r15d, -1
  00499	41 0f 45 ff	 cmovne	 edi, r15d
  0049d	eb 04		 jmp	 SHORT $LN62@unz64local
$LN79@unz64local:
  0049f	41 83 cf ff	 or	 r15d, -1
$LN62@unz64local:

; 1094 :                 lSeek=0;
; 1095 :             else
; 1096 :                 err=UNZ_ERRNO;
; 1097 :         }
; 1098 : 
; 1099 :         if ((file_info.size_file_comment>0) && (commentBufferSize>0))

  004a3	45 85 f6	 test	 r14d, r14d
  004a6	74 21		 je	 SHORT $LN64@unz64local
  004a8	45 85 e4	 test	 r12d, r12d
  004ab	74 1c		 je	 SHORT $LN64@unz64local

; 1100 :             if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)

  004ad	44 8b 4d 3f	 mov	 r9d, DWORD PTR uSizeRead$1$[rbp-177]
  004b1	4c 8b c1	 mov	 r8, rcx
  004b4	48 8b 4e 38	 mov	 rcx, QWORD PTR [rsi+56]
  004b8	48 8b 56 60	 mov	 rdx, QWORD PTR [rsi+96]
  004bc	ff 56 08	 call	 QWORD PTR [rsi+8]
  004bf	3b 45 3f	 cmp	 eax, DWORD PTR uSizeRead$1$[rbp-177]
  004c2	74 05		 je	 SHORT $LN64@unz64local

; 1101 :                 err=UNZ_ERRNO;

  004c4	41 8b ff	 mov	 edi, r15d

; 1102 :         lSeek+=file_info.size_file_comment - uSizeRead;
; 1103 :     }
; 1104 :     else
; 1105 :         lSeek+=file_info.size_file_comment;
; 1106 : 
; 1107 : 
; 1108 :     if ((err==UNZ_OK) && (pfile_info!=NULL))

  004c7	eb 4e		 jmp	 SHORT $LN66@unz64local
$LN64@unz64local:
  004c9	85 ff		 test	 edi, edi
  004cb	75 4a		 jne	 SHORT $LN66@unz64local
$LN75@unz64local:
  004cd	4d 85 ed	 test	 r13, r13
  004d0	74 39		 je	 SHORT $LN76@unz64local

; 1109 :         *pfile_info=file_info;

  004d2	0f 28 44 24 30	 movaps	 xmm0, XMMWORD PTR file_info$[rsp]
  004d7	0f 28 4d 8f	 movaps	 xmm1, XMMWORD PTR file_info$[rbp-161]
  004db	41 0f 11 45 00	 movups	 XMMWORD PTR [r13], xmm0
  004e0	0f 28 45 9f	 movaps	 xmm0, XMMWORD PTR file_info$[rbp-145]
  004e4	41 0f 11 4d 10	 movups	 XMMWORD PTR [r13+16], xmm1
  004e9	0f 28 4d af	 movaps	 xmm1, XMMWORD PTR file_info$[rbp-129]
  004ed	41 0f 11 45 20	 movups	 XMMWORD PTR [r13+32], xmm0
  004f2	0f 28 45 bf	 movaps	 xmm0, XMMWORD PTR file_info$[rbp-113]
  004f6	41 0f 11 4d 30	 movups	 XMMWORD PTR [r13+48], xmm1
  004fb	f2 0f 10 4d cf	 movsd	 xmm1, QWORD PTR file_info$[rbp-97]
  00500	41 0f 11 45 40	 movups	 XMMWORD PTR [r13+64], xmm0
  00505	f2 41 0f 11 4d
	50		 movsd	 QWORD PTR [r13+80], xmm1
$LN76@unz64local:

; 1110 : 
; 1111 :     if ((err==UNZ_OK) && (pfile_info_internal!=NULL))

  0050b	48 8b 45 4f	 mov	 rax, QWORD PTR pfile_info_internal$[rbp-177]
  0050f	48 85 c0	 test	 rax, rax
  00512	74 03		 je	 SHORT $LN66@unz64local

; 1112 :         *pfile_info_internal=file_info_internal;

  00514	48 89 18	 mov	 QWORD PTR [rax], rbx
$LN66@unz64local:
  00517	4c 8b bc 24 a8
	00 00 00	 mov	 r15, QWORD PTR [rsp+168]

; 1113 : 
; 1114 :     return err;

  0051f	8b c7		 mov	 eax, edi
  00521	48 8b bc 24 b0
	00 00 00	 mov	 rdi, QWORD PTR [rsp+176]
  00529	48 8b 9c 24 b8
	00 00 00	 mov	 rbx, QWORD PTR [rsp+184]

; 1115 : }

  00531	48 81 c4 c0 00
	00 00		 add	 rsp, 192		; 000000c0H
  00538	41 5e		 pop	 r14
  0053a	41 5d		 pop	 r13
  0053c	41 5c		 pop	 r12
  0053e	5e		 pop	 rsi
  0053f	5d		 pop	 rbp
  00540	c3		 ret	 0
unz64local_GetCurrentFileInfoInternal ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetCurrentFileInfo64
_TEXT	SEGMENT
file$ = 96
pfile_info$ = 104
szFileName$ = 112
fileNameBufferSize$ = 120
extraField$ = 128
extraFieldBufferSize$ = 136
szComment$ = 144
commentBufferSize$ = 152
unzGetCurrentFileInfo64 PROC				; COMDAT

; 1129 : {

$LN4:
  00000	48 83 ec 58	 sub	 rsp, 88			; 00000058H

; 1130 :     return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,

  00004	8b 84 24 98 00
	00 00		 mov	 eax, DWORD PTR commentBufferSize$[rsp]
  0000b	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  0000f	48 8b 84 24 90
	00 00 00	 mov	 rax, QWORD PTR szComment$[rsp]
  00017	48 89 44 24 38	 mov	 QWORD PTR [rsp+56], rax
  0001c	8b 84 24 88 00
	00 00		 mov	 eax, DWORD PTR extraFieldBufferSize$[rsp]
  00023	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  00027	48 8b 84 24 80
	00 00 00	 mov	 rax, QWORD PTR extraField$[rsp]
  0002f	48 89 44 24 28	 mov	 QWORD PTR [rsp+40], rax
  00034	44 89 4c 24 20	 mov	 DWORD PTR [rsp+32], r9d
  00039	4d 8b c8	 mov	 r9, r8
  0003c	45 33 c0	 xor	 r8d, r8d
  0003f	e8 00 00 00 00	 call	 unz64local_GetCurrentFileInfoInternal

; 1131 :                                                 szFileName,fileNameBufferSize,
; 1132 :                                                 extraField,extraFieldBufferSize,
; 1133 :                                                 szComment,commentBufferSize);
; 1134 : }

  00044	48 83 c4 58	 add	 rsp, 88			; 00000058H
  00048	c3		 ret	 0
unzGetCurrentFileInfo64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetCurrentFileInfo
_TEXT	SEGMENT
file_info64$ = 80
file$ = 192
pfile_info$ = 200
szFileName$ = 208
fileNameBufferSize$ = 216
extraField$ = 224
extraFieldBufferSize$ = 232
szComment$ = 240
commentBufferSize$ = 248
unzGetCurrentFileInfo PROC				; COMDAT

; 1141 : {

$LN7:
  00000	40 53		 push	 rbx
  00002	48 81 ec b0 00
	00 00		 sub	 rsp, 176		; 000000b0H

; 1142 :     int err;
; 1143 :     unz_file_info64 file_info64;
; 1144 :     err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,

  00009	8b 84 24 f8 00
	00 00		 mov	 eax, DWORD PTR commentBufferSize$[rsp]
  00010	48 8b da	 mov	 rbx, rdx
  00013	89 44 24 40	 mov	 DWORD PTR [rsp+64], eax
  00017	48 8d 54 24 50	 lea	 rdx, QWORD PTR file_info64$[rsp]
  0001c	48 8b 84 24 f0
	00 00 00	 mov	 rax, QWORD PTR szComment$[rsp]
  00024	48 89 44 24 38	 mov	 QWORD PTR [rsp+56], rax
  00029	8b 84 24 e8 00
	00 00		 mov	 eax, DWORD PTR extraFieldBufferSize$[rsp]
  00030	89 44 24 30	 mov	 DWORD PTR [rsp+48], eax
  00034	48 8b 84 24 e0
	00 00 00	 mov	 rax, QWORD PTR extraField$[rsp]
  0003c	48 89 44 24 28	 mov	 QWORD PTR [rsp+40], rax
  00041	44 89 4c 24 20	 mov	 DWORD PTR [rsp+32], r9d
  00046	4d 8b c8	 mov	 r9, r8
  00049	45 33 c0	 xor	 r8d, r8d
  0004c	e8 00 00 00 00	 call	 unz64local_GetCurrentFileInfoInternal
  00051	8b d0		 mov	 edx, eax

; 1145 :                                                 szFileName,fileNameBufferSize,
; 1146 :                                                 extraField,extraFieldBufferSize,
; 1147 :                                                 szComment,commentBufferSize);
; 1148 :     if ((err==UNZ_OK) && (pfile_info != NULL))

  00053	85 c0		 test	 eax, eax
  00055	0f 85 92 00 00
	00		 jne	 $LN2@unzGetCurr
  0005b	48 85 db	 test	 rbx, rbx
  0005e	0f 84 89 00 00
	00		 je	 $LN2@unzGetCurr

; 1149 :     {
; 1150 :         pfile_info->version = file_info64.version;
; 1151 :         pfile_info->version_needed = file_info64.version_needed;
; 1152 :         pfile_info->flag = file_info64.flag;
; 1153 :         pfile_info->compression_method = file_info64.compression_method;
; 1154 :         pfile_info->dosDate = file_info64.dosDate;

  00064	8b 44 24 60	 mov	 eax, DWORD PTR file_info64$[rsp+16]
  00068	8b 4c 24 50	 mov	 ecx, DWORD PTR file_info64$[rsp]

; 1155 :         pfile_info->crc = file_info64.crc;
; 1156 : 
; 1157 :         pfile_info->size_filename = file_info64.size_filename;
; 1158 :         pfile_info->size_file_extra = file_info64.size_file_extra;
; 1159 :         pfile_info->size_file_comment = file_info64.size_file_comment;
; 1160 : 
; 1161 :         pfile_info->disk_num_start = file_info64.disk_num_start;
; 1162 :         pfile_info->internal_fa = file_info64.internal_fa;
; 1163 :         pfile_info->external_fa = file_info64.external_fa;
; 1164 : 
; 1165 :         pfile_info->tmu_date = file_info64.tmu_date,

  0006c	0f 28 84 24 90
	00 00 00	 movaps	 xmm0, XMMWORD PTR file_info64$[rsp+64]
  00074	f2 0f 10 8c 24
	a0 00 00 00	 movsd	 xmm1, QWORD PTR file_info64$[rsp+80]
  0007d	89 43 10	 mov	 DWORD PTR [rbx+16], eax
  00080	8b 44 24 64	 mov	 eax, DWORD PTR file_info64$[rsp+20]
  00084	89 43 14	 mov	 DWORD PTR [rbx+20], eax
  00087	8b 44 24 78	 mov	 eax, DWORD PTR file_info64$[rsp+40]
  0008b	89 43 20	 mov	 DWORD PTR [rbx+32], eax
  0008e	8b 44 24 7c	 mov	 eax, DWORD PTR file_info64$[rsp+44]
  00092	89 43 24	 mov	 DWORD PTR [rbx+36], eax
  00095	8b 84 24 80 00
	00 00		 mov	 eax, DWORD PTR file_info64$[rsp+48]
  0009c	89 43 28	 mov	 DWORD PTR [rbx+40], eax
  0009f	8b 84 24 84 00
	00 00		 mov	 eax, DWORD PTR file_info64$[rsp+52]
  000a6	89 43 2c	 mov	 DWORD PTR [rbx+44], eax
  000a9	8b 84 24 88 00
	00 00		 mov	 eax, DWORD PTR file_info64$[rsp+56]
  000b0	89 43 30	 mov	 DWORD PTR [rbx+48], eax
  000b3	8b 84 24 8c 00
	00 00		 mov	 eax, DWORD PTR file_info64$[rsp+60]
  000ba	89 0b		 mov	 DWORD PTR [rbx], ecx
  000bc	8b 4c 24 54	 mov	 ecx, DWORD PTR file_info64$[rsp+4]
  000c0	89 43 34	 mov	 DWORD PTR [rbx+52], eax
  000c3	8b 44 24 68	 mov	 eax, DWORD PTR file_info64$[rsp+24]
  000c7	89 4b 04	 mov	 DWORD PTR [rbx+4], ecx
  000ca	8b 4c 24 58	 mov	 ecx, DWORD PTR file_info64$[rsp+8]
  000ce	89 43 18	 mov	 DWORD PTR [rbx+24], eax

; 1166 : 
; 1167 : 
; 1168 :         pfile_info->compressed_size = (uLong)file_info64.compressed_size;
; 1169 :         pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;

  000d1	8b 44 24 70	 mov	 eax, DWORD PTR file_info64$[rsp+32]
  000d5	89 4b 08	 mov	 DWORD PTR [rbx+8], ecx
  000d8	8b 4c 24 5c	 mov	 ecx, DWORD PTR file_info64$[rsp+12]
  000dc	89 43 1c	 mov	 DWORD PTR [rbx+28], eax

; 1170 : 
; 1171 :     }
; 1172 :     return err;

  000df	8b c2		 mov	 eax, edx
  000e1	0f 11 43 38	 movups	 XMMWORD PTR [rbx+56], xmm0
  000e5	89 4b 0c	 mov	 DWORD PTR [rbx+12], ecx
  000e8	f2 0f 11 4b 48	 movsd	 QWORD PTR [rbx+72], xmm1
$LN2@unzGetCurr:

; 1173 : }

  000ed	48 81 c4 b0 00
	00 00		 add	 rsp, 176		; 000000b0H
  000f4	5b		 pop	 rbx
  000f5	c3		 ret	 0
unzGetCurrentFileInfo ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGoToFirstFile
_TEXT	SEGMENT
file$ = 96
unzGoToFirstFile PROC					; COMDAT

; 1179 : {

$LN5:
  00000	40 57		 push	 rdi
  00002	48 83 ec 50	 sub	 rsp, 80			; 00000050H
  00006	48 8b f9	 mov	 rdi, rcx

; 1180 :     int err=UNZ_OK;
; 1181 :     unz64_s* s;
; 1182 :     if (file==NULL)

  00009	48 85 c9	 test	 rcx, rcx
  0000c	75 09		 jne	 SHORT $LN2@unzGoToFir

; 1183 :         return UNZ_PARAMERROR;

  0000e	8d 41 9a	 lea	 eax, QWORD PTR [rcx-102]

; 1191 :     return err;
; 1192 : }

  00011	48 83 c4 50	 add	 rsp, 80			; 00000050H
  00015	5f		 pop	 rdi
  00016	c3		 ret	 0
$LN2@unzGoToFir:

; 1184 :     s=(unz64_s*)file;
; 1185 :     s->pos_in_central_dir=s->offset_central_dir;

  00017	48 8b 81 a8 00
	00 00		 mov	 rax, QWORD PTR [rcx+168]

; 1186 :     s->num_file=0;
; 1187 :     err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,

  0001e	4c 8d 81 08 01
	00 00		 lea	 r8, QWORD PTR [rcx+264]
  00025	48 89 5c 24 60	 mov	 QWORD PTR [rsp+96], rbx
  0002a	48 8d 91 b0 00
	00 00		 lea	 rdx, QWORD PTR [rcx+176]
  00031	33 db		 xor	 ebx, ebx
  00033	48 89 81 88 00
	00 00		 mov	 QWORD PTR [rcx+136], rax
  0003a	89 5c 24 40	 mov	 DWORD PTR [rsp+64], ebx
  0003e	45 33 c9	 xor	 r9d, r9d
  00041	48 89 5c 24 38	 mov	 QWORD PTR [rsp+56], rbx
  00046	89 5c 24 30	 mov	 DWORD PTR [rsp+48], ebx
  0004a	48 89 5c 24 28	 mov	 QWORD PTR [rsp+40], rbx
  0004f	89 5c 24 20	 mov	 DWORD PTR [rsp+32], ebx
  00053	48 89 99 80 00
	00 00		 mov	 QWORD PTR [rcx+128], rbx
  0005a	e8 00 00 00 00	 call	 unz64local_GetCurrentFileInfoInternal

; 1188 :                                              &s->cur_file_info_internal,
; 1189 :                                              NULL,0,NULL,0,NULL,0);
; 1190 :     s->current_file_ok = (err == UNZ_OK);

  0005f	85 c0		 test	 eax, eax
  00061	0f 94 c3	 sete	 bl
  00064	48 89 9f 90 00
	00 00		 mov	 QWORD PTR [rdi+144], rbx
  0006b	48 8b 5c 24 60	 mov	 rbx, QWORD PTR [rsp+96]

; 1191 :     return err;
; 1192 : }

  00070	48 83 c4 50	 add	 rsp, 80			; 00000050H
  00074	5f		 pop	 rdi
  00075	c3		 ret	 0
unzGoToFirstFile ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGoToNextFile
_TEXT	SEGMENT
file$ = 96
unzGoToNextFile PROC					; COMDAT

; 1200 : {

$LN9:
  00000	40 57		 push	 rdi
  00002	48 83 ec 50	 sub	 rsp, 80			; 00000050H
  00006	48 8b f9	 mov	 rdi, rcx

; 1201 :     unz64_s* s;
; 1202 :     int err;
; 1203 : 
; 1204 :     if (file==NULL)

  00009	48 85 c9	 test	 rcx, rcx
  0000c	75 09		 jne	 SHORT $LN2@unzGoToNex

; 1205 :         return UNZ_PARAMERROR;

  0000e	8d 41 9a	 lea	 eax, QWORD PTR [rcx-102]

; 1220 :     return err;
; 1221 : }

  00011	48 83 c4 50	 add	 rsp, 80			; 00000050H
  00015	5f		 pop	 rdi
  00016	c3		 ret	 0
$LN2@unzGoToNex:

; 1206 :     s=(unz64_s*)file;
; 1207 :     if (!s->current_file_ok)

  00017	48 83 b9 90 00
	00 00 00	 cmp	 QWORD PTR [rcx+144], 0
  0001f	75 0b		 jne	 SHORT $LN3@unzGoToNex
$LN7@unzGoToNex:

; 1208 :         return UNZ_END_OF_LIST_OF_FILE;

  00021	b8 9c ff ff ff	 mov	 eax, -100		; ffffffffffffff9cH

; 1220 :     return err;
; 1221 : }

  00026	48 83 c4 50	 add	 rsp, 80			; 00000050H
  0002a	5f		 pop	 rdi
  0002b	c3		 ret	 0
$LN3@unzGoToNex:

; 1209 :     if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */

  0002c	48 8b 49 68	 mov	 rcx, QWORD PTR [rcx+104]
  00030	48 81 f9 ff ff
	00 00		 cmp	 rcx, 65535		; 0000ffffH
  00037	74 0f		 je	 SHORT $LN5@unzGoToNex

; 1210 :       if (s->num_file+1==s->gi.number_entry)

  00039	48 8b 87 80 00
	00 00		 mov	 rax, QWORD PTR [rdi+128]
  00040	48 ff c0	 inc	 rax
  00043	48 3b c1	 cmp	 rax, rcx
  00046	74 d9		 je	 SHORT $LN7@unzGoToNex
$LN5@unzGoToNex:

; 1211 :         return UNZ_END_OF_LIST_OF_FILE;
; 1212 : 
; 1213 :     s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +

  00048	8b 8f e0 00 00
	00		 mov	 ecx, DWORD PTR [rdi+224]

; 1214 :             s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
; 1215 :     s->num_file++;
; 1216 :     err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,

  0004e	4c 8d 87 08 01
	00 00		 lea	 r8, QWORD PTR [rdi+264]
  00055	8b 87 d8 00 00
	00		 mov	 eax, DWORD PTR [rdi+216]
  0005b	48 8d 97 b0 00
	00 00		 lea	 rdx, QWORD PTR [rdi+176]
  00062	03 8f dc 00 00
	00		 add	 ecx, DWORD PTR [rdi+220]
  00068	83 c0 2e	 add	 eax, 46			; 0000002eH
  0006b	48 ff 87 80 00
	00 00		 inc	 QWORD PTR [rdi+128]
  00072	03 c1		 add	 eax, ecx
  00074	48 01 87 88 00
	00 00		 add	 QWORD PTR [rdi+136], rax
  0007b	45 33 c9	 xor	 r9d, r9d
  0007e	48 89 5c 24 60	 mov	 QWORD PTR [rsp+96], rbx
  00083	48 8b cf	 mov	 rcx, rdi
  00086	33 db		 xor	 ebx, ebx
  00088	89 5c 24 40	 mov	 DWORD PTR [rsp+64], ebx
  0008c	48 89 5c 24 38	 mov	 QWORD PTR [rsp+56], rbx
  00091	89 5c 24 30	 mov	 DWORD PTR [rsp+48], ebx
  00095	48 89 5c 24 28	 mov	 QWORD PTR [rsp+40], rbx
  0009a	89 5c 24 20	 mov	 DWORD PTR [rsp+32], ebx
  0009e	e8 00 00 00 00	 call	 unz64local_GetCurrentFileInfoInternal

; 1217 :                                                &s->cur_file_info_internal,
; 1218 :                                                NULL,0,NULL,0,NULL,0);
; 1219 :     s->current_file_ok = (err == UNZ_OK);

  000a3	85 c0		 test	 eax, eax
  000a5	0f 94 c3	 sete	 bl
  000a8	48 89 9f 90 00
	00 00		 mov	 QWORD PTR [rdi+144], rbx
  000af	48 8b 5c 24 60	 mov	 rbx, QWORD PTR [rsp+96]

; 1220 :     return err;
; 1221 : }

  000b4	48 83 c4 50	 add	 rsp, 80			; 00000050H
  000b8	5f		 pop	 rdi
  000b9	c3		 ret	 0
unzGoToNextFile ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzLocateFile
_TEXT	SEGMENT
cur_file_infoSaved$1$ = 64
cur_file_infoSaved$2$ = 80
cur_file_infoSaved$3$ = 96
cur_file_infoSaved$4$ = 112
cur_file_infoSaved$5$ = 128
szCurrentFileName$1 = 144
cur_file_infoSaved$6$ = 464
file$ = 464
szFileName$ = 472
iCaseSensitivity$ = 480
unzLocateFile PROC					; COMDAT

; 1233 : {

$LN24:
  00000	40 55		 push	 rbp
  00002	56		 push	 rsi
  00003	57		 push	 rdi
  00004	48 81 ec b0 01
	00 00		 sub	 rsp, 432		; 000001b0H
  0000b	41 8b e8	 mov	 ebp, r8d
  0000e	48 8b f2	 mov	 rsi, rdx
  00011	48 8b f9	 mov	 rdi, rcx

; 1234 :     unz64_s* s;
; 1235 :     int err;
; 1236 : 
; 1237 :     /* We remember the 'current' position in the file so that we can jump
; 1238 :      * back there if we fail.
; 1239 :      */
; 1240 :     unz_file_info64 cur_file_infoSaved;
; 1241 :     unz_file_info64_internal cur_file_info_internalSaved;
; 1242 :     ZPOS64_T num_fileSaved;
; 1243 :     ZPOS64_T pos_in_central_dirSaved;
; 1244 : 
; 1245 : 
; 1246 :     if (file==NULL)

  00014	48 85 c9	 test	 rcx, rcx
  00017	75 10		 jne	 SHORT $LN4@unzLocateF
$LN22@unzLocateF:

; 1247 :         return UNZ_PARAMERROR;

  00019	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1286 :     return err;
; 1287 : }

  0001e	48 81 c4 b0 01
	00 00		 add	 rsp, 432		; 000001b0H
  00025	5f		 pop	 rdi
  00026	5e		 pop	 rsi
  00027	5d		 pop	 rbp
  00028	c3		 ret	 0
$LN4@unzLocateF:

; 1248 : 
; 1249 :     if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)

  00029	48 83 c8 ff	 or	 rax, -1
  0002d	0f 1f 00	 npad	 3
$LL15@unzLocateF:
  00030	48 ff c0	 inc	 rax
  00033	80 3c 02 00	 cmp	 BYTE PTR [rdx+rax], 0
  00037	75 f7		 jne	 SHORT $LL15@unzLocateF
  00039	48 3d 00 01 00
	00		 cmp	 rax, 256		; 00000100H
  0003f	73 d8		 jae	 SHORT $LN22@unzLocateF

; 1250 :         return UNZ_PARAMERROR;
; 1251 : 
; 1252 :     s=(unz64_s*)file;
; 1253 :     if (!s->current_file_ok)

  00041	48 83 b9 90 00
	00 00 00	 cmp	 QWORD PTR [rcx+144], 0
  00049	75 10		 jne	 SHORT $LN6@unzLocateF

; 1254 :         return UNZ_END_OF_LIST_OF_FILE;

  0004b	b8 9c ff ff ff	 mov	 eax, -100		; ffffffffffffff9cH

; 1286 :     return err;
; 1287 : }

  00050	48 81 c4 b0 01
	00 00		 add	 rsp, 432		; 000001b0H
  00057	5f		 pop	 rdi
  00058	5e		 pop	 rsi
  00059	5d		 pop	 rbp
  0005a	c3		 ret	 0
$LN6@unzLocateF:

; 1255 : 
; 1256 :     /* Save the current state */
; 1257 :     num_fileSaved = s->num_file;
; 1258 :     pos_in_central_dirSaved = s->pos_in_central_dir;
; 1259 :     cur_file_infoSaved = s->cur_file_info;

  0005b	0f 10 81 b0 00
	00 00		 movups	 xmm0, XMMWORD PTR [rcx+176]
  00062	48 89 9c 24 d8
	01 00 00	 mov	 QWORD PTR [rsp+472], rbx

; 1260 :     cur_file_info_internalSaved = s->cur_file_info_internal;

  0006a	48 8b 99 08 01
	00 00		 mov	 rbx, QWORD PTR [rcx+264]
  00071	0f 11 44 24 40	 movups	 XMMWORD PTR cur_file_infoSaved$1$[rsp], xmm0
  00076	4c 89 a4 24 e0
	01 00 00	 mov	 QWORD PTR [rsp+480], r12
  0007e	0f 10 81 c0 00
	00 00		 movups	 xmm0, XMMWORD PTR [rcx+192]
  00085	4c 89 b4 24 a8
	01 00 00	 mov	 QWORD PTR [rsp+424], r14
  0008d	4c 8b b1 80 00
	00 00		 mov	 r14, QWORD PTR [rcx+128]
  00094	0f 11 44 24 50	 movups	 XMMWORD PTR cur_file_infoSaved$2$[rsp], xmm0
  00099	4c 89 bc 24 a0
	01 00 00	 mov	 QWORD PTR [rsp+416], r15
  000a1	0f 10 81 d0 00
	00 00		 movups	 xmm0, XMMWORD PTR [rcx+208]
  000a8	4c 8b b9 88 00
	00 00		 mov	 r15, QWORD PTR [rcx+136]
  000af	0f 11 44 24 60	 movups	 XMMWORD PTR cur_file_infoSaved$3$[rsp], xmm0
  000b4	0f 10 81 e0 00
	00 00		 movups	 xmm0, XMMWORD PTR [rcx+224]
  000bb	0f 11 44 24 70	 movups	 XMMWORD PTR cur_file_infoSaved$4$[rsp], xmm0
  000c0	0f 10 81 f0 00
	00 00		 movups	 xmm0, XMMWORD PTR [rcx+240]
  000c7	0f 11 84 24 80
	00 00 00	 movups	 XMMWORD PTR cur_file_infoSaved$5$[rsp], xmm0
  000cf	f2 0f 10 81 00
	01 00 00	 movsd	 xmm0, QWORD PTR [rcx+256]
  000d7	f2 0f 11 84 24
	d0 01 00 00	 movsd	 QWORD PTR cur_file_infoSaved$6$[rsp], xmm0

; 1261 : 
; 1262 :     err = unzGoToFirstFile(file);

  000e0	e8 00 00 00 00	 call	 unzGoToFirstFile

; 1263 : 
; 1264 :     while (err == UNZ_OK)

  000e5	85 c0		 test	 eax, eax
  000e7	75 5e		 jne	 SHORT $LN14@unzLocateF
  000e9	45 33 e4	 xor	 r12d, r12d
  000ec	0f 1f 40 00	 npad	 4
$LL2@unzLocateF:

; 1265 :     {
; 1266 :         char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
; 1267 :         err = unzGetCurrentFileInfo64(file,NULL,

  000f0	44 89 64 24 38	 mov	 DWORD PTR [rsp+56], r12d
  000f5	4c 8d 84 24 90
	00 00 00	 lea	 r8, QWORD PTR szCurrentFileName$1[rsp]
  000fd	4c 89 64 24 30	 mov	 QWORD PTR [rsp+48], r12
  00102	41 b9 00 01 00
	00		 mov	 r9d, 256		; 00000100H
  00108	44 89 64 24 28	 mov	 DWORD PTR [rsp+40], r12d
  0010d	33 d2		 xor	 edx, edx
  0010f	48 8b cf	 mov	 rcx, rdi
  00112	4c 89 64 24 20	 mov	 QWORD PTR [rsp+32], r12
  00117	e8 00 00 00 00	 call	 unzGetCurrentFileInfo64

; 1268 :                                     szCurrentFileName,sizeof(szCurrentFileName)-1,
; 1269 :                                     NULL,0,NULL,0);
; 1270 :         if (err == UNZ_OK)

  0011c	85 c0		 test	 eax, eax
  0011e	75 27		 jne	 SHORT $LN14@unzLocateF

; 1271 :         {
; 1272 :             if (unzStringFileNameCompare(szCurrentFileName,
; 1273 :                                             szFileName,iCaseSensitivity)==0)

  00120	44 8b c5	 mov	 r8d, ebp
  00123	48 8d 8c 24 90
	00 00 00	 lea	 rcx, QWORD PTR szCurrentFileName$1[rsp]
  0012b	48 8b d6	 mov	 rdx, rsi
  0012e	e8 00 00 00 00	 call	 unzStringFileNameCompare
  00133	85 c0		 test	 eax, eax
  00135	0f 84 9c 00 00
	00		 je	 $LN11@unzLocateF

; 1275 :             err = unzGoToNextFile(file);

  0013b	48 8b cf	 mov	 rcx, rdi
  0013e	e8 00 00 00 00	 call	 unzGoToNextFile
  00143	85 c0		 test	 eax, eax
  00145	74 a9		 je	 SHORT $LL2@unzLocateF
$LN14@unzLocateF:

; 1276 :         }
; 1277 :     }
; 1278 : 
; 1279 :     /* We failed, so restore the state of the 'current file' to where we
; 1280 :      * were.
; 1281 :      */
; 1282 :     s->num_file = num_fileSaved ;
; 1283 :     s->pos_in_central_dir = pos_in_central_dirSaved ;
; 1284 :     s->cur_file_info = cur_file_infoSaved;

  00147	0f 10 44 24 40	 movups	 xmm0, XMMWORD PTR cur_file_infoSaved$1$[rsp]
  0014c	4c 89 b7 80 00
	00 00		 mov	 QWORD PTR [rdi+128], r14
  00153	0f 10 4c 24 50	 movups	 xmm1, XMMWORD PTR cur_file_infoSaved$2$[rsp]
  00158	4c 89 bf 88 00
	00 00		 mov	 QWORD PTR [rdi+136], r15
  0015f	0f 11 87 b0 00
	00 00		 movups	 XMMWORD PTR [rdi+176], xmm0

; 1285 :     s->cur_file_info_internal = cur_file_info_internalSaved;

  00166	48 89 9f 08 01
	00 00		 mov	 QWORD PTR [rdi+264], rbx
  0016d	0f 10 44 24 60	 movups	 xmm0, XMMWORD PTR cur_file_infoSaved$3$[rsp]
  00172	0f 11 8f c0 00
	00 00		 movups	 XMMWORD PTR [rdi+192], xmm1
  00179	0f 10 4c 24 70	 movups	 xmm1, XMMWORD PTR cur_file_infoSaved$4$[rsp]
  0017e	0f 11 87 d0 00
	00 00		 movups	 XMMWORD PTR [rdi+208], xmm0
  00185	0f 10 84 24 80
	00 00 00	 movups	 xmm0, XMMWORD PTR cur_file_infoSaved$5$[rsp]
  0018d	0f 11 8f e0 00
	00 00		 movups	 XMMWORD PTR [rdi+224], xmm1
  00194	0f 11 87 f0 00
	00 00		 movups	 XMMWORD PTR [rdi+240], xmm0
  0019b	f2 0f 10 84 24
	d0 01 00 00	 movsd	 xmm0, QWORD PTR cur_file_infoSaved$6$[rsp]
  001a4	f2 0f 11 87 00
	01 00 00	 movsd	 QWORD PTR [rdi+256], xmm0
$LN19@unzLocateF:
  001ac	4c 8b b4 24 a8
	01 00 00	 mov	 r14, QWORD PTR [rsp+424]
  001b4	4c 8b a4 24 e0
	01 00 00	 mov	 r12, QWORD PTR [rsp+480]
  001bc	48 8b 9c 24 d8
	01 00 00	 mov	 rbx, QWORD PTR [rsp+472]
  001c4	4c 8b bc 24 a0
	01 00 00	 mov	 r15, QWORD PTR [rsp+416]

; 1286 :     return err;
; 1287 : }

  001cc	48 81 c4 b0 01
	00 00		 add	 rsp, 432		; 000001b0H
  001d3	5f		 pop	 rdi
  001d4	5e		 pop	 rsi
  001d5	5d		 pop	 rbp
  001d6	c3		 ret	 0
$LN11@unzLocateF:

; 1274 :                 return UNZ_OK;

  001d7	33 c0		 xor	 eax, eax
  001d9	eb d1		 jmp	 SHORT $LN19@unzLocateF
unzLocateFile ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetFilePos64
_TEXT	SEGMENT
file$ = 8
file_pos$ = 16
unzGetFilePos64 PROC					; COMDAT

; 1310 :     unz64_s* s;
; 1311 : 
; 1312 :     if (file==NULL || file_pos==NULL)

  00000	48 85 c9	 test	 rcx, rcx
  00003	74 2d		 je	 SHORT $LN3@unzGetFile
  00005	48 85 d2	 test	 rdx, rdx
  00008	74 28		 je	 SHORT $LN3@unzGetFile

; 1314 :     s=(unz64_s*)file;
; 1315 :     if (!s->current_file_ok)

  0000a	48 83 b9 90 00
	00 00 00	 cmp	 QWORD PTR [rcx+144], 0
  00012	75 06		 jne	 SHORT $LN4@unzGetFile

; 1316 :         return UNZ_END_OF_LIST_OF_FILE;

  00014	b8 9c ff ff ff	 mov	 eax, -100		; ffffffffffffff9cH

; 1322 : }

  00019	c3		 ret	 0
$LN4@unzGetFile:

; 1317 : 
; 1318 :     file_pos->pos_in_zip_directory  = s->pos_in_central_dir;

  0001a	48 8b 81 88 00
	00 00		 mov	 rax, QWORD PTR [rcx+136]
  00021	48 89 02	 mov	 QWORD PTR [rdx], rax

; 1319 :     file_pos->num_of_file           = s->num_file;

  00024	48 8b 81 80 00
	00 00		 mov	 rax, QWORD PTR [rcx+128]
  0002b	48 89 42 08	 mov	 QWORD PTR [rdx+8], rax

; 1320 : 
; 1321 :     return UNZ_OK;

  0002f	33 c0		 xor	 eax, eax

; 1322 : }

  00031	c3		 ret	 0
$LN3@unzGetFile:

; 1313 :         return UNZ_PARAMERROR;

  00032	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1322 : }

  00037	c3		 ret	 0
unzGetFilePos64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetFilePos
_TEXT	SEGMENT
file_pos64$ = 32
file$ = 64
file_pos$ = 72
unzGetFilePos PROC					; COMDAT

; 1327 : {

$LN6:
  00000	40 53		 push	 rbx
  00002	48 83 ec 30	 sub	 rsp, 48			; 00000030H
  00006	48 8b da	 mov	 rbx, rdx

; 1328 :     unz64_file_pos file_pos64;
; 1329 :     int err = unzGetFilePos64(file,&file_pos64);

  00009	48 8d 54 24 20	 lea	 rdx, QWORD PTR file_pos64$[rsp]
  0000e	e8 00 00 00 00	 call	 unzGetFilePos64

; 1330 :     if (err==UNZ_OK)

  00013	85 c0		 test	 eax, eax
  00015	75 0d		 jne	 SHORT $LN4@unzGetFile

; 1331 :     {
; 1332 :         file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;

  00017	8b 4c 24 20	 mov	 ecx, DWORD PTR file_pos64$[rsp]
  0001b	89 0b		 mov	 DWORD PTR [rbx], ecx

; 1333 :         file_pos->num_of_file = (uLong)file_pos64.num_of_file;

  0001d	8b 4c 24 28	 mov	 ecx, DWORD PTR file_pos64$[rsp+8]
  00021	89 4b 04	 mov	 DWORD PTR [rbx+4], ecx
$LN4@unzGetFile:

; 1334 :     }
; 1335 :     return err;
; 1336 : }

  00024	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00028	5b		 pop	 rbx
  00029	c3		 ret	 0
unzGetFilePos ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGoToFilePos64
_TEXT	SEGMENT
file$ = 96
file_pos$ = 104
unzGoToFilePos64 PROC					; COMDAT

; 1339 : {

$LN6:
  00000	40 57		 push	 rdi
  00002	48 83 ec 50	 sub	 rsp, 80			; 00000050H
  00006	48 8b f9	 mov	 rdi, rcx

; 1340 :     unz64_s* s;
; 1341 :     int err;
; 1342 : 
; 1343 :     if (file==NULL || file_pos==NULL)

  00009	48 85 c9	 test	 rcx, rcx
  0000c	74 64		 je	 SHORT $LN3@unzGoToFil
  0000e	48 85 d2	 test	 rdx, rdx
  00011	74 5f		 je	 SHORT $LN3@unzGoToFil

; 1345 :     s=(unz64_s*)file;
; 1346 : 
; 1347 :     /* jump to the right spot */
; 1348 :     s->pos_in_central_dir = file_pos->pos_in_zip_directory;

  00013	48 8b 02	 mov	 rax, QWORD PTR [rdx]

; 1349 :     s->num_file           = file_pos->num_of_file;
; 1350 : 
; 1351 :     /* set the current file */
; 1352 :     err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,

  00016	4c 8d 81 08 01
	00 00		 lea	 r8, QWORD PTR [rcx+264]
  0001d	48 89 81 88 00
	00 00		 mov	 QWORD PTR [rcx+136], rax
  00024	45 33 c9	 xor	 r9d, r9d
  00027	48 8b 42 08	 mov	 rax, QWORD PTR [rdx+8]
  0002b	48 8d 91 b0 00
	00 00		 lea	 rdx, QWORD PTR [rcx+176]
  00032	48 89 5c 24 60	 mov	 QWORD PTR [rsp+96], rbx
  00037	33 db		 xor	 ebx, ebx
  00039	89 5c 24 40	 mov	 DWORD PTR [rsp+64], ebx
  0003d	48 89 5c 24 38	 mov	 QWORD PTR [rsp+56], rbx
  00042	89 5c 24 30	 mov	 DWORD PTR [rsp+48], ebx
  00046	48 89 5c 24 28	 mov	 QWORD PTR [rsp+40], rbx
  0004b	89 5c 24 20	 mov	 DWORD PTR [rsp+32], ebx
  0004f	48 89 81 80 00
	00 00		 mov	 QWORD PTR [rcx+128], rax
  00056	e8 00 00 00 00	 call	 unz64local_GetCurrentFileInfoInternal

; 1353 :                                                &s->cur_file_info_internal,
; 1354 :                                                NULL,0,NULL,0,NULL,0);
; 1355 :     /* return results */
; 1356 :     s->current_file_ok = (err == UNZ_OK);

  0005b	85 c0		 test	 eax, eax
  0005d	0f 94 c3	 sete	 bl
  00060	48 89 9f 90 00
	00 00		 mov	 QWORD PTR [rdi+144], rbx
  00067	48 8b 5c 24 60	 mov	 rbx, QWORD PTR [rsp+96]

; 1357 :     return err;
; 1358 : }

  0006c	48 83 c4 50	 add	 rsp, 80			; 00000050H
  00070	5f		 pop	 rdi
  00071	c3		 ret	 0
$LN3@unzGoToFil:

; 1344 :         return UNZ_PARAMERROR;

  00072	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1357 :     return err;
; 1358 : }

  00077	48 83 c4 50	 add	 rsp, 80			; 00000050H
  0007b	5f		 pop	 rdi
  0007c	c3		 ret	 0
unzGoToFilePos64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGoToFilePos
_TEXT	SEGMENT
file_pos64$ = 32
file$ = 64
file_pos$ = 72
unzGoToFilePos PROC					; COMDAT

; 1363 : {

$LN5:
  00000	48 83 ec 38	 sub	 rsp, 56			; 00000038H

; 1364 :     unz64_file_pos file_pos64;
; 1365 :     if (file_pos == NULL)

  00004	48 85 d2	 test	 rdx, rdx
  00007	75 0a		 jne	 SHORT $LN2@unzGoToFil

; 1366 :         return UNZ_PARAMERROR;

  00009	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1371 : }

  0000e	48 83 c4 38	 add	 rsp, 56			; 00000038H
  00012	c3		 ret	 0
$LN2@unzGoToFil:

; 1367 : 
; 1368 :     file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;

  00013	8b 02		 mov	 eax, DWORD PTR [rdx]
  00015	48 89 44 24 20	 mov	 QWORD PTR file_pos64$[rsp], rax

; 1369 :     file_pos64.num_of_file = file_pos->num_of_file;

  0001a	8b 42 04	 mov	 eax, DWORD PTR [rdx+4]

; 1370 :     return unzGoToFilePos64(file,&file_pos64);

  0001d	48 8d 54 24 20	 lea	 rdx, QWORD PTR file_pos64$[rsp]
  00022	48 89 44 24 28	 mov	 QWORD PTR file_pos64$[rsp+8], rax
  00027	e8 00 00 00 00	 call	 unzGoToFilePos64

; 1371 : }

  0002c	48 83 c4 38	 add	 rsp, 56			; 00000038H
  00030	c3		 ret	 0
unzGoToFilePos ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unz64local_CheckCurrentFileCoherencyHeader
_TEXT	SEGMENT
size_extra_field$ = 96
size_filename$ = 96
uData$ = 96
uMagic$ = 96
s$ = 96
uFlags$ = 104
piSizeVar$ = 104
poffset_local_extrafield$ = 112
psize_local_extrafield$ = 120
unz64local_CheckCurrentFileCoherencyHeader PROC		; COMDAT

; 1388 : {

  00000	40 53		 push	 rbx
  00002	56		 push	 rsi
  00003	57		 push	 rdi
  00004	41 54		 push	 r12
  00006	41 56		 push	 r14
  00008	41 57		 push	 r15
  0000a	48 83 ec 28	 sub	 rsp, 40			; 00000028H

; 1389 :     uLong uMagic,uData,uFlags;
; 1390 :     uLong size_filename;
; 1391 :     uLong size_extra_field;
; 1392 :     int err=UNZ_OK;

  0000e	33 db		 xor	 ebx, ebx
  00010	4d 8b e0	 mov	 r12, r8

; 1393 : 
; 1394 :     *piSizeVar = 0;
; 1395 :     *poffset_local_extrafield = 0;

  00013	49 89 18	 mov	 QWORD PTR [r8], rbx
  00016	4d 8b f9	 mov	 r15, r9

; 1396 :     *psize_local_extrafield = 0;
; 1397 : 
; 1398 :     if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
; 1399 :                                 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)

  00019	4c 8b 41 78	 mov	 r8, QWORD PTR [rcx+120]
  0001d	4c 8b f2	 mov	 r14, rdx
  00020	4c 03 81 08 01
	00 00		 add	 r8, QWORD PTR [rcx+264]
  00027	48 8b f9	 mov	 rdi, rcx
  0002a	89 1a		 mov	 DWORD PTR [rdx], ebx
  0002c	48 8b 51 60	 mov	 rdx, QWORD PTR [rcx+96]
  00030	41 89 19	 mov	 DWORD PTR [r9], ebx
  00033	45 33 c9	 xor	 r9d, r9d
  00036	e8 00 00 00 00	 call	 call_zseek64
  0003b	85 c0		 test	 eax, eax
  0003d	74 11		 je	 SHORT $LN2@unz64local

; 1400 :         return UNZ_ERRNO;

  0003f	83 c8 ff	 or	 eax, -1

; 1466 : }

  00042	48 83 c4 28	 add	 rsp, 40			; 00000028H
  00046	41 5f		 pop	 r15
  00048	41 5e		 pop	 r14
  0004a	41 5c		 pop	 r12
  0004c	5f		 pop	 rdi
  0004d	5e		 pop	 rsi
  0004e	5b		 pop	 rbx
  0004f	c3		 ret	 0
$LN2@unz64local:

; 1401 : 
; 1402 : 
; 1403 :     if (err==UNZ_OK)
; 1404 :     {
; 1405 :         if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)

  00050	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  00054	4c 8d 44 24 60	 lea	 r8, QWORD PTR uMagic$[rsp]
  00059	48 89 6c 24 70	 mov	 QWORD PTR [rsp+112], rbp
  0005e	48 8b cf	 mov	 rcx, rdi
  00061	4c 89 6c 24 20	 mov	 QWORD PTR [rsp+32], r13
  00066	e8 00 00 00 00	 call	 unz64local_getLong
  0006b	83 ce ff	 or	 esi, -1
  0006e	41 bd 99 ff ff
	ff		 mov	 r13d, -103		; ffffffffffffff99H
  00074	85 c0		 test	 eax, eax
  00076	74 04		 je	 SHORT $LN4@unz64local

; 1406 :             err=UNZ_ERRNO;

  00078	8b de		 mov	 ebx, esi
  0007a	eb 0c		 jmp	 SHORT $LN6@unz64local
$LN4@unz64local:

; 1407 :         else if (uMagic!=0x04034b50)

  0007c	81 7c 24 60 50
	4b 03 04	 cmp	 DWORD PTR uMagic$[rsp], 67324752 ; 04034b50H
  00084	41 0f 45 dd	 cmovne	 ebx, r13d
$LN6@unz64local:

; 1408 :             err=UNZ_BADZIPFILE;
; 1409 :     }
; 1410 : 
; 1411 :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)

  00088	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  0008c	4c 8d 44 24 60	 lea	 r8, QWORD PTR uData$[rsp]
  00091	48 8b cf	 mov	 rcx, rdi
  00094	e8 00 00 00 00	 call	 unz64local_getShort

; 1412 :         err=UNZ_ERRNO;
; 1413 : /*
; 1414 :     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
; 1415 :         err=UNZ_BADZIPFILE;
; 1416 : */
; 1417 :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)

  00099	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  0009d	4c 8d 44 24 68	 lea	 r8, QWORD PTR uFlags$[rsp]
  000a2	85 c0		 test	 eax, eax
  000a4	48 8b cf	 mov	 rcx, rdi
  000a7	0f 45 de	 cmovne	 ebx, esi
  000aa	e8 00 00 00 00	 call	 unz64local_getShort

; 1418 :         err=UNZ_ERRNO;
; 1419 : 
; 1420 :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)

  000af	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  000b3	4c 8d 44 24 60	 lea	 r8, QWORD PTR uData$[rsp]
  000b8	85 c0		 test	 eax, eax
  000ba	48 8b cf	 mov	 rcx, rdi
  000bd	0f 45 de	 cmovne	 ebx, esi
  000c0	e8 00 00 00 00	 call	 unz64local_getShort
  000c5	85 c0		 test	 eax, eax
  000c7	74 04		 je	 SHORT $LN9@unz64local

; 1421 :         err=UNZ_ERRNO;

  000c9	8b de		 mov	 ebx, esi
  000cb	eb 1f		 jmp	 SHORT $LN12@unz64local
$LN9@unz64local:

; 1422 :     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))

  000cd	85 db		 test	 ebx, ebx
  000cf	75 1b		 jne	 SHORT $LN12@unz64local
  000d1	8b 87 bc 00 00
	00		 mov	 eax, DWORD PTR [rdi+188]
  000d7	39 44 24 60	 cmp	 DWORD PTR uData$[rsp], eax
  000db	75 0c		 jne	 SHORT $LN29@unz64local
  000dd	a9 f3 ff ff ff	 test	 eax, -13		; fffffff3H
  000e2	75 05		 jne	 SHORT $LN29@unz64local
  000e4	83 f8 04	 cmp	 eax, 4
  000e7	75 03		 jne	 SHORT $LN12@unz64local
$LN29@unz64local:

; 1423 :         err=UNZ_BADZIPFILE;
; 1424 : 
; 1425 :     if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
; 1426 : /* #ifdef HAVE_BZIP2 */
; 1427 :                          (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
; 1428 : /* #endif */
; 1429 :                          (s->cur_file_info.compression_method!=Z_DEFLATED))
; 1430 :         err=UNZ_BADZIPFILE;

  000e9	41 8b dd	 mov	 ebx, r13d
$LN12@unz64local:

; 1431 : 
; 1432 :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */

  000ec	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  000f0	4c 8d 44 24 60	 lea	 r8, QWORD PTR uData$[rsp]
  000f5	48 8b cf	 mov	 rcx, rdi
  000f8	e8 00 00 00 00	 call	 unz64local_getLong

; 1433 :         err=UNZ_ERRNO;
; 1434 : 
; 1435 :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */

  000fd	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  00101	4c 8d 44 24 60	 lea	 r8, QWORD PTR uData$[rsp]
  00106	85 c0		 test	 eax, eax
  00108	48 8b cf	 mov	 rcx, rdi
  0010b	0f 45 de	 cmovne	 ebx, esi
  0010e	e8 00 00 00 00	 call	 unz64local_getLong
  00113	8b 6c 24 68	 mov	 ebp, DWORD PTR uFlags$[rsp]
  00117	85 c0		 test	 eax, eax
  00119	74 04		 je	 SHORT $LN14@unz64local

; 1436 :         err=UNZ_ERRNO;

  0011b	8b de		 mov	 ebx, esi
  0011d	eb 18		 jmp	 SHORT $LN16@unz64local
$LN14@unz64local:

; 1437 :     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))

  0011f	85 db		 test	 ebx, ebx
  00121	75 14		 jne	 SHORT $LN16@unz64local
  00123	8b 87 c4 00 00
	00		 mov	 eax, DWORD PTR [rdi+196]
  00129	39 44 24 60	 cmp	 DWORD PTR uData$[rsp], eax
  0012d	74 08		 je	 SHORT $LN16@unz64local
  0012f	40 f6 c5 08	 test	 bpl, 8
  00133	41 0f 44 dd	 cmove	 ebx, r13d
$LN16@unz64local:

; 1438 :         err=UNZ_BADZIPFILE;
; 1439 : 
; 1440 :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */

  00137	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  0013b	4c 8d 44 24 60	 lea	 r8, QWORD PTR uData$[rsp]
  00140	48 8b cf	 mov	 rcx, rdi
  00143	e8 00 00 00 00	 call	 unz64local_getLong
  00148	85 c0		 test	 eax, eax
  0014a	74 04		 je	 SHORT $LN17@unz64local

; 1441 :         err=UNZ_ERRNO;

  0014c	8b de		 mov	 ebx, esi
  0014e	eb 1e		 jmp	 SHORT $LN19@unz64local
$LN17@unz64local:

; 1442 :     else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))

  00150	8b 44 24 60	 mov	 eax, DWORD PTR uData$[rsp]
  00154	83 f8 ff	 cmp	 eax, -1			; ffffffffH
  00157	74 15		 je	 SHORT $LN19@unz64local
  00159	85 db		 test	 ebx, ebx
  0015b	75 11		 jne	 SHORT $LN19@unz64local
  0015d	48 3b 87 c8 00
	00 00		 cmp	 rax, QWORD PTR [rdi+200]
  00164	74 08		 je	 SHORT $LN19@unz64local
  00166	40 f6 c5 08	 test	 bpl, 8
  0016a	41 0f 44 dd	 cmove	 ebx, r13d
$LN19@unz64local:

; 1443 :         err=UNZ_BADZIPFILE;
; 1444 : 
; 1445 :     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */

  0016e	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  00172	4c 8d 44 24 60	 lea	 r8, QWORD PTR uData$[rsp]
  00177	48 8b cf	 mov	 rcx, rdi
  0017a	e8 00 00 00 00	 call	 unz64local_getLong
  0017f	85 c0		 test	 eax, eax
  00181	74 04		 je	 SHORT $LN20@unz64local

; 1446 :         err=UNZ_ERRNO;

  00183	8b de		 mov	 ebx, esi
  00185	eb 1e		 jmp	 SHORT $LN22@unz64local
$LN20@unz64local:

; 1447 :     else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))

  00187	8b 44 24 60	 mov	 eax, DWORD PTR uData$[rsp]
  0018b	83 f8 ff	 cmp	 eax, -1			; ffffffffH
  0018e	74 15		 je	 SHORT $LN22@unz64local
  00190	85 db		 test	 ebx, ebx
  00192	75 11		 jne	 SHORT $LN22@unz64local
  00194	48 3b 87 d0 00
	00 00		 cmp	 rax, QWORD PTR [rdi+208]
  0019b	74 08		 je	 SHORT $LN22@unz64local
  0019d	40 f6 c5 08	 test	 bpl, 8
  001a1	41 0f 44 dd	 cmove	 ebx, r13d
$LN22@unz64local:

; 1448 :         err=UNZ_BADZIPFILE;
; 1449 : 
; 1450 :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)

  001a5	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  001a9	4c 8d 44 24 60	 lea	 r8, QWORD PTR size_filename$[rsp]
  001ae	48 8b cf	 mov	 rcx, rdi
  001b1	e8 00 00 00 00	 call	 unz64local_getShort
  001b6	8b 6c 24 60	 mov	 ebp, DWORD PTR size_filename$[rsp]
  001ba	85 c0		 test	 eax, eax
  001bc	74 04		 je	 SHORT $LN23@unz64local

; 1451 :         err=UNZ_ERRNO;

  001be	8b de		 mov	 ebx, esi
  001c0	eb 0e		 jmp	 SHORT $LN25@unz64local
$LN23@unz64local:

; 1452 :     else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))

  001c2	85 db		 test	 ebx, ebx
  001c4	75 0a		 jne	 SHORT $LN25@unz64local
  001c6	3b af d8 00 00
	00		 cmp	 ebp, DWORD PTR [rdi+216]
  001cc	41 0f 45 dd	 cmovne	 ebx, r13d
$LN25@unz64local:

; 1453 :         err=UNZ_BADZIPFILE;
; 1454 : 
; 1455 :     *piSizeVar += (uInt)size_filename;
; 1456 : 
; 1457 :     if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)

  001d0	48 8b 57 60	 mov	 rdx, QWORD PTR [rdi+96]
  001d4	4c 8d 44 24 60	 lea	 r8, QWORD PTR size_extra_field$[rsp]
  001d9	41 01 2e	 add	 DWORD PTR [r14], ebp
  001dc	48 8b cf	 mov	 rcx, rdi
  001df	e8 00 00 00 00	 call	 unz64local_getShort

; 1458 :         err=UNZ_ERRNO;
; 1459 :     *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
; 1460 :                                     SIZEZIPLOCALHEADER + size_filename;
; 1461 :     *psize_local_extrafield = (uInt)size_extra_field;

  001e4	8b 4c 24 60	 mov	 ecx, DWORD PTR size_extra_field$[rsp]
  001e8	48 8d 55 1e	 lea	 rdx, QWORD PTR [rbp+30]
  001ec	4c 8b 6c 24 20	 mov	 r13, QWORD PTR [rsp+32]
  001f1	85 c0		 test	 eax, eax
  001f3	48 8b 6c 24 70	 mov	 rbp, QWORD PTR [rsp+112]
  001f8	0f 45 de	 cmovne	 ebx, esi
  001fb	41 89 0f	 mov	 DWORD PTR [r15], ecx
  001fe	48 03 97 08 01
	00 00		 add	 rdx, QWORD PTR [rdi+264]

; 1462 : 
; 1463 :     *piSizeVar += (uInt)size_extra_field;
; 1464 : 
; 1465 :     return err;

  00205	8b c3		 mov	 eax, ebx
  00207	41 01 0e	 add	 DWORD PTR [r14], ecx
  0020a	49 89 14 24	 mov	 QWORD PTR [r12], rdx

; 1466 : }

  0020e	48 83 c4 28	 add	 rsp, 40			; 00000028H
  00212	41 5f		 pop	 r15
  00214	41 5e		 pop	 r14
  00216	41 5c		 pop	 r12
  00218	5f		 pop	 rdi
  00219	5e		 pop	 rsi
  0021a	5b		 pop	 rbx
  0021b	c3		 ret	 0
unz64local_CheckCurrentFileCoherencyHeader ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpenCurrentFile3
_TEXT	SEGMENT
iSizeVar$ = 32
offset_local_extrafield$ = 40
file$ = 80
method$ = 88
level$ = 96
raw$ = 104
size_local_extrafield$ = 112
password$ = 112
unzOpenCurrentFile3 PROC				; COMDAT

; 1474 : {

$LN29:
  00000	48 89 6c 24 18	 mov	 QWORD PTR [rsp+24], rbp
  00005	56		 push	 rsi
  00006	57		 push	 rdi
  00007	41 56		 push	 r14
  00009	48 83 ec 30	 sub	 rsp, 48			; 00000030H

; 1475 :     int err=UNZ_OK;
; 1476 :     uInt iSizeVar;
; 1477 :     unz64_s* s;
; 1478 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 1479 :     ZPOS64_T offset_local_extrafield;  /* offset of the local extra field */
; 1480 :     uInt  size_local_extrafield;    /* size of the local extra field */
; 1481 : #    ifndef NOUNCRYPT
; 1482 :     char source[12];
; 1483 : #    else
; 1484 :     if (password != NULL)

  0000d	48 83 7c 24 70
	00		 cmp	 QWORD PTR password$[rsp], 0
  00013	41 8b e9	 mov	 ebp, r9d
  00016	49 8b f0	 mov	 rsi, r8
  00019	4c 8b f2	 mov	 r14, rdx
  0001c	48 8b f9	 mov	 rdi, rcx
  0001f	74 13		 je	 SHORT $LN4@unzOpenCur
$LN27@unzOpenCur:

; 1485 :         return UNZ_PARAMERROR;

  00021	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1639 : }

  00026	48 8b 6c 24 60	 mov	 rbp, QWORD PTR [rsp+96]
  0002b	48 83 c4 30	 add	 rsp, 48			; 00000030H
  0002f	41 5e		 pop	 r14
  00031	5f		 pop	 rdi
  00032	5e		 pop	 rsi
  00033	c3		 ret	 0
$LN4@unzOpenCur:

; 1486 : #    endif
; 1487 : 
; 1488 :     if (file==NULL)

  00034	48 85 ff	 test	 rdi, rdi
  00037	74 e8		 je	 SHORT $LN27@unzOpenCur

; 1489 :         return UNZ_PARAMERROR;
; 1490 :     s=(unz64_s*)file;
; 1491 :     if (!s->current_file_ok)

  00039	48 83 b9 90 00
	00 00 00	 cmp	 QWORD PTR [rcx+144], 0
  00041	74 de		 je	 SHORT $LN27@unzOpenCur

; 1492 :         return UNZ_PARAMERROR;
; 1493 : 
; 1494 :     if (s->pfile_in_zip_read != NULL)

  00043	48 83 b9 10 01
	00 00 00	 cmp	 QWORD PTR [rcx+272], 0
  0004b	74 05		 je	 SHORT $LN7@unzOpenCur

; 1495 :         unzCloseCurrentFile(file);

  0004d	e8 00 00 00 00	 call	 unzCloseCurrentFile
$LN7@unzOpenCur:

; 1496 : 
; 1497 :     if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)

  00052	4c 8d 4c 24 70	 lea	 r9, QWORD PTR size_local_extrafield$[rsp]
  00057	48 8b cf	 mov	 rcx, rdi
  0005a	4c 8d 44 24 28	 lea	 r8, QWORD PTR offset_local_extrafield$[rsp]
  0005f	48 8d 54 24 20	 lea	 rdx, QWORD PTR iSizeVar$[rsp]
  00064	e8 00 00 00 00	 call	 unz64local_CheckCurrentFileCoherencyHeader
  00069	85 c0		 test	 eax, eax
  0006b	74 13		 je	 SHORT $LN8@unzOpenCur

; 1498 :         return UNZ_BADZIPFILE;

  0006d	b8 99 ff ff ff	 mov	 eax, -103		; ffffffffffffff99H

; 1639 : }

  00072	48 8b 6c 24 60	 mov	 rbp, QWORD PTR [rsp+96]
  00077	48 83 c4 30	 add	 rsp, 48			; 00000030H
  0007b	41 5e		 pop	 r14
  0007d	5f		 pop	 rdi
  0007e	5e		 pop	 rsi
  0007f	c3		 ret	 0
$LN8@unzOpenCur:

; 1499 : 
; 1500 :     pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));

  00080	b9 20 01 00 00	 mov	 ecx, 288		; 00000120H
  00085	48 89 5c 24 50	 mov	 QWORD PTR [rsp+80], rbx
  0008a	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc
  00090	48 8b d8	 mov	 rbx, rax

; 1501 :     if (pfile_in_zip_read_info==NULL)

  00093	48 85 c0	 test	 rax, rax
  00096	75 08		 jne	 SHORT $LN9@unzOpenCur

; 1502 :         return UNZ_INTERNALERROR;

  00098	8d 43 98	 lea	 eax, QWORD PTR [rbx-104]
  0009b	e9 79 01 00 00	 jmp	 $LN25@unzOpenCur
$LN9@unzOpenCur:

; 1503 : 
; 1504 :     pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);

  000a0	b9 00 40 00 00	 mov	 ecx, 16384		; 00004000H
  000a5	4c 89 7c 24 58	 mov	 QWORD PTR [rsp+88], r15
  000aa	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc

; 1505 :     pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;

  000b0	48 8b 4c 24 28	 mov	 rcx, QWORD PTR offset_local_extrafield$[rsp]

; 1506 :     pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
; 1507 :     pfile_in_zip_read_info->pos_local_extrafield=0;

  000b5	45 33 ff	 xor	 r15d, r15d
  000b8	48 89 4b 70	 mov	 QWORD PTR [rbx+112], rcx
  000bc	8b 4c 24 70	 mov	 ecx, DWORD PTR size_local_extrafield$[rsp]
  000c0	89 4b 78	 mov	 DWORD PTR [rbx+120], ecx
  000c3	48 89 03	 mov	 QWORD PTR [rbx], rax
  000c6	4c 89 bb 80 00
	00 00		 mov	 QWORD PTR [rbx+128], r15

; 1508 :     pfile_in_zip_read_info->raw=raw;

  000cd	89 ab 18 01 00
	00		 mov	 DWORD PTR [rbx+280], ebp

; 1509 : 
; 1510 :     if (pfile_in_zip_read_info->read_buffer==NULL)

  000d3	48 85 c0	 test	 rax, rax
  000d6	75 12		 jne	 SHORT $LN10@unzOpenCur

; 1511 :     {
; 1512 :         TRYFREE(pfile_in_zip_read_info);

  000d8	48 8b cb	 mov	 rcx, rbx
  000db	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free

; 1513 :         return UNZ_INTERNALERROR;

  000e1	41 8d 47 98	 lea	 eax, QWORD PTR [r15-104]
  000e5	e9 2a 01 00 00	 jmp	 $LN26@unzOpenCur
$LN10@unzOpenCur:

; 1514 :     }
; 1515 : 
; 1516 :     pfile_in_zip_read_info->stream_initialised=0;

  000ea	44 89 7b 68	 mov	 DWORD PTR [rbx+104], r15d

; 1517 : 
; 1518 :     if (method!=NULL)

  000ee	4d 85 f6	 test	 r14, r14
  000f1	74 09		 je	 SHORT $LN12@unzOpenCur

; 1519 :         *method = (int)s->cur_file_info.compression_method;

  000f3	8b 87 bc 00 00
	00		 mov	 eax, DWORD PTR [rdi+188]
  000f9	41 89 06	 mov	 DWORD PTR [r14], eax
$LN12@unzOpenCur:

; 1520 : 
; 1521 :     if (level!=NULL)

  000fc	48 85 f6	 test	 rsi, rsi
  000ff	74 34		 je	 SHORT $LN2@unzOpenCur

; 1522 :     {
; 1523 :         *level = 6;

  00101	c7 06 06 00 00
	00		 mov	 DWORD PTR [rsi], 6

; 1524 :         switch (s->cur_file_info.flag & 0x06)

  00107	8b 87 b8 00 00
	00		 mov	 eax, DWORD PTR [rdi+184]
  0010d	83 e0 06	 and	 eax, 6
  00110	83 f8 02	 cmp	 eax, 2
  00113	74 1a		 je	 SHORT $LN16@unzOpenCur
  00115	83 f8 04	 cmp	 eax, 4
  00118	74 0d		 je	 SHORT $LN15@unzOpenCur
  0011a	83 f8 06	 cmp	 eax, 6
  0011d	75 16		 jne	 SHORT $LN2@unzOpenCur

; 1525 :         {
; 1526 :           case 6 : *level = 1; break;

  0011f	c7 06 01 00 00
	00		 mov	 DWORD PTR [rsi], 1
  00125	eb 0e		 jmp	 SHORT $LN2@unzOpenCur
$LN15@unzOpenCur:

; 1527 :           case 4 : *level = 2; break;

  00127	c7 06 02 00 00
	00		 mov	 DWORD PTR [rsi], 2
  0012d	eb 06		 jmp	 SHORT $LN2@unzOpenCur
$LN16@unzOpenCur:

; 1528 :           case 2 : *level = 9; break;

  0012f	c7 06 09 00 00
	00		 mov	 DWORD PTR [rsi], 9
$LN2@unzOpenCur:

; 1529 :         }
; 1530 :     }
; 1531 : 
; 1532 :     if ((s->cur_file_info.compression_method!=0) &&
; 1533 : /* #ifdef HAVE_BZIP2 */
; 1534 :         (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
; 1535 : /* #endif */
; 1536 :         (s->cur_file_info.compression_method!=Z_DEFLATED))
; 1537 : 
; 1538 :         err=UNZ_BADZIPFILE;
; 1539 : 
; 1540 :     pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;

  00135	8b 87 c4 00 00
	00		 mov	 eax, DWORD PTR [rdi+196]
  0013b	89 83 94 00 00
	00		 mov	 DWORD PTR [rbx+148], eax

; 1541 :     pfile_in_zip_read_info->crc32=0;

  00141	44 89 bb 90 00
	00 00		 mov	 DWORD PTR [rbx+144], r15d

; 1542 :     pfile_in_zip_read_info->total_out_64=0;

  00148	4c 89 bb 88 00
	00 00		 mov	 QWORD PTR [rbx+136], r15

; 1543 :     pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;

  0014f	8b 87 bc 00 00
	00		 mov	 eax, DWORD PTR [rdi+188]
  00155	89 83 08 01 00
	00		 mov	 DWORD PTR [rbx+264], eax

; 1544 :     pfile_in_zip_read_info->filestream=s->filestream;

  0015b	48 8b 47 60	 mov	 rax, QWORD PTR [rdi+96]
  0015f	48 89 83 00 01
	00 00		 mov	 QWORD PTR [rbx+256], rax

; 1545 :     pfile_in_zip_read_info->z_filefunc=s->z_filefunc;

  00166	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00169	0f 11 83 a8 00
	00 00		 movups	 XMMWORD PTR [rbx+168], xmm0
  00170	0f 10 4f 10	 movups	 xmm1, XMMWORD PTR [rdi+16]
  00174	0f 11 8b b8 00
	00 00		 movups	 XMMWORD PTR [rbx+184], xmm1
  0017b	0f 10 47 20	 movups	 xmm0, XMMWORD PTR [rdi+32]
  0017f	0f 11 83 c8 00
	00 00		 movups	 XMMWORD PTR [rbx+200], xmm0
  00186	0f 10 4f 30	 movups	 xmm1, XMMWORD PTR [rdi+48]
  0018a	0f 11 8b d8 00
	00 00		 movups	 XMMWORD PTR [rbx+216], xmm1
  00191	0f 10 47 40	 movups	 xmm0, XMMWORD PTR [rdi+64]
  00195	0f 11 83 e8 00
	00 00		 movups	 XMMWORD PTR [rbx+232], xmm0
  0019c	f2 0f 10 4f 50	 movsd	 xmm1, QWORD PTR [rdi+80]
  001a1	f2 0f 11 8b f8
	00 00 00	 movsd	 QWORD PTR [rbx+248], xmm1

; 1546 :     pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;

  001a9	48 8b 47 78	 mov	 rax, QWORD PTR [rdi+120]
  001ad	48 89 83 10 01
	00 00		 mov	 QWORD PTR [rbx+272], rax

; 1547 : 
; 1548 :     pfile_in_zip_read_info->stream.total_out = 0;

  001b4	44 89 7b 24	 mov	 DWORD PTR [rbx+36], r15d

; 1549 : 
; 1550 :     if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))

  001b8	8b 87 bc 00 00
	00		 mov	 eax, DWORD PTR [rdi+188]
  001be	83 f8 0c	 cmp	 eax, 12
  001c1	75 69		 jne	 SHORT $LN18@unzOpenCur
  001c3	85 ed		 test	 ebp, ebp
  001c5	75 65		 jne	 SHORT $LN18@unzOpenCur

; 1551 :     {
; 1552 : #ifdef HAVE_BZIP2
; 1553 :       pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
; 1554 :       pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
; 1555 :       pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
; 1556 :       pfile_in_zip_read_info->bstream.state = (voidpf)0;
; 1557 : 
; 1558 :       pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
; 1559 :       pfile_in_zip_read_info->stream.zfree = (free_func)0;
; 1560 :       pfile_in_zip_read_info->stream.opaque = (voidpf)0;
; 1561 :       pfile_in_zip_read_info->stream.next_in = (voidpf)0;
; 1562 :       pfile_in_zip_read_info->stream.avail_in = 0;
; 1563 : 
; 1564 :       err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
; 1565 :       if (err == Z_OK)
; 1566 :         pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
; 1567 :       else
; 1568 :       {
; 1569 :         TRYFREE(pfile_in_zip_read_info);
; 1570 :         return err;
; 1571 :       }
; 1572 : #else
; 1573 :       pfile_in_zip_read_info->raw=1;

  001c7	c7 83 18 01 00
	00 01 00 00 00	 mov	 DWORD PTR [rbx+280], 1
$LN22@unzOpenCur:

; 1591 :       }
; 1592 :         /* windowBits is passed < 0 to tell that there is no zlib header.
; 1593 :          * Note that in this case inflate *requires* an extra "dummy" byte
; 1594 :          * after the compressed stream in order to complete decompression and
; 1595 :          * return Z_STREAM_END.
; 1596 :          * In unzip, i don't wait absolutely Z_STREAM_END because I known the
; 1597 :          * size of both compressed and uncompressed data
; 1598 :          */
; 1599 :     }
; 1600 :     pfile_in_zip_read_info->rest_read_compressed =

  001d1	48 8b 87 c8 00
	00 00		 mov	 rax, QWORD PTR [rdi+200]

; 1601 :             s->cur_file_info.compressed_size ;
; 1602 :     pfile_in_zip_read_info->rest_read_uncompressed =
; 1603 :             s->cur_file_info.uncompressed_size ;
; 1604 : 
; 1605 : 
; 1606 :     pfile_in_zip_read_info->pos_in_zipfile =

  001d8	8b 4c 24 20	 mov	 ecx, DWORD PTR iSizeVar$[rsp]
  001dc	48 89 83 98 00
	00 00		 mov	 QWORD PTR [rbx+152], rax
  001e3	48 83 c1 1e	 add	 rcx, 30
  001e7	48 8b 87 d0 00
	00 00		 mov	 rax, QWORD PTR [rdi+208]
  001ee	48 89 83 a0 00
	00 00		 mov	 QWORD PTR [rbx+160], rax
  001f5	48 03 8f 08 01
	00 00		 add	 rcx, QWORD PTR [rdi+264]
  001fc	48 89 4b 60	 mov	 QWORD PTR [rbx+96], rcx

; 1607 :             s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
; 1608 :               iSizeVar;
; 1609 : 
; 1610 :     pfile_in_zip_read_info->stream.avail_in = (uInt)0;
; 1611 : 
; 1612 :     s->pfile_in_zip_read = pfile_in_zip_read_info;
; 1613 :                 s->encrypted = 0;
; 1614 : 
; 1615 : #    ifndef NOUNCRYPT
; 1616 :     if (password != NULL)
; 1617 :     {
; 1618 :         int i;
; 1619 :         s->pcrc_32_tab = get_crc_table();
; 1620 :         init_keys(password,s->keys,s->pcrc_32_tab);
; 1621 :         if (ZSEEK64(s->z_filefunc, s->filestream,
; 1622 :                   s->pfile_in_zip_read->pos_in_zipfile +
; 1623 :                      s->pfile_in_zip_read->byte_before_the_zipfile,
; 1624 :                   SEEK_SET)!=0)
; 1625 :             return UNZ_INTERNALERROR;
; 1626 :         if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)
; 1627 :             return UNZ_INTERNALERROR;
; 1628 : 
; 1629 :         for (i = 0; i<12; i++)
; 1630 :             zdecode(s->keys,s->pcrc_32_tab,source[i]);
; 1631 : 
; 1632 :         s->pfile_in_zip_read->pos_in_zipfile+=12;
; 1633 :         s->encrypted=1;
; 1634 :     }
; 1635 : #    endif
; 1636 : 
; 1637 : 
; 1638 :     return UNZ_OK;

  00200	33 c0		 xor	 eax, eax
  00202	44 89 7b 10	 mov	 DWORD PTR [rbx+16], r15d
  00206	48 89 9f 10 01
	00 00		 mov	 QWORD PTR [rdi+272], rbx
  0020d	44 89 bf 18 01
	00 00		 mov	 DWORD PTR [rdi+280], r15d
$LN26@unzOpenCur:
  00214	4c 8b 7c 24 58	 mov	 r15, QWORD PTR [rsp+88]
$LN25@unzOpenCur:
  00219	48 8b 5c 24 50	 mov	 rbx, QWORD PTR [rsp+80]

; 1639 : }

  0021e	48 8b 6c 24 60	 mov	 rbp, QWORD PTR [rsp+96]
  00223	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00227	41 5e		 pop	 r14
  00229	5f		 pop	 rdi
  0022a	5e		 pop	 rsi
  0022b	c3		 ret	 0
$LN18@unzOpenCur:

; 1574 : #endif
; 1575 :     }
; 1576 :     else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))

  0022c	83 f8 08	 cmp	 eax, 8
  0022f	75 a0		 jne	 SHORT $LN22@unzOpenCur
  00231	85 ed		 test	 ebp, ebp
  00233	75 9c		 jne	 SHORT $LN22@unzOpenCur

; 1577 :     {
; 1578 :       pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
; 1579 :       pfile_in_zip_read_info->stream.zfree = (free_func)0;
; 1580 :       pfile_in_zip_read_info->stream.opaque = (voidpf)0;
; 1581 :       pfile_in_zip_read_info->stream.next_in = 0;

  00235	48 8d 4b 08	 lea	 rcx, QWORD PTR [rbx+8]
  00239	4c 89 7b 38	 mov	 QWORD PTR [rbx+56], r15

; 1582 :       pfile_in_zip_read_info->stream.avail_in = 0;
; 1583 : 
; 1584 :       err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);

  0023d	44 8d 48 50	 lea	 r9d, QWORD PTR [rax+80]
  00241	4c 89 39	 mov	 QWORD PTR [rcx], r15
  00244	4c 8d 05 00 00
	00 00		 lea	 r8, OFFSET FLAT:??_C@_06CJNJFBNP@1?42?411?$AA@
  0024b	4c 89 7b 40	 mov	 QWORD PTR [rbx+64], r15
  0024f	8d 50 e9	 lea	 edx, QWORD PTR [rax-23]
  00252	4c 89 7b 48	 mov	 QWORD PTR [rbx+72], r15
  00256	44 89 7b 10	 mov	 DWORD PTR [rbx+16], r15d
  0025a	e8 00 00 00 00	 call	 inflateInit2_
  0025f	8b f0		 mov	 esi, eax

; 1585 :       if (err == Z_OK)

  00261	85 c0		 test	 eax, eax
  00263	75 0c		 jne	 SHORT $LN21@unzOpenCur

; 1586 :         pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;

  00265	c7 43 68 08 00
	00 00		 mov	 DWORD PTR [rbx+104], 8
  0026c	e9 60 ff ff ff	 jmp	 $LN22@unzOpenCur
$LN21@unzOpenCur:

; 1587 :       else
; 1588 :       {
; 1589 :         TRYFREE(pfile_in_zip_read_info);

  00271	48 8b cb	 mov	 rcx, rbx
  00274	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free

; 1590 :         return err;

  0027a	8b c6		 mov	 eax, esi
  0027c	eb 96		 jmp	 SHORT $LN26@unzOpenCur
unzOpenCurrentFile3 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpenCurrentFile
_TEXT	SEGMENT
file$ = 64
unzOpenCurrentFile PROC					; COMDAT

; 1642 : {

$LN4:
  00000	48 83 ec 38	 sub	 rsp, 56			; 00000038H

; 1643 :     return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);

  00004	45 33 c9	 xor	 r9d, r9d
  00007	48 c7 44 24 20
	00 00 00 00	 mov	 QWORD PTR [rsp+32], 0
  00010	45 33 c0	 xor	 r8d, r8d
  00013	33 d2		 xor	 edx, edx
  00015	e8 00 00 00 00	 call	 unzOpenCurrentFile3

; 1644 : }

  0001a	48 83 c4 38	 add	 rsp, 56			; 00000038H
  0001e	c3		 ret	 0
unzOpenCurrentFile ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpenCurrentFilePassword
_TEXT	SEGMENT
file$ = 64
password$ = 72
unzOpenCurrentFilePassword PROC				; COMDAT

; 1647 : {

$LN4:
  00000	48 83 ec 38	 sub	 rsp, 56			; 00000038H

; 1648 :     return unzOpenCurrentFile3(file, NULL, NULL, 0, password);

  00004	48 89 54 24 20	 mov	 QWORD PTR [rsp+32], rdx
  00009	45 33 c9	 xor	 r9d, r9d
  0000c	33 d2		 xor	 edx, edx
  0000e	45 33 c0	 xor	 r8d, r8d
  00011	e8 00 00 00 00	 call	 unzOpenCurrentFile3

; 1649 : }

  00016	48 83 c4 38	 add	 rsp, 56			; 00000038H
  0001a	c3		 ret	 0
unzOpenCurrentFilePassword ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzOpenCurrentFile2
_TEXT	SEGMENT
file$ = 64
method$ = 72
level$ = 80
raw$ = 88
unzOpenCurrentFile2 PROC				; COMDAT

; 1652 : {

$LN4:
  00000	48 83 ec 38	 sub	 rsp, 56			; 00000038H

; 1653 :     return unzOpenCurrentFile3(file, method, level, raw, NULL);

  00004	48 c7 44 24 20
	00 00 00 00	 mov	 QWORD PTR [rsp+32], 0
  0000d	e8 00 00 00 00	 call	 unzOpenCurrentFile3

; 1654 : }

  00012	48 83 c4 38	 add	 rsp, 56			; 00000038H
  00016	c3		 ret	 0
unzOpenCurrentFile2 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetCurrentFileZStreamPos64
_TEXT	SEGMENT
file$ = 8
unzGetCurrentFileZStreamPos64 PROC			; COMDAT

; 1660 :     unz64_s* s;
; 1661 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 1662 :     s=(unz64_s*)file;
; 1663 :     if (file==NULL)

  00000	48 85 c9	 test	 rcx, rcx
  00003	75 03		 jne	 SHORT $LN2@unzGetCurr
$LN5@unzGetCurr:

; 1664 :         return 0; //UNZ_PARAMERROR;

  00005	33 c0		 xor	 eax, eax

; 1669 :                          pfile_in_zip_read_info->byte_before_the_zipfile;
; 1670 : }

  00007	c3		 ret	 0
$LN2@unzGetCurr:

; 1665 :     pfile_in_zip_read_info=s->pfile_in_zip_read;

  00008	48 8b 89 10 01
	00 00		 mov	 rcx, QWORD PTR [rcx+272]

; 1666 :     if (pfile_in_zip_read_info==NULL)

  0000f	48 85 c9	 test	 rcx, rcx
  00012	74 f1		 je	 SHORT $LN5@unzGetCurr

; 1667 :         return 0; //UNZ_PARAMERROR;
; 1668 :     return pfile_in_zip_read_info->pos_in_zipfile +

  00014	48 8b 81 10 01
	00 00		 mov	 rax, QWORD PTR [rcx+272]
  0001b	48 03 41 60	 add	 rax, QWORD PTR [rcx+96]

; 1669 :                          pfile_in_zip_read_info->byte_before_the_zipfile;
; 1670 : }

  0001f	c3		 ret	 0
unzGetCurrentFileZStreamPos64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzReadCurrentFile
_TEXT	SEGMENT
file$ = 80
buf$ = 88
len$ = 96
unzReadCurrentFile PROC					; COMDAT

; 1685 : {

$LN56:
  00000	41 54		 push	 r12
  00002	48 83 ec 40	 sub	 rsp, 64			; 00000040H

; 1686 :     int err=UNZ_OK;
; 1687 :     uInt iRead = 0;

  00006	45 33 e4	 xor	 r12d, r12d

; 1688 :     unz64_s* s;
; 1689 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 1690 :     if (file==NULL)

  00009	48 85 c9	 test	 rcx, rcx
  0000c	75 0a		 jne	 SHORT $LN7@unzReadCur

; 1691 :         return UNZ_PARAMERROR;

  0000e	8d 41 9a	 lea	 eax, QWORD PTR [rcx-102]

; 1883 : }

  00011	48 83 c4 40	 add	 rsp, 64			; 00000040H
  00015	41 5c		 pop	 r12
  00017	c3		 ret	 0
$LN7@unzReadCur:
  00018	48 89 5c 24 50	 mov	 QWORD PTR [rsp+80], rbx

; 1692 :     s=(unz64_s*)file;
; 1693 :     pfile_in_zip_read_info=s->pfile_in_zip_read;

  0001d	48 8b 99 10 01
	00 00		 mov	 rbx, QWORD PTR [rcx+272]

; 1694 : 
; 1695 :     if (pfile_in_zip_read_info==NULL)

  00024	48 85 db	 test	 rbx, rbx
  00027	75 0f		 jne	 SHORT $LN8@unzReadCur

; 1696 :         return UNZ_PARAMERROR;

  00029	8d 43 9a	 lea	 eax, QWORD PTR [rbx-102]
  0002c	48 8b 5c 24 50	 mov	 rbx, QWORD PTR [rsp+80]

; 1883 : }

  00031	48 83 c4 40	 add	 rsp, 64			; 00000040H
  00035	41 5c		 pop	 r12
  00037	c3		 ret	 0
$LN8@unzReadCur:

; 1697 : 
; 1698 : 
; 1699 :     if (pfile_in_zip_read_info->read_buffer == NULL)

  00038	4c 39 23	 cmp	 QWORD PTR [rbx], r12
  0003b	75 11		 jne	 SHORT $LN9@unzReadCur

; 1700 :         return UNZ_END_OF_LIST_OF_FILE;

  0003d	b8 9c ff ff ff	 mov	 eax, -100		; ffffffffffffff9cH
  00042	48 8b 5c 24 50	 mov	 rbx, QWORD PTR [rsp+80]

; 1883 : }

  00047	48 83 c4 40	 add	 rsp, 64			; 00000040H
  0004b	41 5c		 pop	 r12
  0004d	c3		 ret	 0
$LN9@unzReadCur:

; 1701 :     if (len==0)

  0004e	45 85 c0	 test	 r8d, r8d
  00051	75 0e		 jne	 SHORT $LN10@unzReadCur

; 1702 :         return 0;

  00053	33 c0		 xor	 eax, eax
  00055	48 8b 5c 24 50	 mov	 rbx, QWORD PTR [rsp+80]

; 1883 : }

  0005a	48 83 c4 40	 add	 rsp, 64			; 00000040H
  0005e	41 5c		 pop	 r12
  00060	c3		 ret	 0
$LN10@unzReadCur:

; 1703 : 
; 1704 :     pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
; 1705 : 
; 1706 :     pfile_in_zip_read_info->stream.avail_out = (uInt)len;
; 1707 : 
; 1708 :     if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&

  00061	41 8b c8	 mov	 ecx, r8d
  00064	48 89 53 18	 mov	 QWORD PTR [rbx+24], rdx
  00068	44 89 43 20	 mov	 DWORD PTR [rbx+32], r8d
  0006c	48 3b 8b a0 00
	00 00		 cmp	 rcx, QWORD PTR [rbx+160]
  00073	76 12		 jbe	 SHORT $LN11@unzReadCur
  00075	44 39 a3 18 01
	00 00		 cmp	 DWORD PTR [rbx+280], r12d
  0007c	75 09		 jne	 SHORT $LN11@unzReadCur

; 1709 :         (!(pfile_in_zip_read_info->raw)))
; 1710 :         pfile_in_zip_read_info->stream.avail_out =

  0007e	8b 83 a0 00 00
	00		 mov	 eax, DWORD PTR [rbx+160]
  00084	89 43 20	 mov	 DWORD PTR [rbx+32], eax
$LN11@unzReadCur:

; 1711 :             (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
; 1712 : 
; 1713 :     if ((len>pfile_in_zip_read_info->rest_read_compressed+
; 1714 :            pfile_in_zip_read_info->stream.avail_in) &&

  00087	8b 53 10	 mov	 edx, DWORD PTR [rbx+16]
  0008a	8b c2		 mov	 eax, edx
  0008c	48 03 83 98 00
	00 00		 add	 rax, QWORD PTR [rbx+152]
  00093	48 3b c8	 cmp	 rcx, rax
  00096	76 14		 jbe	 SHORT $LN31@unzReadCur
  00098	44 39 a3 18 01
	00 00		 cmp	 DWORD PTR [rbx+280], r12d
  0009f	74 0b		 je	 SHORT $LN31@unzReadCur

; 1715 :          (pfile_in_zip_read_info->raw))
; 1716 :         pfile_in_zip_read_info->stream.avail_out =

  000a1	8b 8b 98 00 00
	00		 mov	 ecx, DWORD PTR [rbx+152]
  000a7	03 ca		 add	 ecx, edx
  000a9	89 4b 20	 mov	 DWORD PTR [rbx+32], ecx
$LN31@unzReadCur:

; 1717 :             (uInt)pfile_in_zip_read_info->rest_read_compressed+
; 1718 :             pfile_in_zip_read_info->stream.avail_in;
; 1719 : 
; 1720 :     while (pfile_in_zip_read_info->stream.avail_out>0)

  000ac	48 89 6c 24 58	 mov	 QWORD PTR [rsp+88], rbp
  000b1	48 89 74 24 60	 mov	 QWORD PTR [rsp+96], rsi
  000b6	48 89 7c 24 38	 mov	 QWORD PTR [rsp+56], rdi
  000bb	4c 89 6c 24 30	 mov	 QWORD PTR [rsp+48], r13
  000c0	4c 89 74 24 28	 mov	 QWORD PTR [rsp+40], r14
  000c5	4c 89 7c 24 20	 mov	 QWORD PTR [rsp+32], r15
  000ca	44 39 63 20	 cmp	 DWORD PTR [rbx+32], r12d
  000ce	0f 86 b4 01 00
	00		 jbe	 $LN46@unzReadCur
  000d4	41 bd fd ff ff
	ff		 mov	 r13d, -3
  000da	66 0f 1f 44 00
	00		 npad	 6
$LL2@unzReadCur:

; 1721 :     {
; 1722 :         if ((pfile_in_zip_read_info->stream.avail_in==0) &&

  000e0	83 7b 10 00	 cmp	 DWORD PTR [rbx+16], 0
  000e4	0f 85 82 00 00
	00		 jne	 $LN13@unzReadCur
  000ea	48 8b 83 98 00
	00 00		 mov	 rax, QWORD PTR [rbx+152]
  000f1	48 85 c0	 test	 rax, rax
  000f4	74 76		 je	 SHORT $LN13@unzReadCur

; 1723 :             (pfile_in_zip_read_info->rest_read_compressed>0))
; 1724 :         {
; 1725 :             uInt uReadThis = UNZ_BUFSIZE;

  000f6	bf 00 40 00 00	 mov	 edi, 16384		; 00004000H

; 1726 :             if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)

  000fb	48 3b c7	 cmp	 rax, rdi
  000fe	73 0a		 jae	 SHORT $LN45@unzReadCur

; 1727 :                 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;

  00100	8b f8		 mov	 edi, eax

; 1728 :             if (uReadThis == 0)

  00102	85 c0		 test	 eax, eax
  00104	0f 84 ab 01 00
	00		 je	 $LN33@unzReadCur
$LN45@unzReadCur:

; 1730 :             if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
; 1731 :                       pfile_in_zip_read_info->filestream,
; 1732 :                       pfile_in_zip_read_info->pos_in_zipfile +
; 1733 :                          pfile_in_zip_read_info->byte_before_the_zipfile,
; 1734 :                          ZLIB_FILEFUNC_SEEK_SET)!=0)

  0010a	4c 8b 83 10 01
	00 00		 mov	 r8, QWORD PTR [rbx+272]
  00111	48 8d 8b a8 00
	00 00		 lea	 rcx, QWORD PTR [rbx+168]
  00118	4c 03 43 60	 add	 r8, QWORD PTR [rbx+96]
  0011c	45 33 c9	 xor	 r9d, r9d
  0011f	48 8b 93 00 01
	00 00		 mov	 rdx, QWORD PTR [rbx+256]
  00126	e8 00 00 00 00	 call	 call_zseek64
  0012b	85 c0		 test	 eax, eax
  0012d	0f 85 86 01 00
	00		 jne	 $LN34@unzReadCur

; 1736 :             if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
; 1737 :                       pfile_in_zip_read_info->filestream,
; 1738 :                       pfile_in_zip_read_info->read_buffer,
; 1739 :                       uReadThis)!=uReadThis)

  00133	4c 8b 03	 mov	 r8, QWORD PTR [rbx]
  00136	44 8b cf	 mov	 r9d, edi
  00139	48 8b 93 00 01
	00 00		 mov	 rdx, QWORD PTR [rbx+256]
  00140	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  00147	ff 93 b0 00 00
	00		 call	 QWORD PTR [rbx+176]
  0014d	3b c7		 cmp	 eax, edi
  0014f	0f 85 64 01 00
	00		 jne	 $LN34@unzReadCur

; 1740 :                 return UNZ_ERRNO;
; 1741 : 
; 1742 : 
; 1743 : #            ifndef NOUNCRYPT
; 1744 :             if(s->encrypted)
; 1745 :             {
; 1746 :                 uInt i;
; 1747 :                 for(i=0;i<uReadThis;i++)
; 1748 :                   pfile_in_zip_read_info->read_buffer[i] =
; 1749 :                       zdecode(s->keys,s->pcrc_32_tab,
; 1750 :                               pfile_in_zip_read_info->read_buffer[i]);
; 1751 :             }
; 1752 : #            endif
; 1753 : 
; 1754 : 
; 1755 :             pfile_in_zip_read_info->pos_in_zipfile += uReadThis;

  00155	8b c7		 mov	 eax, edi
  00157	48 01 43 60	 add	 QWORD PTR [rbx+96], rax

; 1756 : 
; 1757 :             pfile_in_zip_read_info->rest_read_compressed-=uReadThis;

  0015b	48 29 83 98 00
	00 00		 sub	 QWORD PTR [rbx+152], rax

; 1758 : 
; 1759 :             pfile_in_zip_read_info->stream.next_in =

  00162	48 8b 03	 mov	 rax, QWORD PTR [rbx]
  00165	48 89 43 08	 mov	 QWORD PTR [rbx+8], rax

; 1760 :                 (Bytef*)pfile_in_zip_read_info->read_buffer;
; 1761 :             pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;

  00169	89 7b 10	 mov	 DWORD PTR [rbx+16], edi
$LN13@unzReadCur:

; 1762 :         }
; 1763 : 
; 1764 :         if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))

  0016c	8b 83 08 01 00
	00		 mov	 eax, DWORD PTR [rbx+264]
  00172	85 c0		 test	 eax, eax
  00174	0f 84 82 00 00
	00		 je	 $LN20@unzReadCur
  0017a	83 bb 18 01 00
	00 00		 cmp	 DWORD PTR [rbx+280], 0
  00181	75 79		 jne	 SHORT $LN20@unzReadCur

; 1794 :         }
; 1795 :         else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)

  00183	83 f8 0c	 cmp	 eax, 12
  00186	0f 84 f2 00 00
	00		 je	 $LN28@unzReadCur

; 1796 :         {
; 1797 : #ifdef HAVE_BZIP2
; 1798 :             uLong uTotalOutBefore,uTotalOutAfter;
; 1799 :             const Bytef *bufBefore;
; 1800 :             uLong uOutThis;
; 1801 : 
; 1802 :             pfile_in_zip_read_info->bstream.next_in        = (char*)pfile_in_zip_read_info->stream.next_in;
; 1803 :             pfile_in_zip_read_info->bstream.avail_in       = pfile_in_zip_read_info->stream.avail_in;
; 1804 :             pfile_in_zip_read_info->bstream.total_in_lo32  = pfile_in_zip_read_info->stream.total_in;
; 1805 :             pfile_in_zip_read_info->bstream.total_in_hi32  = 0;
; 1806 :             pfile_in_zip_read_info->bstream.next_out       = (char*)pfile_in_zip_read_info->stream.next_out;
; 1807 :             pfile_in_zip_read_info->bstream.avail_out      = pfile_in_zip_read_info->stream.avail_out;
; 1808 :             pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;
; 1809 :             pfile_in_zip_read_info->bstream.total_out_hi32 = 0;
; 1810 : 
; 1811 :             uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;
; 1812 :             bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;
; 1813 : 
; 1814 :             err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);
; 1815 : 
; 1816 :             uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;
; 1817 :             uOutThis = uTotalOutAfter-uTotalOutBefore;
; 1818 : 
; 1819 :             pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
; 1820 : 
; 1821 :             pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));
; 1822 :             pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
; 1823 :             iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
; 1824 : 
; 1825 :             pfile_in_zip_read_info->stream.next_in   = (Bytef*)pfile_in_zip_read_info->bstream.next_in;
; 1826 :             pfile_in_zip_read_info->stream.avail_in  = pfile_in_zip_read_info->bstream.avail_in;
; 1827 :             pfile_in_zip_read_info->stream.total_in  = pfile_in_zip_read_info->bstream.total_in_lo32;
; 1828 :             pfile_in_zip_read_info->stream.next_out  = (Bytef*)pfile_in_zip_read_info->bstream.next_out;
; 1829 :             pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;
; 1830 :             pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;
; 1831 : 
; 1832 :             if (err==BZ_STREAM_END)
; 1833 :               return (iRead==0) ? UNZ_EOF : iRead;
; 1834 :             if (err!=BZ_OK)
; 1835 :               break;
; 1836 : #endif
; 1837 :         } // end Z_BZIP2ED
; 1838 :         else
; 1839 :         {
; 1840 :             ZPOS64_T uTotalOutBefore,uTotalOutAfter;
; 1841 :             const Bytef *bufBefore;
; 1842 :             ZPOS64_T uOutThis;
; 1843 :             int flush=Z_SYNC_FLUSH;
; 1844 : 
; 1845 :             uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;

  0018c	44 8b 73 24	 mov	 r14d, DWORD PTR [rbx+36]

; 1846 :             bufBefore = pfile_in_zip_read_info->stream.next_out;
; 1847 : 
; 1848 :             /*
; 1849 :             if ((pfile_in_zip_read_info->rest_read_uncompressed ==
; 1850 :                      pfile_in_zip_read_info->stream.avail_out) &&
; 1851 :                 (pfile_in_zip_read_info->rest_read_compressed == 0))
; 1852 :                 flush = Z_FINISH;
; 1853 :             */
; 1854 :             err=inflate(&pfile_in_zip_read_info->stream,flush);

  00190	48 8d 4b 08	 lea	 rcx, QWORD PTR [rbx+8]
  00194	4c 8b 7b 18	 mov	 r15, QWORD PTR [rbx+24]
  00198	ba 02 00 00 00	 mov	 edx, 2
  0019d	e8 00 00 00 00	 call	 inflate
  001a2	8b e8		 mov	 ebp, eax

; 1855 : 
; 1856 :             if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))

  001a4	85 c0		 test	 eax, eax
  001a6	78 09		 js	 SHORT $LN26@unzReadCur
  001a8	48 83 7b 28 00	 cmp	 QWORD PTR [rbx+40], 0
  001ad	41 0f 45 ed	 cmovne	 ebp, r13d
$LN26@unzReadCur:

; 1857 :               err = Z_DATA_ERROR;
; 1858 : 
; 1859 :             uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;

  001b1	8b 73 24	 mov	 esi, DWORD PTR [rbx+36]

; 1860 :             uOutThis = uTotalOutAfter-uTotalOutBefore;
; 1861 : 
; 1862 :             pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
; 1863 : 
; 1864 :             pfile_in_zip_read_info->crc32 =

  001b4	49 8b d7	 mov	 rdx, r15
  001b7	8b 8b 90 00 00
	00		 mov	 ecx, DWORD PTR [rbx+144]
  001bd	8b fe		 mov	 edi, esi
  001bf	49 2b fe	 sub	 rdi, r14
  001c2	48 01 bb 88 00
	00 00		 add	 QWORD PTR [rbx+136], rdi
  001c9	44 8b c7	 mov	 r8d, edi
  001cc	e8 00 00 00 00	 call	 crc32

; 1865 :                 crc32(pfile_in_zip_read_info->crc32,bufBefore,
; 1866 :                         (uInt)(uOutThis));
; 1867 : 
; 1868 :             pfile_in_zip_read_info->rest_read_uncompressed -=

  001d1	48 29 bb a0 00
	00 00		 sub	 QWORD PTR [rbx+160], rdi

; 1869 :                 uOutThis;
; 1870 : 
; 1871 :             iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);

  001d8	41 2b f6	 sub	 esi, r14d
  001db	44 03 e6	 add	 r12d, esi
  001de	89 83 90 00 00
	00		 mov	 DWORD PTR [rbx+144], eax

; 1872 : 
; 1873 :             if (err==Z_STREAM_END)

  001e4	83 fd 01	 cmp	 ebp, 1
  001e7	0f 84 9b 00 00
	00		 je	 $LN46@unzReadCur

; 1875 :             if (err!=Z_OK)

  001ed	85 ed		 test	 ebp, ebp
  001ef	0f 84 89 00 00
	00		 je	 $LN28@unzReadCur

; 1882 :     return err;

  001f5	8b c5		 mov	 eax, ebp

; 1874 :                 return (iRead==0) ? UNZ_EOF : iRead;

  001f7	e9 8f 00 00 00	 jmp	 $LN53@unzReadCur
$LN20@unzReadCur:

; 1765 :         {
; 1766 :             uInt uDoCopy,i ;
; 1767 : 
; 1768 :             if ((pfile_in_zip_read_info->stream.avail_in == 0) &&

  001fc	8b 6b 10	 mov	 ebp, DWORD PTR [rbx+16]
  001ff	85 ed		 test	 ebp, ebp
  00201	75 0a		 jne	 SHORT $LN21@unzReadCur
  00203	48 83 bb 98 00
	00 00 00	 cmp	 QWORD PTR [rbx+152], 0
  0020b	74 7b		 je	 SHORT $LN46@unzReadCur
$LN21@unzReadCur:

; 1769 :                 (pfile_in_zip_read_info->rest_read_compressed == 0))
; 1770 :                 return (iRead==0) ? UNZ_EOF : iRead;
; 1771 : 
; 1772 :             if (pfile_in_zip_read_info->stream.avail_out <

  0020d	39 6b 20	 cmp	 DWORD PTR [rbx+32], ebp
  00210	0f 42 6b 20	 cmovb	 ebp, DWORD PTR [rbx+32]

; 1773 :                             pfile_in_zip_read_info->stream.avail_in)
; 1774 :                 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
; 1775 :             else
; 1776 :                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
; 1777 : 
; 1778 :             for (i=0;i<uDoCopy;i++)

  00214	85 ed		 test	 ebp, ebp
  00216	74 23		 je	 SHORT $LN5@unzReadCur
  00218	33 d2		 xor	 edx, edx
  0021a	44 8b c5	 mov	 r8d, ebp
  0021d	0f 1f 00	 npad	 3
$LL6@unzReadCur:

; 1779 :                 *(pfile_in_zip_read_info->stream.next_out+i) =

  00220	48 8b 43 08	 mov	 rax, QWORD PTR [rbx+8]
  00224	48 8d 52 01	 lea	 rdx, QWORD PTR [rdx+1]
  00228	48 8b 4b 18	 mov	 rcx, QWORD PTR [rbx+24]
  0022c	0f b6 44 02 ff	 movzx	 eax, BYTE PTR [rdx+rax-1]
  00231	88 44 0a ff	 mov	 BYTE PTR [rdx+rcx-1], al
  00235	49 83 e8 01	 sub	 r8, 1
  00239	75 e5		 jne	 SHORT $LL6@unzReadCur
$LN5@unzReadCur:

; 1780 :                         *(pfile_in_zip_read_info->stream.next_in+i);
; 1781 : 
; 1782 :             pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;
; 1783 : 
; 1784 :             pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,

  0023b	48 8b 7b 18	 mov	 rdi, QWORD PTR [rbx+24]
  0023f	44 8b c5	 mov	 r8d, ebp
  00242	8b 8b 90 00 00
	00		 mov	 ecx, DWORD PTR [rbx+144]
  00248	48 8b d7	 mov	 rdx, rdi
  0024b	8b f5		 mov	 esi, ebp
  0024d	48 01 b3 88 00
	00 00		 add	 QWORD PTR [rbx+136], rsi
  00254	e8 00 00 00 00	 call	 crc32

; 1785 :                                 pfile_in_zip_read_info->stream.next_out,
; 1786 :                                 uDoCopy);
; 1787 :             pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;

  00259	48 29 b3 a0 00
	00 00		 sub	 QWORD PTR [rbx+160], rsi

; 1788 :             pfile_in_zip_read_info->stream.avail_in -= uDoCopy;

  00260	29 6b 10	 sub	 DWORD PTR [rbx+16], ebp

; 1789 :             pfile_in_zip_read_info->stream.avail_out -= uDoCopy;

  00263	29 6b 20	 sub	 DWORD PTR [rbx+32], ebp

; 1790 :             pfile_in_zip_read_info->stream.next_out += uDoCopy;
; 1791 :             pfile_in_zip_read_info->stream.next_in += uDoCopy;

  00266	48 01 73 08	 add	 QWORD PTR [rbx+8], rsi

; 1792 :             pfile_in_zip_read_info->stream.total_out += uDoCopy;

  0026a	01 6b 24	 add	 DWORD PTR [rbx+36], ebp
  0026d	89 83 90 00 00
	00		 mov	 DWORD PTR [rbx+144], eax

; 1793 :             iRead += uDoCopy;

  00273	44 03 e5	 add	 r12d, ebp
  00276	48 8d 04 2f	 lea	 rax, QWORD PTR [rdi+rbp]
  0027a	48 89 43 18	 mov	 QWORD PTR [rbx+24], rax
$LN28@unzReadCur:

; 1717 :             (uInt)pfile_in_zip_read_info->rest_read_compressed+
; 1718 :             pfile_in_zip_read_info->stream.avail_in;
; 1719 : 
; 1720 :     while (pfile_in_zip_read_info->stream.avail_out>0)

  0027e	83 7b 20 00	 cmp	 DWORD PTR [rbx+32], 0
  00282	0f 87 58 fe ff
	ff		 ja	 $LL2@unzReadCur
$LN46@unzReadCur:

; 1876 :                 break;
; 1877 :         }
; 1878 :     }
; 1879 : 
; 1880 :     if (err==Z_OK)
; 1881 :         return iRead;

  00288	41 8b c4	 mov	 eax, r12d
$LN53@unzReadCur:
  0028b	4c 8b 74 24 28	 mov	 r14, QWORD PTR [rsp+40]
  00290	4c 8b 6c 24 30	 mov	 r13, QWORD PTR [rsp+48]
  00295	48 8b 7c 24 38	 mov	 rdi, QWORD PTR [rsp+56]
  0029a	48 8b 74 24 60	 mov	 rsi, QWORD PTR [rsp+96]
  0029f	48 8b 6c 24 58	 mov	 rbp, QWORD PTR [rsp+88]
  002a4	4c 8b 7c 24 20	 mov	 r15, QWORD PTR [rsp+32]
  002a9	48 8b 5c 24 50	 mov	 rbx, QWORD PTR [rsp+80]

; 1883 : }

  002ae	48 83 c4 40	 add	 rsp, 64			; 00000040H
  002b2	41 5c		 pop	 r12
  002b4	c3		 ret	 0
$LN33@unzReadCur:

; 1729 :                 return UNZ_EOF;

  002b5	33 c0		 xor	 eax, eax
  002b7	eb d2		 jmp	 SHORT $LN53@unzReadCur
$LN34@unzReadCur:

; 1735 :                 return UNZ_ERRNO;

  002b9	83 c8 ff	 or	 eax, -1
  002bc	eb cd		 jmp	 SHORT $LN53@unzReadCur
unzReadCurrentFile ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unztell
_TEXT	SEGMENT
file$ = 8
unztell	PROC						; COMDAT

; 1891 :     unz64_s* s;
; 1892 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 1893 :     if (file==NULL)

  00000	48 85 c9	 test	 rcx, rcx
  00003	75 06		 jne	 SHORT $LN2@unztell
$LN5@unztell:

; 1894 :         return UNZ_PARAMERROR;

  00005	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1902 : }

  0000a	c3		 ret	 0
$LN2@unztell:

; 1895 :     s=(unz64_s*)file;
; 1896 :     pfile_in_zip_read_info=s->pfile_in_zip_read;

  0000b	48 8b 81 10 01
	00 00		 mov	 rax, QWORD PTR [rcx+272]

; 1897 : 
; 1898 :     if (pfile_in_zip_read_info==NULL)

  00012	48 85 c0	 test	 rax, rax
  00015	74 ee		 je	 SHORT $LN5@unztell

; 1899 :         return UNZ_PARAMERROR;
; 1900 : 
; 1901 :     return (z_off_t)pfile_in_zip_read_info->stream.total_out;

  00017	8b 40 24	 mov	 eax, DWORD PTR [rax+36]

; 1902 : }

  0001a	c3		 ret	 0
unztell	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unztell64
_TEXT	SEGMENT
file$ = 8
unztell64 PROC						; COMDAT

; 1906 : 
; 1907 :     unz64_s* s;
; 1908 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 1909 :     if (file==NULL)

  00000	48 85 c9	 test	 rcx, rcx
  00003	75 05		 jne	 SHORT $LN2@unztell64
$LN5@unztell64:

; 1910 :         return (ZPOS64_T)-1;

  00005	48 83 c8 ff	 or	 rax, -1

; 1918 : }

  00009	c3		 ret	 0
$LN2@unztell64:

; 1911 :     s=(unz64_s*)file;
; 1912 :     pfile_in_zip_read_info=s->pfile_in_zip_read;

  0000a	48 8b 81 10 01
	00 00		 mov	 rax, QWORD PTR [rcx+272]

; 1913 : 
; 1914 :     if (pfile_in_zip_read_info==NULL)

  00011	48 85 c0	 test	 rax, rax
  00014	74 ef		 je	 SHORT $LN5@unztell64

; 1915 :         return (ZPOS64_T)-1;
; 1916 : 
; 1917 :     return pfile_in_zip_read_info->total_out_64;

  00016	48 8b 80 88 00
	00 00		 mov	 rax, QWORD PTR [rax+136]

; 1918 : }

  0001d	c3		 ret	 0
unztell64 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzeof
_TEXT	SEGMENT
file$ = 8
unzeof	PROC						; COMDAT

; 1926 :     unz64_s* s;
; 1927 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 1928 :     if (file==NULL)

  00000	48 85 c9	 test	 rcx, rcx
  00003	75 06		 jne	 SHORT $LN2@unzeof
$LN7@unzeof:

; 1929 :         return UNZ_PARAMERROR;

  00005	b8 9a ff ff ff	 mov	 eax, -102		; ffffffffffffff9aH

; 1937 :         return 1;
; 1938 :     else
; 1939 :         return 0;
; 1940 : }

  0000a	c3		 ret	 0
$LN2@unzeof:

; 1930 :     s=(unz64_s*)file;
; 1931 :     pfile_in_zip_read_info=s->pfile_in_zip_read;

  0000b	48 8b 91 10 01
	00 00		 mov	 rdx, QWORD PTR [rcx+272]

; 1932 : 
; 1933 :     if (pfile_in_zip_read_info==NULL)

  00012	48 85 d2	 test	 rdx, rdx
  00015	74 ee		 je	 SHORT $LN7@unzeof

; 1934 :         return UNZ_PARAMERROR;
; 1935 : 
; 1936 :     if (pfile_in_zip_read_info->rest_read_uncompressed == 0)

  00017	33 c0		 xor	 eax, eax
  00019	48 39 82 a0 00
	00 00		 cmp	 QWORD PTR [rdx+160], rax
  00020	0f 94 c0	 sete	 al

; 1937 :         return 1;
; 1938 :     else
; 1939 :         return 0;
; 1940 : }

  00023	c3		 ret	 0
unzeof	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetLocalExtrafield
_TEXT	SEGMENT
file$ = 48
buf$ = 56
len$ = 64
unzGetLocalExtrafield PROC				; COMDAT

; 1957 : {

$LN13:
  00000	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000a	41 8b f8	 mov	 edi, r8d
  0000d	48 8b f2	 mov	 rsi, rdx

; 1958 :     unz64_s* s;
; 1959 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 1960 :     uInt read_now;
; 1961 :     ZPOS64_T size_to_read;
; 1962 : 
; 1963 :     if (file==NULL)

  00010	48 85 c9	 test	 rcx, rcx
  00013	75 0e		 jne	 SHORT $LN2@unzGetLoca

; 1964 :         return UNZ_PARAMERROR;

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

; 1995 :         return UNZ_ERRNO;
; 1996 : 
; 1997 :     return (int)read_now;
; 1998 : }

  00018	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  0001d	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00021	5f		 pop	 rdi
  00022	c3		 ret	 0
$LN2@unzGetLoca:
  00023	48 89 5c 24 30	 mov	 QWORD PTR [rsp+48], rbx

; 1965 :     s=(unz64_s*)file;
; 1966 :     pfile_in_zip_read_info=s->pfile_in_zip_read;

  00028	48 8b 99 10 01
	00 00		 mov	 rbx, QWORD PTR [rcx+272]

; 1967 : 
; 1968 :     if (pfile_in_zip_read_info==NULL)

  0002f	48 85 db	 test	 rbx, rbx
  00032	75 13		 jne	 SHORT $LN3@unzGetLoca

; 1969 :         return UNZ_PARAMERROR;

  00034	8d 43 9a	 lea	 eax, QWORD PTR [rbx-102]
  00037	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]

; 1995 :         return UNZ_ERRNO;
; 1996 : 
; 1997 :     return (int)read_now;
; 1998 : }

  0003c	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00041	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00045	5f		 pop	 rdi
  00046	c3		 ret	 0
$LN3@unzGetLoca:

; 1970 : 
; 1971 :     size_to_read = (pfile_in_zip_read_info->size_local_extrafield -

  00047	48 8b 93 80 00
	00 00		 mov	 rdx, QWORD PTR [rbx+128]
  0004e	8b 4b 78	 mov	 ecx, DWORD PTR [rbx+120]
  00051	48 2b ca	 sub	 rcx, rdx

; 1972 :                 pfile_in_zip_read_info->pos_local_extrafield);
; 1973 : 
; 1974 :     if (buf==NULL)

  00054	48 85 f6	 test	 rsi, rsi
  00057	75 12		 jne	 SHORT $LN4@unzGetLoca

; 1975 :         return (int)size_to_read;

  00059	8b c1		 mov	 eax, ecx
  0005b	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]

; 1995 :         return UNZ_ERRNO;
; 1996 : 
; 1997 :     return (int)read_now;
; 1998 : }

  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
$LN4@unzGetLoca:

; 1976 : 
; 1977 :     if (len>size_to_read)

  0006b	48 3b f9	 cmp	 rdi, rcx
  0006e	0f 47 f9	 cmova	 edi, ecx

; 1978 :         read_now = (uInt)size_to_read;
; 1979 :     else
; 1980 :         read_now = (uInt)len ;
; 1981 : 
; 1982 :     if (read_now==0)

  00071	85 ff		 test	 edi, edi
  00073	75 12		 jne	 SHORT $LN7@unzGetLoca

; 1983 :         return 0;

  00075	33 c0		 xor	 eax, eax
  00077	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]

; 1995 :         return UNZ_ERRNO;
; 1996 : 
; 1997 :     return (int)read_now;
; 1998 : }

  0007c	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00081	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00085	5f		 pop	 rdi
  00086	c3		 ret	 0
$LN7@unzGetLoca:

; 1984 : 
; 1985 :     if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
; 1986 :               pfile_in_zip_read_info->filestream,
; 1987 :               pfile_in_zip_read_info->offset_local_extrafield +
; 1988 :               pfile_in_zip_read_info->pos_local_extrafield,
; 1989 :               ZLIB_FILEFUNC_SEEK_SET)!=0)

  00087	4c 8b 43 70	 mov	 r8, QWORD PTR [rbx+112]
  0008b	48 8d 8b a8 00
	00 00		 lea	 rcx, QWORD PTR [rbx+168]
  00092	4c 03 c2	 add	 r8, rdx
  00095	45 33 c9	 xor	 r9d, r9d
  00098	48 8b 93 00 01
	00 00		 mov	 rdx, QWORD PTR [rbx+256]
  0009f	e8 00 00 00 00	 call	 call_zseek64
  000a4	85 c0		 test	 eax, eax
  000a6	74 13		 je	 SHORT $LN8@unzGetLoca

; 1990 :         return UNZ_ERRNO;

  000a8	83 c8 ff	 or	 eax, -1
  000ab	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]

; 1995 :         return UNZ_ERRNO;
; 1996 : 
; 1997 :     return (int)read_now;
; 1998 : }

  000b0	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  000b5	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000b9	5f		 pop	 rdi
  000ba	c3		 ret	 0
$LN8@unzGetLoca:

; 1991 : 
; 1992 :     if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
; 1993 :               pfile_in_zip_read_info->filestream,
; 1994 :               buf,read_now)!=read_now)

  000bb	48 8b 93 00 01
	00 00		 mov	 rdx, QWORD PTR [rbx+256]
  000c2	44 8b cf	 mov	 r9d, edi
  000c5	48 8b 8b e0 00
	00 00		 mov	 rcx, QWORD PTR [rbx+224]
  000cc	4c 8b c6	 mov	 r8, rsi
  000cf	ff 93 b0 00 00
	00		 call	 QWORD PTR [rbx+176]
  000d5	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  000da	83 c9 ff	 or	 ecx, -1

; 1995 :         return UNZ_ERRNO;
; 1996 : 
; 1997 :     return (int)read_now;
; 1998 : }

  000dd	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  000e2	3b c7		 cmp	 eax, edi
  000e4	0f 45 f9	 cmovne	 edi, ecx
  000e7	8b c7		 mov	 eax, edi
  000e9	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000ed	5f		 pop	 rdi
  000ee	c3		 ret	 0
unzGetLocalExtrafield ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzCloseCurrentFile
_TEXT	SEGMENT
file$ = 48
unzCloseCurrentFile PROC				; COMDAT

; 2005 : {

$LN12:
  00000	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 2006 :     int err=UNZ_OK;

  0000a	33 ff		 xor	 edi, edi
  0000c	48 8b f1	 mov	 rsi, rcx

; 2007 : 
; 2008 :     unz64_s* s;
; 2009 :     file_in_zip64_read_info_s* pfile_in_zip_read_info;
; 2010 :     if (file==NULL)

  0000f	48 85 c9	 test	 rcx, rcx
  00012	75 0e		 jne	 SHORT $LN2@unzCloseCu

; 2011 :         return UNZ_PARAMERROR;

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

; 2043 : }

  00017	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  0001c	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00020	5f		 pop	 rdi
  00021	c3		 ret	 0
$LN2@unzCloseCu:
  00022	48 89 5c 24 30	 mov	 QWORD PTR [rsp+48], rbx

; 2012 :     s=(unz64_s*)file;
; 2013 :     pfile_in_zip_read_info=s->pfile_in_zip_read;

  00027	48 8b 99 10 01
	00 00		 mov	 rbx, QWORD PTR [rcx+272]

; 2014 : 
; 2015 :     if (pfile_in_zip_read_info==NULL)

  0002e	48 85 db	 test	 rbx, rbx
  00031	75 13		 jne	 SHORT $LN3@unzCloseCu

; 2016 :         return UNZ_PARAMERROR;

  00033	8d 43 9a	 lea	 eax, QWORD PTR [rbx-102]
  00036	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]

; 2043 : }

  0003b	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00040	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00044	5f		 pop	 rdi
  00045	c3		 ret	 0
$LN3@unzCloseCu:

; 2017 : 
; 2018 : 
; 2019 :     if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&

  00046	48 39 bb a0 00
	00 00		 cmp	 QWORD PTR [rbx+160], rdi
  0004d	75 1c		 jne	 SHORT $LN5@unzCloseCu
  0004f	39 bb 18 01 00
	00		 cmp	 DWORD PTR [rbx+280], edi
  00055	75 14		 jne	 SHORT $LN5@unzCloseCu

; 2020 :         (!pfile_in_zip_read_info->raw))
; 2021 :     {
; 2022 :         if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)

  00057	8b 83 94 00 00
	00		 mov	 eax, DWORD PTR [rbx+148]
  0005d	b9 97 ff ff ff	 mov	 ecx, -105		; ffffffffffffff97H
  00062	39 83 90 00 00
	00		 cmp	 DWORD PTR [rbx+144], eax
  00068	0f 45 f9	 cmovne	 edi, ecx
$LN5@unzCloseCu:

; 2023 :             err=UNZ_CRCERROR;
; 2024 :     }
; 2025 : 
; 2026 : 
; 2027 :     TRYFREE(pfile_in_zip_read_info->read_buffer);

  0006b	48 8b 0b	 mov	 rcx, QWORD PTR [rbx]
  0006e	48 85 c9	 test	 rcx, rcx
  00071	74 06		 je	 SHORT $LN6@unzCloseCu
  00073	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free
$LN6@unzCloseCu:

; 2028 :     pfile_in_zip_read_info->read_buffer = NULL;
; 2029 :     if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)

  00079	83 7b 68 08	 cmp	 DWORD PTR [rbx+104], 8
  0007d	48 c7 03 00 00
	00 00		 mov	 QWORD PTR [rbx], 0
  00084	75 09		 jne	 SHORT $LN7@unzCloseCu

; 2030 :         inflateEnd(&pfile_in_zip_read_info->stream);

  00086	48 8d 4b 08	 lea	 rcx, QWORD PTR [rbx+8]
  0008a	e8 00 00 00 00	 call	 inflateEnd
$LN7@unzCloseCu:

; 2031 : #ifdef HAVE_BZIP2
; 2032 :     else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
; 2033 :         BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
; 2034 : #endif
; 2035 : 
; 2036 : 
; 2037 :     pfile_in_zip_read_info->stream_initialised = 0;
; 2038 :     TRYFREE(pfile_in_zip_read_info);

  0008f	48 8b cb	 mov	 rcx, rbx
  00092	c7 43 68 00 00
	00 00		 mov	 DWORD PTR [rbx+104], 0
  00099	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_free
  0009f	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]

; 2039 : 
; 2040 :     s->pfile_in_zip_read=NULL;
; 2041 : 
; 2042 :     return err;

  000a4	8b c7		 mov	 eax, edi
  000a6	48 c7 86 10 01
	00 00 00 00 00
	00		 mov	 QWORD PTR [rsi+272], 0

; 2043 : }

  000b1	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  000b6	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000ba	5f		 pop	 rdi
  000bb	c3		 ret	 0
unzCloseCurrentFile ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\contrib\minizip\unzip.c
;	COMDAT unzGetGlobalComment
_TEXT	SEGMENT
file$ = 48
szComment$ = 56
uSizeBuf$ = 64
unzGetGlobalComment PROC				; COMDAT

; 2052 : {

$LN12:
  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	57		 push	 rdi
  0000b	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000f	41 8b e8	 mov	 ebp, r8d
  00012	48 8b fa	 mov	 rdi, rdx
  00015	48 8b d9	 mov	 rbx, rcx

; 2053 :     unz64_s* s;
; 2054 :     uLong uReadThis ;
; 2055 :     if (file==NULL)

  00018	48 85 c9	 test	 rcx, rcx
  0001b	75 13		 jne	 SHORT $LN2@unzGetGlob

; 2056 :         return (int)UNZ_PARAMERROR;

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

; 2076 : }

  00020	48 8b 5c 24 38	 mov	 rbx, QWORD PTR [rsp+56]
  00025	48 8b 6c 24 40	 mov	 rbp, QWORD PTR [rsp+64]
  0002a	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0002e	5f		 pop	 rdi
  0002f	c3		 ret	 0
$LN2@unzGetGlob:

; 2057 :     s=(unz64_s*)file;
; 2058 : 
; 2059 :     uReadThis = uSizeBuf;
; 2060 :     if (uReadThis>s->gi.size_comment)

  00030	3b 69 70	 cmp	 ebp, DWORD PTR [rcx+112]

; 2061 :         uReadThis = s->gi.size_comment;
; 2062 : 
; 2063 :     if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)

  00033	4c 8b 81 98 00
	00 00		 mov	 r8, QWORD PTR [rcx+152]
  0003a	48 8b 51 60	 mov	 rdx, QWORD PTR [rcx+96]
  0003e	48 89 74 24 30	 mov	 QWORD PTR [rsp+48], rsi
  00043	8b f5		 mov	 esi, ebp
  00045	0f 47 71 70	 cmova	 esi, DWORD PTR [rcx+112]
  00049	49 83 c0 16	 add	 r8, 22
  0004d	45 33 c9	 xor	 r9d, r9d
  00050	e8 00 00 00 00	 call	 call_zseek64
  00055	85 c0		 test	 eax, eax
  00057	75 1b		 jne	 SHORT $LN10@unzGetGlob

; 2064 :         return UNZ_ERRNO;
; 2065 : 
; 2066 :     if (uReadThis>0)

  00059	85 f6		 test	 esi, esi
  0005b	74 1c		 je	 SHORT $LN6@unzGetGlob

; 2067 :     {
; 2068 :       *szComment='\0';

  0005d	88 07		 mov	 BYTE PTR [rdi], al

; 2069 :       if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)

  0005f	44 8b ce	 mov	 r9d, esi
  00062	48 8b 53 60	 mov	 rdx, QWORD PTR [rbx+96]
  00066	4c 8b c7	 mov	 r8, rdi
  00069	48 8b 4b 38	 mov	 rcx, QWORD PTR [rbx+56]
  0006d	ff 53 08	 call	 QWORD PTR [rbx+8]
  00070	3b c6		 cmp	 eax, esi
  00072	74 05		 je	 SHORT $LN6@unzGetGlob
$LN10@unzGetGlob:

; 2070 :         return UNZ_ERRNO;

  00074	83 c8 ff	 or	 eax, -1
  00077	eb 12		 jmp	 SHORT $LN9@unzGetGlob
$LN6@unzGetGlob:

; 2071 :     }
; 2072 : 
; 2073 :     if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))

  00079	48 85 ff	 test	 rdi, rdi
  0007c	74 0b		 je	 SHORT $LN7@unzGetGlob
  0007e	8b 43 70	 mov	 eax, DWORD PTR [rbx+112]
  00081	3b e8		 cmp	 ebp, eax
  00083	76 04		 jbe	 SHORT $LN7@unzGetGlob

; 2074 :         *(szComment+s->gi.size_comment)='\0';

  00085	c6 04 38 00	 mov	 BYTE PTR [rax+rdi], 0
$LN7@unzGetGlob:

; 2075 :     return (int)uReadThis;

  00089	8b c6		 mov	 eax, esi
$LN9@unzGetGlob:
  0008b	48 8b 74 24 30	 mov	 rsi, QWORD PTR [rsp+48]

; 2076 : }

  00090	48 8b 5c 24 38	 mov	 rbx, QWORD PTR [rsp+56]
  00095	48 8b 6c 24 40	 mov	 rbp, QWORD PTR [rsp+64]
  0009a	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0009e	5f		 pop	 rdi
  0009f	c3		 ret	 0
unzGetGlobalComment ENDP
_TEXT	ENDS
END
