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

include listing.inc

INCLUDELIB OLDNAMES

PUBLIC	_length_code
PUBLIC	_dist_code
_length_code DB	00H
	DB	01H
	DB	02H
	DB	03H
	DB	04H
	DB	05H
	DB	06H
	DB	07H
	DB	08H
	DB	08H
	DB	09H
	DB	09H
	DB	0aH
	DB	0aH
	DB	0bH
	DB	0bH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	010H
	DB	010H
	DB	010H
	DB	010H
	DB	010H
	DB	010H
	DB	010H
	DB	010H
	DB	011H
	DB	011H
	DB	011H
	DB	011H
	DB	011H
	DB	011H
	DB	011H
	DB	011H
	DB	012H
	DB	012H
	DB	012H
	DB	012H
	DB	012H
	DB	012H
	DB	012H
	DB	012H
	DB	013H
	DB	013H
	DB	013H
	DB	013H
	DB	013H
	DB	013H
	DB	013H
	DB	013H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01cH
_dist_code DB	00H
	DB	01H
	DB	02H
	DB	03H
	DB	04H
	DB	04H
	DB	05H
	DB	05H
	DB	06H
	DB	06H
	DB	06H
	DB	06H
	DB	07H
	DB	07H
	DB	07H
	DB	07H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	09H
	DB	09H
	DB	09H
	DB	09H
	DB	09H
	DB	09H
	DB	09H
	DB	09H
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0aH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0bH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0dH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0eH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	0fH
	DB	00H
	DB	00H
	DB	010H
	DB	011H
	DB	012H
	DB	012H
	DB	013H
	DB	013H
	DB	014H
	DB	014H
	DB	014H
	DB	014H
	DB	015H
	DB	015H
	DB	015H
	DB	015H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	016H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	017H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	018H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	019H
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01aH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01bH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01cH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
	DB	01dH
static_dtree DW	00H
	DW	05H
	DW	010H
	DW	05H
	DW	08H
	DW	05H
	DW	018H
	DW	05H
	DW	04H
	DW	05H
	DW	014H
	DW	05H
	DW	0cH
	DW	05H
	DW	01cH
	DW	05H
	DW	02H
	DW	05H
	DW	012H
	DW	05H
	DW	0aH
	DW	05H
	DW	01aH
	DW	05H
	DW	06H
	DW	05H
	DW	016H
	DW	05H
	DW	0eH
	DW	05H
	DW	01eH
	DW	05H
	DW	01H
	DW	05H
	DW	011H
	DW	05H
	DW	09H
	DW	05H
	DW	019H
	DW	05H
	DW	05H
	DW	05H
	DW	015H
	DW	05H
	DW	0dH
	DW	05H
	DW	01dH
	DW	05H
	DW	03H
	DW	05H
	DW	013H
	DW	05H
	DW	0bH
	DW	05H
	DW	01bH
	DW	05H
	DW	07H
	DW	05H
	DW	017H
	DW	05H
	ORG $+8
extra_blbits DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	02H
	DD	03H
	DD	07H
	ORG $+4
extra_lbits DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	04H
	DD	04H
	DD	04H
	DD	04H
	DD	05H
	DD	05H
	DD	05H
	DD	05H
	DD	00H
	ORG $+12
base_dist DD	00H
	DD	01H
	DD	02H
	DD	03H
	DD	04H
	DD	06H
	DD	08H
	DD	0cH
	DD	010H
	DD	018H
	DD	020H
	DD	030H
	DD	040H
	DD	060H
	DD	080H
	DD	0c0H
	DD	0100H
	DD	0180H
	DD	0200H
	DD	0300H
	DD	0400H
	DD	0600H
	DD	0800H
	DD	0c00H
	DD	01000H
	DD	01800H
	DD	02000H
	DD	03000H
	DD	04000H
	DD	06000H
	ORG $+8
base_length DD	00H
	DD	01H
	DD	02H
	DD	03H
	DD	04H
	DD	05H
	DD	06H
	DD	07H
	DD	08H
	DD	0aH
	DD	0cH
	DD	0eH
	DD	010H
	DD	014H
	DD	018H
	DD	01cH
	DD	020H
	DD	028H
	DD	030H
	DD	038H
	DD	040H
	DD	050H
	DD	060H
	DD	070H
	DD	080H
	DD	0a0H
	DD	0c0H
	DD	0e0H
	DD	00H
	ORG $+4
static_l_desc DQ FLAT:static_ltree
	DQ	FLAT:extra_lbits
	DD	0101H
	DD	011eH
	DD	0fH
	ORG $+4
static_bl_desc DQ 0000000000000000H
	DQ	FLAT:extra_blbits
	DD	00H
	DD	013H
	DD	07H
	ORG $+4
	ORG $+8
extra_dbits DD	00H
	DD	00H
	DD	00H
	DD	00H
	DD	01H
	DD	01H
	DD	02H
	DD	02H
	DD	03H
	DD	03H
	DD	04H
	DD	04H
	DD	05H
	DD	05H
	DD	06H
	DD	06H
	DD	07H
	DD	07H
	DD	08H
	DD	08H
	DD	09H
	DD	09H
	DD	0aH
	DD	0aH
	DD	0bH
	DD	0bH
	DD	0cH
	DD	0cH
	DD	0dH
	DD	0dH
	ORG $+8
static_ltree DW	0cH
	DW	08H
	DW	08cH
	DW	08H
	DW	04cH
	DW	08H
	DW	0ccH
	DW	08H
	DW	02cH
	DW	08H
	DW	0acH
	DW	08H
	DW	06cH
	DW	08H
	DW	0ecH
	DW	08H
	DW	01cH
	DW	08H
	DW	09cH
	DW	08H
	DW	05cH
	DW	08H
	DW	0dcH
	DW	08H
	DW	03cH
	DW	08H
	DW	0bcH
	DW	08H
	DW	07cH
	DW	08H
	DW	0fcH
	DW	08H
	DW	02H
	DW	08H
	DW	082H
	DW	08H
	DW	042H
	DW	08H
	DW	0c2H
	DW	08H
	DW	022H
	DW	08H
	DW	0a2H
	DW	08H
	DW	062H
	DW	08H
	DW	0e2H
	DW	08H
	DW	012H
	DW	08H
	DW	092H
	DW	08H
	DW	052H
	DW	08H
	DW	0d2H
	DW	08H
	DW	032H
	DW	08H
	DW	0b2H
	DW	08H
	DW	072H
	DW	08H
	DW	0f2H
	DW	08H
	DW	0aH
	DW	08H
	DW	08aH
	DW	08H
	DW	04aH
	DW	08H
	DW	0caH
	DW	08H
	DW	02aH
	DW	08H
	DW	0aaH
	DW	08H
	DW	06aH
	DW	08H
	DW	0eaH
	DW	08H
	DW	01aH
	DW	08H
	DW	09aH
	DW	08H
	DW	05aH
	DW	08H
	DW	0daH
	DW	08H
	DW	03aH
	DW	08H
	DW	0baH
	DW	08H
	DW	07aH
	DW	08H
	DW	0faH
	DW	08H
	DW	06H
	DW	08H
	DW	086H
	DW	08H
	DW	046H
	DW	08H
	DW	0c6H
	DW	08H
	DW	026H
	DW	08H
	DW	0a6H
	DW	08H
	DW	066H
	DW	08H
	DW	0e6H
	DW	08H
	DW	016H
	DW	08H
	DW	096H
	DW	08H
	DW	056H
	DW	08H
	DW	0d6H
	DW	08H
	DW	036H
	DW	08H
	DW	0b6H
	DW	08H
	DW	076H
	DW	08H
	DW	0f6H
	DW	08H
	DW	0eH
	DW	08H
	DW	08eH
	DW	08H
	DW	04eH
	DW	08H
	DW	0ceH
	DW	08H
	DW	02eH
	DW	08H
	DW	0aeH
	DW	08H
	DW	06eH
	DW	08H
	DW	0eeH
	DW	08H
	DW	01eH
	DW	08H
	DW	09eH
	DW	08H
	DW	05eH
	DW	08H
	DW	0deH
	DW	08H
	DW	03eH
	DW	08H
	DW	0beH
	DW	08H
	DW	07eH
	DW	08H
	DW	0feH
	DW	08H
	DW	01H
	DW	08H
	DW	081H
	DW	08H
	DW	041H
	DW	08H
	DW	0c1H
	DW	08H
	DW	021H
	DW	08H
	DW	0a1H
	DW	08H
	DW	061H
	DW	08H
	DW	0e1H
	DW	08H
	DW	011H
	DW	08H
	DW	091H
	DW	08H
	DW	051H
	DW	08H
	DW	0d1H
	DW	08H
	DW	031H
	DW	08H
	DW	0b1H
	DW	08H
	DW	071H
	DW	08H
	DW	0f1H
	DW	08H
	DW	09H
	DW	08H
	DW	089H
	DW	08H
	DW	049H
	DW	08H
	DW	0c9H
	DW	08H
	DW	029H
	DW	08H
	DW	0a9H
	DW	08H
	DW	069H
	DW	08H
	DW	0e9H
	DW	08H
	DW	019H
	DW	08H
	DW	099H
	DW	08H
	DW	059H
	DW	08H
	DW	0d9H
	DW	08H
	DW	039H
	DW	08H
	DW	0b9H
	DW	08H
	DW	079H
	DW	08H
	DW	0f9H
	DW	08H
	DW	05H
	DW	08H
	DW	085H
	DW	08H
	DW	045H
	DW	08H
	DW	0c5H
	DW	08H
	DW	025H
	DW	08H
	DW	0a5H
	DW	08H
	DW	065H
	DW	08H
	DW	0e5H
	DW	08H
	DW	015H
	DW	08H
	DW	095H
	DW	08H
	DW	055H
	DW	08H
	DW	0d5H
	DW	08H
	DW	035H
	DW	08H
	DW	0b5H
	DW	08H
	DW	075H
	DW	08H
	DW	0f5H
	DW	08H
	DW	0dH
	DW	08H
	DW	08dH
	DW	08H
	DW	04dH
	DW	08H
	DW	0cdH
	DW	08H
	DW	02dH
	DW	08H
	DW	0adH
	DW	08H
	DW	06dH
	DW	08H
	DW	0edH
	DW	08H
	DW	01dH
	DW	08H
	DW	09dH
	DW	08H
	DW	05dH
	DW	08H
	DW	0ddH
	DW	08H
	DW	03dH
	DW	08H
	DW	0bdH
	DW	08H
	DW	07dH
	DW	08H
	DW	0fdH
	DW	08H
	DW	013H
	DW	09H
	DW	0113H
	DW	09H
	DW	093H
	DW	09H
	DW	0193H
	DW	09H
	DW	053H
	DW	09H
	DW	0153H
	DW	09H
	DW	0d3H
	DW	09H
	DW	01d3H
	DW	09H
	DW	033H
	DW	09H
	DW	0133H
	DW	09H
	DW	0b3H
	DW	09H
	DW	01b3H
	DW	09H
	DW	073H
	DW	09H
	DW	0173H
	DW	09H
	DW	0f3H
	DW	09H
	DW	01f3H
	DW	09H
	DW	0bH
	DW	09H
	DW	010bH
	DW	09H
	DW	08bH
	DW	09H
	DW	018bH
	DW	09H
	DW	04bH
	DW	09H
	DW	014bH
	DW	09H
	DW	0cbH
	DW	09H
	DW	01cbH
	DW	09H
	DW	02bH
	DW	09H
	DW	012bH
	DW	09H
	DW	0abH
	DW	09H
	DW	01abH
	DW	09H
	DW	06bH
	DW	09H
	DW	016bH
	DW	09H
	DW	0ebH
	DW	09H
	DW	01ebH
	DW	09H
	DW	01bH
	DW	09H
	DW	011bH
	DW	09H
	DW	09bH
	DW	09H
	DW	019bH
	DW	09H
	DW	05bH
	DW	09H
	DW	015bH
	DW	09H
	DW	0dbH
	DW	09H
	DW	01dbH
	DW	09H
	DW	03bH
	DW	09H
	DW	013bH
	DW	09H
	DW	0bbH
	DW	09H
	DW	01bbH
	DW	09H
	DW	07bH
	DW	09H
	DW	017bH
	DW	09H
	DW	0fbH
	DW	09H
	DW	01fbH
	DW	09H
	DW	07H
	DW	09H
	DW	0107H
	DW	09H
	DW	087H
	DW	09H
	DW	0187H
	DW	09H
	DW	047H
	DW	09H
	DW	0147H
	DW	09H
	DW	0c7H
	DW	09H
	DW	01c7H
	DW	09H
	DW	027H
	DW	09H
	DW	0127H
	DW	09H
	DW	0a7H
	DW	09H
	DW	01a7H
	DW	09H
	DW	067H
	DW	09H
	DW	0167H
	DW	09H
	DW	0e7H
	DW	09H
	DW	01e7H
	DW	09H
	DW	017H
	DW	09H
	DW	0117H
	DW	09H
	DW	097H
	DW	09H
	DW	0197H
	DW	09H
	DW	057H
	DW	09H
	DW	0157H
	DW	09H
	DW	0d7H
	DW	09H
	DW	01d7H
	DW	09H
	DW	037H
	DW	09H
	DW	0137H
	DW	09H
	DW	0b7H
	DW	09H
	DW	01b7H
	DW	09H
	DW	077H
	DW	09H
	DW	0177H
	DW	09H
	DW	0f7H
	DW	09H
	DW	01f7H
	DW	09H
	DW	0fH
	DW	09H
	DW	010fH
	DW	09H
	DW	08fH
	DW	09H
	DW	018fH
	DW	09H
	DW	04fH
	DW	09H
	DW	014fH
	DW	09H
	DW	0cfH
	DW	09H
	DW	01cfH
	DW	09H
	DW	02fH
	DW	09H
	DW	012fH
	DW	09H
	DW	0afH
	DW	09H
	DW	01afH
	DW	09H
	DW	06fH
	DW	09H
	DW	016fH
	DW	09H
	DW	0efH
	DW	09H
	DW	01efH
	DW	09H
	DW	01fH
	DW	09H
	DW	011fH
	DW	09H
	DW	09fH
	DW	09H
	DW	019fH
	DW	09H
	DW	05fH
	DW	09H
	DW	015fH
	DW	09H
	DW	0dfH
	DW	09H
	DW	01dfH
	DW	09H
	DW	03fH
	DW	09H
	DW	013fH
	DW	09H
	DW	0bfH
	DW	09H
	DW	01bfH
	DW	09H
	DW	07fH
	DW	09H
	DW	017fH
	DW	09H
	DW	0ffH
	DW	09H
	DW	01ffH
	DW	09H
	DW	00H
	DW	07H
	DW	040H
	DW	07H
	DW	020H
	DW	07H
	DW	060H
	DW	07H
	DW	010H
	DW	07H
	DW	050H
	DW	07H
	DW	030H
	DW	07H
	DW	070H
	DW	07H
	DW	08H
	DW	07H
	DW	048H
	DW	07H
	DW	028H
	DW	07H
	DW	068H
	DW	07H
	DW	018H
	DW	07H
	DW	058H
	DW	07H
	DW	038H
	DW	07H
	DW	078H
	DW	07H
	DW	04H
	DW	07H
	DW	044H
	DW	07H
	DW	024H
	DW	07H
	DW	064H
	DW	07H
	DW	014H
	DW	07H
	DW	054H
	DW	07H
	DW	034H
	DW	07H
	DW	074H
	DW	07H
	DW	03H
	DW	08H
	DW	083H
	DW	08H
	DW	043H
	DW	08H
	DW	0c3H
	DW	08H
	DW	023H
	DW	08H
	DW	0a3H
	DW	08H
	DW	063H
	DW	08H
	DW	0e3H
	DW	08H
static_d_desc DQ FLAT:static_dtree
	DQ	FLAT:extra_dbits
	DD	00H
	DD	01eH
	DD	0fH
	ORG $+4
bl_order DB	010H
	DB	011H
	DB	012H
	DB	00H
	DB	08H
	DB	07H
	DB	09H
	DB	06H
	DB	0aH
	DB	05H
	DB	0bH
	DB	04H
	DB	0cH
	DB	03H
	DB	0dH
	DB	02H
	DB	0eH
	DB	01H
	DB	0fH
PUBLIC	_tr_align
PUBLIC	_tr_init
PUBLIC	_tr_flush_block
PUBLIC	_tr_flush_bits
PUBLIC	_tr_stored_block
;	COMDAT pdata
pdata	SEGMENT
$pdata$compress_block DD imagerel compress_block
	DD	imagerel compress_block+8
	DD	imagerel $unwind$compress_block
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$compress_block DD imagerel compress_block+8
	DD	imagerel compress_block+43
	DD	imagerel $chain$1$compress_block
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$compress_block DD imagerel compress_block+43
	DD	imagerel compress_block+921
	DD	imagerel $chain$4$compress_block
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$5$compress_block DD imagerel compress_block+921
	DD	imagerel compress_block+953
	DD	imagerel $chain$5$compress_block
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$6$compress_block DD imagerel compress_block+953
	DD	imagerel compress_block+1093
	DD	imagerel $chain$6$compress_block
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$send_all_trees DD imagerel send_all_trees
	DD	imagerel send_all_trees+635
	DD	imagerel $unwind$send_all_trees
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$build_bl_tree DD imagerel build_bl_tree
	DD	imagerel build_bl_tree+197
	DD	imagerel $unwind$build_bl_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$send_tree DD imagerel send_tree
	DD	imagerel send_tree+59
	DD	imagerel $unwind$send_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$6$send_tree DD imagerel send_tree+59
	DD	imagerel send_tree+1473
	DD	imagerel $chain$6$send_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$7$send_tree DD imagerel send_tree+1473
	DD	imagerel send_tree+1479
	DD	imagerel $chain$7$send_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$scan_tree DD imagerel scan_tree
	DD	imagerel scan_tree+82
	DD	imagerel $unwind$scan_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$scan_tree DD imagerel scan_tree+82
	DD	imagerel scan_tree+309
	DD	imagerel $chain$4$scan_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$5$scan_tree DD imagerel scan_tree+309
	DD	imagerel scan_tree+318
	DD	imagerel $chain$5$scan_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$build_tree DD imagerel build_tree
	DD	imagerel build_tree+566
	DD	imagerel $unwind$build_tree
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$gen_codes DD imagerel gen_codes
	DD	imagerel gen_codes+142
	DD	imagerel $unwind$gen_codes
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$gen_bitlen DD imagerel gen_bitlen
	DD	imagerel gen_bitlen+118
	DD	imagerel $unwind$gen_bitlen
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$0$gen_bitlen DD imagerel gen_bitlen+118
	DD	imagerel gen_bitlen+284
	DD	imagerel $chain$0$gen_bitlen
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$gen_bitlen DD imagerel gen_bitlen+284
	DD	imagerel gen_bitlen+515
	DD	imagerel $chain$1$gen_bitlen
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$pqdownheap DD imagerel pqdownheap
	DD	imagerel pqdownheap+39
	DD	imagerel $unwind$pqdownheap
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$1$pqdownheap DD imagerel pqdownheap+39
	DD	imagerel pqdownheap+221
	DD	imagerel $chain$1$pqdownheap
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$3$pqdownheap DD imagerel pqdownheap+221
	DD	imagerel pqdownheap+248
	DD	imagerel $chain$3$pqdownheap
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$4$pqdownheap DD imagerel pqdownheap+248
	DD	imagerel pqdownheap+265
	DD	imagerel $chain$4$pqdownheap
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$_tr_flush_block DD imagerel $LN19
	DD	imagerel $LN19+557
	DD	imagerel $unwind$_tr_flush_block
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$_tr_stored_block DD imagerel $LN6
	DD	imagerel $LN6+253
	DD	imagerel $unwind$_tr_stored_block
;	COMDAT xdata
xdata	SEGMENT
$unwind$_tr_stored_block DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$_tr_flush_block DD 081401H
	DD	086414H
	DD	075414H
	DD	063414H
	DD	070103214H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$pqdownheap DD 021H
	DD	imagerel pqdownheap
	DD	imagerel pqdownheap+39
	DD	imagerel $unwind$pqdownheap
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$3$pqdownheap DD 040021H
	DD	035400H
	DD	023400H
	DD	imagerel pqdownheap
	DD	imagerel pqdownheap+39
	DD	imagerel $unwind$pqdownheap
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$pqdownheap DD 040a21H
	DD	02340aH
	DD	035405H
	DD	imagerel pqdownheap
	DD	imagerel pqdownheap+39
	DD	imagerel $unwind$pqdownheap
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$pqdownheap DD 030601H
	DD	046406H
	DD	07006H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$gen_bitlen DD 021H
	DD	imagerel gen_bitlen
	DD	imagerel gen_bitlen+118
	DD	imagerel $unwind$gen_bitlen
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$0$gen_bitlen DD 020521H
	DD	07e405H
	DD	imagerel gen_bitlen
	DD	imagerel gen_bitlen+118
	DD	imagerel $unwind$gen_bitlen
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$gen_bitlen DD 091201H
	DD	095412H
	DD	083412H
	DD	0d010f012H
	DD	0700cc00eH
	DD	0600bH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$gen_codes DD 040a01H
	DD	0a340aH
	DD	07006720aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$build_tree DD 0c1e01H
	DD	0b741eH
	DD	0a641eH
	DD	09541eH
	DD	08341eH
	DD	0f01a321eH
	DD	0c016e018H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$5$scan_tree DD 021H
	DD	imagerel scan_tree
	DD	imagerel scan_tree+82
	DD	imagerel $unwind$scan_tree
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$scan_tree DD 0a1c21H
	DD	0f41cH
	DD	01e414H
	DD	08c40fH
	DD	07740aH
	DD	066405H
	DD	imagerel scan_tree
	DD	imagerel scan_tree+82
	DD	imagerel $unwind$scan_tree
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$scan_tree DD 040901H
	DD	0d0051209H
	DD	030025003H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$7$send_tree DD 021H
	DD	imagerel send_tree
	DD	imagerel send_tree+59
	DD	imagerel $unwind$send_tree
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$6$send_tree DD 0e2621H
	DD	0f426H
	DD	01e422H
	DD	02d419H
	DD	03c414H
	DD	09640fH
	DD	07540aH
	DD	063405H
	DD	imagerel send_tree
	DD	imagerel send_tree+59
	DD	imagerel $unwind$send_tree
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$send_tree DD 020601H
	DD	070023206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$build_bl_tree DD 020601H
	DD	030023206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$send_all_trees DD 060f01H
	DD	07640fH
	DD	06340fH
	DD	0700b320fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$6$compress_block DD 021H
	DD	imagerel compress_block
	DD	imagerel compress_block+8
	DD	imagerel $unwind$compress_block
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$5$compress_block DD 021H
	DD	imagerel compress_block+8
	DD	imagerel compress_block+43
	DD	imagerel $chain$1$compress_block
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$4$compress_block DD 061621H
	DD	067416H
	DD	056411H
	DD	07c405H
	DD	imagerel compress_block+8
	DD	imagerel compress_block+43
	DD	imagerel $chain$1$compress_block
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$chain$1$compress_block DD 040e21H
	DD	0f40eH
	DD	045405H
	DD	imagerel compress_block
	DD	imagerel compress_block+8
	DD	imagerel $unwind$compress_block
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$compress_block DD 030801H
	DD	0e0040208H
	DD	03002H
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT _tr_stored_block
_TEXT	SEGMENT
s$ = 48
buf$ = 56
stored_len$ = 64
last$ = 72
_tr_stored_block PROC					; COMDAT

; 868  : {

$LN6:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000a	48 8b d9	 mov	 rbx, rcx
  0000d	41 8b f8	 mov	 edi, r8d

; 869  :     send_bits(s, (STORED_BLOCK<<1)+last, 3);    /* send block type */

  00010	8b 89 14 17 00
	00		 mov	 ecx, DWORD PTR [rcx+5908]
  00016	4c 8b d2	 mov	 r10, rdx
  00019	83 f9 0d	 cmp	 ecx, 13
  0001c	7e 56		 jle	 SHORT $LN2@tr_stored_
  0001e	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  00021	41 0f b7 c1	 movzx	 eax, r9w
  00025	66 d3 e0	 shl	 ax, cl
  00028	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  0002f	0f b6 83 10 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5904]
  00036	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  0003a	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  0003d	ff 43 28	 inc	 DWORD PTR [rbx+40]
  00040	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  00043	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  00047	0f b6 83 11 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5905]
  0004e	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  00051	b9 10 00 00 00	 mov	 ecx, 16
  00056	2a 8b 14 17 00
	00		 sub	 cl, BYTE PTR [rbx+5908]
  0005c	ff 43 28	 inc	 DWORD PTR [rbx+40]
  0005f	66 41 d3 e9	 shr	 r9w, cl
  00063	83 83 14 17 00
	00 f3		 add	 DWORD PTR [rbx+5908], -13
  0006a	66 44 89 8b 10
	17 00 00	 mov	 WORD PTR [rbx+5904], r9w
  00072	eb 15		 jmp	 SHORT $LN3@tr_stored_
$LN2@tr_stored_:
  00074	66 41 d3 e1	 shl	 r9w, cl
  00078	8d 41 03	 lea	 eax, DWORD PTR [rcx+3]
  0007b	66 44 09 8b 10
	17 00 00	 or	 WORD PTR [rbx+5904], r9w
  00083	89 83 14 17 00
	00		 mov	 DWORD PTR [rbx+5908], eax
$LN3@tr_stored_:

; 870  :     bi_windup(s);        /* align on byte boundary */

  00089	48 8b cb	 mov	 rcx, rbx
  0008c	e8 00 00 00 00	 call	 bi_windup

; 871  :     put_short(s, (ush)stored_len);

  00091	8b 4b 28	 mov	 ecx, DWORD PTR [rbx+40]

; 872  :     put_short(s, (ush)~stored_len);
; 873  :     zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);

  00094	4c 8b c7	 mov	 r8, rdi
  00097	48 8b 43 10	 mov	 rax, QWORD PTR [rbx+16]
  0009b	40 88 3c 01	 mov	 BYTE PTR [rcx+rax], dil
  0009f	0f b7 cf	 movzx	 ecx, di
  000a2	ff 43 28	 inc	 DWORD PTR [rbx+40]
  000a5	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  000a8	48 8b 43 10	 mov	 rax, QWORD PTR [rbx+16]
  000ac	66 c1 e9 08	 shr	 cx, 8
  000b0	88 0c 02	 mov	 BYTE PTR [rdx+rax], cl
  000b3	40 0f b6 cf	 movzx	 ecx, dil
  000b7	ff 43 28	 inc	 DWORD PTR [rbx+40]
  000ba	f6 d1		 not	 cl
  000bc	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  000bf	48 8b 43 10	 mov	 rax, QWORD PTR [rbx+16]
  000c3	88 0c 02	 mov	 BYTE PTR [rdx+rax], cl
  000c6	0f b7 cf	 movzx	 ecx, di
  000c9	ff 43 28	 inc	 DWORD PTR [rbx+40]
  000cc	66 f7 d1	 not	 cx
  000cf	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  000d2	48 8b 43 10	 mov	 rax, QWORD PTR [rbx+16]
  000d6	66 c1 e9 08	 shr	 cx, 8
  000da	88 0c 02	 mov	 BYTE PTR [rdx+rax], cl
  000dd	49 8b d2	 mov	 rdx, r10
  000e0	ff 43 28	 inc	 DWORD PTR [rbx+40]
  000e3	8b 4b 28	 mov	 ecx, DWORD PTR [rbx+40]
  000e6	48 03 4b 10	 add	 rcx, QWORD PTR [rbx+16]
  000ea	e8 00 00 00 00	 call	 memcpy

; 874  :     s->pending += stored_len;

  000ef	01 7b 28	 add	 DWORD PTR [rbx+40], edi

; 875  : #ifdef ZLIB_DEBUG
; 876  :     s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
; 877  :     s->compressed_len += (stored_len + 4) << 3;
; 878  :     s->bits_sent += 2*16;
; 879  :     s->bits_sent += stored_len<<3;
; 880  : #endif
; 881  : }

  000f2	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  000f7	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000fb	5f		 pop	 rdi
  000fc	c3		 ret	 0
_tr_stored_block ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT _tr_flush_bits
_TEXT	SEGMENT
s$ = 8
_tr_flush_bits PROC					; COMDAT

; 889  :     bi_flush(s);

  00000	e9 00 00 00 00	 jmp	 bi_flush
_tr_flush_bits ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT _tr_flush_block
_TEXT	SEGMENT
s$ = 48
buf$ = 56
stored_len$ = 64
last$ = 72
_tr_flush_block PROC					; COMDAT

; 916  : {

$LN19:
  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	41 8b f9	 mov	 edi, r9d
  00017	41 8b f0	 mov	 esi, r8d

; 917  :     ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
; 918  :     int max_blindex = 0;  /* index of last bit length code of non zero freq */

  0001a	45 33 c9	 xor	 r9d, r9d
  0001d	48 8b ea	 mov	 rbp, rdx
  00020	48 8b d9	 mov	 rbx, rcx

; 919  : 
; 920  :     /* Build the Huffman trees unless a stored block is forced */
; 921  :     if (s->level > 0) {

  00023	44 39 89 ac 00
	00 00		 cmp	 DWORD PTR [rcx+172], r9d
  0002a	7e 5f		 jle	 SHORT $LN2@tr_flush_b

; 922  : 
; 923  :         /* Check if the file is binary or text */
; 924  :         if (s->strm->data_type == Z_UNKNOWN)

  0002c	4c 8b 11	 mov	 r10, QWORD PTR [rcx]
  0002f	41 83 7a 48 02	 cmp	 DWORD PTR [r10+72], 2
  00034	75 09		 jne	 SHORT $LN4@tr_flush_b

; 925  :             s->strm->data_type = detect_data_type(s);

  00036	e8 00 00 00 00	 call	 detect_data_type
  0003b	41 89 42 48	 mov	 DWORD PTR [r10+72], eax
$LN4@tr_flush_b:

; 926  : 
; 927  :         /* Construct the literal and distance trees */
; 928  :         build_tree(s, (tree_desc *)(&(s->l_desc)));

  0003f	48 8d 93 40 0b
	00 00		 lea	 rdx, QWORD PTR [rbx+2880]
  00046	48 8b cb	 mov	 rcx, rbx
  00049	e8 00 00 00 00	 call	 build_tree

; 929  :         Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
; 930  :                 s->static_len));
; 931  : 
; 932  :         build_tree(s, (tree_desc *)(&(s->d_desc)));

  0004e	48 8d 93 58 0b
	00 00		 lea	 rdx, QWORD PTR [rbx+2904]
  00055	48 8b cb	 mov	 rcx, rbx
  00058	e8 00 00 00 00	 call	 build_tree

; 933  :         Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
; 934  :                 s->static_len));
; 935  :         /* At this point, opt_len and static_len are the total bit lengths of
; 936  :          * the compressed block data, excluding the tree representations.
; 937  :          */
; 938  : 
; 939  :         /* Build the bit length tree for the above two trees, and get the index
; 940  :          * in bl_order of the last bit length code to send.
; 941  :          */
; 942  :         max_blindex = build_bl_tree(s);

  0005d	48 8b cb	 mov	 rcx, rbx
  00060	e8 00 00 00 00	 call	 build_bl_tree

; 943  : 
; 944  :         /* Determine the best encoding. Compute the block lengths in bytes. */
; 945  :         opt_lenb = (s->opt_len+3+7)>>3;

  00065	8b 8b 00 17 00
	00		 mov	 ecx, DWORD PTR [rbx+5888]
  0006b	44 8b c8	 mov	 r9d, eax

; 946  :         static_lenb = (s->static_len+3+7)>>3;

  0006e	8b 93 04 17 00
	00		 mov	 edx, DWORD PTR [rbx+5892]
  00074	83 c1 0a	 add	 ecx, 10
  00077	83 c2 0a	 add	 edx, 10
  0007a	c1 e9 03	 shr	 ecx, 3
  0007d	c1 ea 03	 shr	 edx, 3
  00080	3b d1		 cmp	 edx, ecx
  00082	44 8b c2	 mov	 r8d, edx
  00085	44 0f 47 c1	 cmova	 r8d, ecx

; 947  : 
; 948  :         Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
; 949  :                 opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
; 950  :                 s->last_lit));
; 951  : 
; 952  :         if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
; 953  : 
; 954  :     } else {

  00089	eb 07		 jmp	 SHORT $LN3@tr_flush_b
$LN2@tr_flush_b:

; 955  :         Assert(buf != (char*)0, "lost buf");
; 956  :         opt_lenb = static_lenb = stored_len + 5; /* force a stored block */

  0008b	41 8d 50 05	 lea	 edx, DWORD PTR [r8+5]
  0008f	44 8b c2	 mov	 r8d, edx
$LN3@tr_flush_b:

; 957  :     }
; 958  : 
; 959  : #ifdef FORCE_STORED
; 960  :     if (buf != (char*)0) { /* force stored block */
; 961  : #else
; 962  :     if (stored_len+4 <= opt_lenb && buf != (char*)0) {

  00092	8d 46 04	 lea	 eax, DWORD PTR [rsi+4]
  00095	41 3b c0	 cmp	 eax, r8d
  00098	77 1b		 ja	 SHORT $LN6@tr_flush_b
  0009a	48 85 ed	 test	 rbp, rbp
  0009d	74 16		 je	 SHORT $LN6@tr_flush_b

; 963  :                        /* 4: two words for the lengths */
; 964  : #endif
; 965  :         /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
; 966  :          * Otherwise we can't have processed more than WSIZE input bytes since
; 967  :          * the last block flush, because compression would have been
; 968  :          * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
; 969  :          * transform a block into a stored block.
; 970  :          */
; 971  :         _tr_stored_block(s, buf, stored_len, last);

  0009f	44 8b cf	 mov	 r9d, edi
  000a2	44 8b c6	 mov	 r8d, esi
  000a5	48 8b d5	 mov	 rdx, rbp
  000a8	48 8b cb	 mov	 rcx, rbx
  000ab	e8 00 00 00 00	 call	 _tr_stored_block
  000b0	e9 52 01 00 00	 jmp	 $LN9@tr_flush_b
$LN6@tr_flush_b:

; 972  : 
; 973  : #ifdef FORCE_STATIC
; 974  :     } else if (static_lenb >= 0) { /* force static trees */
; 975  : #else
; 976  :     } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {

  000b5	83 bb b0 00 00
	00 04		 cmp	 DWORD PTR [rbx+176], 4
  000bc	0f 84 b4 00 00
	00		 je	 $LN10@tr_flush_b
  000c2	41 3b d0	 cmp	 edx, r8d
  000c5	0f 84 ab 00 00
	00		 je	 $LN10@tr_flush_b

; 980  :                        (const ct_data *)static_dtree);
; 981  : #ifdef ZLIB_DEBUG
; 982  :         s->compressed_len += 3 + s->static_len;
; 983  : #endif
; 984  :     } else {
; 985  :         send_bits(s, (DYN_TREES<<1)+last, 3);

  000cb	8b 8b 14 17 00
	00		 mov	 ecx, DWORD PTR [rbx+5908]
  000d1	83 f9 0d	 cmp	 ecx, 13
  000d4	7e 5a		 jle	 SHORT $LN13@tr_flush_b
  000d6	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  000d9	44 8d 47 04	 lea	 r8d, DWORD PTR [rdi+4]
  000dd	41 0f b7 c0	 movzx	 eax, r8w
  000e1	66 d3 e0	 shl	 ax, cl
  000e4	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  000eb	0f b6 83 10 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5904]
  000f2	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  000f6	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  000f9	ff 43 28	 inc	 DWORD PTR [rbx+40]
  000fc	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  000ff	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  00103	0f b6 83 11 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5905]
  0010a	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  0010d	b9 10 00 00 00	 mov	 ecx, 16
  00112	2a 8b 14 17 00
	00		 sub	 cl, BYTE PTR [rbx+5908]
  00118	ff 43 28	 inc	 DWORD PTR [rbx+40]
  0011b	66 41 d3 e8	 shr	 r8w, cl
  0011f	83 83 14 17 00
	00 f3		 add	 DWORD PTR [rbx+5908], -13
  00126	66 44 89 83 10
	17 00 00	 mov	 WORD PTR [rbx+5904], r8w
  0012e	eb 16		 jmp	 SHORT $LN14@tr_flush_b
$LN13@tr_flush_b:
  00130	8d 47 04	 lea	 eax, DWORD PTR [rdi+4]
  00133	66 d3 e0	 shl	 ax, cl
  00136	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  0013d	8d 41 03	 lea	 eax, DWORD PTR [rcx+3]
  00140	89 83 14 17 00
	00		 mov	 DWORD PTR [rbx+5908], eax
$LN14@tr_flush_b:

; 986  :         send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,

  00146	44 8b 83 60 0b
	00 00		 mov	 r8d, DWORD PTR [rbx+2912]
  0014d	41 ff c1	 inc	 r9d
  00150	8b 93 48 0b 00
	00		 mov	 edx, DWORD PTR [rbx+2888]
  00156	41 ff c0	 inc	 r8d
  00159	ff c2		 inc	 edx
  0015b	48 8b cb	 mov	 rcx, rbx
  0015e	e8 00 00 00 00	 call	 send_all_trees

; 987  :                        max_blindex+1);
; 988  :         compress_block(s, (const ct_data *)s->dyn_ltree,

  00163	4c 8d 83 b0 09
	00 00		 lea	 r8, QWORD PTR [rbx+2480]
  0016a	48 8d 93 bc 00
	00 00		 lea	 rdx, QWORD PTR [rbx+188]
  00171	e9 89 00 00 00	 jmp	 $LN17@tr_flush_b
$LN10@tr_flush_b:

; 977  : #endif
; 978  :         send_bits(s, (STATIC_TREES<<1)+last, 3);

  00176	8b 8b 14 17 00
	00		 mov	 ecx, DWORD PTR [rbx+5908]
  0017c	83 f9 0d	 cmp	 ecx, 13
  0017f	7e 5a		 jle	 SHORT $LN11@tr_flush_b
  00181	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  00184	44 8d 47 02	 lea	 r8d, DWORD PTR [rdi+2]
  00188	41 0f b7 c0	 movzx	 eax, r8w
  0018c	66 d3 e0	 shl	 ax, cl
  0018f	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  00196	0f b6 83 10 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5904]
  0019d	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  001a1	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  001a4	ff 43 28	 inc	 DWORD PTR [rbx+40]
  001a7	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  001aa	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  001ae	0f b6 83 11 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5905]
  001b5	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  001b8	b9 10 00 00 00	 mov	 ecx, 16
  001bd	2a 8b 14 17 00
	00		 sub	 cl, BYTE PTR [rbx+5908]
  001c3	ff 43 28	 inc	 DWORD PTR [rbx+40]
  001c6	66 41 d3 e8	 shr	 r8w, cl
  001ca	83 83 14 17 00
	00 f3		 add	 DWORD PTR [rbx+5908], -13
  001d1	66 44 89 83 10
	17 00 00	 mov	 WORD PTR [rbx+5904], r8w
  001d9	eb 16		 jmp	 SHORT $LN12@tr_flush_b
$LN11@tr_flush_b:
  001db	8d 47 02	 lea	 eax, DWORD PTR [rdi+2]
  001de	66 d3 e0	 shl	 ax, cl
  001e1	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  001e8	8d 41 03	 lea	 eax, DWORD PTR [rcx+3]
  001eb	89 83 14 17 00
	00		 mov	 DWORD PTR [rbx+5908], eax
$LN12@tr_flush_b:

; 979  :         compress_block(s, (const ct_data *)static_ltree,

  001f1	4c 8d 05 00 00
	00 00		 lea	 r8, OFFSET FLAT:static_dtree
  001f8	48 8d 15 00 00
	00 00		 lea	 rdx, OFFSET FLAT:static_ltree
$LN17@tr_flush_b:
  001ff	48 8b cb	 mov	 rcx, rbx
  00202	e8 00 00 00 00	 call	 compress_block
$LN9@tr_flush_b:

; 989  :                        (const ct_data *)s->dyn_dtree);
; 990  : #ifdef ZLIB_DEBUG
; 991  :         s->compressed_len += 3 + s->opt_len;
; 992  : #endif
; 993  :     }
; 994  :     Assert (s->compressed_len == s->bits_sent, "bad compressed size");
; 995  :     /* The above check is made mod 2^32, for files larger than 512 MB
; 996  :      * and uLong implemented on 32 bits.
; 997  :      */
; 998  :     init_block(s);

  00207	48 8b cb	 mov	 rcx, rbx
  0020a	e8 00 00 00 00	 call	 init_block

; 999  : 
; 1000 :     if (last) {

  0020f	85 ff		 test	 edi, edi
  00211	74 05		 je	 SHORT $LN15@tr_flush_b

; 1001 :         bi_windup(s);

  00213	e8 00 00 00 00	 call	 bi_windup
$LN15@tr_flush_b:

; 1002 : #ifdef ZLIB_DEBUG
; 1003 :         s->compressed_len += 7;  /* align on byte boundary */
; 1004 : #endif
; 1005 :     }
; 1006 :     Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
; 1007 :            s->compressed_len-7*last));
; 1008 : }

  00218	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0021d	48 8b 6c 24 38	 mov	 rbp, QWORD PTR [rsp+56]
  00222	48 8b 74 24 40	 mov	 rsi, QWORD PTR [rsp+64]
  00227	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0022b	5f		 pop	 rdi
  0022c	c3		 ret	 0
_tr_flush_block ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT _tr_init
_TEXT	SEGMENT
s$ = 8
_tr_init PROC						; COMDAT

; 382  :     tr_static_init();
; 383  : 
; 384  :     s->l_desc.dyn_tree = s->dyn_ltree;

  00000	48 8d 81 bc 00
	00 00		 lea	 rax, QWORD PTR [rcx+188]
  00007	48 89 81 40 0b
	00 00		 mov	 QWORD PTR [rcx+2880], rax

; 385  :     s->l_desc.stat_desc = &static_l_desc;

  0000e	48 8d 05 00 00
	00 00		 lea	 rax, OFFSET FLAT:static_l_desc
  00015	48 89 81 50 0b
	00 00		 mov	 QWORD PTR [rcx+2896], rax

; 386  : 
; 387  :     s->d_desc.dyn_tree = s->dyn_dtree;

  0001c	48 8d 81 b0 09
	00 00		 lea	 rax, QWORD PTR [rcx+2480]
  00023	48 89 81 58 0b
	00 00		 mov	 QWORD PTR [rcx+2904], rax

; 388  :     s->d_desc.stat_desc = &static_d_desc;

  0002a	48 8d 05 00 00
	00 00		 lea	 rax, OFFSET FLAT:static_d_desc
  00031	48 89 81 68 0b
	00 00		 mov	 QWORD PTR [rcx+2920], rax

; 389  : 
; 390  :     s->bl_desc.dyn_tree = s->bl_tree;

  00038	48 8d 81 a4 0a
	00 00		 lea	 rax, QWORD PTR [rcx+2724]
  0003f	48 89 81 70 0b
	00 00		 mov	 QWORD PTR [rcx+2928], rax

; 391  :     s->bl_desc.stat_desc = &static_bl_desc;

  00046	48 8d 05 00 00
	00 00		 lea	 rax, OFFSET FLAT:static_bl_desc
  0004d	48 89 81 80 0b
	00 00		 mov	 QWORD PTR [rcx+2944], rax

; 392  : 
; 393  :     s->bi_buf = 0;

  00054	33 c0		 xor	 eax, eax
  00056	66 89 81 10 17
	00 00		 mov	 WORD PTR [rcx+5904], ax

; 394  :     s->bi_valid = 0;

  0005d	89 81 14 17 00
	00		 mov	 DWORD PTR [rcx+5908], eax

; 395  : #ifdef ZLIB_DEBUG
; 396  :     s->compressed_len = 0L;
; 397  :     s->bits_sent = 0L;
; 398  : #endif
; 399  : 
; 400  :     /* Initialize the first block of the first file: */
; 401  :     init_block(s);

  00063	e9 00 00 00 00	 jmp	 init_block
_tr_init ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT _tr_align
_TEXT	SEGMENT
s$ = 8
_tr_align PROC						; COMDAT

; 899  :     send_bits(s, STATIC_TREES<<1, 3);

  00000	41 bb 10 00 00
	00		 mov	 r11d, 16
  00006	4c 8b c9	 mov	 r9, rcx
  00009	8b 89 14 17 00
	00		 mov	 ecx, DWORD PTR [rcx+5908]
  0000f	45 8d 43 f2	 lea	 r8d, QWORD PTR [r11-14]
  00013	83 f9 0d	 cmp	 ecx, 13
  00016	7e 5c		 jle	 SHORT $LN2@tr_align
  00018	41 8b 51 28	 mov	 edx, DWORD PTR [r9+40]
  0001c	41 8b c0	 mov	 eax, r8d
  0001f	66 d3 e0	 shl	 ax, cl
  00022	66 41 09 81 10
	17 00 00	 or	 WORD PTR [r9+5904], ax
  0002a	41 0f b6 81 10
	17 00 00	 movzx	 eax, BYTE PTR [r9+5904]
  00032	49 8b 49 10	 mov	 rcx, QWORD PTR [r9+16]
  00036	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  00039	41 ff 41 28	 inc	 DWORD PTR [r9+40]
  0003d	41 8b 51 28	 mov	 edx, DWORD PTR [r9+40]
  00041	49 8b 49 10	 mov	 rcx, QWORD PTR [r9+16]
  00045	41 0f b6 81 11
	17 00 00	 movzx	 eax, BYTE PTR [r9+5905]
  0004d	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  00050	41 8b cb	 mov	 ecx, r11d
  00053	41 2a 89 14 17
	00 00		 sub	 cl, BYTE PTR [r9+5908]
  0005a	41 ff 41 28	 inc	 DWORD PTR [r9+40]
  0005e	66 41 d3 e8	 shr	 r8w, cl
  00062	41 83 81 14 17
	00 00 f3	 add	 DWORD PTR [r9+5908], -13
  0006a	66 45 89 81 10
	17 00 00	 mov	 WORD PTR [r9+5904], r8w
  00072	eb 16		 jmp	 SHORT $LN3@tr_align
$LN2@tr_align:
  00074	66 41 d3 e0	 shl	 r8w, cl
  00078	8d 41 03	 lea	 eax, DWORD PTR [rcx+3]
  0007b	66 45 09 81 10
	17 00 00	 or	 WORD PTR [r9+5904], r8w
  00083	41 89 81 14 17
	00 00		 mov	 DWORD PTR [r9+5908], eax
$LN3@tr_align:

; 900  :     send_code(s, END_BLOCK, static_ltree);

  0008a	41 8b 89 14 17
	00 00		 mov	 ecx, DWORD PTR [r9+5908]
  00091	45 33 d2	 xor	 r10d, r10d
  00094	83 f9 09	 cmp	 ecx, 9
  00097	7e 65		 jle	 SHORT $LN4@tr_align
  00099	45 8b 41 28	 mov	 r8d, DWORD PTR [r9+40]
  0009d	41 8b c2	 mov	 eax, r10d
  000a0	49 8b 51 10	 mov	 rdx, QWORD PTR [r9+16]
  000a4	66 d3 e0	 shl	 ax, cl
  000a7	66 41 09 81 10
	17 00 00	 or	 WORD PTR [r9+5904], ax
  000af	41 0f b6 81 10
	17 00 00	 movzx	 eax, BYTE PTR [r9+5904]
  000b7	41 88 04 10	 mov	 BYTE PTR [r8+rdx], al
  000bb	41 ff 41 28	 inc	 DWORD PTR [r9+40]
  000bf	45 8b 41 28	 mov	 r8d, DWORD PTR [r9+40]
  000c3	41 0f b6 81 11
	17 00 00	 movzx	 eax, BYTE PTR [r9+5905]
  000cb	49 8b 51 10	 mov	 rdx, QWORD PTR [r9+16]
  000cf	41 88 04 10	 mov	 BYTE PTR [r8+rdx], al
  000d3	45 2a 99 14 17
	00 00		 sub	 r11b, BYTE PTR [r9+5908]
  000da	41 ff 41 28	 inc	 DWORD PTR [r9+40]
  000de	41 0f b6 cb	 movzx	 ecx, r11b
  000e2	41 83 81 14 17
	00 00 f7	 add	 DWORD PTR [r9+5908], -9
  000ea	66 41 d3 ea	 shr	 r10w, cl

; 901  : #ifdef ZLIB_DEBUG
; 902  :     s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
; 903  : #endif
; 904  :     bi_flush(s);

  000ee	49 8b c9	 mov	 rcx, r9
  000f1	66 45 89 91 10
	17 00 00	 mov	 WORD PTR [r9+5904], r10w
  000f9	e9 00 00 00 00	 jmp	 bi_flush
$LN4@tr_align:

; 900  :     send_code(s, END_BLOCK, static_ltree);

  000fe	66 41 d3 e2	 shl	 r10w, cl
  00102	8d 41 07	 lea	 eax, DWORD PTR [rcx+7]
  00105	66 45 09 91 10
	17 00 00	 or	 WORD PTR [r9+5904], r10w

; 901  : #ifdef ZLIB_DEBUG
; 902  :     s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
; 903  : #endif
; 904  :     bi_flush(s);

  0010d	49 8b c9	 mov	 rcx, r9
  00110	41 89 81 14 17
	00 00		 mov	 DWORD PTR [r9+5908], eax
  00117	e9 00 00 00 00	 jmp	 bi_flush
_tr_align ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT tr_static_init
_TEXT	SEGMENT
tr_static_init PROC					; COMDAT

; 234  : #if defined(GEN_TREES_H) || !defined(STDC)
; 235  :     static int static_init_done = 0;
; 236  :     int n;        /* iterates over tree elements */
; 237  :     int bits;     /* bit counter */
; 238  :     int length;   /* length value */
; 239  :     int code;     /* code value */
; 240  :     int dist;     /* distance index */
; 241  :     ush bl_count[MAX_BITS+1];
; 242  :     /* number of codes at each bit length for an optimal tree */
; 243  : 
; 244  :     if (static_init_done) return;
; 245  : 
; 246  :     /* For some embedded targets, global variables are not initialized: */
; 247  : #ifdef NO_INIT_GLOBAL_POINTERS
; 248  :     static_l_desc.static_tree = static_ltree;
; 249  :     static_l_desc.extra_bits = extra_lbits;
; 250  :     static_d_desc.static_tree = static_dtree;
; 251  :     static_d_desc.extra_bits = extra_dbits;
; 252  :     static_bl_desc.extra_bits = extra_blbits;
; 253  : #endif
; 254  : 
; 255  :     /* Initialize the mapping length (0..255) -> length code (0..28) */
; 256  :     length = 0;
; 257  :     for (code = 0; code < LENGTH_CODES-1; code++) {
; 258  :         base_length[code] = length;
; 259  :         for (n = 0; n < (1<<extra_lbits[code]); n++) {
; 260  :             _length_code[length++] = (uch)code;
; 261  :         }
; 262  :     }
; 263  :     Assert (length == 256, "tr_static_init: length != 256");
; 264  :     /* Note that the length 255 (match length 258) can be represented
; 265  :      * in two different ways: code 284 + 5 bits or code 285, so we
; 266  :      * overwrite length_code[255] to use the best encoding:
; 267  :      */
; 268  :     _length_code[length-1] = (uch)code;
; 269  : 
; 270  :     /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
; 271  :     dist = 0;
; 272  :     for (code = 0 ; code < 16; code++) {
; 273  :         base_dist[code] = dist;
; 274  :         for (n = 0; n < (1<<extra_dbits[code]); n++) {
; 275  :             _dist_code[dist++] = (uch)code;
; 276  :         }
; 277  :     }
; 278  :     Assert (dist == 256, "tr_static_init: dist != 256");
; 279  :     dist >>= 7; /* from now on, all distances are divided by 128 */
; 280  :     for ( ; code < D_CODES; code++) {
; 281  :         base_dist[code] = dist << 7;
; 282  :         for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
; 283  :             _dist_code[256 + dist++] = (uch)code;
; 284  :         }
; 285  :     }
; 286  :     Assert (dist == 256, "tr_static_init: 256+dist != 512");
; 287  : 
; 288  :     /* Construct the codes of the static literal tree */
; 289  :     for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
; 290  :     n = 0;
; 291  :     while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
; 292  :     while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
; 293  :     while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
; 294  :     while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
; 295  :     /* Codes 286 and 287 do not exist, but we must include them in the
; 296  :      * tree construction to get a canonical Huffman tree (longest code
; 297  :      * all ones)
; 298  :      */
; 299  :     gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
; 300  : 
; 301  :     /* The static distance tree is trivial: */
; 302  :     for (n = 0; n < D_CODES; n++) {
; 303  :         static_dtree[n].Len = 5;
; 304  :         static_dtree[n].Code = bi_reverse((unsigned)n, 5);
; 305  :     }
; 306  :     static_init_done = 1;
; 307  : 
; 308  : #  ifdef GEN_TREES_H
; 309  :     gen_trees_header();
; 310  : #  endif
; 311  : #endif /* defined(GEN_TREES_H) || !defined(STDC) */
; 312  : }

  00000	c2 00 00	 ret	 0
tr_static_init ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT init_block
_TEXT	SEGMENT
s$ = 8
init_block PROC						; COMDAT

; 410  :     int n; /* iterates over tree elements */
; 411  : 
; 412  :     /* Initialize the trees. */
; 413  :     for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;

  00000	48 8d 81 bc 00
	00 00		 lea	 rax, QWORD PTR [rcx+188]
  00007	ba 1e 01 00 00	 mov	 edx, 286		; 0000011eH
  0000c	45 33 c0	 xor	 r8d, r8d
  0000f	90		 npad	 1
$LL4@init_block:
  00010	66 44 89 00	 mov	 WORD PTR [rax], r8w
  00014	48 8d 40 04	 lea	 rax, QWORD PTR [rax+4]
  00018	48 83 ea 01	 sub	 rdx, 1
  0001c	75 f2		 jne	 SHORT $LL4@init_block

; 414  :     for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;

  0001e	48 8d 81 b0 09
	00 00		 lea	 rax, QWORD PTR [rcx+2480]
  00025	ba 1e 00 00 00	 mov	 edx, 30
  0002a	66 0f 1f 44 00
	00		 npad	 6
$LL7@init_block:
  00030	66 44 89 00	 mov	 WORD PTR [rax], r8w
  00034	48 8d 40 04	 lea	 rax, QWORD PTR [rax+4]
  00038	48 83 ea 01	 sub	 rdx, 1
  0003c	75 f2		 jne	 SHORT $LL7@init_block

; 415  :     for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;

  0003e	48 8d 81 a4 0a
	00 00		 lea	 rax, QWORD PTR [rcx+2724]
  00045	ba 13 00 00 00	 mov	 edx, 19
  0004a	66 0f 1f 44 00
	00		 npad	 6
$LL10@init_block:
  00050	66 44 89 00	 mov	 WORD PTR [rax], r8w
  00054	48 8d 40 04	 lea	 rax, QWORD PTR [rax+4]
  00058	48 83 ea 01	 sub	 rdx, 1
  0005c	75 f2		 jne	 SHORT $LL10@init_block

; 416  : 
; 417  :     s->dyn_ltree[END_BLOCK].Freq = 1;

  0005e	b8 01 00 00 00	 mov	 eax, 1

; 418  :     s->opt_len = s->static_len = 0L;

  00063	4c 89 81 00 17
	00 00		 mov	 QWORD PTR [rcx+5888], r8
  0006a	66 89 81 bc 04
	00 00		 mov	 WORD PTR [rcx+1212], ax

; 419  :     s->last_lit = s->matches = 0;

  00071	44 89 81 08 17
	00 00		 mov	 DWORD PTR [rcx+5896], r8d
  00078	44 89 81 f4 16
	00 00		 mov	 DWORD PTR [rcx+5876], r8d

; 420  : }

  0007f	c3		 ret	 0
init_block ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT pqdownheap
_TEXT	SEGMENT
s$ = 16
tree$ = 24
k$ = 32
pqdownheap PROC						; COMDAT

; 455  : {

  00000	48 89 74 24 18	 mov	 QWORD PTR [rsp+24], rsi
  00005	57		 push	 rdi

; 456  :     int v = s->heap[k];

  00006	49 63 c0	 movsxd	 rax, r8d

; 457  :     int j = k << 1;  /* left son of k */

  00009	47 8d 0c 00	 lea	 r9d, DWORD PTR [r8+r8]
  0000d	48 8b fa	 mov	 rdi, rdx
  00010	48 63 b4 81 a8
	0b 00 00	 movsxd	 rsi, DWORD PTR [rcx+rax*4+2984]

; 458  :     while (j <= s->heap_len) {

  00018	8b 81 9c 14 00
	00		 mov	 eax, DWORD PTR [rcx+5276]
  0001e	44 3b c8	 cmp	 r9d, eax
  00021	0f 8f d1 00 00
	00		 jg	 $LN16@pqdownheap
  00027	48 89 6c 24 18	 mov	 QWORD PTR [rsp+24], rbp
  0002c	48 89 5c 24 10	 mov	 QWORD PTR [rsp+16], rbx
$LN20@pqdownheap:

; 459  :         /* Set j to the smallest of the two sons: */
; 460  :         if (j < s->heap_len &&

  00031	7d 41		 jge	 SHORT $LN4@pqdownheap
  00033	41 8d 51 01	 lea	 edx, DWORD PTR [r9+1]
  00037	48 63 c2	 movsxd	 rax, edx
  0003a	4c 63 9c 81 a8
	0b 00 00	 movsxd	 r11, DWORD PTR [rcx+rax*4+2984]
  00042	49 63 c1	 movsxd	 rax, r9d
  00045	48 63 9c 81 a8
	0b 00 00	 movsxd	 rbx, DWORD PTR [rcx+rax*4+2984]
  0004d	42 0f b7 04 9f	 movzx	 eax, WORD PTR [rdi+r11*4]
  00052	44 0f b7 14 9f	 movzx	 r10d, WORD PTR [rdi+rbx*4]
  00057	66 41 3b c2	 cmp	 ax, r10w
  0005b	72 14		 jb	 SHORT $LN5@pqdownheap
  0005d	75 15		 jne	 SHORT $LN4@pqdownheap
  0005f	0f b6 84 0b a4
	14 00 00	 movzx	 eax, BYTE PTR [rbx+rcx+5284]
  00067	41 38 84 0b a4
	14 00 00	 cmp	 BYTE PTR [r11+rcx+5284], al
  0006f	77 03		 ja	 SHORT $LN4@pqdownheap
$LN5@pqdownheap:

; 461  :             smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
; 462  :             j++;

  00071	44 8b ca	 mov	 r9d, edx
$LN4@pqdownheap:

; 463  :         }
; 464  :         /* Exit if v is smaller than both sons */
; 465  :         if (smaller(tree, v, s->heap[j], s->depth)) break;

  00074	49 63 c1	 movsxd	 rax, r9d
  00077	4c 63 9c 81 a8
	0b 00 00	 movsxd	 r11, DWORD PTR [rcx+rax*4+2984]
  0007f	0f b7 04 b7	 movzx	 eax, WORD PTR [rdi+rsi*4]
  00083	4d 8b d3	 mov	 r10, r11
  00086	42 0f b7 14 9f	 movzx	 edx, WORD PTR [rdi+r11*4]
  0008b	66 3b c2	 cmp	 ax, dx
  0008e	72 4d		 jb	 SHORT $LN14@pqdownheap
  00090	75 12		 jne	 SHORT $LN6@pqdownheap
  00092	41 0f b6 84 0b
	a4 14 00 00	 movzx	 eax, BYTE PTR [r11+rcx+5284]
  0009b	38 84 31 a4 14
	00 00		 cmp	 BYTE PTR [rcx+rsi+5284], al
  000a2	76 39		 jbe	 SHORT $LN14@pqdownheap
$LN6@pqdownheap:

; 466  : 
; 467  :         /* Exchange v with the smallest son */
; 468  :         s->heap[k] = s->heap[j];  k = j;

  000a4	49 63 c0	 movsxd	 rax, r8d
  000a7	4d 63 c1	 movsxd	 r8, r9d

; 469  : 
; 470  :         /* And continue down the tree, setting j to the left son of k */
; 471  :         j <<= 1;

  000aa	45 03 c9	 add	 r9d, r9d
  000ad	44 89 9c 81 a8
	0b 00 00	 mov	 DWORD PTR [rcx+rax*4+2984], r11d
  000b5	8b 81 9c 14 00
	00		 mov	 eax, DWORD PTR [rcx+5276]
  000bb	44 3b c8	 cmp	 r9d, eax
  000be	0f 8e 6d ff ff
	ff		 jle	 $LN20@pqdownheap

; 472  :     }
; 473  :     s->heap[k] = v;

  000c4	48 8b 5c 24 10	 mov	 rbx, QWORD PTR [rsp+16]
  000c9	48 8b 6c 24 18	 mov	 rbp, QWORD PTR [rsp+24]
  000ce	42 89 b4 81 a8
	0b 00 00	 mov	 DWORD PTR [rcx+r8*4+2984], esi

; 474  : }

  000d6	48 8b 74 24 20	 mov	 rsi, QWORD PTR [rsp+32]
  000db	5f		 pop	 rdi
  000dc	c3		 ret	 0
$LN14@pqdownheap:
  000dd	48 8b 5c 24 10	 mov	 rbx, QWORD PTR [rsp+16]
  000e2	48 8b 6c 24 18	 mov	 rbp, QWORD PTR [rsp+24]

; 472  :     }
; 473  :     s->heap[k] = v;

  000e7	49 63 c0	 movsxd	 rax, r8d
  000ea	89 b4 81 a8 0b
	00 00		 mov	 DWORD PTR [rcx+rax*4+2984], esi

; 474  : }

  000f1	48 8b 74 24 20	 mov	 rsi, QWORD PTR [rsp+32]
  000f6	5f		 pop	 rdi
  000f7	c3		 ret	 0
$LN16@pqdownheap:

; 472  :     }
; 473  :     s->heap[k] = v;

  000f8	49 63 c0	 movsxd	 rax, r8d
  000fb	89 b4 81 a8 0b
	00 00		 mov	 DWORD PTR [rcx+rax*4+2984], esi

; 474  : }

  00102	48 8b 74 24 20	 mov	 rsi, QWORD PTR [rsp+32]
  00107	5f		 pop	 rdi
  00108	c3		 ret	 0
pqdownheap ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT gen_bitlen
_TEXT	SEGMENT
h$1$ = 48
s$ = 48
desc$ = 56
gen_bitlen PROC						; COMDAT

; 489  : {

  00000	48 89 5c 24 18	 mov	 QWORD PTR [rsp+24], rbx
  00005	48 89 6c 24 20	 mov	 QWORD PTR [rsp+32], rbp
  0000a	56		 push	 rsi
  0000b	57		 push	 rdi
  0000c	41 54		 push	 r12
  0000e	41 55		 push	 r13
  00010	41 57		 push	 r15

; 490  :     ct_data *tree        = desc->dyn_tree;
; 491  :     int max_code         = desc->max_code;
; 492  :     const ct_data *stree = desc->stat_desc->static_tree;

  00012	48 8b 42 10	 mov	 rax, QWORD PTR [rdx+16]
  00016	48 8d b9 88 0b
	00 00		 lea	 rdi, QWORD PTR [rcx+2952]
  0001d	48 8b 32	 mov	 rsi, QWORD PTR [rdx]
  00020	4c 8b c1	 mov	 r8, rcx
  00023	8b 5a 08	 mov	 ebx, DWORD PTR [rdx+8]

; 496  :     int h;              /* heap index */
; 497  :     int n, m;           /* iterate over the tree elements */
; 498  :     int bits;           /* bit length */
; 499  :     int xbits;          /* extra bits */
; 500  :     ush f;              /* frequency */
; 501  :     int overflow = 0;   /* number of elements with bit length too large */
; 502  : 
; 503  :     for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;

  00026	b9 10 00 00 00	 mov	 ecx, 16
  0002b	33 d2		 xor	 edx, edx

; 504  : 
; 505  :     /* In a first pass, compute the optimal bit lengths (which may
; 506  :      * overflow in the case of the bit length tree).
; 507  :      */
; 508  :     tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
; 509  : 
; 510  :     for (h = s->heap_max+1; h < HEAP_SIZE; h++) {

  0002d	bd 3d 02 00 00	 mov	 ebp, 573		; 0000023dH
  00032	4c 8b 38	 mov	 r15, QWORD PTR [rax]
  00035	44 8b d2	 mov	 r10d, edx
  00038	4c 8b 68 08	 mov	 r13, QWORD PTR [rax+8]
  0003c	44 8b 60 10	 mov	 r12d, DWORD PTR [rax+16]
  00040	4c 63 48 18	 movsxd	 r9, DWORD PTR [rax+24]
  00044	0f b7 c2	 movzx	 eax, dx
  00047	66 f3 ab	 rep stosw
  0004a	49 63 80 a0 14
	00 00		 movsxd	 rax, DWORD PTR [r8+5280]
  00051	49 63 8c 80 a8
	0b 00 00	 movsxd	 rcx, DWORD PTR [r8+rax*4+2984]
  00059	66 89 54 8e 02	 mov	 WORD PTR [rsi+rcx*4+2], dx
  0005e	41 8b 88 a0 14
	00 00		 mov	 ecx, DWORD PTR [r8+5280]
  00065	ff c1		 inc	 ecx
  00067	48 63 c1	 movsxd	 rax, ecx
  0006a	48 3b c5	 cmp	 rax, rbp
  0006d	0f 8d 7d 01 00
	00		 jge	 $LN14@gen_bitlen
  00073	48 2b e8	 sub	 rbp, rax
  00076	4c 89 74 24 38	 mov	 QWORD PTR [rsp+56], r14
  0007b	03 cd		 add	 ecx, ebp
  0007d	4d 8d 98 a8 0b
	00 00		 lea	 r11, QWORD PTR [r8+2984]
  00084	89 4c 24 30	 mov	 DWORD PTR h$1$[rsp], ecx
  00088	4d 8d 1c 83	 lea	 r11, QWORD PTR [r11+rax*4]
  0008c	0f 1f 40 00	 npad	 4
$LL7@gen_bitlen:

; 511  :         n = s->heap[h];

  00090	49 63 13	 movsxd	 rdx, DWORD PTR [r11]

; 512  :         bits = tree[tree[n].Dad].Len + 1;

  00093	4c 8d 34 95 00
	00 00 00	 lea	 r14, QWORD PTR [rdx*4]
  0009b	41 0f b7 44 36
	02		 movzx	 eax, WORD PTR [r14+rsi+2]
  000a1	0f b7 4c 86 02	 movzx	 ecx, WORD PTR [rsi+rax*4+2]
  000a6	ff c1		 inc	 ecx

; 513  :         if (bits > max_length) bits = max_length, overflow++;

  000a8	41 3b c9	 cmp	 ecx, r9d
  000ab	7e 06		 jle	 SHORT $LN18@gen_bitlen
  000ad	41 8b c9	 mov	 ecx, r9d
  000b0	41 ff c2	 inc	 r10d
$LN18@gen_bitlen:

; 514  :         tree[n].Len = (ush)bits;

  000b3	66 41 89 4c 36
	02		 mov	 WORD PTR [r14+rsi+2], cx

; 515  :         /* We overwrite tree[n].Dad which is no longer needed */
; 516  : 
; 517  :         if (n > max_code) continue; /* not a leaf node */

  000b9	3b d3		 cmp	 edx, ebx
  000bb	7f 47		 jg	 SHORT $LN5@gen_bitlen

; 518  : 
; 519  :         s->bl_count[bits]++;

  000bd	48 63 c1	 movsxd	 rax, ecx

; 520  :         xbits = 0;

  000c0	33 ff		 xor	 edi, edi
  000c2	66 41 ff 84 40
	88 0b 00 00	 inc	 WORD PTR [r8+rax*2+2952]

; 521  :         if (n >= base) xbits = extra[n-base];

  000cb	41 3b d4	 cmp	 edx, r12d
  000ce	7c 0b		 jl	 SHORT $LN20@gen_bitlen
  000d0	41 2b d4	 sub	 edx, r12d
  000d3	48 63 c2	 movsxd	 rax, edx
  000d6	41 8b 7c 85 00	 mov	 edi, DWORD PTR [r13+rax*4]
$LN20@gen_bitlen:

; 522  :         f = tree[n].Freq;
; 523  :         s->opt_len += (ulg)f * (unsigned)(bits + xbits);

  000db	41 0f b7 14 36	 movzx	 edx, WORD PTR [r14+rsi]
  000e0	8d 04 0f	 lea	 eax, DWORD PTR [rdi+rcx]
  000e3	0f af c2	 imul	 eax, edx
  000e6	41 01 80 00 17
	00 00		 add	 DWORD PTR [r8+5888], eax

; 524  :         if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);

  000ed	4d 85 ff	 test	 r15, r15
  000f0	74 12		 je	 SHORT $LN5@gen_bitlen
  000f2	43 0f b7 44 3e
	02		 movzx	 eax, WORD PTR [r14+r15+2]
  000f8	03 c7		 add	 eax, edi
  000fa	0f af c2	 imul	 eax, edx
  000fd	41 01 80 04 17
	00 00		 add	 DWORD PTR [r8+5892], eax
$LN5@gen_bitlen:

; 504  : 
; 505  :     /* In a first pass, compute the optimal bit lengths (which may
; 506  :      * overflow in the case of the bit length tree).
; 507  :      */
; 508  :     tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
; 509  : 
; 510  :     for (h = s->heap_max+1; h < HEAP_SIZE; h++) {

  00104	49 83 c3 04	 add	 r11, 4
  00108	48 83 ed 01	 sub	 rbp, 1
  0010c	75 82		 jne	 SHORT $LL7@gen_bitlen

; 525  :     }
; 526  :     if (overflow == 0) return;

  0010e	4c 8b 74 24 38	 mov	 r14, QWORD PTR [rsp+56]
  00113	45 85 d2	 test	 r10d, r10d
  00116	0f 84 d4 00 00
	00		 je	 $LN14@gen_bitlen

; 493  :     const intf *extra    = desc->stat_desc->extra_bits;
; 494  :     int base             = desc->stat_desc->extra_base;
; 495  :     int max_length       = desc->stat_desc->max_length;

  0011c	41 8d 79 ff	 lea	 edi, DWORD PTR [r9-1]
  00120	41 bb ff ff 00
	00		 mov	 r11d, 65535		; 0000ffffH
  00126	4b 8d 14 48	 lea	 rdx, QWORD PTR [r8+r9*2]
  0012a	66 0f 1f 44 00
	00		 npad	 6
$LL10@gen_bitlen:

; 527  : 
; 528  :     Tracev((stderr,"\nbit length overflow\n"));
; 529  :     /* This happens for example on obj2 and pic of the Calgary corpus */
; 530  : 
; 531  :     /* Find the first bit length which could increase: */
; 532  :     do {
; 533  :         bits = max_length-1;

  00130	48 63 cf	 movsxd	 rcx, edi

; 534  :         while (s->bl_count[bits] == 0) bits--;

  00133	66 41 83 bc 48
	88 0b 00 00 00	 cmp	 WORD PTR [r8+rcx*2+2952], 0
  0013d	75 12		 jne	 SHORT $LN12@gen_bitlen
  0013f	90		 npad	 1
$LL11@gen_bitlen:
  00140	ff c9		 dec	 ecx
  00142	48 63 c1	 movsxd	 rax, ecx
  00145	66 41 83 bc 40
	88 0b 00 00 00	 cmp	 WORD PTR [r8+rax*2+2952], 0
  0014f	74 ef		 je	 SHORT $LL11@gen_bitlen
$LN12@gen_bitlen:

; 535  :         s->bl_count[bits]--;      /* move one leaf down the tree */

  00151	48 63 c1	 movsxd	 rax, ecx

; 536  :         s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
; 537  :         s->bl_count[max_length]--;
; 538  :         /* The brother of the overflow item also moves one step up,
; 539  :          * but this does not affect bl_count[max_length]
; 540  :          */
; 541  :         overflow -= 2;

  00154	41 83 ea 02	 sub	 r10d, 2
  00158	66 45 01 9c 40
	88 0b 00 00	 add	 WORD PTR [r8+rax*2+2952], r11w
  00161	8d 41 01	 lea	 eax, DWORD PTR [rcx+1]
  00164	48 63 c8	 movsxd	 rcx, eax
  00167	66 41 83 84 48
	88 0b 00 00 02	 add	 WORD PTR [r8+rcx*2+2952], 2
  00171	66 44 01 9a 88
	0b 00 00	 add	 WORD PTR [rdx+2952], r11w

; 542  :     } while (overflow > 0);

  00179	45 85 d2	 test	 r10d, r10d
  0017c	7f b2		 jg	 SHORT $LL10@gen_bitlen

; 543  : 
; 544  :     /* Now recompute all bit lengths, scanning in increasing frequency.
; 545  :      * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
; 546  :      * lengths instead of fixing only the wrong ones. This idea is taken
; 547  :      * from 'ar' written by Haruhiko Okumura.)
; 548  :      */
; 549  :     for (bits = max_length; bits != 0; bits--) {

  0017e	45 85 c9	 test	 r9d, r9d
  00181	74 6d		 je	 SHORT $LN14@gen_bitlen
  00183	4c 63 5c 24 30	 movsxd	 r11, DWORD PTR h$1$[rsp]
  00188	0f 1f 84 00 00
	00 00 00	 npad	 8
$LL15@gen_bitlen:

; 550  :         n = s->bl_count[bits];

  00190	49 63 c1	 movsxd	 rax, r9d
  00193	41 0f b7 94 40
	88 0b 00 00	 movzx	 edx, WORD PTR [r8+rax*2+2952]
  0019c	85 d2		 test	 edx, edx

; 551  :         while (n != 0) {

  0019e	74 4a		 je	 SHORT $LN13@gen_bitlen

; 550  :         n = s->bl_count[bits];

  001a0	4d 8d 90 a8 0b
	00 00		 lea	 r10, QWORD PTR [r8+2984]
  001a7	4f 8d 14 9a	 lea	 r10, QWORD PTR [r10+r11*4]
  001ab	0f 1f 44 00 00	 npad	 5
$LL16@gen_bitlen:

; 552  :             m = s->heap[--h];

  001b0	49 63 42 fc	 movsxd	 rax, DWORD PTR [r10-4]
  001b4	4d 8d 52 fc	 lea	 r10, QWORD PTR [r10-4]
  001b8	49 ff cb	 dec	 r11

; 553  :             if (m > max_code) continue;

  001bb	3b c3		 cmp	 eax, ebx
  001bd	7f 27		 jg	 SHORT $LN36@gen_bitlen

; 554  :             if ((unsigned) tree[m].Len != (unsigned) bits) {

  001bf	48 8d 3c 86	 lea	 rdi, QWORD PTR [rsi+rax*4]
  001c3	0f b7 44 86 02	 movzx	 eax, WORD PTR [rsi+rax*4+2]
  001c8	41 3b c1	 cmp	 eax, r9d
  001cb	74 17		 je	 SHORT $LN24@gen_bitlen

; 555  :                 Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
; 556  :                 s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;

  001cd	41 8b c9	 mov	 ecx, r9d
  001d0	2b c8		 sub	 ecx, eax
  001d2	0f b7 07	 movzx	 eax, WORD PTR [rdi]
  001d5	0f af c8	 imul	 ecx, eax
  001d8	41 01 88 00 17
	00 00		 add	 DWORD PTR [r8+5888], ecx

; 557  :                 tree[m].Len = (ush)bits;

  001df	66 44 89 4f 02	 mov	 WORD PTR [rdi+2], r9w
$LN24@gen_bitlen:

; 558  :             }
; 559  :             n--;

  001e4	ff ca		 dec	 edx
$LN36@gen_bitlen:

; 551  :         while (n != 0) {

  001e6	85 d2		 test	 edx, edx
  001e8	75 c6		 jne	 SHORT $LL16@gen_bitlen
$LN13@gen_bitlen:

; 543  : 
; 544  :     /* Now recompute all bit lengths, scanning in increasing frequency.
; 545  :      * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
; 546  :      * lengths instead of fixing only the wrong ones. This idea is taken
; 547  :      * from 'ar' written by Haruhiko Okumura.)
; 548  :      */
; 549  :     for (bits = max_length; bits != 0; bits--) {

  001ea	41 83 e9 01	 sub	 r9d, 1
  001ee	75 a0		 jne	 SHORT $LL15@gen_bitlen
$LN14@gen_bitlen:

; 560  :         }
; 561  :     }
; 562  : }

  001f0	48 8b 5c 24 40	 mov	 rbx, QWORD PTR [rsp+64]
  001f5	48 8b 6c 24 48	 mov	 rbp, QWORD PTR [rsp+72]
  001fa	41 5f		 pop	 r15
  001fc	41 5d		 pop	 r13
  001fe	41 5c		 pop	 r12
  00200	5f		 pop	 rdi
  00201	5e		 pop	 rsi
  00202	c3		 ret	 0
gen_bitlen ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT gen_codes
_TEXT	SEGMENT
next_code$ = 32
tree$ = 80
max_code$ = 88
bl_count$ = 96
gen_codes PROC						; COMDAT

; 576  : {

  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 40	 sub	 rsp, 64			; 00000040H

; 577  :     ush next_code[MAX_BITS+1]; /* next code value for each bit length */
; 578  :     unsigned code = 0;         /* running code value */

  0000a	45 33 c9	 xor	 r9d, r9d
  0000d	48 63 fa	 movsxd	 rdi, edx

; 579  :     int bits;                  /* bit index */
; 580  :     int n;                     /* code index */
; 581  : 
; 582  :     /* The distribution counts are first used to generate the code values
; 583  :      * without bit reversal.
; 584  :      */
; 585  :     for (bits = 1; bits <= MAX_BITS; bits++) {

  00010	48 8d 44 24 22	 lea	 rax, QWORD PTR next_code$[rsp+2]
  00015	45 8b d1	 mov	 r10d, r9d
  00018	4c 2b c0	 sub	 r8, rax
  0001b	48 8b d9	 mov	 rbx, rcx
  0001e	41 bb 01 00 00
	00		 mov	 r11d, 1
  00024	0f 1f 40 00 0f
	1f 84 00 00 00
	00 00		 npad	 12
$LL14@gen_codes:
  00030	4b 8d 04 58	 lea	 rax, QWORD PTR [r8+r11*2]

; 586  :         code = (code + bl_count[bits-1]) << 1;

  00034	0f b7 54 04 20	 movzx	 edx, WORD PTR next_code$[rsp+rax]
  00039	44 03 d2	 add	 r10d, edx
  0003c	45 03 d2	 add	 r10d, r10d

; 587  :         next_code[bits] = (ush)code;

  0003f	66 46 89 54 5c
	20		 mov	 WORD PTR next_code$[rsp+r11*2], r10w
  00045	49 ff c3	 inc	 r11
  00048	49 83 fb 0f	 cmp	 r11, 15
  0004c	7e e2		 jle	 SHORT $LL14@gen_codes

; 588  :     }
; 589  :     /* Check that the bit counts in bl_count are consistent. The last code
; 590  :      * must be all ones.
; 591  :      */
; 592  :     Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
; 593  :             "inconsistent bit counts");
; 594  :     Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
; 595  : 
; 596  :     for (n = 0;  n <= max_code; n++) {

  0004e	85 ff		 test	 edi, edi
  00050	78 31		 js	 SHORT $LN6@gen_codes
$LL7@gen_codes:

; 597  :         int len = tree[n].Len;

  00052	42 0f b7 54 8b
	02		 movzx	 edx, WORD PTR [rbx+r9*4+2]
  00058	85 d2		 test	 edx, edx

; 598  :         if (len == 0) continue;

  0005a	74 1f		 je	 SHORT $LN5@gen_codes

; 599  :         /* Now reverse the bits */
; 600  :         tree[n].Code = (ush)bi_reverse(next_code[len]++, len);

  0005c	4c 8d 44 24 20	 lea	 r8, QWORD PTR next_code$[rsp]
  00061	41 0f b7 0c 50	 movzx	 ecx, WORD PTR [r8+rdx*2]
  00066	4d 8d 04 50	 lea	 r8, QWORD PTR [r8+rdx*2]
  0006a	8d 41 01	 lea	 eax, DWORD PTR [rcx+1]
  0006d	66 41 89 00	 mov	 WORD PTR [r8], ax
  00071	e8 00 00 00 00	 call	 bi_reverse
  00076	66 42 89 04 8b	 mov	 WORD PTR [rbx+r9*4], ax
$LN5@gen_codes:

; 588  :     }
; 589  :     /* Check that the bit counts in bl_count are consistent. The last code
; 590  :      * must be all ones.
; 591  :      */
; 592  :     Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
; 593  :             "inconsistent bit counts");
; 594  :     Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
; 595  : 
; 596  :     for (n = 0;  n <= max_code; n++) {

  0007b	49 ff c1	 inc	 r9
  0007e	4c 3b cf	 cmp	 r9, rdi
  00081	7e cf		 jle	 SHORT $LL7@gen_codes
$LN6@gen_codes:

; 601  : 
; 602  :         Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
; 603  :              n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
; 604  :     }
; 605  : }

  00083	48 8b 5c 24 50	 mov	 rbx, QWORD PTR [rsp+80]
  00088	48 83 c4 40	 add	 rsp, 64			; 00000040H
  0008c	5f		 pop	 rdi
  0008d	c3		 ret	 0
gen_codes ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT build_tree
_TEXT	SEGMENT
s$ = 64
desc$ = 72
build_tree PROC						; COMDAT

; 618  : {

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

; 619  :     ct_data *tree         = desc->dyn_tree;
; 620  :     const ct_data *stree  = desc->stat_desc->static_tree;

  0001e	48 8b 42 10	 mov	 rax, QWORD PTR [rdx+16]
  00022	4c 8b fa	 mov	 r15, rdx
  00025	48 8b 32	 mov	 rsi, QWORD PTR [rdx]

; 621  :     int elems             = desc->stat_desc->elems;
; 622  :     int n, m;          /* iterate over heap elements */
; 623  :     int max_code = -1; /* largest code with non zero frequency */

  00028	83 cd ff	 or	 ebp, -1

; 624  :     int node;          /* new node being created */
; 625  : 
; 626  :     /* Construct the initial heap, with least frequent element in
; 627  :      * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
; 628  :      * heap[0] is not used.
; 629  :      */
; 630  :     s->heap_len = 0, s->heap_max = HEAP_SIZE;

  0002b	33 d2		 xor	 edx, edx
  0002d	48 8b d9	 mov	 rbx, rcx

; 631  : 
; 632  :     for (n = 0; n < elems; n++) {

  00030	44 8b c2	 mov	 r8d, edx
  00033	4c 63 70 14	 movsxd	 r14, DWORD PTR [rax+20]
  00037	4c 8b 10	 mov	 r10, QWORD PTR [rax]
  0003a	89 91 9c 14 00
	00		 mov	 DWORD PTR [rcx+5276], edx
  00040	c7 81 a0 14 00
	00 3d 02 00 00	 mov	 DWORD PTR [rcx+5280], 573 ; 0000023dH
  0004a	8b ca		 mov	 ecx, edx
  0004c	45 85 f6	 test	 r14d, r14d
  0004f	7e 37		 jle	 SHORT $LN22@build_tree
$LL4@build_tree:

; 633  :         if (tree[n].Freq != 0) {

  00051	66 39 14 8e	 cmp	 WORD PTR [rsi+rcx*4], dx
  00055	74 21		 je	 SHORT $LN13@build_tree

; 634  :             s->heap[++(s->heap_len)] = max_code = n;

  00057	ff 83 9c 14 00
	00		 inc	 DWORD PTR [rbx+5276]
  0005d	41 8b e8	 mov	 ebp, r8d
  00060	48 63 83 9c 14
	00 00		 movsxd	 rax, DWORD PTR [rbx+5276]
  00067	44 89 84 83 a8
	0b 00 00	 mov	 DWORD PTR [rbx+rax*4+2984], r8d

; 635  :             s->depth[n] = 0;

  0006f	88 94 19 a4 14
	00 00		 mov	 BYTE PTR [rcx+rbx+5284], dl

; 636  :         } else {

  00076	eb 05		 jmp	 SHORT $LN2@build_tree
$LN13@build_tree:

; 637  :             tree[n].Len = 0;

  00078	66 89 54 8e 02	 mov	 WORD PTR [rsi+rcx*4+2], dx
$LN2@build_tree:

; 631  : 
; 632  :     for (n = 0; n < elems; n++) {

  0007d	41 ff c0	 inc	 r8d
  00080	48 ff c1	 inc	 rcx
  00083	49 3b ce	 cmp	 rcx, r14
  00086	7c c9		 jl	 SHORT $LL4@build_tree
$LN22@build_tree:

; 638  :         }
; 639  :     }
; 640  : 
; 641  :     /* The pkzip format requires that at least one distance code exists,
; 642  :      * and that at least one bit should be sent even if there is only one
; 643  :      * possible code. So to avoid special checks later on we force at least
; 644  :      * two codes of non zero frequency.
; 645  :      */
; 646  :     while (s->heap_len < 2) {

  00088	83 bb 9c 14 00
	00 02		 cmp	 DWORD PTR [rbx+5276], 2
  0008f	41 bc 01 00 00
	00		 mov	 r12d, 1
  00095	7d 50		 jge	 SHORT $LN6@build_tree
$LL5@build_tree:

; 647  :         node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);

  00097	83 fd 02	 cmp	 ebp, 2
  0009a	7d 06		 jge	 SHORT $LN17@build_tree
  0009c	ff c5		 inc	 ebp
  0009e	8b cd		 mov	 ecx, ebp
  000a0	eb 02		 jmp	 SHORT $LN18@build_tree
$LN17@build_tree:
  000a2	8b ca		 mov	 ecx, edx
$LN18@build_tree:
  000a4	ff 83 9c 14 00
	00		 inc	 DWORD PTR [rbx+5276]
  000aa	48 63 83 9c 14
	00 00		 movsxd	 rax, DWORD PTR [rbx+5276]
  000b1	89 8c 83 a8 0b
	00 00		 mov	 DWORD PTR [rbx+rax*4+2984], ecx

; 648  :         tree[node].Freq = 1;

  000b8	48 63 c1	 movsxd	 rax, ecx
  000bb	66 44 89 24 86	 mov	 WORD PTR [rsi+rax*4], r12w

; 649  :         s->depth[node] = 0;

  000c0	88 94 18 a4 14
	00 00		 mov	 BYTE PTR [rax+rbx+5284], dl

; 650  :         s->opt_len--; if (stree) s->static_len -= stree[node].Len;

  000c7	ff 8b 00 17 00
	00		 dec	 DWORD PTR [rbx+5888]
  000cd	4d 85 d2	 test	 r10, r10
  000d0	74 0c		 je	 SHORT $LN15@build_tree
  000d2	41 0f b7 44 82
	02		 movzx	 eax, WORD PTR [r10+rax*4+2]
  000d8	29 83 04 17 00
	00		 sub	 DWORD PTR [rbx+5892], eax
$LN15@build_tree:

; 638  :         }
; 639  :     }
; 640  : 
; 641  :     /* The pkzip format requires that at least one distance code exists,
; 642  :      * and that at least one bit should be sent even if there is only one
; 643  :      * possible code. So to avoid special checks later on we force at least
; 644  :      * two codes of non zero frequency.
; 645  :      */
; 646  :     while (s->heap_len < 2) {

  000de	83 bb 9c 14 00
	00 02		 cmp	 DWORD PTR [rbx+5276], 2
  000e5	7c b0		 jl	 SHORT $LL5@build_tree
$LN6@build_tree:

; 651  :         /* node is 0 or 1 so it does not have extra bits */
; 652  :     }
; 653  :     desc->max_code = max_code;

  000e7	41 89 6f 08	 mov	 DWORD PTR [r15+8], ebp

; 654  : 
; 655  :     /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
; 656  :      * establish sub-heaps of increasing lengths:
; 657  :      */
; 658  :     for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);

  000eb	8b 83 9c 14 00
	00		 mov	 eax, DWORD PTR [rbx+5276]
  000f1	99		 cdq
  000f2	2b c2		 sub	 eax, edx
  000f4	d1 f8		 sar	 eax, 1
  000f6	8b f8		 mov	 edi, eax
  000f8	41 3b c4	 cmp	 eax, r12d
  000fb	7c 18		 jl	 SHORT $LL12@build_tree
  000fd	0f 1f 00	 npad	 3
$LL9@build_tree:
  00100	44 8b c7	 mov	 r8d, edi
  00103	48 8b d6	 mov	 rdx, rsi
  00106	48 8b cb	 mov	 rcx, rbx
  00109	e8 00 00 00 00	 call	 pqdownheap
  0010e	ff cf		 dec	 edi
  00110	41 3b fc	 cmp	 edi, r12d
  00113	7d eb		 jge	 SHORT $LL9@build_tree
$LL12@build_tree:

; 659  : 
; 660  :     /* Construct the Huffman tree by repeatedly combining the least two
; 661  :      * frequent nodes.
; 662  :      */
; 663  :     node = elems;              /* next internal node of the tree */
; 664  :     do {
; 665  :         pqremove(s, tree, n);  /* n = node of least frequency */

  00115	48 63 83 9c 14
	00 00		 movsxd	 rax, DWORD PTR [rbx+5276]
  0011c	45 8b c4	 mov	 r8d, r12d
  0011f	48 63 bb ac 0b
	00 00		 movsxd	 rdi, DWORD PTR [rbx+2988]
  00126	48 8b d6	 mov	 rdx, rsi
  00129	8b 8c 83 a8 0b
	00 00		 mov	 ecx, DWORD PTR [rbx+rax*4+2984]
  00130	89 8b ac 0b 00
	00		 mov	 DWORD PTR [rbx+2988], ecx
  00136	48 8b cb	 mov	 rcx, rbx
  00139	ff 8b 9c 14 00
	00		 dec	 DWORD PTR [rbx+5276]
  0013f	e8 00 00 00 00	 call	 pqdownheap

; 666  :         m = s->heap[SMALLEST]; /* m = node of next least frequency */

  00144	48 63 8b ac 0b
	00 00		 movsxd	 rcx, DWORD PTR [rbx+2988]

; 667  : 
; 668  :         s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */

  0014b	ff 8b a0 14 00
	00		 dec	 DWORD PTR [rbx+5280]

; 669  :         s->heap[--(s->heap_max)] = m;
; 670  : 
; 671  :         /* Create a new node father of n and m */
; 672  :         tree[node].Freq = tree[n].Freq + tree[m].Freq;

  00151	4c 8d 04 8e	 lea	 r8, QWORD PTR [rsi+rcx*4]
  00155	48 63 83 a0 14
	00 00		 movsxd	 rax, DWORD PTR [rbx+5280]
  0015c	4d 63 ce	 movsxd	 r9, r14d
  0015f	89 bc 83 a8 0b
	00 00		 mov	 DWORD PTR [rbx+rax*4+2984], edi
  00166	ff 8b a0 14 00
	00		 dec	 DWORD PTR [rbx+5280]
  0016c	48 63 83 a0 14
	00 00		 movsxd	 rax, DWORD PTR [rbx+5280]
  00173	89 8c 83 a8 0b
	00 00		 mov	 DWORD PTR [rbx+rax*4+2984], ecx
  0017a	41 0f b7 00	 movzx	 eax, WORD PTR [r8]
  0017e	66 03 04 be	 add	 ax, WORD PTR [rsi+rdi*4]
  00182	66 42 89 04 8e	 mov	 WORD PTR [rsi+r9*4], ax

; 673  :         s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?

  00187	0f b6 84 19 a4
	14 00 00	 movzx	 eax, BYTE PTR [rcx+rbx+5284]
  0018f	38 84 1f a4 14
	00 00		 cmp	 BYTE PTR [rdi+rbx+5284], al
  00196	72 0a		 jb	 SHORT $LN19@build_tree
  00198	0f b6 84 1f a4
	14 00 00	 movzx	 eax, BYTE PTR [rdi+rbx+5284]
  001a0	eb 08		 jmp	 SHORT $LN20@build_tree
$LN19@build_tree:
  001a2	0f b6 84 19 a4
	14 00 00	 movzx	 eax, BYTE PTR [rcx+rbx+5284]
$LN20@build_tree:
  001aa	fe c0		 inc	 al

; 674  :                                 s->depth[n] : s->depth[m]) + 1);
; 675  :         tree[n].Dad = tree[m].Dad = (ush)node;
; 676  : #ifdef DUMP_BL_TREE
; 677  :         if (tree == s->bl_tree) {
; 678  :             fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
; 679  :                     node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
; 680  :         }
; 681  : #endif
; 682  :         /* and insert the new node in the heap */
; 683  :         s->heap[SMALLEST] = node++;
; 684  :         pqdownheap(s, tree, SMALLEST);

  001ac	48 8b d6	 mov	 rdx, rsi
  001af	41 88 84 19 a4
	14 00 00	 mov	 BYTE PTR [r9+rbx+5284], al
  001b7	48 8b cb	 mov	 rcx, rbx
  001ba	66 45 89 70 02	 mov	 WORD PTR [r8+2], r14w
  001bf	45 8b c4	 mov	 r8d, r12d
  001c2	66 44 89 74 be
	02		 mov	 WORD PTR [rsi+rdi*4+2], r14w
  001c8	44 89 b3 ac 0b
	00 00		 mov	 DWORD PTR [rbx+2988], r14d
  001cf	41 ff c6	 inc	 r14d
  001d2	e8 00 00 00 00	 call	 pqdownheap

; 685  : 
; 686  :     } while (s->heap_len >= 2);

  001d7	83 bb 9c 14 00
	00 02		 cmp	 DWORD PTR [rbx+5276], 2
  001de	0f 8d 31 ff ff
	ff		 jge	 $LL12@build_tree

; 687  : 
; 688  :     s->heap[--(s->heap_max)] = s->heap[SMALLEST];

  001e4	ff 8b a0 14 00
	00		 dec	 DWORD PTR [rbx+5280]

; 689  : 
; 690  :     /* At this point, the fields freq and dad are set. We can now
; 691  :      * generate the bit lengths.
; 692  :      */
; 693  :     gen_bitlen(s, (tree_desc *)desc);

  001ea	49 8b d7	 mov	 rdx, r15
  001ed	4c 63 83 a0 14
	00 00		 movsxd	 r8, DWORD PTR [rbx+5280]
  001f4	8b 83 ac 0b 00
	00		 mov	 eax, DWORD PTR [rbx+2988]
  001fa	42 89 84 83 a8
	0b 00 00	 mov	 DWORD PTR [rbx+r8*4+2984], eax
  00202	e8 00 00 00 00	 call	 gen_bitlen

; 694  : 
; 695  :     /* The field len is now set, we can generate the bit codes */
; 696  :     gen_codes ((ct_data *)tree, max_code, s->bl_count);

  00207	4c 8d 83 88 0b
	00 00		 lea	 r8, QWORD PTR [rbx+2952]
  0020e	8b d5		 mov	 edx, ebp
  00210	48 8b ce	 mov	 rcx, rsi

; 697  : }

  00213	48 8b 5c 24 40	 mov	 rbx, QWORD PTR [rsp+64]
  00218	48 8b 6c 24 48	 mov	 rbp, QWORD PTR [rsp+72]
  0021d	48 8b 74 24 50	 mov	 rsi, QWORD PTR [rsp+80]
  00222	48 8b 7c 24 58	 mov	 rdi, QWORD PTR [rsp+88]
  00227	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0022b	41 5f		 pop	 r15
  0022d	41 5e		 pop	 r14
  0022f	41 5c		 pop	 r12

; 694  : 
; 695  :     /* The field len is now set, we can generate the bit codes */
; 696  :     gen_codes ((ct_data *)tree, max_code, s->bl_count);

  00231	e9 00 00 00 00	 jmp	 gen_codes
build_tree ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT scan_tree
_TEXT	SEGMENT
s$ = 48
tree$ = 56
max_code$ = 64
scan_tree PROC						; COMDAT

; 707  : {

  00000	40 53		 push	 rbx
  00002	55		 push	 rbp
  00003	41 55		 push	 r13
  00005	48 83 ec 10	 sub	 rsp, 16

; 710  :     int curlen;                /* length of current code */
; 711  :     int nextlen = tree[0].Len; /* length of next code */

  00009	44 0f b7 5a 02	 movzx	 r11d, WORD PTR [rdx+2]

; 712  :     int count = 0;             /* repeat count of the current code */
; 713  :     int max_count = 7;         /* max repeat count */
; 714  :     int min_count = 4;         /* min repeat count */
; 715  : 
; 716  :     if (nextlen == 0) max_count = 138, min_count = 3;
; 717  :     tree[max_code+1].Len = (ush)0xffff; /* guard */

  0000e	41 8d 40 01	 lea	 eax, DWORD PTR [r8+1]
  00012	4c 63 c8	 movsxd	 r9, eax
  00015	83 cd ff	 or	 ebp, -1
  00018	45 33 d2	 xor	 r10d, r10d
  0001b	b8 ff ff 00 00	 mov	 eax, 65535		; 0000ffffH
  00020	45 85 db	 test	 r11d, r11d
  00023	48 8b da	 mov	 rbx, rdx
  00026	41 bd 07 00 00
	00		 mov	 r13d, 7
  0002c	66 42 89 44 8a
	02		 mov	 WORD PTR [rdx+r9*4+2], ax
  00032	ba 8a 00 00 00	 mov	 edx, 138		; 0000008aH
  00037	41 0f 45 d5	 cmovne	 edx, r13d

; 718  : 
; 719  :     for (n = 0; n <= max_code; n++) {

  0003b	4d 63 c8	 movsxd	 r9, r8d
  0003e	33 c0		 xor	 eax, eax
  00040	45 85 db	 test	 r11d, r11d
  00043	0f 95 c0	 setne	 al
  00046	83 c0 03	 add	 eax, 3
  00049	45 85 c0	 test	 r8d, r8d
  0004c	0f 88 e3 00 00
	00		 js	 $LN3@scan_tree

; 708  :     int n;                     /* iterates over all tree elements */
; 709  :     int prevlen = -1;          /* last emitted length */

  00052	48 89 74 24 30	 mov	 QWORD PTR [rsp+48], rsi
  00057	48 89 7c 24 38	 mov	 QWORD PTR [rsp+56], rdi
  0005c	4c 89 64 24 40	 mov	 QWORD PTR [rsp+64], r12
  00061	4c 89 74 24 08	 mov	 QWORD PTR [rsp+8], r14
  00066	4c 8d 73 06	 lea	 r14, QWORD PTR [rbx+6]
  0006a	4c 89 3c 24	 mov	 QWORD PTR [rsp], r15
  0006e	4d 8d 79 01	 lea	 r15, QWORD PTR [r9+1]
  00072	0f 1f 40 00 66
	66 0f 1f 84 00
	00 00 00 00	 npad	 14
$LL4@scan_tree:

; 720  :         curlen = nextlen; nextlen = tree[n+1].Len;
; 721  :         if (++count < max_count && curlen == nextlen) {

  00080	41 ff c2	 inc	 r10d
  00083	41 8b f3	 mov	 esi, r11d
  00086	41 8b db	 mov	 ebx, r11d
  00089	45 8b e3	 mov	 r12d, r11d
  0008c	45 8b cb	 mov	 r9d, r11d
  0008f	45 8b c3	 mov	 r8d, r11d
  00092	41 8b fb	 mov	 edi, r11d
  00095	45 0f b7 1e	 movzx	 r11d, WORD PTR [r14]
  00099	44 3b d2	 cmp	 r10d, edx
  0009c	7d 05		 jge	 SHORT $LN6@scan_tree
  0009e	41 3b fb	 cmp	 edi, r11d
  000a1	74 6c		 je	 SHORT $LN2@scan_tree
$LN6@scan_tree:

; 722  :             continue;
; 723  :         } else if (count < min_count) {

  000a3	44 3b d0	 cmp	 r10d, eax
  000a6	7d 0b		 jge	 SHORT $LN8@scan_tree

; 724  :             s->bl_tree[curlen].Freq += count;

  000a8	66 44 01 94 99
	a4 0a 00 00	 add	 WORD PTR [rcx+rbx*4+2724], r10w
  000b1	eb 30		 jmp	 SHORT $LN14@scan_tree
$LN8@scan_tree:
  000b3	45 85 c9	 test	 r9d, r9d

; 725  :         } else if (curlen != 0) {

  000b6	74 15		 je	 SHORT $LN10@scan_tree

; 726  :             if (curlen != prevlen) s->bl_tree[curlen].Freq++;

  000b8	3b fd		 cmp	 edi, ebp
  000ba	74 08		 je	 SHORT $LN12@scan_tree
  000bc	66 ff 84 b1 a4
	0a 00 00	 inc	 WORD PTR [rcx+rsi*4+2724]
$LN12@scan_tree:

; 727  :             s->bl_tree[REP_3_6].Freq++;

  000c4	66 ff 81 e4 0a
	00 00		 inc	 WORD PTR [rcx+2788]
  000cb	eb 16		 jmp	 SHORT $LN14@scan_tree
$LN10@scan_tree:

; 728  :         } else if (count <= 10) {

  000cd	41 83 fa 0a	 cmp	 r10d, 10
  000d1	7f 09		 jg	 SHORT $LN13@scan_tree

; 729  :             s->bl_tree[REPZ_3_10].Freq++;

  000d3	66 ff 81 e8 0a
	00 00		 inc	 WORD PTR [rcx+2792]

; 730  :         } else {

  000da	eb 07		 jmp	 SHORT $LN14@scan_tree
$LN13@scan_tree:

; 731  :             s->bl_tree[REPZ_11_138].Freq++;

  000dc	66 ff 81 ec 0a
	00 00		 inc	 WORD PTR [rcx+2796]
$LN14@scan_tree:

; 732  :         }
; 733  :         count = 0; prevlen = curlen;

  000e3	45 33 d2	 xor	 r10d, r10d
  000e6	8b ef		 mov	 ebp, edi
  000e8	45 85 db	 test	 r11d, r11d

; 734  :         if (nextlen == 0) {

  000eb	75 0b		 jne	 SHORT $LN15@scan_tree

; 735  :             max_count = 138, min_count = 3;

  000ed	ba 8a 00 00 00	 mov	 edx, 138		; 0000008aH
  000f2	41 8d 42 03	 lea	 eax, QWORD PTR [r10+3]
  000f6	eb 17		 jmp	 SHORT $LN2@scan_tree
$LN15@scan_tree:
  000f8	45 3b e3	 cmp	 r12d, r11d

; 736  :         } else if (curlen == nextlen) {

  000fb	75 0a		 jne	 SHORT $LN17@scan_tree

; 737  :             max_count = 6, min_count = 3;

  000fd	ba 06 00 00 00	 mov	 edx, 6
  00102	8d 42 fd	 lea	 eax, QWORD PTR [rdx-3]

; 738  :         } else {

  00105	eb 08		 jmp	 SHORT $LN2@scan_tree
$LN17@scan_tree:

; 739  :             max_count = 7, min_count = 4;

  00107	41 8b d5	 mov	 edx, r13d
  0010a	b8 04 00 00 00	 mov	 eax, 4
$LN2@scan_tree:

; 718  : 
; 719  :     for (n = 0; n <= max_code; n++) {

  0010f	49 83 c6 04	 add	 r14, 4
  00113	49 83 ef 01	 sub	 r15, 1
  00117	0f 85 63 ff ff
	ff		 jne	 $LL4@scan_tree
  0011d	4c 8b 3c 24	 mov	 r15, QWORD PTR [rsp]
  00121	4c 8b 74 24 08	 mov	 r14, QWORD PTR [rsp+8]
  00126	4c 8b 64 24 40	 mov	 r12, QWORD PTR [rsp+64]
  0012b	48 8b 7c 24 38	 mov	 rdi, QWORD PTR [rsp+56]
  00130	48 8b 74 24 30	 mov	 rsi, QWORD PTR [rsp+48]
$LN3@scan_tree:

; 740  :         }
; 741  :     }
; 742  : }

  00135	48 83 c4 10	 add	 rsp, 16
  00139	41 5d		 pop	 r13
  0013b	5d		 pop	 rbp
  0013c	5b		 pop	 rbx
  0013d	c3		 ret	 0
scan_tree ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT send_tree
_TEXT	SEGMENT
s$ = 48
tree$ = 56
tv1189 = 64
max_code$ = 64
send_tree PROC						; COMDAT

; 752  : {

  00000	40 57		 push	 rdi
  00002	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 755  :     int curlen;                /* length of current code */
; 756  :     int nextlen = tree[0].Len; /* length of next code */

  00006	0f b7 7a 02	 movzx	 edi, WORD PTR [rdx+2]
  0000a	48 8b c1	 mov	 rax, rcx
  0000d	41 83 c9 ff	 or	 r9d, -1

; 757  :     int count = 0;             /* repeat count of the current code */
; 758  :     int max_count = 7;         /* max repeat count */
; 759  :     int min_count = 4;         /* min repeat count */
; 760  : 
; 761  :     /* tree[max_code+1].Len = -1; */  /* guard already set */
; 762  :     if (nextlen == 0) max_count = 138, min_count = 3;
; 763  : 
; 764  :     for (n = 0; n <= max_code; n++) {

  00011	4d 63 d8	 movsxd	 r11, r8d
  00014	45 33 d2	 xor	 r10d, r10d
  00017	b9 07 00 00 00	 mov	 ecx, 7
  0001c	85 ff		 test	 edi, edi
  0001e	41 b8 8a 00 00
	00		 mov	 r8d, 138		; 0000008aH
  00024	44 0f 45 c1	 cmovne	 r8d, ecx
  00028	33 c9		 xor	 ecx, ecx
  0002a	85 ff		 test	 edi, edi
  0002c	0f 95 c1	 setne	 cl
  0002f	83 c1 03	 add	 ecx, 3
  00032	4d 85 db	 test	 r11, r11
  00035	0f 88 86 05 00
	00		 js	 $LN3@send_tree

; 753  :     int n;                     /* iterates over all tree elements */
; 754  :     int prevlen = -1;          /* last emitted length */

  0003b	48 89 5c 24 30	 mov	 QWORD PTR [rsp+48], rbx
  00040	48 89 6c 24 38	 mov	 QWORD PTR [rsp+56], rbp
  00045	48 89 74 24 48	 mov	 QWORD PTR [rsp+72], rsi
  0004a	4c 89 64 24 18	 mov	 QWORD PTR [rsp+24], r12
  0004f	4c 89 6c 24 10	 mov	 QWORD PTR [rsp+16], r13
  00054	4d 8d 6b 01	 lea	 r13, QWORD PTR [r11+1]
  00058	4c 89 74 24 08	 mov	 QWORD PTR [rsp+8], r14
  0005d	4c 89 3c 24	 mov	 QWORD PTR [rsp], r15
  00061	4c 8d 7a 06	 lea	 r15, QWORD PTR [rdx+6]
  00065	66 66 66 0f 1f
	84 00 00 00 00
	00		 npad	 11
$LL4@send_tree:

; 765  :         curlen = nextlen; nextlen = tree[n+1].Len;
; 766  :         if (++count < max_count && curlen == nextlen) {

  00070	41 ff c2	 inc	 r10d
  00073	8b ef		 mov	 ebp, edi
  00075	44 8b f7	 mov	 r14d, edi
  00078	44 8b df	 mov	 r11d, edi
  0007b	8b f7		 mov	 esi, edi
  0007d	8b d7		 mov	 edx, edi
  0007f	8b df		 mov	 ebx, edi
  00081	44 8b e7	 mov	 r12d, edi
  00084	41 0f b7 3f	 movzx	 edi, WORD PTR [r15]
  00088	45 3b d0	 cmp	 r10d, r8d
  0008b	7d 08		 jge	 SHORT $LN9@send_tree
  0008d	3b d7		 cmp	 edx, edi
  0008f	0f 84 fc 04 00
	00		 je	 $LN2@send_tree
$LN9@send_tree:

; 767  :             continue;
; 768  :         } else if (count < min_count) {

  00095	44 3b d1	 cmp	 r10d, ecx
  00098	0f 8d ba 00 00
	00		 jge	 $LN11@send_tree
  0009e	48 8d 34 98	 lea	 rsi, QWORD PTR [rax+rbx*4]
  000a2	48 8d 1c 98	 lea	 rbx, QWORD PTR [rax+rbx*4]
  000a6	66 66 0f 1f 84
	00 00 00 00 00	 npad	 10
$LL7@send_tree:

; 769  :             do { send_code(s, curlen, s->bl_tree); } while (--count != 0);

  000b0	44 0f b7 9e a6
	0a 00 00	 movzx	 r11d, WORD PTR [rsi+2726]
  000b8	ba 10 00 00 00	 mov	 edx, 16
  000bd	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  000c3	41 2b d3	 sub	 edx, r11d
  000c6	3b ca		 cmp	 ecx, edx
  000c8	7e 65		 jle	 SHORT $LN13@send_tree
  000ca	44 0f b7 8b a4
	0a 00 00	 movzx	 r9d, WORD PTR [rbx+2724]
  000d2	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  000d6	41 0f b7 d1	 movzx	 edx, r9w
  000da	66 d3 e2	 shl	 dx, cl
  000dd	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  000e4	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  000eb	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  000ef	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  000f3	ff 40 28	 inc	 DWORD PTR [rax+40]
  000f6	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  000fd	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00101	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00105	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00109	b9 10 00 00 00	 mov	 ecx, 16
  0010e	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  00114	ff 40 28	 inc	 DWORD PTR [rax+40]
  00117	66 41 d3 e9	 shr	 r9w, cl
  0011b	41 8d 4b f0	 lea	 ecx, DWORD PTR [r11-16]
  0011f	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  00125	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  0012d	eb 1a		 jmp	 SHORT $LN5@send_tree
$LN13@send_tree:
  0012f	0f b7 93 a4 0a
	00 00		 movzx	 edx, WORD PTR [rbx+2724]
  00136	66 d3 e2	 shl	 dx, cl
  00139	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00140	41 03 cb	 add	 ecx, r11d
  00143	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN5@send_tree:
  00149	41 83 ea 01	 sub	 r10d, 1
  0014d	0f 85 5d ff ff
	ff		 jne	 $LL7@send_tree

; 770  : 
; 771  :         } else if (curlen != 0) {

  00153	e9 0b 04 00 00	 jmp	 $LN33@send_tree
$LN11@send_tree:
  00158	45 85 db	 test	 r11d, r11d
  0015b	0f 84 c9 01 00
	00		 je	 $LN15@send_tree

; 772  :             if (curlen != prevlen) {

  00161	45 3b e1	 cmp	 r12d, r9d
  00164	0f 84 a2 00 00
	00		 je	 $LN17@send_tree

; 773  :                 send_code(s, curlen, s->bl_tree); count--;

  0016a	44 0f b7 9c b0
	a6 0a 00 00	 movzx	 r11d, WORD PTR [rax+rsi*4+2726]
  00173	ba 10 00 00 00	 mov	 edx, 16
  00178	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  0017e	41 2b d3	 sub	 edx, r11d
  00181	3b ca		 cmp	 ecx, edx
  00183	7e 66		 jle	 SHORT $LN18@send_tree
  00185	46 0f b7 8c b0
	a4 0a 00 00	 movzx	 r9d, WORD PTR [rax+r14*4+2724]
  0018e	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00192	41 0f b7 d1	 movzx	 edx, r9w
  00196	66 d3 e2	 shl	 dx, cl
  00199	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  001a0	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  001a7	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  001ab	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  001af	ff 40 28	 inc	 DWORD PTR [rax+40]
  001b2	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  001b9	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  001bd	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  001c1	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  001c5	b9 10 00 00 00	 mov	 ecx, 16
  001ca	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  001d0	ff 40 28	 inc	 DWORD PTR [rax+40]
  001d3	66 41 d3 e9	 shr	 r9w, cl
  001d7	41 8d 4b f0	 lea	 ecx, DWORD PTR [r11-16]
  001db	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  001e1	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  001e9	eb 1e		 jmp	 SHORT $LN19@send_tree
$LN18@send_tree:
  001eb	44 0f b7 84 a8
	a4 0a 00 00	 movzx	 r8d, WORD PTR [rax+rbp*4+2724]
  001f4	66 41 d3 e0	 shl	 r8w, cl
  001f8	66 44 09 80 10
	17 00 00	 or	 WORD PTR [rax+5904], r8w
  00200	41 03 cb	 add	 ecx, r11d
  00203	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN19@send_tree:
  00209	41 ff ca	 dec	 r10d
$LN17@send_tree:

; 774  :             }
; 775  :             Assert(count >= 3 && count <= 6, " 3_6?");
; 776  :             send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);

  0020c	44 0f b7 98 e6
	0a 00 00	 movzx	 r11d, WORD PTR [rax+2790]
  00214	ba 10 00 00 00	 mov	 edx, 16
  00219	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  0021f	41 2b d3	 sub	 edx, r11d
  00222	3b ca		 cmp	 ecx, edx
  00224	7e 65		 jle	 SHORT $LN20@send_tree
  00226	44 0f b7 88 e4
	0a 00 00	 movzx	 r9d, WORD PTR [rax+2788]
  0022e	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00232	41 0f b7 d1	 movzx	 edx, r9w
  00236	66 d3 e2	 shl	 dx, cl
  00239	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00240	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  00247	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  0024b	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  0024f	ff 40 28	 inc	 DWORD PTR [rax+40]
  00252	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  00259	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  0025d	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00261	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00265	b9 10 00 00 00	 mov	 ecx, 16
  0026a	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  00270	ff 40 28	 inc	 DWORD PTR [rax+40]
  00273	66 41 d3 e9	 shr	 r9w, cl
  00277	41 8d 4b f0	 lea	 ecx, DWORD PTR [r11-16]
  0027b	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  00281	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  00289	eb 1a		 jmp	 SHORT $LN21@send_tree
$LN20@send_tree:
  0028b	0f b7 90 e4 0a
	00 00		 movzx	 edx, WORD PTR [rax+2788]
  00292	66 d3 e2	 shl	 dx, cl
  00295	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  0029c	41 03 cb	 add	 ecx, r11d
  0029f	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN21@send_tree:
  002a5	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  002ab	83 f9 0e	 cmp	 ecx, 14
  002ae	7e 61		 jle	 SHORT $LN22@send_tree
  002b0	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  002b4	45 8d 4a fd	 lea	 r9d, DWORD PTR [r10-3]
  002b8	41 0f b7 d1	 movzx	 edx, r9w
  002bc	66 d3 e2	 shl	 dx, cl
  002bf	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  002c6	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  002cd	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  002d1	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  002d5	ff 40 28	 inc	 DWORD PTR [rax+40]
  002d8	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  002df	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  002e3	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  002e7	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  002eb	b9 10 00 00 00	 mov	 ecx, 16
  002f0	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  002f6	ff 40 28	 inc	 DWORD PTR [rax+40]
  002f9	66 41 d3 e9	 shr	 r9w, cl
  002fd	83 80 14 17 00
	00 f2		 add	 DWORD PTR [rax+5908], -14
  00304	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  0030c	e9 52 02 00 00	 jmp	 $LN33@send_tree
$LN22@send_tree:
  00311	66 41 83 ea 03	 sub	 r10w, 3
  00316	66 41 d3 e2	 shl	 r10w, cl
  0031a	66 44 09 90 10
	17 00 00	 or	 WORD PTR [rax+5904], r10w
  00322	83 c1 02	 add	 ecx, 2
  00325	e9 33 02 00 00	 jmp	 $LN46@send_tree
$LN15@send_tree:

; 777  : 
; 778  :         } else if (count <= 10) {
; 779  :             send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);

  0032a	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  00330	ba 10 00 00 00	 mov	 edx, 16
  00335	41 83 fa 0a	 cmp	 r10d, 10
  00339	0f 8f 13 01 00
	00		 jg	 $LN24@send_tree
  0033f	44 0f b7 98 ea
	0a 00 00	 movzx	 r11d, WORD PTR [rax+2794]
  00347	41 2b d3	 sub	 edx, r11d
  0034a	3b ca		 cmp	 ecx, edx
  0034c	7e 65		 jle	 SHORT $LN26@send_tree
  0034e	44 0f b7 88 e8
	0a 00 00	 movzx	 r9d, WORD PTR [rax+2792]
  00356	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  0035a	41 0f b7 d1	 movzx	 edx, r9w
  0035e	66 d3 e2	 shl	 dx, cl
  00361	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00368	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  0036f	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00373	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00377	ff 40 28	 inc	 DWORD PTR [rax+40]
  0037a	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  00381	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00385	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00389	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  0038d	b9 10 00 00 00	 mov	 ecx, 16
  00392	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  00398	ff 40 28	 inc	 DWORD PTR [rax+40]
  0039b	66 41 d3 e9	 shr	 r9w, cl
  0039f	41 8d 4b f0	 lea	 ecx, DWORD PTR [r11-16]
  003a3	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  003a9	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  003b1	eb 1a		 jmp	 SHORT $LN27@send_tree
$LN26@send_tree:
  003b3	0f b7 90 e8 0a
	00 00		 movzx	 edx, WORD PTR [rax+2792]
  003ba	66 d3 e2	 shl	 dx, cl
  003bd	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  003c4	41 03 cb	 add	 ecx, r11d
  003c7	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN27@send_tree:
  003cd	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  003d3	83 f9 0d	 cmp	 ecx, 13
  003d6	7e 61		 jle	 SHORT $LN28@send_tree
  003d8	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  003dc	45 8d 4a fd	 lea	 r9d, DWORD PTR [r10-3]
  003e0	41 0f b7 d1	 movzx	 edx, r9w
  003e4	66 d3 e2	 shl	 dx, cl
  003e7	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  003ee	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  003f5	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  003f9	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  003fd	ff 40 28	 inc	 DWORD PTR [rax+40]
  00400	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  00407	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  0040b	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  0040f	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00413	b9 10 00 00 00	 mov	 ecx, 16
  00418	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  0041e	ff 40 28	 inc	 DWORD PTR [rax+40]
  00421	66 41 d3 e9	 shr	 r9w, cl
  00425	83 80 14 17 00
	00 f3		 add	 DWORD PTR [rax+5908], -13
  0042c	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  00434	e9 2a 01 00 00	 jmp	 $LN33@send_tree
$LN28@send_tree:
  00439	66 41 83 ea 03	 sub	 r10w, 3
  0043e	66 41 d3 e2	 shl	 r10w, cl
  00442	66 44 09 90 10
	17 00 00	 or	 WORD PTR [rax+5904], r10w
  0044a	83 c1 03	 add	 ecx, 3

; 780  : 
; 781  :         } else {

  0044d	e9 0b 01 00 00	 jmp	 $LN46@send_tree
$LN24@send_tree:

; 782  :             send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);

  00452	44 0f b7 98 ee
	0a 00 00	 movzx	 r11d, WORD PTR [rax+2798]
  0045a	41 2b d3	 sub	 edx, r11d
  0045d	3b ca		 cmp	 ecx, edx
  0045f	7e 65		 jle	 SHORT $LN30@send_tree
  00461	44 0f b7 88 ec
	0a 00 00	 movzx	 r9d, WORD PTR [rax+2796]
  00469	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  0046d	41 0f b7 d1	 movzx	 edx, r9w
  00471	66 d3 e2	 shl	 dx, cl
  00474	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  0047b	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  00482	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00486	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  0048a	ff 40 28	 inc	 DWORD PTR [rax+40]
  0048d	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  00494	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00498	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  0049c	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  004a0	b9 10 00 00 00	 mov	 ecx, 16
  004a5	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  004ab	ff 40 28	 inc	 DWORD PTR [rax+40]
  004ae	66 41 d3 e9	 shr	 r9w, cl
  004b2	41 8d 4b f0	 lea	 ecx, DWORD PTR [r11-16]
  004b6	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  004bc	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  004c4	eb 1a		 jmp	 SHORT $LN31@send_tree
$LN30@send_tree:
  004c6	0f b7 90 ec 0a
	00 00		 movzx	 edx, WORD PTR [rax+2796]
  004cd	66 d3 e2	 shl	 dx, cl
  004d0	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  004d7	41 03 cb	 add	 ecx, r11d
  004da	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN31@send_tree:
  004e0	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  004e6	83 f9 09	 cmp	 ecx, 9
  004e9	7e 5e		 jle	 SHORT $LN32@send_tree
  004eb	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  004ef	45 8d 4a f5	 lea	 r9d, DWORD PTR [r10-11]
  004f3	41 0f b7 d1	 movzx	 edx, r9w
  004f7	66 d3 e2	 shl	 dx, cl
  004fa	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00501	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  00508	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  0050c	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00510	ff 40 28	 inc	 DWORD PTR [rax+40]
  00513	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  0051a	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  0051e	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00522	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00526	b9 10 00 00 00	 mov	 ecx, 16
  0052b	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  00531	ff 40 28	 inc	 DWORD PTR [rax+40]
  00534	66 41 d3 e9	 shr	 r9w, cl
  00538	83 80 14 17 00
	00 f7		 add	 DWORD PTR [rax+5908], -9
  0053f	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  00547	eb 1a		 jmp	 SHORT $LN33@send_tree
$LN32@send_tree:
  00549	66 41 83 ea 0b	 sub	 r10w, 11
  0054e	66 41 d3 e2	 shl	 r10w, cl
  00552	66 44 09 90 10
	17 00 00	 or	 WORD PTR [rax+5904], r10w
  0055a	83 c1 07	 add	 ecx, 7
$LN46@send_tree:
  0055d	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN33@send_tree:

; 783  :         }
; 784  :         count = 0; prevlen = curlen;

  00563	45 33 d2	 xor	 r10d, r10d
  00566	45 8b cc	 mov	 r9d, r12d
  00569	85 ff		 test	 edi, edi

; 785  :         if (nextlen == 0) {

  0056b	75 0b		 jne	 SHORT $LN34@send_tree

; 786  :             max_count = 138, min_count = 3;

  0056d	8d 4f 03	 lea	 ecx, QWORD PTR [rdi+3]
  00570	41 b8 8a 00 00
	00		 mov	 r8d, 138		; 0000008aH
  00576	eb 19		 jmp	 SHORT $LN2@send_tree
$LN34@send_tree:
  00578	44 3b cf	 cmp	 r9d, edi

; 787  :         } else if (curlen == nextlen) {

  0057b	75 0b		 jne	 SHORT $LN36@send_tree

; 788  :             max_count = 6, min_count = 3;

  0057d	b9 03 00 00 00	 mov	 ecx, 3
  00582	44 8d 41 03	 lea	 r8d, QWORD PTR [rcx+3]

; 789  :         } else {

  00586	eb 09		 jmp	 SHORT $LN2@send_tree
$LN36@send_tree:

; 790  :             max_count = 7, min_count = 4;

  00588	b9 04 00 00 00	 mov	 ecx, 4
  0058d	44 8d 41 03	 lea	 r8d, QWORD PTR [rcx+3]
$LN2@send_tree:

; 757  :     int count = 0;             /* repeat count of the current code */
; 758  :     int max_count = 7;         /* max repeat count */
; 759  :     int min_count = 4;         /* min repeat count */
; 760  : 
; 761  :     /* tree[max_code+1].Len = -1; */  /* guard already set */
; 762  :     if (nextlen == 0) max_count = 138, min_count = 3;
; 763  : 
; 764  :     for (n = 0; n <= max_code; n++) {

  00591	49 83 c7 04	 add	 r15, 4
  00595	49 83 ed 01	 sub	 r13, 1
  00599	0f 85 d1 fa ff
	ff		 jne	 $LL4@send_tree
  0059f	4c 8b 3c 24	 mov	 r15, QWORD PTR [rsp]
  005a3	4c 8b 74 24 08	 mov	 r14, QWORD PTR [rsp+8]
  005a8	4c 8b 6c 24 10	 mov	 r13, QWORD PTR [rsp+16]
  005ad	4c 8b 64 24 18	 mov	 r12, QWORD PTR [rsp+24]
  005b2	48 8b 74 24 48	 mov	 rsi, QWORD PTR [rsp+72]
  005b7	48 8b 6c 24 38	 mov	 rbp, QWORD PTR [rsp+56]
  005bc	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
$LN3@send_tree:

; 791  :         }
; 792  :     }
; 793  : }

  005c1	48 83 c4 20	 add	 rsp, 32			; 00000020H
  005c5	5f		 pop	 rdi
  005c6	c3		 ret	 0
send_tree ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT build_bl_tree
_TEXT	SEGMENT
s$ = 48
build_bl_tree PROC					; COMDAT

; 801  : {

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

; 802  :     int max_blindex;  /* index of last bit length code of non zero freq */
; 803  : 
; 804  :     /* Determine the bit length frequencies for literal and distance trees */
; 805  :     scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);

  00006	44 8b 81 48 0b
	00 00		 mov	 r8d, DWORD PTR [rcx+2888]
  0000d	48 8d 91 bc 00
	00 00		 lea	 rdx, QWORD PTR [rcx+188]
  00014	48 8b d9	 mov	 rbx, rcx
  00017	e8 00 00 00 00	 call	 scan_tree

; 806  :     scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);

  0001c	44 8b 81 60 0b
	00 00		 mov	 r8d, DWORD PTR [rcx+2912]
  00023	48 8d 91 b0 09
	00 00		 lea	 rdx, QWORD PTR [rcx+2480]
  0002a	e8 00 00 00 00	 call	 scan_tree

; 807  : 
; 808  :     /* Build the bit length tree: */
; 809  :     build_tree(s, (tree_desc *)(&(s->bl_desc)));

  0002f	48 8d 91 70 0b
	00 00		 lea	 rdx, QWORD PTR [rcx+2928]
  00036	e8 00 00 00 00	 call	 build_tree

; 810  :     /* opt_len now includes the length of the tree representations, except
; 811  :      * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
; 812  :      */
; 813  : 
; 814  :     /* Determine the number of bit length codes to send. The pkzip format
; 815  :      * requires that at least 4 bit length codes be sent. (appnote.txt says
; 816  :      * 3 but the actual value used is 4.)
; 817  :      */
; 818  :     for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {

  0003b	ba 12 00 00 00	 mov	 edx, 18
  00040	4c 8d 05 00 00
	00 00		 lea	 r8, OFFSET FLAT:bl_order
  00047	8b c2		 mov	 eax, edx
  00049	0f 1f 80 00 00
	00 00		 npad	 7
$LL4@build_bl_t:

; 819  :         if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;

  00050	42 0f b6 0c 00	 movzx	 ecx, BYTE PTR [rax+r8]
  00055	66 83 bc 8b a6
	0a 00 00 00	 cmp	 WORD PTR [rbx+rcx*4+2726], 0
  0005e	75 4e		 jne	 SHORT $LN14@build_bl_t
  00060	42 0f b6 4c 00
	ff		 movzx	 ecx, BYTE PTR [rax+r8-1]
  00066	66 83 bc 8b a6
	0a 00 00 00	 cmp	 WORD PTR [rbx+rcx*4+2726], 0
  0006f	75 3b		 jne	 SHORT $LN11@build_bl_t
  00071	42 0f b6 4c 00
	fe		 movzx	 ecx, BYTE PTR [rax+r8-2]
  00077	66 83 bc 8b a6
	0a 00 00 00	 cmp	 WORD PTR [rbx+rcx*4+2726], 0
  00080	75 25		 jne	 SHORT $LN12@build_bl_t
  00082	42 0f b6 4c 00
	fd		 movzx	 ecx, BYTE PTR [rax+r8-3]
  00088	66 83 bc 8b a6
	0a 00 00 00	 cmp	 WORD PTR [rbx+rcx*4+2726], 0
  00091	75 0f		 jne	 SHORT $LN13@build_bl_t

; 810  :     /* opt_len now includes the length of the tree representations, except
; 811  :      * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
; 812  :      */
; 813  : 
; 814  :     /* Determine the number of bit length codes to send. The pkzip format
; 815  :      * requires that at least 4 bit length codes be sent. (appnote.txt says
; 816  :      * 3 but the actual value used is 4.)
; 817  :      */
; 818  :     for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {

  00093	48 83 e8 04	 sub	 rax, 4
  00097	83 ea 04	 sub	 edx, 4
  0009a	48 83 f8 03	 cmp	 rax, 3
  0009e	7d b0		 jge	 SHORT $LL4@build_bl_t
  000a0	eb 0c		 jmp	 SHORT $LN14@build_bl_t
$LN13@build_bl_t:

; 819  :         if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;

  000a2	83 ea 03	 sub	 edx, 3
  000a5	eb 07		 jmp	 SHORT $LN14@build_bl_t
$LN12@build_bl_t:
  000a7	83 ea 02	 sub	 edx, 2

; 810  :     /* opt_len now includes the length of the tree representations, except
; 811  :      * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
; 812  :      */
; 813  : 
; 814  :     /* Determine the number of bit length codes to send. The pkzip format
; 815  :      * requires that at least 4 bit length codes be sent. (appnote.txt says
; 816  :      * 3 but the actual value used is 4.)
; 817  :      */
; 818  :     for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {

  000aa	eb 02		 jmp	 SHORT $LN14@build_bl_t
$LN11@build_bl_t:

; 819  :         if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;

  000ac	ff ca		 dec	 edx
$LN14@build_bl_t:

; 820  :     }
; 821  :     /* Update opt_len to include the bit length tree and counts */
; 822  :     s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;

  000ae	8d 0c 55 11 00
	00 00		 lea	 ecx, DWORD PTR [rdx*2+17]

; 823  :     Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
; 824  :             s->opt_len, s->static_len));
; 825  : 
; 826  :     return max_blindex;

  000b5	8b c2		 mov	 eax, edx
  000b7	03 ca		 add	 ecx, edx
  000b9	01 8b 00 17 00
	00		 add	 DWORD PTR [rbx+5888], ecx

; 827  : }

  000bf	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000c3	5b		 pop	 rbx
  000c4	c3		 ret	 0
build_bl_tree ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT send_all_trees
_TEXT	SEGMENT
s$ = 48
lcodes$ = 56
dcodes$ = 64
blcodes$ = 72
send_all_trees PROC					; COMDAT

; 837  : {

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

; 838  :     int rank;                    /* index in bl_order */
; 839  : 
; 840  :     Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
; 841  :     Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
; 842  :             "too many codes");
; 843  :     Tracev((stderr, "\nbl counts: "));
; 844  :     send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */

  00015	8b 89 14 17 00
	00		 mov	 ecx, DWORD PTR [rcx+5908]
  0001b	41 8b f8	 mov	 edi, r8d
  0001e	8b f2		 mov	 esi, edx
  00020	83 f9 0b	 cmp	 ecx, 11
  00023	7e 5d		 jle	 SHORT $LN5@send_all_t
  00025	44 8d 92 ff fe
	ff ff		 lea	 r10d, DWORD PTR [rdx-257]
  0002c	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  0002f	41 0f b7 c2	 movzx	 eax, r10w
  00033	66 d3 e0	 shl	 ax, cl
  00036	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  0003d	0f b6 83 10 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5904]
  00044	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  00048	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  0004b	ff 43 28	 inc	 DWORD PTR [rbx+40]
  0004e	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  00051	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  00055	0f b6 83 11 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5905]
  0005c	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  0005f	b9 10 00 00 00	 mov	 ecx, 16
  00064	2a 8b 14 17 00
	00		 sub	 cl, BYTE PTR [rbx+5908]
  0006a	ff 43 28	 inc	 DWORD PTR [rbx+40]
  0006d	66 41 d3 ea	 shr	 r10w, cl
  00071	83 83 14 17 00
	00 f5		 add	 DWORD PTR [rbx+5908], -11
  00078	66 44 89 93 10
	17 00 00	 mov	 WORD PTR [rbx+5904], r10w
  00080	eb 1e		 jmp	 SHORT $LN6@send_all_t
$LN5@send_all_t:
  00082	0f b7 c6	 movzx	 eax, si
  00085	ba 01 01 00 00	 mov	 edx, 257		; 00000101H
  0008a	66 2b c2	 sub	 ax, dx
  0008d	66 d3 e0	 shl	 ax, cl
  00090	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  00097	8d 41 05	 lea	 eax, DWORD PTR [rcx+5]
  0009a	89 83 14 17 00
	00		 mov	 DWORD PTR [rbx+5908], eax
$LN6@send_all_t:

; 845  :     send_bits(s, dcodes-1,   5);

  000a0	8b 8b 14 17 00
	00		 mov	 ecx, DWORD PTR [rbx+5908]
  000a6	83 f9 0b	 cmp	 ecx, 11
  000a9	7e 59		 jle	 SHORT $LN7@send_all_t
  000ab	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  000ae	41 ff c8	 dec	 r8d
  000b1	41 0f b7 c0	 movzx	 eax, r8w
  000b5	66 d3 e0	 shl	 ax, cl
  000b8	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  000bf	0f b6 83 10 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5904]
  000c6	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  000ca	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  000cd	ff 43 28	 inc	 DWORD PTR [rbx+40]
  000d0	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  000d3	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  000d7	0f b6 83 11 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5905]
  000de	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  000e1	b9 10 00 00 00	 mov	 ecx, 16
  000e6	2a 8b 14 17 00
	00		 sub	 cl, BYTE PTR [rbx+5908]
  000ec	ff 43 28	 inc	 DWORD PTR [rbx+40]
  000ef	66 41 d3 e8	 shr	 r8w, cl
  000f3	83 83 14 17 00
	00 f5		 add	 DWORD PTR [rbx+5908], -11
  000fa	66 44 89 83 10
	17 00 00	 mov	 WORD PTR [rbx+5904], r8w
  00102	eb 17		 jmp	 SHORT $LN8@send_all_t
$LN7@send_all_t:
  00104	41 8d 40 ff	 lea	 eax, DWORD PTR [r8-1]
  00108	66 d3 e0	 shl	 ax, cl
  0010b	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  00112	8d 41 05	 lea	 eax, DWORD PTR [rcx+5]
  00115	89 83 14 17 00
	00		 mov	 DWORD PTR [rbx+5908], eax
$LN8@send_all_t:

; 846  :     send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */

  0011b	8b 8b 14 17 00
	00		 mov	 ecx, DWORD PTR [rbx+5908]
  00121	83 f9 0c	 cmp	 ecx, 12
  00124	7e 5a		 jle	 SHORT $LN9@send_all_t
  00126	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  00129	45 8d 43 fc	 lea	 r8d, DWORD PTR [r11-4]
  0012d	41 0f b7 c0	 movzx	 eax, r8w
  00131	66 d3 e0	 shl	 ax, cl
  00134	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  0013b	0f b6 83 10 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5904]
  00142	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  00146	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  00149	ff 43 28	 inc	 DWORD PTR [rbx+40]
  0014c	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  0014f	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  00153	0f b6 83 11 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5905]
  0015a	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  0015d	b9 10 00 00 00	 mov	 ecx, 16
  00162	2a 8b 14 17 00
	00		 sub	 cl, BYTE PTR [rbx+5908]
  00168	ff 43 28	 inc	 DWORD PTR [rbx+40]
  0016b	66 41 d3 e8	 shr	 r8w, cl
  0016f	83 83 14 17 00
	00 f4		 add	 DWORD PTR [rbx+5908], -12
  00176	66 44 89 83 10
	17 00 00	 mov	 WORD PTR [rbx+5904], r8w
  0017e	eb 17		 jmp	 SHORT $LN10@send_all_t
$LN9@send_all_t:
  00180	41 8d 43 fc	 lea	 eax, DWORD PTR [r11-4]
  00184	66 d3 e0	 shl	 ax, cl
  00187	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  0018e	8d 41 04	 lea	 eax, DWORD PTR [rcx+4]
  00191	89 83 14 17 00
	00		 mov	 DWORD PTR [rbx+5908], eax
$LN10@send_all_t:

; 847  :     for (rank = 0; rank < blcodes; rank++) {

  00197	45 85 db	 test	 r11d, r11d
  0019a	0f 8e a6 00 00
	00		 jle	 $LN3@send_all_t
  001a0	4c 8d 0d 00 00
	00 00		 lea	 r9, OFFSET FLAT:bl_order
  001a7	4d 8b d3	 mov	 r10, r11
  001aa	66 0f 1f 44 00
	00		 npad	 6
$LL4@send_all_t:

; 848  :         Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
; 849  :         send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);

  001b0	8b 8b 14 17 00
	00		 mov	 ecx, DWORD PTR [rbx+5908]
  001b6	41 0f b6 01	 movzx	 eax, BYTE PTR [r9]
  001ba	83 f9 0d	 cmp	 ecx, 13
  001bd	7e 5f		 jle	 SHORT $LN11@send_all_t
  001bf	44 0f b7 84 83
	a6 0a 00 00	 movzx	 r8d, WORD PTR [rbx+rax*4+2726]
  001c8	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  001cb	41 0f b7 c0	 movzx	 eax, r8w
  001cf	66 d3 e0	 shl	 ax, cl
  001d2	66 09 83 10 17
	00 00		 or	 WORD PTR [rbx+5904], ax
  001d9	0f b6 83 10 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5904]
  001e0	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  001e4	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  001e7	ff 43 28	 inc	 DWORD PTR [rbx+40]
  001ea	8b 53 28	 mov	 edx, DWORD PTR [rbx+40]
  001ed	48 8b 4b 10	 mov	 rcx, QWORD PTR [rbx+16]
  001f1	0f b6 83 11 17
	00 00		 movzx	 eax, BYTE PTR [rbx+5905]
  001f8	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  001fb	b9 10 00 00 00	 mov	 ecx, 16
  00200	2a 8b 14 17 00
	00		 sub	 cl, BYTE PTR [rbx+5908]
  00206	ff 43 28	 inc	 DWORD PTR [rbx+40]
  00209	66 41 d3 e8	 shr	 r8w, cl
  0020d	83 83 14 17 00
	00 f3		 add	 DWORD PTR [rbx+5908], -13
  00214	66 44 89 83 10
	17 00 00	 mov	 WORD PTR [rbx+5904], r8w
  0021c	eb 1b		 jmp	 SHORT $LN2@send_all_t
$LN11@send_all_t:
  0021e	0f b7 94 83 a6
	0a 00 00	 movzx	 edx, WORD PTR [rbx+rax*4+2726]
  00226	8d 41 03	 lea	 eax, DWORD PTR [rcx+3]
  00229	66 d3 e2	 shl	 dx, cl
  0022c	66 09 93 10 17
	00 00		 or	 WORD PTR [rbx+5904], dx
  00233	89 83 14 17 00
	00		 mov	 DWORD PTR [rbx+5908], eax
$LN2@send_all_t:

; 847  :     for (rank = 0; rank < blcodes; rank++) {

  00239	49 ff c1	 inc	 r9
  0023c	49 83 ea 01	 sub	 r10, 1
  00240	0f 85 6a ff ff
	ff		 jne	 $LL4@send_all_t
$LN3@send_all_t:

; 850  :     }
; 851  :     Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
; 852  : 
; 853  :     send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */

  00246	44 8d 46 ff	 lea	 r8d, DWORD PTR [rsi-1]
  0024a	48 8b cb	 mov	 rcx, rbx
  0024d	48 8d 93 bc 00
	00 00		 lea	 rdx, QWORD PTR [rbx+188]
  00254	e8 00 00 00 00	 call	 send_tree

; 854  :     Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
; 855  : 
; 856  :     send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */

  00259	44 8d 47 ff	 lea	 r8d, DWORD PTR [rdi-1]
  0025d	48 8b cb	 mov	 rcx, rbx
  00260	48 8d 93 b0 09
	00 00		 lea	 rdx, QWORD PTR [rbx+2480]

; 857  :     Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
; 858  : }

  00267	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0026c	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  00271	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00275	5f		 pop	 rdi

; 854  :     Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
; 855  : 
; 856  :     send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */

  00276	e9 00 00 00 00	 jmp	 send_tree
send_all_trees ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT compress_block
_TEXT	SEGMENT
s$ = 32
ltree$ = 40
dtree$ = 48
compress_block PROC					; COMDAT

; 1068 : {

  00000	40 53		 push	 rbx
  00002	41 56		 push	 r14
  00004	48 83 ec 08	 sub	 rsp, 8
  00008	48 89 6c 24 20	 mov	 QWORD PTR [rsp+32], rbp
  0000d	4c 8b f2	 mov	 r14, rdx

; 1069 :     unsigned dist;      /* distance of matched string */
; 1070 :     int lc;             /* match length or unmatched char (if dist == 0) */
; 1071 :     unsigned lx = 0;    /* running index in l_buf */

  00010	33 ed		 xor	 ebp, ebp
  00012	4c 89 3c 24	 mov	 QWORD PTR [rsp], r15
  00016	4d 8b f8	 mov	 r15, r8
  00019	48 8b c1	 mov	 rax, rcx

; 1072 :     unsigned code;      /* the code to send */
; 1073 :     int extra;          /* number of extra bits to send */
; 1074 : 
; 1075 :     if (s->last_lit != 0) do {

  0001c	8d 5d 10	 lea	 ebx, QWORD PTR [rbp+16]
  0001f	39 a9 f4 16 00
	00		 cmp	 DWORD PTR [rcx+5876], ebp
  00025	0f 84 6e 03 00
	00		 je	 $LN3@compress_b
  0002b	4c 89 64 24 38	 mov	 QWORD PTR [rsp+56], r12
  00030	4c 8d 25 00 00
	00 00		 lea	 r12, OFFSET FLAT:__ImageBase
  00037	48 89 74 24 28	 mov	 QWORD PTR [rsp+40], rsi
  0003c	48 89 7c 24 30	 mov	 QWORD PTR [rsp+48], rdi
$LL4@compress_b:

; 1076 :         dist = s->d_buf[lx];

  00041	48 8b 88 f8 16
	00 00		 mov	 rcx, QWORD PTR [rax+5880]

; 1077 :         lc = s->l_buf[lx++];
; 1078 :         if (dist == 0) {
; 1079 :             send_code(s, lc, ltree); /* send a literal byte */

  00048	8b d3		 mov	 edx, ebx
  0004a	44 0f b7 14 69	 movzx	 r10d, WORD PTR [rcx+rbp*2]
  0004f	48 8b 88 e8 16
	00 00		 mov	 rcx, QWORD PTR [rax+5864]
  00056	44 0f b6 5c 0d
	00		 movzx	 r11d, BYTE PTR [rbp+rcx]
  0005c	ff c5		 inc	 ebp
  0005e	45 85 d2	 test	 r10d, r10d
  00061	0f 85 91 00 00
	00		 jne	 $LN6@compress_b
  00067	49 63 cb	 movsxd	 rcx, r11d
  0006a	45 0f b7 54 8e
	02		 movzx	 r10d, WORD PTR [r14+rcx*4+2]
  00070	4d 8d 04 8e	 lea	 r8, QWORD PTR [r14+rcx*4]
  00074	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  0007a	41 2b d2	 sub	 edx, r10d
  0007d	3b ca		 cmp	 ecx, edx
  0007f	7e 61		 jle	 SHORT $LN8@compress_b
  00081	45 0f b7 08	 movzx	 r9d, WORD PTR [r8]
  00085	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00089	41 0f b7 d1	 movzx	 edx, r9w
  0008d	66 d3 e2	 shl	 dx, cl
  00090	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00097	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  0009e	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  000a2	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  000a6	ff 40 28	 inc	 DWORD PTR [rax+40]
  000a9	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  000b0	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  000b4	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  000b8	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  000bc	8b cb		 mov	 ecx, ebx
  000be	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  000c4	ff 40 28	 inc	 DWORD PTR [rax+40]
  000c7	66 41 d3 e9	 shr	 r9w, cl
  000cb	41 8d 4a f0	 lea	 ecx, DWORD PTR [r10-16]
  000cf	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  000d5	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  000dd	e9 9c 02 00 00	 jmp	 $LN2@compress_b
$LN8@compress_b:
  000e2	41 0f b7 10	 movzx	 edx, WORD PTR [r8]
  000e6	66 d3 e2	 shl	 dx, cl
  000e9	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  000f0	41 03 ca	 add	 ecx, r10d

; 1080 :             Tracecv(isgraph(lc), (stderr," '%c' ", lc));
; 1081 :         } else {

  000f3	e9 80 02 00 00	 jmp	 $LN28@compress_b
$LN6@compress_b:

; 1082 :             /* Here, lc is the match length - MIN_MATCH */
; 1083 :             code = _length_code[lc];

  000f8	43 0f b6 b4 23
	00 00 00 00	 movzx	 esi, BYTE PTR _length_code[r11+r12]

; 1084 :             send_code(s, code+LITERALS+1, ltree); /* send the length code */

  00101	8d 8e 01 01 00
	00		 lea	 ecx, DWORD PTR [rsi+257]
  00107	41 0f b7 7c 8e
	02		 movzx	 edi, WORD PTR [r14+rcx*4+2]
  0010d	4d 8d 04 8e	 lea	 r8, QWORD PTR [r14+rcx*4]
  00111	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  00117	2b d7		 sub	 edx, edi
  00119	3b ca		 cmp	 ecx, edx
  0011b	7e 5d		 jle	 SHORT $LN10@compress_b
  0011d	45 0f b7 08	 movzx	 r9d, WORD PTR [r8]
  00121	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00125	41 0f b7 d1	 movzx	 edx, r9w
  00129	66 d3 e2	 shl	 dx, cl
  0012c	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00133	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  0013a	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  0013e	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00142	ff 40 28	 inc	 DWORD PTR [rax+40]
  00145	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  0014c	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00150	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00154	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00158	8b cb		 mov	 ecx, ebx
  0015a	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  00160	ff 40 28	 inc	 DWORD PTR [rax+40]
  00163	66 41 d3 e9	 shr	 r9w, cl
  00167	8d 4f f0	 lea	 ecx, DWORD PTR [rdi-16]
  0016a	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  00170	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  00178	eb 16		 jmp	 SHORT $LN11@compress_b
$LN10@compress_b:
  0017a	41 0f b7 10	 movzx	 edx, WORD PTR [r8]
  0017e	66 d3 e2	 shl	 dx, cl
  00181	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00188	03 cf		 add	 ecx, edi
  0018a	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN11@compress_b:

; 1085 :             extra = extra_lbits[code];

  00190	45 8b 8c b4 00
	00 00 00	 mov	 r9d, DWORD PTR extra_lbits[r12+rsi*4]

; 1086 :             if (extra != 0) {

  00198	45 85 c9	 test	 r9d, r9d
  0019b	0f 84 86 00 00
	00		 je	 $LN14@compress_b

; 1087 :                 lc -= base_length[code];

  001a1	45 2b 9c b4 00
	00 00 00	 sub	 r11d, DWORD PTR base_length[r12+rsi*4]

; 1088 :                 send_bits(s, lc, extra);       /* send the extra length bits */

  001a9	8b d3		 mov	 edx, ebx
  001ab	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  001b1	41 2b d1	 sub	 edx, r9d
  001b4	3b ca		 cmp	 ecx, edx
  001b6	7e 5a		 jle	 SHORT $LN13@compress_b
  001b8	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  001bc	41 0f b7 d3	 movzx	 edx, r11w
  001c0	66 d3 e2	 shl	 dx, cl
  001c3	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  001ca	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  001d1	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  001d5	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  001d9	ff 40 28	 inc	 DWORD PTR [rax+40]
  001dc	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  001e3	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  001e7	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  001eb	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  001ef	8b cb		 mov	 ecx, ebx
  001f1	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  001f7	ff 40 28	 inc	 DWORD PTR [rax+40]
  001fa	66 41 d3 eb	 shr	 r11w, cl
  001fe	41 8d 49 f0	 lea	 ecx, DWORD PTR [r9-16]
  00202	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  00208	66 44 89 98 10
	17 00 00	 mov	 WORD PTR [rax+5904], r11w
  00210	eb 15		 jmp	 SHORT $LN14@compress_b
$LN13@compress_b:
  00212	66 41 d3 e3	 shl	 r11w, cl
  00216	66 44 09 98 10
	17 00 00	 or	 WORD PTR [rax+5904], r11w
  0021e	41 03 c9	 add	 ecx, r9d
  00221	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN14@compress_b:

; 1089 :             }
; 1090 :             dist--; /* dist is now the match distance - 1 */

  00227	41 ff ca	 dec	 r10d

; 1091 :             code = d_code(dist);

  0022a	41 81 fa 00 01
	00 00		 cmp	 r10d, 256		; 00000100H
  00231	73 0b		 jae	 SHORT $LN23@compress_b
  00233	43 0f b6 94 22
	00 00 00 00	 movzx	 edx, BYTE PTR _dist_code[r10+r12]
  0023c	eb 15		 jmp	 SHORT $LN24@compress_b
$LN23@compress_b:
  0023e	41 8b ca	 mov	 ecx, r10d
  00241	c1 e9 07	 shr	 ecx, 7
  00244	81 c1 00 01 00
	00		 add	 ecx, 256		; 00000100H
  0024a	42 0f b6 94 21
	00 00 00 00	 movzx	 edx, BYTE PTR _dist_code[rcx+r12]
$LN24@compress_b:

; 1092 :             Assert (code < D_CODES, "bad d_code");
; 1093 : 
; 1094 :             send_code(s, code, dtree);       /* send the distance code */

  00253	0f b6 ca	 movzx	 ecx, dl
  00256	8b d3		 mov	 edx, ebx
  00258	4c 8d 1c 8d 00
	00 00 00	 lea	 r11, QWORD PTR [rcx*4]
  00260	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  00266	43 0f b7 7c 3b
	02		 movzx	 edi, WORD PTR [r11+r15+2]
  0026c	2b d7		 sub	 edx, edi
  0026e	3b ca		 cmp	 ecx, edx
  00270	7e 5e		 jle	 SHORT $LN15@compress_b
  00272	47 0f b7 0c 3b	 movzx	 r9d, WORD PTR [r11+r15]
  00277	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  0027b	41 0f b7 d1	 movzx	 edx, r9w
  0027f	66 d3 e2	 shl	 dx, cl
  00282	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00289	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  00290	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00294	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00298	ff 40 28	 inc	 DWORD PTR [rax+40]
  0029b	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  002a2	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  002a6	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  002aa	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  002ae	8b cb		 mov	 ecx, ebx
  002b0	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  002b6	ff 40 28	 inc	 DWORD PTR [rax+40]
  002b9	66 41 d3 e9	 shr	 r9w, cl
  002bd	8d 4f f0	 lea	 ecx, DWORD PTR [rdi-16]
  002c0	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  002c6	66 44 89 88 10
	17 00 00	 mov	 WORD PTR [rax+5904], r9w
  002ce	eb 17		 jmp	 SHORT $LN16@compress_b
$LN15@compress_b:
  002d0	43 0f b7 14 3b	 movzx	 edx, WORD PTR [r11+r15]
  002d5	66 d3 e2	 shl	 dx, cl
  002d8	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  002df	03 cf		 add	 ecx, edi
  002e1	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN16@compress_b:

; 1095 :             extra = extra_dbits[code];

  002e7	47 8b 8c 23 00
	00 00 00	 mov	 r9d, DWORD PTR extra_dbits[r11+r12]

; 1096 :             if (extra != 0) {

  002ef	45 85 c9	 test	 r9d, r9d
  002f2	0f 84 86 00 00
	00		 je	 $LN2@compress_b

; 1097 :                 dist -= (unsigned)base_dist[code];

  002f8	47 2b 94 23 00
	00 00 00	 sub	 r10d, DWORD PTR base_dist[r11+r12]

; 1098 :                 send_bits(s, dist, extra);   /* send the extra distance bits */

  00300	8b d3		 mov	 edx, ebx
  00302	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  00308	41 2b d1	 sub	 edx, r9d
  0030b	3b ca		 cmp	 ecx, edx
  0030d	7e 5a		 jle	 SHORT $LN18@compress_b
  0030f	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  00313	41 0f b7 d2	 movzx	 edx, r10w
  00317	66 d3 e2	 shl	 dx, cl
  0031a	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00321	0f b6 88 10 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5904]
  00328	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  0032c	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00330	ff 40 28	 inc	 DWORD PTR [rax+40]
  00333	0f b6 88 11 17
	00 00		 movzx	 ecx, BYTE PTR [rax+5905]
  0033a	44 8b 40 28	 mov	 r8d, DWORD PTR [rax+40]
  0033e	48 8b 50 10	 mov	 rdx, QWORD PTR [rax+16]
  00342	41 88 0c 10	 mov	 BYTE PTR [r8+rdx], cl
  00346	8b cb		 mov	 ecx, ebx
  00348	2a 88 14 17 00
	00		 sub	 cl, BYTE PTR [rax+5908]
  0034e	ff 40 28	 inc	 DWORD PTR [rax+40]
  00351	66 41 d3 ea	 shr	 r10w, cl
  00355	41 8d 49 f0	 lea	 ecx, DWORD PTR [r9-16]
  00359	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  0035f	66 44 89 90 10
	17 00 00	 mov	 WORD PTR [rax+5904], r10w
  00367	eb 15		 jmp	 SHORT $LN2@compress_b
$LN18@compress_b:
  00369	66 41 d3 e2	 shl	 r10w, cl
  0036d	66 44 09 90 10
	17 00 00	 or	 WORD PTR [rax+5904], r10w
  00375	41 03 c9	 add	 ecx, r9d
$LN28@compress_b:
  00378	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx
$LN2@compress_b:

; 1099 :             }
; 1100 :         } /* literal or match pair ? */
; 1101 : 
; 1102 :         /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
; 1103 :         Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
; 1104 :                "pendingBuf overflow");
; 1105 : 
; 1106 :     } while (lx < s->last_lit);

  0037e	3b a8 f4 16 00
	00		 cmp	 ebp, DWORD PTR [rax+5876]
  00384	0f 82 b7 fc ff
	ff		 jb	 $LL4@compress_b
  0038a	4c 8b 64 24 38	 mov	 r12, QWORD PTR [rsp+56]
  0038f	48 8b 7c 24 30	 mov	 rdi, QWORD PTR [rsp+48]
  00394	48 8b 74 24 28	 mov	 rsi, QWORD PTR [rsp+40]
$LN3@compress_b:

; 1107 : 
; 1108 :     send_code(s, END_BLOCK, ltree);

  00399	45 0f b7 9e 02
	04 00 00	 movzx	 r11d, WORD PTR [r14+1026]
  003a1	8b d3		 mov	 edx, ebx
  003a3	8b 88 14 17 00
	00		 mov	 ecx, DWORD PTR [rax+5908]
  003a9	41 2b d3	 sub	 edx, r11d
  003ac	4c 8b 3c 24	 mov	 r15, QWORD PTR [rsp]
  003b0	48 8b 6c 24 20	 mov	 rbp, QWORD PTR [rsp+32]
  003b5	3b ca		 cmp	 ecx, edx
  003b7	7e 69		 jle	 SHORT $LN20@compress_b
  003b9	45 0f b7 96 00
	04 00 00	 movzx	 r10d, WORD PTR [r14+1024]
  003c1	44 8b 48 28	 mov	 r9d, DWORD PTR [rax+40]
  003c5	41 0f b7 d2	 movzx	 edx, r10w
  003c9	4c 8b 40 10	 mov	 r8, QWORD PTR [rax+16]
  003cd	66 d3 e2	 shl	 dx, cl
  003d0	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  003d7	0f b6 90 10 17
	00 00		 movzx	 edx, BYTE PTR [rax+5904]
  003de	43 88 14 01	 mov	 BYTE PTR [r9+r8], dl
  003e2	ff 40 28	 inc	 DWORD PTR [rax+40]
  003e5	44 8b 48 28	 mov	 r9d, DWORD PTR [rax+40]
  003e9	0f b6 90 11 17
	00 00		 movzx	 edx, BYTE PTR [rax+5905]
  003f0	4c 8b 40 10	 mov	 r8, QWORD PTR [rax+16]
  003f4	43 88 14 01	 mov	 BYTE PTR [r9+r8], dl
  003f8	2a 98 14 17 00
	00		 sub	 bl, BYTE PTR [rax+5908]
  003fe	ff 40 28	 inc	 DWORD PTR [rax+40]
  00401	0f b6 cb	 movzx	 ecx, bl
  00404	66 41 d3 ea	 shr	 r10w, cl
  00408	41 8d 4b f0	 lea	 ecx, DWORD PTR [r11-16]
  0040c	01 88 14 17 00
	00		 add	 DWORD PTR [rax+5908], ecx
  00412	66 44 89 90 10
	17 00 00	 mov	 WORD PTR [rax+5904], r10w

; 1109 : }

  0041a	48 83 c4 08	 add	 rsp, 8
  0041e	41 5e		 pop	 r14
  00420	5b		 pop	 rbx
  00421	c3		 ret	 0
$LN20@compress_b:

; 1107 : 
; 1108 :     send_code(s, END_BLOCK, ltree);

  00422	41 0f b7 96 00
	04 00 00	 movzx	 edx, WORD PTR [r14+1024]
  0042a	66 d3 e2	 shl	 dx, cl
  0042d	66 09 90 10 17
	00 00		 or	 WORD PTR [rax+5904], dx
  00434	41 03 cb	 add	 ecx, r11d
  00437	89 88 14 17 00
	00		 mov	 DWORD PTR [rax+5908], ecx

; 1109 : }

  0043d	48 83 c4 08	 add	 rsp, 8
  00441	41 5e		 pop	 r14
  00443	5b		 pop	 rbx
  00444	c3		 ret	 0
compress_block ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT detect_data_type
_TEXT	SEGMENT
s$ = 8
detect_data_type PROC					; COMDAT

; 1126 : {

  00000	4c 8b c9	 mov	 r9, rcx

; 1127 :     /* black_mask is the bit mask of black-listed bytes
; 1128 :      * set bits 0..6, 14..25, and 28..31
; 1129 :      * 0xf3ffc07f = binary 11110011111111111100000001111111
; 1130 :      */
; 1131 :     unsigned long black_mask = 0xf3ffc07fUL;

  00003	48 8d 81 bc 00
	00 00		 lea	 rax, QWORD PTR [rcx+188]

; 1132 :     int n;
; 1133 : 
; 1134 :     /* Check for non-textual ("black-listed") bytes. */
; 1135 :     for (n = 0; n <= 31; n++, black_mask >>= 1)

  0000a	33 d2		 xor	 edx, edx
  0000c	41 b8 7f c0 ff
	f3		 mov	 r8d, -201342849		; f3ffc07fH
$LL4@detect_dat:

; 1136 :         if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))

  00012	41 f6 c0 01	 test	 r8b, 1
  00016	74 06		 je	 SHORT $LN2@detect_dat
  00018	66 83 38 00	 cmp	 WORD PTR [rax], 0
  0001c	75 50		 jne	 SHORT $LN15@detect_dat
$LN2@detect_dat:

; 1132 :     int n;
; 1133 : 
; 1134 :     /* Check for non-textual ("black-listed") bytes. */
; 1135 :     for (n = 0; n <= 31; n++, black_mask >>= 1)

  0001e	48 ff c2	 inc	 rdx
  00021	41 d1 e8	 shr	 r8d, 1
  00024	48 83 c0 04	 add	 rax, 4
  00028	48 83 fa 1f	 cmp	 rdx, 31
  0002c	7e e4		 jle	 SHORT $LL4@detect_dat

; 1137 :             return Z_BINARY;
; 1138 : 
; 1139 :     /* Check for textual ("white-listed") bytes. */
; 1140 :     if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
; 1141 :             || s->dyn_ltree[13].Freq != 0)

  0002e	66 83 b9 e0 00
	00 00 00	 cmp	 WORD PTR [rcx+224], 0
  00036	75 39		 jne	 SHORT $LN10@detect_dat
  00038	66 83 b9 e4 00
	00 00 00	 cmp	 WORD PTR [rcx+228], 0
  00040	75 2f		 jne	 SHORT $LN10@detect_dat
  00042	66 83 b9 f0 00
	00 00 00	 cmp	 WORD PTR [rcx+240], 0
  0004a	75 25		 jne	 SHORT $LN10@detect_dat

; 1143 :     for (n = 32; n < LITERALS; n++)

  0004c	b9 20 00 00 00	 mov	 ecx, 32			; 00000020H
  00051	49 8d 81 3c 01
	00 00		 lea	 rax, QWORD PTR [r9+316]
$LL7@detect_dat:

; 1144 :         if (s->dyn_ltree[n].Freq != 0)

  00058	66 83 38 00	 cmp	 WORD PTR [rax], 0
  0005c	75 13		 jne	 SHORT $LN10@detect_dat

; 1143 :     for (n = 32; n < LITERALS; n++)

  0005e	48 ff c1	 inc	 rcx
  00061	48 83 c0 04	 add	 rax, 4
  00065	48 81 f9 00 01
	00 00		 cmp	 rcx, 256		; 00000100H
  0006c	7c ea		 jl	 SHORT $LL7@detect_dat
$LN15@detect_dat:

; 1145 :             return Z_TEXT;
; 1146 : 
; 1147 :     /* There are no "black-listed" or "white-listed" bytes:
; 1148 :      * this stream either is empty or has tolerated ("gray-listed") bytes only.
; 1149 :      */
; 1150 :     return Z_BINARY;

  0006e	33 c0		 xor	 eax, eax

; 1151 : }

  00070	c3		 ret	 0
$LN10@detect_dat:

; 1142 :         return Z_TEXT;

  00071	b8 01 00 00 00	 mov	 eax, 1

; 1151 : }

  00076	c3		 ret	 0
detect_data_type ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT bi_reverse
_TEXT	SEGMENT
code$ = 8
len$ = 16
bi_reverse PROC						; COMDAT

; 1162 :     register unsigned res = 0;

  00000	33 c0		 xor	 eax, eax
$LL4@bi_reverse:

; 1163 :     do {
; 1164 :         res |= code & 1;

  00002	44 8b c1	 mov	 r8d, ecx

; 1165 :         code >>= 1, res <<= 1;
; 1166 :     } while (--len > 0);

  00005	ff ca		 dec	 edx
  00007	41 83 e0 01	 and	 r8d, 1
  0000b	d1 e9		 shr	 ecx, 1
  0000d	41 0b c0	 or	 eax, r8d
  00010	03 c0		 add	 eax, eax
  00012	85 d2		 test	 edx, edx
  00014	7f ec		 jg	 SHORT $LL4@bi_reverse

; 1167 :     return res >> 1;

  00016	d1 e8		 shr	 eax, 1

; 1168 : }

  00018	c3		 ret	 0
bi_reverse ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT bi_flush
_TEXT	SEGMENT
s$ = 8
bi_flush PROC						; COMDAT

; 1176 :     if (s->bi_valid == 16) {

  00000	8b 81 14 17 00
	00		 mov	 eax, DWORD PTR [rcx+5908]
  00006	4c 8b c9	 mov	 r9, rcx
  00009	83 f8 10	 cmp	 eax, 16
  0000c	75 3e		 jne	 SHORT $LN2@bi_flush

; 1177 :         put_short(s, s->bi_buf);

  0000e	0f b6 81 10 17
	00 00		 movzx	 eax, BYTE PTR [rcx+5904]
  00015	44 8b 41 28	 mov	 r8d, DWORD PTR [rcx+40]
  00019	48 8b 51 10	 mov	 rdx, QWORD PTR [rcx+16]
  0001d	41 88 04 10	 mov	 BYTE PTR [r8+rdx], al
  00021	ff 41 28	 inc	 DWORD PTR [rcx+40]
  00024	8b 51 28	 mov	 edx, DWORD PTR [rcx+40]
  00027	41 0f b6 81 11
	17 00 00	 movzx	 eax, BYTE PTR [r9+5905]
  0002f	48 8b 49 10	 mov	 rcx, QWORD PTR [rcx+16]
  00033	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  00036	41 ff 41 28	 inc	 DWORD PTR [r9+40]

; 1178 :         s->bi_buf = 0;

  0003a	33 c0		 xor	 eax, eax

; 1179 :         s->bi_valid = 0;

  0003c	41 89 81 14 17
	00 00		 mov	 DWORD PTR [r9+5908], eax

; 1182 :         s->bi_buf >>= 8;

  00043	66 41 89 81 10
	17 00 00	 mov	 WORD PTR [r9+5904], ax

; 1184 :     }
; 1185 : }

  0004b	c3		 ret	 0
$LN2@bi_flush:

; 1180 :     } else if (s->bi_valid >= 8) {

  0004c	83 f8 08	 cmp	 eax, 8
  0004f	7c 2e		 jl	 SHORT $LN4@bi_flush

; 1181 :         put_byte(s, (Byte)s->bi_buf);

  00051	8b 51 28	 mov	 edx, DWORD PTR [rcx+40]
  00054	41 0f b6 81 10
	17 00 00	 movzx	 eax, BYTE PTR [r9+5904]
  0005c	48 8b 49 10	 mov	 rcx, QWORD PTR [rcx+16]
  00060	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  00063	41 ff 41 28	 inc	 DWORD PTR [r9+40]

; 1182 :         s->bi_buf >>= 8;

  00067	41 0f b6 81 11
	17 00 00	 movzx	 eax, BYTE PTR [r9+5905]

; 1183 :         s->bi_valid -= 8;

  0006f	41 83 81 14 17
	00 00 f8	 add	 DWORD PTR [r9+5908], -8
  00077	66 41 89 81 10
	17 00 00	 mov	 WORD PTR [r9+5904], ax
$LN4@bi_flush:

; 1184 :     }
; 1185 : }

  0007f	c3		 ret	 0
bi_flush ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File c:\mywork\pkcs\zlib-1.2.11\trees.c
;	COMDAT bi_windup
_TEXT	SEGMENT
s$ = 8
bi_windup PROC						; COMDAT

; 1193 :     if (s->bi_valid > 8) {

  00000	8b 81 14 17 00
	00		 mov	 eax, DWORD PTR [rcx+5908]
  00006	4c 8b c9	 mov	 r9, rcx
  00009	83 f8 08	 cmp	 eax, 8
  0000c	7e 1f		 jle	 SHORT $LN2@bi_windup

; 1194 :         put_short(s, s->bi_buf);

  0000e	44 8b 41 28	 mov	 r8d, DWORD PTR [rcx+40]
  00012	0f b6 81 10 17
	00 00		 movzx	 eax, BYTE PTR [rcx+5904]
  00019	48 8b 51 10	 mov	 rdx, QWORD PTR [rcx+16]
  0001d	41 88 04 10	 mov	 BYTE PTR [r8+rdx], al
  00021	ff 41 28	 inc	 DWORD PTR [rcx+40]
  00024	0f b6 81 11 17
	00 00		 movzx	 eax, BYTE PTR [rcx+5905]
  0002b	eb 0c		 jmp	 SHORT $LN6@bi_windup
$LN2@bi_windup:

; 1195 :     } else if (s->bi_valid > 0) {

  0002d	85 c0		 test	 eax, eax
  0002f	7e 16		 jle	 SHORT $LN4@bi_windup

; 1196 :         put_byte(s, (Byte)s->bi_buf);

  00031	41 0f b6 81 10
	17 00 00	 movzx	 eax, BYTE PTR [r9+5904]
$LN6@bi_windup:
  00039	8b 51 28	 mov	 edx, DWORD PTR [rcx+40]
  0003c	48 8b 49 10	 mov	 rcx, QWORD PTR [rcx+16]
  00040	88 04 0a	 mov	 BYTE PTR [rdx+rcx], al
  00043	41 ff 41 28	 inc	 DWORD PTR [r9+40]
$LN4@bi_windup:

; 1197 :     }
; 1198 :     s->bi_buf = 0;

  00047	33 c0		 xor	 eax, eax
  00049	66 41 89 81 10
	17 00 00	 mov	 WORD PTR [r9+5904], ax

; 1199 :     s->bi_valid = 0;

  00051	41 89 81 14 17
	00 00		 mov	 DWORD PTR [r9+5908], eax

; 1200 : #ifdef ZLIB_DEBUG
; 1201 :     s->bits_sent = (s->bits_sent+7) & ~7;
; 1202 : #endif
; 1203 : }

  00058	c3		 ret	 0
bi_windup ENDP
_TEXT	ENDS
END
