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

	TITLE	d:\_KAZE_new-stuff\_KAZE_hash_test_r2\_Peter_source\hash.cpp
	.686P
	.XMM
	include listing.inc
	.model	flat

INCLUDELIB OLDNAMES

PUBLIC	?HashMaPrime2c@@YAIPBDK@Z			; HashMaPrime2c
PUBLIC	?HashSBox@@YAIPBDK@Z				; HashSBox
PUBLIC	?NovakHashUnrolled@@YAIPBDK@Z			; NovakHashUnrolled
PUBLIC	?HashHanson@@YAIPBDK@Z				; HashHanson
PUBLIC	?HashMurmur2@@YAIPBDK@Z				; HashMurmur2
PUBLIC	?HashFletcher@@YAIPBDK@Z			; HashFletcher
PUBLIC	?HashRamakrishna@@YAIPBDK@Z			; HashRamakrishna
PUBLIC	?CRC32@@YAIPBDK@Z				; CRC32
PUBLIC	?HashArashPartow@@YAIPBDK@Z			; HashArashPartow
PUBLIC	?HashLookup3@@YAIPBDK@Z				; HashLookup3
PUBLIC	?HashOneAtTime@@YAIPBDK@Z			; HashOneAtTime
PUBLIC	?HashPaulHsieh@@YAIPBDK@Z			; HashPaulHsieh
PUBLIC	?HashLarson@@YAIPBDK@Z				; HashLarson
PUBLIC	?HashWeinberger@@YAIPBDK@Z			; HashWeinberger
PUBLIC	?HashUniversal@@YAIPBDK@Z			; HashUniversal
PUBLIC	?Hash65599@@YAIPBDK@Z				; Hash65599
PUBLIC	?Hash17_unrolled@@YAIPBDK@Z			; Hash17_unrolled
PUBLIC	?HashKernighanRitchie@@YAIPBDK@Z		; HashKernighanRitchie
PUBLIC	?HashBernstein@@YAIPBDK@Z			; HashBernstein
PUBLIC	?HashAlfalfa_QWORD@@YAIPBDK@Z			; HashAlfalfa_QWORD
PUBLIC	?HashAlfalfa_DWORD@@YAIPBDK@Z			; HashAlfalfa_DWORD
PUBLIC	?HashAlfalfa_HALF@@YAIPBDK@Z			; HashAlfalfa_HALF
PUBLIC	?HashAlfalfa@@YAIPBDK@Z				; HashAlfalfa
PUBLIC	?HashAlfalfa_Rollick@@YAIPBDK@Z			; HashAlfalfa_Rollick
PUBLIC	?Hash_Sixtinsensitive@@YAIPBDK@Z		; Hash_Sixtinsensitive
PUBLIC	?Hash_Sixtinsensitive_Boosted@@YAIPBDK@Z	; Hash_Sixtinsensitive_Boosted
PUBLIC	?HashFNV1a@@YAIPBDK@Z				; HashFNV1a
PUBLIC	?HashFNV1A_Nefertiti@@YAIPBDK@Z			; HashFNV1A_Nefertiti
PUBLIC	?FNV1A_Hash_WHIZ@@YAIPBDK@Z			; FNV1A_Hash_WHIZ
PUBLIC	?FNV1A_Hash_Peregrine@@YAIPBDK@Z		; FNV1A_Hash_Peregrine
PUBLIC	?FNV1A_Hash_Smaragd@@YAIPBDK@Z			; FNV1A_Hash_Smaragd
PUBLIC	?FNV1A_Hash_Jester@@YAIPBDK@Z			; FNV1A_Hash_Jester
PUBLIC	?FNV1A_Hash_Jesteress@@YAIPBDK@Z		; FNV1A_Hash_Jesteress
PUBLIC	?GetRDTSC@@YA_KXZ				; GetRDTSC
PUBLIC	?g_next_free_chain@@3IA				; g_next_free_chain
PUBLIC	?g_lines_count@@3KA				; g_lines_count
PUBLIC	?g_lines@@3PAULINE@@A				; g_lines
PUBLIC	?g_table_size@@3KA				; g_table_size
PUBLIC	?g_chains@@3PAUCHAIN@@A				; g_chains
PUBLIC	?g_crc_precalc@@3PAY0BAA@IA			; g_crc_precalc
PUBLIC	?g_text@@3PADA					; g_text
PUBLIC	?g_table_size_mask@@3KA				; g_table_size_mask
PUBLIC	?g_table@@3PAPAUCHAIN@@A			; g_table
EXTRN	_fseek:PROC
EXTRN	_ftell:PROC
EXTRN	_exit:PROC
EXTRN	_puts:PROC
EXTRN	_realloc:PROC
EXTRN	__imp__inet_addr@4:PROC
EXTRN	_fclose:PROC
EXTRN	_fgets:PROC
EXTRN	_fopen:PROC
EXTRN	_malloc:PROC
EXTRN	_free:PROC
EXTRN	_strncpy:PROC
EXTRN	_atoi:PROC
EXTRN	_printf:PROC
?g_next_free_chain@@3IA DD 01H DUP (?)			; g_next_free_chain
?g_lines_count@@3KA DD 01H DUP (?)			; g_lines_count
?g_lines@@3PAULINE@@A DD 01H DUP (?)			; g_lines
?g_table_size@@3KA DD 01H DUP (?)			; g_table_size
?g_chains@@3PAUCHAIN@@A DD 01H DUP (?)			; g_chains
?g_crc_precalc@@3PAY0BAA@IA DD 0400H DUP (?)		; g_crc_precalc
?g_text@@3PADA DD 01H DUP (?)				; g_text
?g_table_size_mask@@3KA DD 01H DUP (?)			; g_table_size_mask
?g_table@@3PAPAUCHAIN@@A DD 01H DUP (?)			; g_table
;	COMDAT ?name@?1??main@@9@4PAPBDA
_DATA	SEGMENT
?name@?1??main@@9@4PAPBDA DD FLAT:$SG-49		; `main'::`2'::name
	DD	FLAT:$SG-50
	DD	FLAT:$SG-51
	DD	FLAT:$SG-52
	DD	FLAT:$SG-53
	DD	FLAT:$SG-54
	DD	FLAT:$SG-55
	DD	FLAT:$SG-56
	DD	FLAT:$SG-57
	DD	FLAT:$SG-58
	DD	FLAT:$SG-59
	DD	FLAT:$SG-60
	DD	FLAT:$SG-61
	DD	FLAT:$SG-62
	DD	FLAT:$SG-63
	DD	FLAT:$SG-64
	DD	FLAT:$SG-65
	DD	FLAT:$SG-66
	DD	FLAT:$SG-67
	DD	FLAT:$SG-68
	DD	FLAT:$SG-69
	DD	FLAT:$SG-70
	DD	FLAT:$SG-71
	DD	FLAT:$SG-72
	DD	FLAT:$SG-73
	DD	FLAT:$SG-74
	DD	FLAT:$SG-75
	DD	FLAT:$SG-76
	DD	FLAT:$SG-77
	DD	FLAT:$SG-78
	DD	FLAT:$SG-79
	DD	FLAT:$SG-80
	DD	FLAT:$SG-81
_DATA	ENDS
;	COMDAT ?func@?1??main@@9@4QBQ6AIPBDK@ZB
CONST	SEGMENT
?func@?1??main@@9@4QBQ6AIPBDK@ZB DD FLAT:?FNV1A_Hash_Jesteress@@YAIPBDK@Z ; `main'::`2'::func
	DD	FLAT:?FNV1A_Hash_Jester@@YAIPBDK@Z
	DD	FLAT:?FNV1A_Hash_Smaragd@@YAIPBDK@Z
	DD	FLAT:?FNV1A_Hash_Peregrine@@YAIPBDK@Z
	DD	FLAT:?FNV1A_Hash_WHIZ@@YAIPBDK@Z
	DD	FLAT:?HashFNV1A_Nefertiti@@YAIPBDK@Z
	DD	FLAT:?HashFNV1a@@YAIPBDK@Z
	DD	FLAT:?Hash_Sixtinsensitive_Boosted@@YAIPBDK@Z
	DD	FLAT:?Hash_Sixtinsensitive@@YAIPBDK@Z
	DD	FLAT:?HashAlfalfa_Rollick@@YAIPBDK@Z
	DD	FLAT:?HashAlfalfa@@YAIPBDK@Z
	DD	FLAT:?HashAlfalfa_HALF@@YAIPBDK@Z
	DD	FLAT:?HashAlfalfa_DWORD@@YAIPBDK@Z
	DD	FLAT:?HashAlfalfa_QWORD@@YAIPBDK@Z
	DD	FLAT:?HashBernstein@@YAIPBDK@Z
	DD	FLAT:?HashKernighanRitchie@@YAIPBDK@Z
	DD	FLAT:?Hash17_unrolled@@YAIPBDK@Z
	DD	FLAT:?Hash65599@@YAIPBDK@Z
	DD	FLAT:?HashUniversal@@YAIPBDK@Z
	DD	FLAT:?HashWeinberger@@YAIPBDK@Z
	DD	FLAT:?HashLarson@@YAIPBDK@Z
	DD	FLAT:?HashPaulHsieh@@YAIPBDK@Z
	DD	FLAT:?HashOneAtTime@@YAIPBDK@Z
	DD	FLAT:?HashLookup3@@YAIPBDK@Z
	DD	FLAT:?HashArashPartow@@YAIPBDK@Z
	DD	FLAT:?CRC32@@YAIPBDK@Z
	DD	FLAT:?HashRamakrishna@@YAIPBDK@Z
	DD	FLAT:?HashFletcher@@YAIPBDK@Z
	DD	FLAT:?HashMurmur2@@YAIPBDK@Z
	DD	FLAT:?HashHanson@@YAIPBDK@Z
	DD	FLAT:?NovakHashUnrolled@@YAIPBDK@Z
	DD	FLAT:?HashSBox@@YAIPBDK@Z
	DD	FLAT:?HashMaPrime2c@@YAIPBDK@Z
CONST	ENDS
;	COMDAT ?word@?1??PrintTestWords@@YAXQBQ6AIPBDK@ZQAPBDK@Z@4PAPBDA
_DATA	SEGMENT
?word@?1??PrintTestWords@@YAXQBQ6AIPBDK@ZQAPBDK@Z@4PAPBDA DD FLAT:$SG-19 ; `PrintTestWords'::`2'::word
	DD	FLAT:$SG-20
	DD	FLAT:$SG-21
	DD	FLAT:$SG-22
	DD	FLAT:$SG-23
	DD	FLAT:$SG-24
	DD	FLAT:$SG-25
	DD	FLAT:$SG-26
	DD	FLAT:$SG-27
	DD	FLAT:$SG-28
	DD	FLAT:$SG-29
	DD	FLAT:$SG-30
	DD	FLAT:$SG-31
	DD	FLAT:$SG-32
	DD	FLAT:$SG-33
	DD	FLAT:$SG-34
	DD	FLAT:$SG-35
	DD	FLAT:$SG-36
_sTable	DB	0a3H
	DB	0d7H
	DB	09H
	DB	083H
	DB	0f8H
	DB	048H
	DB	0f6H
	DB	0f4H
	DB	0b3H
	DB	021H
	DB	015H
	DB	078H
	DB	099H
	DB	0b1H
	DB	0afH
	DB	0f9H
	DB	0e7H
	DB	02dH
	DB	04dH
	DB	08aH
	DB	0ceH
	DB	04cH
	DB	0caH
	DB	02eH
	DB	052H
	DB	095H
	DB	0d9H
	DB	01eH
	DB	04eH
	DB	038H
	DB	044H
	DB	028H
	DB	0aH
	DB	0dfH
	DB	02H
	DB	0a0H
	DB	017H
	DB	0f1H
	DB	060H
	DB	068H
	DB	012H
	DB	0b7H
	DB	07aH
	DB	0c3H
	DB	0e9H
	DB	0faH
	DB	03dH
	DB	053H
	DB	096H
	DB	084H
	DB	06bH
	DB	0baH
	DB	0f2H
	DB	063H
	DB	09aH
	DB	019H
	DB	07cH
	DB	0aeH
	DB	0e5H
	DB	0f5H
	DB	0f7H
	DB	016H
	DB	06aH
	DB	0a2H
	DB	039H
	DB	0b6H
	DB	07bH
	DB	0fH
	DB	0c1H
	DB	093H
	DB	081H
	DB	01bH
	DB	0eeH
	DB	0b4H
	DB	01aH
	DB	0eaH
	DB	0d0H
	DB	091H
	DB	02fH
	DB	0b8H
	DB	055H
	DB	0b9H
	DB	0daH
	DB	085H
	DB	03fH
	DB	041H
	DB	0bfH
	DB	0e0H
	DB	05aH
	DB	058H
	DB	080H
	DB	05fH
	DB	066H
	DB	0bH
	DB	0d8H
	DB	090H
	DB	035H
	DB	0d5H
	DB	0c0H
	DB	0a7H
	DB	033H
	DB	06H
	DB	065H
	DB	069H
	DB	045H
	DB	00H
	DB	094H
	DB	056H
	DB	06dH
	DB	098H
	DB	09bH
	DB	076H
	DB	097H
	DB	0fcH
	DB	0b2H
	DB	0c2H
	DB	0b0H
	DB	0feH
	DB	0dbH
	DB	020H
	DB	0e1H
	DB	0ebH
	DB	0d6H
	DB	0e4H
	DB	0ddH
	DB	047H
	DB	04aH
	DB	01dH
	DB	042H
	DB	0edH
	DB	09eH
	DB	06eH
	DB	049H
	DB	03cH
	DB	0cdH
	DB	043H
	DB	027H
	DB	0d2H
	DB	07H
	DB	0d4H
	DB	0deH
	DB	0c7H
	DB	067H
	DB	018H
	DB	089H
	DB	0cbH
	DB	030H
	DB	01fH
	DB	08dH
	DB	0c6H
	DB	08fH
	DB	0aaH
	DB	0c8H
	DB	074H
	DB	0dcH
	DB	0c9H
	DB	05dH
	DB	05cH
	DB	031H
	DB	0a4H
	DB	070H
	DB	088H
	DB	061H
	DB	02cH
	DB	09fH
	DB	0dH
	DB	02bH
	DB	087H
	DB	050H
	DB	082H
	DB	054H
	DB	064H
	DB	026H
	DB	07dH
	DB	03H
	DB	040H
	DB	034H
	DB	04bH
	DB	01cH
	DB	073H
	DB	0d1H
	DB	0c4H
	DB	0fdH
	DB	03bH
	DB	0ccH
	DB	0fbH
	DB	07fH
	DB	0abH
	DB	0e6H
	DB	03eH
	DB	05bH
	DB	0a5H
	DB	0adH
	DB	04H
	DB	023H
	DB	09cH
	DB	014H
	DB	051H
	DB	022H
	DB	0f0H
	DB	029H
	DB	079H
	DB	071H
	DB	07eH
	DB	0ffH
	DB	08cH
	DB	0eH
	DB	0e2H
	DB	0cH
	DB	0efH
	DB	0bcH
	DB	072H
	DB	075H
	DB	06fH
	DB	037H
	DB	0a1H
	DB	0ecH
	DB	0d3H
	DB	08eH
	DB	062H
	DB	08bH
	DB	086H
	DB	010H
	DB	0e8H
	DB	08H
	DB	077H
	DB	011H
	DB	0beH
	DB	092H
	DB	04fH
	DB	024H
	DB	0c5H
	DB	032H
	DB	036H
	DB	09dH
	DB	0cfH
	DB	0f3H
	DB	0a6H
	DB	0bbH
	DB	0acH
	DB	05eH
	DB	06cH
	DB	0a9H
	DB	013H
	DB	057H
	DB	025H
	DB	0b5H
	DB	0e3H
	DB	0bdH
	DB	0a8H
	DB	03aH
	DB	01H
	DB	05H
	DB	059H
	DB	02aH
	DB	046H
_sbox	DD	0f53e1837H
	DD	05f14c86bH
	DD	09ee3964cH
	DD	0fa796d53H
	DD	032223fc3H
	DD	04d82bc98H
	DD	0a0c7fa62H
	DD	063e2c982H
	DD	024994a5bH
	DD	01ece7beeH
	DD	0292b38efH
	DD	0d5cd4e56H
	DD	0514f4303H
	DD	07be12b83H
	DD	07192f195H
	DD	082dc7300H
	DD	084380b4H
	DD	0480b55d3H
	DD	05f430471H
	DD	013f75991H
	DD	03f9cf22cH
	DD	02fe0907aH
	DD	0fd8e1e69H
	DD	07b1d5de8H
	DD	0d575a85cH
	DD	0ad01c50aH
	DD	07ee00737H
	DD	03ce981e8H
	DD	0e447efaH
	DD	023089dd6H
	DD	0b59f149fH
	DD	013600ec7H
	DD	0e802c8e6H
	DD	0670921e4H
	DD	07207eff0H
	DD	0e74761b0H
	DD	069035234H
	DD	0bfa40f19H
	DD	0f63651a0H
	DD	029e64c26H
	DD	01f98cca7H
	DD	0d957007eH
	DD	0e71ddc75H
	DD	03e729595H
	DD	07580b7ccH
	DD	0d7faf60bH
	DD	092484323H
	DD	0a44113ebH
	DD	0e4cbde08H
	DD	0346827c9H
	DD	03cf32afaH
	DD	0b29bcf1H
	DD	06e29f7dfH
	DD	0b01e71cbH
	DD	03bfbc0d1H
	DD	062edc5b8H
	DD	0b7de789aH
	DD	0a4748ec9H
	DD	0e17a4c4fH
	DD	067e5bd03H
	DD	0f3b33d1aH
	DD	097d8d3e9H
	DD	09121bc0H
	DD	0347b2d2cH
	DD	079a1913cH
	DD	0504172deH
	DD	07f1f8483H
	DD	013ac3cf6H
	DD	07a2094dbH
	DD	0c778fa12H
	DD	0adf7469fH
	DD	021786b7bH
	DD	071a445d0H
	DD	0a8896c1bH
	DD	0656f62fbH
	DD	083a059b3H
	DD	0972dfe6eH
	DD	04122000cH
	DD	097d9da19H
	DD	017d5947bH
	DD	0b1affd0cH
	DD	06ef83b97H
	DD	0af7f780bH
	DD	04613138aH
	DD	07c3e73a6H
	DD	0cf15e03dH
	DD	041576322H
	DD	0672df292H
	DD	0b658588dH
	DD	033ebefa9H
	DD	0938cbf06H
	DD	06b67381H
	DD	07f192c6H
	DD	02bda5855H
	DD	0348ee0e8H
	DD	019dbb6e3H
	DD	03222184bH
	DD	0b69d5dbaH
	DD	07e760b88H
	DD	0af4d8154H
	DD	07a51adH
	DD	035112500H
	DD	0c9cd2d7dH
	DD	04f4fb761H
	DD	0694772e3H
	DD	0694c8351H
	DD	04a7e3af5H
	DD	067d65ce1H
	DD	09287de92H
	DD	02518db3cH
	DD	08cb4ec06H
	DD	0d154d38fH
	DD	0e19a26bbH
	DD	0295ee439H
	DD	0c50a1104H
	DD	02153c6a7H
	DD	082366656H
	DD	0713bc2fH
	DD	06462215aH
	DD	021d9bfceH
	DD	0ba8eace6H
	DD	0ae2df4c1H
	DD	02a8d5e80H
	DD	03f7e52d1H
	DD	029359399H
	DD	0fea1d19cH
	DD	018879313H
	DD	0455afa81H
	DD	0fadfe838H
	DD	062609838H
	DD	0d1028839H
	DD	0736e92fH
	DD	03bca22a3H
	DD	01485b08aH
	DD	02da7900bH
	DD	0852c156dH
	DD	0e8f24803H
	DD	078472H
	DD	013f0d332H
	DD	02acfd0cfH
	DD	05f747f5cH
	DD	087bb1e2fH
	DD	0a7efcb63H
	DD	023f432f0H
	DD	0e6ce7c5cH
	DD	01f954ef6H
	DD	0b609c91bH
	DD	03b4571bfH
	DD	0eed17dc0H
	DD	0e556cda0H
	DD	0a7846a8dH
	DD	0ff105f94H
	DD	052b7ccdeH
	DD	0e33e801H
	DD	0664455eaH
	DD	0f2c70414H
	DD	073e7b486H
	DD	08f830661H
	DD	08b59e826H
	DD	0bb8aedcaH
	DD	0f3d70ab9H
	DD	0d739f2b9H
	DD	04a04c34aH
	DD	088d0f089H
	DD	0e02191a2H
	DD	0d89d9c78H
	DD	0192c2749H
	DD	0fc43a78fH
	DD	0aac88cbH
	DD	09438d42dH
	DD	09e280f7aH
	DD	036063802H
	DD	038e8d018H
	DD	01c42a9cbH
	DD	092aaff6cH
	DD	0a24820c5H
	DD	07f077fH
	DD	0ce5bc543H
	DD	069668d58H
	DD	010d6ff74H
	DD	0be00f621H
	DD	021300bbeH
	DD	02e9e8f46H
	DD	05acea629H
	DD	0fa1f86c7H
	DD	052f206b8H
	DD	03edf1a75H
	DD	06da8d843H
	DD	0cf719928H
	DD	073e3891fH
	DD	0b4b95dd6H
	DD	0b2a42d27H
	DD	0eda20bbfH
	DD	01a58dbdfH
	DD	0a449ad03H
	DD	06ddef22bH
	DD	0900531e6H
	DD	03d3bff35H
	DD	05b24aba2H
	DD	0472b3e4cH
	DD	0387f2d75H
	DD	04d8dba36H
	DD	071cb5641H
	DD	0e3473f3fH
	DD	0f6cd4b7fH
	DD	0bf7d1428H
	DD	0344b64d0H
	DD	0c5cdfcb6H
	DD	0fe2e0182H
	DD	02c37a673H
	DD	0de4eb7a3H
	DD	063fdc933H
	DD	01dc4063H
	DD	0611f3571H
	DD	0d167bfafH
	DD	04496596fH
	DD	03dee0689H
	DD	0d8704910H
	DD	07052a114H
	DD	068c9ec5H
	DD	075d0e766H
	DD	04d54cc20H
	DD	0b44ecde2H
	DD	04abc653eH
	DD	02c550a21H
	DD	01a52c0dbH
	DD	0cfed03d0H
	DD	0119bafe2H
	DD	0876a6133H
	DD	0bc232088H
	DD	0435ba1b2H
	DD	0ae99bbfaH
	DD	0bb4f08e4H
	DD	0a62b5f49H
	DD	01da4b695H
	DD	0336b84deH
	DD	0dc813d31H
	DD	0c134fbH
	DD	0397a98e6H
	DD	0151f0e64H
	DD	0d9eb3e69H
	DD	0d3c7df60H
	DD	0d2f2c336H
	DD	02ddd067bH
	DD	0bd122835H
	DD	0b0b3bd3aH
	DD	0b0d54e46H
	DD	08641f1e4H
	DD	0a0b38f96H
	DD	051d39199H
	DD	037a6ad75H
	DD	0df84ee41H
	DD	03c034cbaH
	DD	0acda62fcH
	DD	011923b8bH
	DD	045ef170aH
$SG-5	DB	'Not enough memory', 00H
	ORG $+2
$SG-6	DB	'r', 00H
	ORG $+2
$SG-7	DB	'Can''t open the file', 00H
$SG-8	DB	'Not enough memory', 00H
	ORG $+2
$SG-9	DB	'Not enough memory', 00H
	ORG $+6
$SG-10	DB	'table too large (decrease the number of bits or use a 64'
	DB	'-bit compiler)', 00H
	ORG $+1
$SG-11	DB	'Not enough memory', 00H
	ORG $+2
$SG-12	DB	'Not enough memory', 00H
	ORG $+2
$SG-13	DB	'%20s: ', 00H
	ORG $+1
$SG-14	DB	' %8.3f %c', 0aH, 00H
	ORG $+1
$SG-15	DB	'%20s: ', 00H
	ORG $+1
$SG-16	DB	'%10I64d', 00H
$SG-17	DB	'|%10I64d', 00H
	ORG $+3
$SG-18	DB	' [%8d]', 0aH, 00H
$SG-19	DB	'too', 00H
$SG-20	DB	'top', 00H
$SG-21	DB	'tor', 00H
$SG-22	DB	'tpp', 00H
$SG-23	DB	'a000', 00H
	ORG $+3
$SG-24	DB	'a001', 00H
	ORG $+3
$SG-25	DB	'a002', 00H
	ORG $+3
$SG-26	DB	'a003', 00H
	ORG $+3
$SG-27	DB	'a004', 00H
	ORG $+3
$SG-28	DB	'a005', 00H
	ORG $+3
$SG-29	DB	'a006', 00H
	ORG $+3
$SG-30	DB	'a007', 00H
	ORG $+3
$SG-31	DB	'a008', 00H
	ORG $+3
$SG-32	DB	'a009', 00H
	ORG $+3
$SG-33	DB	'a010', 00H
	ORG $+3
$SG-34	DB	'a', 00H
	ORG $+2
$SG-35	DB	'aa', 00H
	ORG $+1
$SG-36	DB	'aaa', 00H
$SG-37	DB	'%4c', 00H
$SG-38	DB	'%10s', 00H
	ORG $+3
$SG-39	DB	0aH, 00H
	ORG $+2
$SG-40	DB	'%4s', 00H
$SG-41	DB	'%10x', 00H
	ORG $+3
$SG-42	DB	0aH, 00H
	ORG $+2
$SG-43	DB	'%20c  ', 00H
	ORG $+1
$SG-44	DB	' %8d', 00H
	ORG $+3
$SG-45	DB	0aH, 00H
	ORG $+2
$SG-46	DB	'%20s: ', 00H
	ORG $+1
$SG-47	DB	' %8d', 00H
	ORG $+3
$SG-48	DB	0aH, 00H
	ORG $+2
$SG-49	DB	'FNV1A_Jesteress', 00H
$SG-50	DB	'FNV1A_Jester', 00H
	ORG $+3
$SG-51	DB	'FNV1A_Smaragd', 00H
	ORG $+2
$SG-52	DB	'FNV1A_Peregrine', 00H
$SG-53	DB	'FNV1A_Whiz', 00H
	ORG $+1
$SG-54	DB	'FNV1A_Nefertiti', 00H
$SG-55	DB	'FNV-1a', 00H
	ORG $+1
$SG-56	DB	'Sixtinsensitive+', 00H
	ORG $+3
$SG-57	DB	'Sixtinsensitive', 00H
$SG-58	DB	'Alfalfa_Rollick', 00H
$SG-59	DB	'Alfalfa', 00H
$SG-60	DB	'Alfalfa_HALF', 00H
	ORG $+3
$SG-61	DB	'Alfalfa_DWORD', 00H
	ORG $+2
$SG-62	DB	'Alfalfa_QWORD', 00H
	ORG $+2
$SG-63	DB	'Bernstein', 00H
	ORG $+2
$SG-64	DB	'K&R', 00H
$SG-65	DB	'x17 unrolled', 00H
	ORG $+3
$SG-66	DB	'x65599', 00H
	ORG $+1
$SG-67	DB	'Sedgewick', 00H
	ORG $+2
$SG-68	DB	'Weinberger', 00H
	ORG $+1
$SG-69	DB	'Paul Larson', 00H
$SG-70	DB	'Paul Hsieh', 00H
	ORG $+1
$SG-71	DB	'One At Time', 00H
$SG-72	DB	'lookup3', 00H
$SG-73	DB	'Arash Partow', 00H
	ORG $+3
$SG-74	DB	'CRC-32', 00H
	ORG $+1
$SG-75	DB	'Ramakrishna', 00H
$SG-76	DB	'Fletcher', 00H
	ORG $+3
$SG-77	DB	'Murmur2', 00H
$SG-78	DB	'Hanson', 00H
	ORG $+1
$SG-79	DB	'Novak unrolled', 00H
	ORG $+1
$SG-80	DB	'SBox', 00H
	ORG $+3
$SG-81	DB	'MaPrime2c', 00H
	ORG $+2
$SG-82	DB	'More than one file name on command line', 00H
$SG-83	DB	'ip', 00H
	ORG $+1
$SG-84	DB	'c', 00H
	ORG $+2
$SG-85	DB	'q', 00H
	ORG $+2
$SG-86	DB	'Invalid command-line switch', 00H
$SG-88	DB	'%d lines read', 0aH, '%d elements in the table (%d bits)'
	DB	0aH, 00H
	ORG $+2
$SG-87	DB	'Usage: hash TEXT-FILE [/sBITS] [/ip] [/c]', 0aH, '  /s  '
	DB	' The number of bits, e.g. /s16 for a 65536-element table. ', 0aH
	DB	'       If not given, a default value is used', 0aH, '  /ip  R'
	DB	'ead IPv4 addresses', 0aH, '  /c   Tabulate collisions', 0aH, ' '
	DB	' /q   Hash function quality', 0aH, 00H
$SG-89	DB	'iSCSI CRC', 00H
_scatter DD	07be9c1bdH
	DD	088aa102H
	DD	03d38509bH
	DD	0746b9fbeH
	DD	02d04417fH
	DD	0775d4351H
	DD	053c48d96H
	DD	02b26e0bH
	DD	0418fedcfH
	DD	019dbc19eH
	DD	078512adbH
	DD	01a1f5e2bH
	DD	0307d7761H
	DD	06584c1f0H
	DD	024e3c36fH
	DD	02232310fH
	DD	02dac5cebH
	DD	0106e8b5aH
	DD	05a05a938H
	DD	05e6392b6H
	DD	066b90348H
	DD	075264901H
	DD	04174f402H
	DD	0618b18a4H
	DD	03a6ab4bfH
	DD	03c4bc289H
	DD	02657a9a9H
	DD	04e68589bH
	DD	09648aa6H
	DD	03fc489bbH
	DD	01c1b715cH
	DD	054e4c63H
	DD	0484f2abdH
	DD	05953c1f8H
	DD	079b9ec22H
	DD	075536c3dH
	DD	050b10549H
	DD	04d7e79b8H
	DD	07805da48H
	DD	01240f318H
	DD	0675a3b56H
	DD	070570523H
	DD	02c605143H
	DD	017d7b2b7H
	DD	055dbc713H
	DD	0514414b2H
	DD	03a09e3c7H
	DD	038823ffH
	DD	061b2a00cH
	DD	0140f8cffH
	DD	061ebb6b5H
	DD	0486ba354H
	DD	0935d600H
	DD	02360aab8H
	DD	029f6bbf8H
	DD	043a08abfH
	DD	05fac6d41H
	DD	0504e65a2H
	DD	01208e35bH
	DD	06910f7e7H
	DD	01012ef5dH
	DD	02e2454b7H
	DD	06e5f444bH
	DD	058621a1bH
	DD	077816afH
	DD	06819306dH
	DD	04db58658H
	DD	058291bf8H
	DD	03597aa25H
	DD	045bb60a0H
	DD	06a6a0f11H
	DD	01cf1e57cH
	DD	0361265c4H
	DD	016ca6054H
	DD	034c99833H
	DD	0bee2cd7H
	DD	0680e7507H
	DD	06ed37bfaH
	DD	0f7650d6H
	DD	049c11513H
	DD	02e308f9H
	DD	07162078cH
	DD	0122cb868H
	DD	0c18defaH
	DD	014c2b244H
	DD	03c237460H
	DD	04fb969b9H
	DD	0746f1f85H
	DD	0c71da02H
	DD	061c24d14H
	DD	05d80176dH
	DD	01c84c960H
	DD	0fe6a1ccH
	DD	04bdf5bb8H
	DD	074e6e37bH
	DD	0175eb87bH
	DD	033f88c25H
	DD	0429c69d3H
	DD	06f87d474H
	DD	06990364aH
	DD	0857ca73H
	DD	059f1e385H
	DD	06821bc6H
	DD	03e6a3037H
	DD	070bc43d9H
	DD	03b4bb3faH
	DD	04a585d0fH
	DD	058cab8e0H
	DD	02a1f2ff4H
	DD	059ceade5H
	DD	0228bcdf4H
	DD	02d0238eeH
	DD	04b30b571H
	DD	034b8865cH
	DD	0391b17e8H
	DD	05ff367b5H
	DD	070dbfabcH
	DD	08d481a1H
	DD	05462873bH
	DD	07d4dd4bfH
	DD	06a96ceb6H
	DD	031e29ea8H
	DD	019d29e1fH
	DD	07a7d7082H
	DD	07dc1fa60H
	DD	0eb9819aH
	DD	011dc28fdH
	DD	031ba8685H
	DD	05155eb6dH
	DD	0163fd71H
	DD	01b4abccfH
	DD	059adb5e0H
	DD	05b55e0f6H
	DD	021ccd896H
	DD	01817e618H
	DD	04c1224d0H
	DD	05d188c90H
	DD	062704327H
	DD	024dcddb0H
	DD	0737bc84H
	DD	03c3ef10cH
	DD	04768aba4H
	DD	03439f572H
	DD	076fa67eH
	DD	07c213200H
	DD	06d550d5aH
	DD	067630e33H
	DD	06cfd2cbdH
	DD	076298efcH
	DD	03bc5956eH
	DD	06a4b017cH
	DD	060c05db2H
	DD	06da83416H
	DD	041d9f9bH
	DD	05b3dce34H
	DD	06b6a2e76H
	DD	012d72135H
	DD	06d19f731H
	DD	01d24b4fbH
	DD	0642d0ca2H
	DD	06e7df4a3H
	DD	0386f71cbH
	DD	03ddac282H
	DD	049d3d599H
	DD	05a3c4a61H
	DD	055f2a89aH
	DD	015e5fa69H
	DD	03754d6f1H
	DD	03862ebc1H
	DD	03ac2d81aH
	DD	03e8c9375H
	DD	074a1dcceH
	DD	022b83beH
	DD	072c688e8H
	DD	07c11834cH
	DD	07e4cb5bfH
	DD	0601b9642H
	DD	06374917fH
	DD	06b49e27cH
	DD	05645253eH
	DD	01f3a26eeH
	DD	05594e3f8H
	DD	0370582f0H
	DD	0ce25b04H
	DD	059b28393H
	DD	012435124H
	DD	0784c897bH
	DD	06c89a4c8H
	DD	07f5d4856H
	DD	015713e76H
	DD	050b6b16aH
	DD	06ddb3cf9H
	DD	04de0b041H
	DD	0e9173ecH
	DD	037af1292H
	DD	0281cfaa2H
	DD	064841c87H
	DD	04d950cfcH
	DD	05f71d193H
	DD	01ce70848H
	DD	0857e516H
	DD	01dfe6509H
	DD	01188e516H
	DD	0a8368d4H
	DD	010c4edf1H
	DD	0d9a6862H
	DD	08d01e93H
	DD	070e08433H
	DD	0710ef9e2H
	DD	0741a010fH
	DD	04725a972H
	DD	0104920d0H
	DD	049aee507H
	DD	07e2b2c62H
	DD	01d2b7bd4H
	DD	02361689aH
	DD	0106e7d87H
	DD	01578054fH
	DD	0feb0d62H
	DD	0fcbc5ddH
	DD	02ae943c6H
	DD	060a1beccH
	DD	07da702d6H
	DD	078c9f407H
	DD	06f3332b9H
	DD	035561568H
	DD	020e6eeaaH
	DD	053b74f40H
	DD	02eb2264H
	DD	058c03dH
	DD	0709e5788H
	DD	0b43077aH
	DD	01e572546H
	DD	02273c9fH
	DD	015c6704fH
	DD	02f1c1337H
	DD	0fc1a501H
	DD	01e968ee2H
	DD	01ffc976bH
	DD	0d09ee3H
	DD	012b08ff2H
	DD	0672240ddH
	DD	01119bfb3H
	DD	05c5f74f9H
	DD	0654d6d3fH
	DD	02e453b88H
	DD	07fc0dd94H
	DD	075bbeac6H
	DD	043bd40d7H
	DD	0fabeaf6H
	DD	0587b0a3H
	DD	06ea6849dH
	DD	0704da9c3H
	DD	032eb379H
	DD	0677078a5H
	DD	05f80dc7cH
_rijndaelSBox DB 063H
	DB	07cH
	DB	077H
	DB	07bH
	DB	0f2H
	DB	06bH
	DB	06fH
	DB	0c5H
	DB	030H
	DB	01H
	DB	067H
	DB	02bH
	DB	0feH
	DB	0d7H
	DB	0abH
	DB	076H
	DB	0caH
	DB	082H
	DB	0c9H
	DB	07dH
	DB	0faH
	DB	059H
	DB	047H
	DB	0f0H
	DB	0adH
	DB	0d4H
	DB	0a2H
	DB	0afH
	DB	09cH
	DB	0a4H
	DB	072H
	DB	0c0H
	DB	0b7H
	DB	0fdH
	DB	093H
	DB	026H
	DB	036H
	DB	03fH
	DB	0f7H
	DB	0ccH
	DB	034H
	DB	0a5H
	DB	0e5H
	DB	0f1H
	DB	071H
	DB	0d8H
	DB	031H
	DB	015H
	DB	04H
	DB	0c7H
	DB	023H
	DB	0c3H
	DB	018H
	DB	096H
	DB	05H
	DB	09aH
	DB	07H
	DB	012H
	DB	080H
	DB	0e2H
	DB	0ebH
	DB	027H
	DB	0b2H
	DB	075H
	DB	09H
	DB	083H
	DB	02cH
	DB	01aH
	DB	01bH
	DB	06eH
	DB	05aH
	DB	0a0H
	DB	052H
	DB	03bH
	DB	0d6H
	DB	0b3H
	DB	029H
	DB	0e3H
	DB	02fH
	DB	084H
	DB	053H
	DB	0d1H
	DB	00H
	DB	0edH
	DB	020H
	DB	0fcH
	DB	0b1H
	DB	05bH
	DB	06aH
	DB	0cbH
	DB	0beH
	DB	039H
	DB	04aH
	DB	04cH
	DB	058H
	DB	0cfH
	DB	0d0H
	DB	0efH
	DB	0aaH
	DB	0fbH
	DB	043H
	DB	04dH
	DB	033H
	DB	085H
	DB	045H
	DB	0f9H
	DB	02H
	DB	07fH
	DB	050H
	DB	03cH
	DB	09fH
	DB	0a8H
	DB	051H
	DB	0a3H
	DB	040H
	DB	08fH
	DB	092H
	DB	09dH
	DB	038H
	DB	0f5H
	DB	0bcH
	DB	0b6H
	DB	0daH
	DB	021H
	DB	010H
	DB	0ffH
	DB	0f3H
	DB	0d2H
	DB	0cdH
	DB	0cH
	DB	013H
	DB	0ecH
	DB	05fH
	DB	097H
	DB	044H
	DB	017H
	DB	0c4H
	DB	0a7H
	DB	07eH
	DB	03dH
	DB	064H
	DB	05dH
	DB	019H
	DB	073H
	DB	060H
	DB	081H
	DB	04fH
	DB	0dcH
	DB	022H
	DB	02aH
	DB	090H
	DB	088H
	DB	046H
	DB	0eeH
	DB	0b8H
	DB	014H
	DB	0deH
	DB	05eH
	DB	0bH
	DB	0dbH
	DB	0e0H
	DB	032H
	DB	03aH
	DB	0aH
	DB	049H
	DB	06H
	DB	024H
	DB	05cH
	DB	0c2H
	DB	0d3H
	DB	0acH
	DB	062H
	DB	091H
	DB	095H
	DB	0e4H
	DB	079H
	DB	0e7H
	DB	0c8H
	DB	037H
	DB	06dH
	DB	08dH
	DB	0d5H
	DB	04eH
	DB	0a9H
	DB	06cH
	DB	056H
	DB	0f4H
	DB	0eaH
	DB	065H
	DB	07aH
	DB	0aeH
	DB	08H
	DB	0baH
	DB	078H
	DB	025H
	DB	02eH
	DB	01cH
	DB	0a6H
	DB	0b4H
	DB	0c6H
	DB	0e8H
	DB	0ddH
	DB	074H
	DB	01fH
	DB	04bH
	DB	0bdH
	DB	08bH
	DB	08aH
	DB	070H
	DB	03eH
	DB	0b5H
	DB	066H
	DB	048H
	DB	03H
	DB	0f6H
	DB	0eH
	DB	061H
	DB	035H
	DB	057H
	DB	0b9H
	DB	086H
	DB	0c1H
	DB	01dH
	DB	09eH
	DB	0e1H
	DB	0f8H
	DB	098H
	DB	011H
	DB	069H
	DB	0d9H
	DB	08eH
	DB	094H
	DB	09bH
	DB	01eH
	DB	087H
	DB	0e9H
	DB	0ceH
	DB	055H
	DB	028H
	DB	0dfH
	DB	08cH
	DB	0a1H
	DB	089H
	DB	0dH
	DB	0bfH
	DB	0e6H
	DB	042H
	DB	068H
	DB	041H
	DB	099H
	DB	02dH
	DB	0fH
	DB	0b0H
	DB	054H
	DB	0bbH
	DB	016H
; Function compile flags: /Ogtpy
; File d:\_kaze_new-stuff\_kaze_hash_test_r2\_peter_source\hash.cpp
;	COMDAT ?GetRDTSC@@YA_KXZ
_TEXT	SEGMENT
?GetRDTSC@@YA_KXZ PROC					; GetRDTSC, COMDAT

; 1483 : UINT64 inline GetRDTSC(void) {

  00000	53		 push	 ebx

; 1485 :       ; Flush the pipeline
; 1486 :       XOR eax, eax

  00001	33 c0		 xor	 eax, eax

; 1487 :       CPUID

  00003	0f a2		 cpuid

; 1488 :       ; Get RDTSC counter in edx:eax
; 1489 :       RDTSC

  00005	0f 31		 rdtsc

; 1484 :    __asm {

  00007	5b		 pop	 ebx

; 1490 :    }
; 1491 : }

  00008	c3		 ret	 0
?GetRDTSC@@YA_KXZ ENDP					; GetRDTSC
_TEXT	ENDS
PUBLIC	__real@41f0000000000000
PUBLIC	?CountQuality@@YANI@Z				; CountQuality
EXTRN	__fltused:DWORD
;	COMDAT __real@41f0000000000000
CONST	SEGMENT
__real@41f0000000000000 DQ 041f0000000000000r	; 4.29497e+009
; Function compile flags: /Ogtpy
CONST	ENDS
_TEXT	SEGMENT
tv206 = -4						; size = 4
tv204 = -4						; size = 4
tv203 = -4						; size = 4
tv201 = -4						; size = 4
?CountQuality@@YANI@Z PROC				; CountQuality

; 1383 : double CountQuality(UINT items_count) {

  00000	51		 push	 ecx
  00001	55		 push	 ebp
  00002	8b 2d 00 00 00
	00		 mov	 ebp, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  00008	56		 push	 esi

; 1384 : 	UINT sum = 0;
; 1385 : 	for (UINT i = 0; i < g_table_size; i++) {

  00009	8b 35 00 00 00
	00		 mov	 esi, DWORD PTR ?g_table_size@@3KA ; g_table_size
  0000f	57		 push	 edi
  00010	33 ff		 xor	 edi, edi
  00012	33 d2		 xor	 edx, edx
  00014	85 f6		 test	 esi, esi
  00016	76 2e		 jbe	 SHORT $LN4@CountQuali
  00018	53		 push	 ebx
  00019	8b 1d 00 00 00
	00		 mov	 ebx, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  0001f	90		 npad	 1
$LL13@CountQuali:

; 1386 : 		UINT count = 0;
; 1387 : 		for (CHAIN* chain = g_table[i]; chain != NULL; chain = chain->next)

  00020	8b 04 93	 mov	 eax, DWORD PTR [ebx+edx*4]
  00023	33 c9		 xor	 ecx, ecx
  00025	85 c0		 test	 eax, eax
  00027	74 0f		 je	 SHORT $LN1@CountQuali
  00029	8d a4 24 00 00
	00 00		 npad	 7
$LL3@CountQuali:
  00030	8b 40 04	 mov	 eax, DWORD PTR [eax+4]

; 1388 : 			count++;

  00033	41		 inc	 ecx
  00034	85 c0		 test	 eax, eax
  00036	75 f8		 jne	 SHORT $LL3@CountQuali
$LN1@CountQuali:

; 1389 : 		sum += count * (count + 1);

  00038	8d 41 01	 lea	 eax, DWORD PTR [ecx+1]
  0003b	0f af c1	 imul	 eax, ecx
  0003e	42		 inc	 edx
  0003f	03 f8		 add	 edi, eax
  00041	3b d6		 cmp	 edx, esi
  00043	72 db		 jb	 SHORT $LL13@CountQuali
  00045	5b		 pop	 ebx
$LN4@CountQuali:

; 1390 : 	}
; 1391 : 	return (double)sum * g_table_size /
; 1392 : 		((double)items_count * (items_count + 2 * g_table_size - 1));

  00046	8b ce		 mov	 ecx, esi
  00048	89 4c 24 0c	 mov	 DWORD PTR tv206[esp+16], ecx
  0004c	db 44 24 0c	 fild	 DWORD PTR tv206[esp+16]
  00050	85 c9		 test	 ecx, ecx
  00052	7d 06		 jge	 SHORT $LN14@CountQuali
  00054	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@41f0000000000000
$LN14@CountQuali:
  0005a	89 7c 24 0c	 mov	 DWORD PTR tv204[esp+16], edi
  0005e	db 44 24 0c	 fild	 DWORD PTR tv204[esp+16]
  00062	85 ff		 test	 edi, edi
  00064	7d 06		 jge	 SHORT $LN15@CountQuali
  00066	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@41f0000000000000
$LN15@CountQuali:
  0006c	8d 54 75 ff	 lea	 edx, DWORD PTR [ebp+esi*2-1]
  00070	de c9		 fmulp	 ST(1), ST(0)
  00072	89 54 24 0c	 mov	 DWORD PTR tv203[esp+16], edx
  00076	db 44 24 0c	 fild	 DWORD PTR tv203[esp+16]
  0007a	85 d2		 test	 edx, edx
  0007c	7d 06		 jge	 SHORT $LN16@CountQuali
  0007e	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@41f0000000000000
$LN16@CountQuali:
  00084	89 6c 24 0c	 mov	 DWORD PTR tv201[esp+16], ebp
  00088	db 44 24 0c	 fild	 DWORD PTR tv201[esp+16]
  0008c	85 ed		 test	 ebp, ebp
  0008e	7d 06		 jge	 SHORT $LN17@CountQuali
  00090	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@41f0000000000000
$LN17@CountQuali:
  00096	5f		 pop	 edi
  00097	de c9		 fmulp	 ST(1), ST(0)
  00099	5e		 pop	 esi
  0009a	5d		 pop	 ebp
  0009b	de f9		 fdivp	 ST(1), ST(0)

; 1393 : }

  0009d	59		 pop	 ecx
  0009e	c3		 ret	 0
?CountQuality@@YANI@Z ENDP				; CountQuality
_TEXT	ENDS
PUBLIC	?CountCollisions@@YAII@Z			; CountCollisions
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?CountCollisions@@YAII@Z PROC				; CountCollisions

; 1375 : 	UINT cells_count = 0;
; 1376 : 	for(UINT i = 0; i < g_table_size; i++)

  000a0	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR ?g_table_size@@3KA ; g_table_size
  000a6	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  000ab	56		 push	 esi
  000ac	33 f6		 xor	 esi, esi
  000ae	33 c9		 xor	 ecx, ecx
  000b0	85 d2		 test	 edx, edx
  000b2	76 19		 jbe	 SHORT $LN2@CountColli
  000b4	57		 push	 edi
  000b5	8b 3d 00 00 00
	00		 mov	 edi, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  000bb	eb 03 8d 49 00	 npad	 5
$LL4@CountColli:

; 1377 : 		if (g_table[i])

  000c0	83 3c 8f 00	 cmp	 DWORD PTR [edi+ecx*4], 0
  000c4	74 01		 je	 SHORT $LN3@CountColli

; 1378 : 			cells_count++;

  000c6	46		 inc	 esi
$LN3@CountColli:

; 1375 : 	UINT cells_count = 0;
; 1376 : 	for(UINT i = 0; i < g_table_size; i++)

  000c7	41		 inc	 ecx
  000c8	3b ca		 cmp	 ecx, edx
  000ca	72 f4		 jb	 SHORT $LL4@CountColli
  000cc	5f		 pop	 edi
$LN2@CountColli:

; 1379 : 	return items_count - cells_count;

  000cd	2b c6		 sub	 eax, esi
  000cf	5e		 pop	 esi

; 1380 : }

  000d0	c3		 ret	 0
?CountCollisions@@YAII@Z ENDP				; CountCollisions
_TEXT	ENDS
PUBLIC	?Lookup@@YAHPBDKP6AI0K@ZH@Z			; Lookup
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_key$ = 8						; size = 4
_hash_func$ = 12					; size = 4
_add$ = 16						; size = 4
?Lookup@@YAHPBDKP6AI0K@ZH@Z PROC			; Lookup
; _len$ = ebx

; 1354 : #ifdef USE_PRIME
; 1355 : 	UINT hash = hash_func(key, len) % g_table_size;
; 1356 : #else
; 1357 : 	UINT hash = hash_func(key, len) & g_table_size_mask;

  000e0	8b 44 24 04	 mov	 eax, DWORD PTR _key$[esp-4]
  000e4	55		 push	 ebp
  000e5	56		 push	 esi
  000e6	57		 push	 edi
  000e7	53		 push	 ebx
  000e8	50		 push	 eax
  000e9	ff 54 24 1c	 call	 DWORD PTR _hash_func$[esp+16]

; 1358 : #endif
; 1359 : 	// Look up the value in the chain
; 1360 : 	for(CHAIN* chain = g_table[hash]; chain != NULL; chain = chain->next) {

  000ed	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  000f3	8b f8		 mov	 edi, eax
  000f5	23 3d 00 00 00
	00		 and	 edi, DWORD PTR ?g_table_size_mask@@3KA ; g_table_size_mask
  000fb	83 c4 08	 add	 esp, 8
  000fe	8b 2c b9	 mov	 ebp, DWORD PTR [ecx+edi*4]
  00101	85 ed		 test	 ebp, ebp
  00103	74 4d		 je	 SHORT $LN3@Lookup
$LL19@Lookup:

; 1361 : 		if( memcmp(chain->key, key, len * sizeof(CHAR)) == 0 )

  00105	8b 54 24 10	 mov	 edx, DWORD PTR _key$[esp+8]
  00109	8b 75 00	 mov	 esi, DWORD PTR [ebp]
  0010c	8b cb		 mov	 ecx, ebx
  0010e	83 fb 04	 cmp	 ebx, 4
  00111	72 14		 jb	 SHORT $LN15@Lookup
$LL9@Lookup:
  00113	8b 06		 mov	 eax, DWORD PTR [esi]
  00115	3b 02		 cmp	 eax, DWORD PTR [edx]
  00117	75 32		 jne	 SHORT $LN4@Lookup
  00119	83 e9 04	 sub	 ecx, 4
  0011c	83 c2 04	 add	 edx, 4
  0011f	83 c6 04	 add	 esi, 4
  00122	83 f9 04	 cmp	 ecx, 4
  00125	73 ec		 jae	 SHORT $LL9@Lookup
$LN15@Lookup:
  00127	85 c9		 test	 ecx, ecx
  00129	74 65		 je	 SHORT $LN20@Lookup
  0012b	8a 02		 mov	 al, BYTE PTR [edx]
  0012d	3a 06		 cmp	 al, BYTE PTR [esi]
  0012f	75 1a		 jne	 SHORT $LN4@Lookup
  00131	83 f9 01	 cmp	 ecx, 1
  00134	76 5a		 jbe	 SHORT $LN20@Lookup
  00136	8a 42 01	 mov	 al, BYTE PTR [edx+1]
  00139	3a 46 01	 cmp	 al, BYTE PTR [esi+1]
  0013c	75 0d		 jne	 SHORT $LN4@Lookup
  0013e	83 f9 02	 cmp	 ecx, 2
  00141	76 4d		 jbe	 SHORT $LN20@Lookup
  00143	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  00146	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  00149	74 45		 je	 SHORT $LN20@Lookup
$LN4@Lookup:

; 1358 : #endif
; 1359 : 	// Look up the value in the chain
; 1360 : 	for(CHAIN* chain = g_table[hash]; chain != NULL; chain = chain->next) {

  0014b	8b 6d 04	 mov	 ebp, DWORD PTR [ebp+4]
  0014e	85 ed		 test	 ebp, ebp
  00150	75 b3		 jne	 SHORT $LL19@Lookup
$LN3@Lookup:

; 1363 : 	}
; 1364 : 	// If it was not found, add it
; 1365 : 	if(add) {

  00152	83 7c 24 18 00	 cmp	 DWORD PTR _add$[esp+8], 0
  00157	74 31		 je	 SHORT $LN1@Lookup

; 1366 : 		CHAIN* next = g_table[hash];

  00159	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  0015f	8b 0c ba	 mov	 ecx, DWORD PTR [edx+edi*4]

; 1367 : 		g_table[hash] = &g_chains[g_next_free_chain++];

  00162	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_next_free_chain@@3IA ; g_next_free_chain
  00167	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR ?g_chains@@3PAUCHAIN@@A ; g_chains
  0016d	8d 34 c2	 lea	 esi, DWORD PTR [edx+eax*8]
  00170	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  00176	40		 inc	 eax
  00177	a3 00 00 00 00	 mov	 DWORD PTR ?g_next_free_chain@@3IA, eax ; g_next_free_chain

; 1368 : 		g_table[hash]->next = next;

  0017c	8b c6		 mov	 eax, esi
  0017e	89 48 04	 mov	 DWORD PTR [eax+4], ecx

; 1369 : 		g_table[hash]->key = key;

  00181	8b 4c 24 10	 mov	 ecx, DWORD PTR _key$[esp+8]
  00185	89 34 ba	 mov	 DWORD PTR [edx+edi*4], esi
  00188	89 08		 mov	 DWORD PTR [eax], ecx
$LN1@Lookup:
  0018a	5f		 pop	 edi
  0018b	5e		 pop	 esi

; 1370 : 	}
; 1371 : 	return FALSE;

  0018c	33 c0		 xor	 eax, eax
  0018e	5d		 pop	 ebp

; 1372 : }

  0018f	c3		 ret	 0
$LN20@Lookup:
  00190	5f		 pop	 edi
  00191	5e		 pop	 esi

; 1362 : 			return TRUE;

  00192	b8 01 00 00 00	 mov	 eax, 1
  00197	5d		 pop	 ebp

; 1372 : }

  00198	c3		 ret	 0
?Lookup@@YAHPBDKP6AI0K@ZH@Z ENDP			; Lookup
_TEXT	ENDS
PUBLIC	?InitHashTable@@YAXXZ				; InitHashTable
EXTRN	_memset:PROC
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?InitHashTable@@YAXXZ PROC				; InitHashTable

; 1349 : 	g_next_free_chain = 0;
; 1350 : 	memset(g_table, 0, g_table_size * sizeof(CHAIN *));

  001a0	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_table_size@@3KA ; g_table_size
  001a5	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  001ab	8d 0c 85 00 00
	00 00		 lea	 ecx, DWORD PTR [eax*4]
  001b2	51		 push	 ecx
  001b3	6a 00		 push	 0
  001b5	52		 push	 edx
  001b6	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR ?g_next_free_chain@@3IA, 0 ; g_next_free_chain
  001c0	e8 00 00 00 00	 call	 _memset
  001c5	83 c4 0c	 add	 esp, 12			; 0000000cH

; 1351 : }

  001c8	c3		 ret	 0
?InitHashTable@@YAXXZ ENDP				; InitHashTable
_TEXT	ENDS
PUBLIC	?FreeHashTable@@YAXXZ				; FreeHashTable
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?FreeHashTable@@YAXXZ PROC				; FreeHashTable

; 1344 : 	free(g_table);

  001d0	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  001d5	50		 push	 eax
  001d6	e8 00 00 00 00	 call	 _free

; 1345 : 	free(g_chains);

  001db	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_chains@@3PAUCHAIN@@A ; g_chains
  001e1	51		 push	 ecx
  001e2	e8 00 00 00 00	 call	 _free
  001e7	83 c4 08	 add	 esp, 8

; 1346 : }

  001ea	c3		 ret	 0
?FreeHashTable@@YAXXZ ENDP				; FreeHashTable
_TEXT	ENDS
PUBLIC	?FreeTxtFile@@YAXXZ				; FreeTxtFile
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?FreeTxtFile@@YAXXZ PROC				; FreeTxtFile

; 1312 : 	free(g_lines);

  001f0	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines
  001f5	50		 push	 eax
  001f6	e8 00 00 00 00	 call	 _free

; 1313 : 	free(g_text);

  001fb	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_text@@3PADA ; g_text
  00201	51		 push	 ecx
  00202	e8 00 00 00 00	 call	 _free
  00207	83 c4 08	 add	 esp, 8

; 1314 : }

  0020a	c3		 ret	 0
?FreeTxtFile@@YAXXZ ENDP				; FreeTxtFile
_TEXT	ENDS
PUBLIC	?Die@@YAXPBD@Z					; Die
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?Die@@YAXPBD@Z PROC					; Die
; _msg$ = eax

; 1211 : 	puts(msg);

  00210	50		 push	 eax
  00211	e8 00 00 00 00	 call	 _puts
  00216	83 c4 04	 add	 esp, 4

; 1212 : 	exit(1);

  00219	6a 01		 push	 1
  0021b	e8 00 00 00 00	 call	 _exit
$LN4@Die:
$LN3@Die:
  00220	cc		 int	 3
?Die@@YAXPBD@Z ENDP					; Die
_TEXT	ENDS
PUBLIC	?NextLog2@@YAII@Z				; NextLog2
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?NextLog2@@YAII@Z PROC					; NextLog2
; _x$ = eax

; 1197 : 	// Henry Warren, "Hacker's Delight", ch. 5.3
; 1198 : 	if(x <= 1) return x;

  00230	83 f8 01	 cmp	 eax, 1
  00233	76 4a		 jbe	 SHORT $LN7@NextLog2

; 1199 : 	x--;

  00235	48		 dec	 eax

; 1200 : 	UINT n = 0;
; 1201 : 	UINT y;
; 1202 : 	y = x >>16; if(y) {n += 16; x = y;}

  00236	8b c8		 mov	 ecx, eax
  00238	c1 e9 10	 shr	 ecx, 16			; 00000010H
  0023b	33 d2		 xor	 edx, edx
  0023d	85 c9		 test	 ecx, ecx
  0023f	74 07		 je	 SHORT $LN5@NextLog2
  00241	ba 10 00 00 00	 mov	 edx, 16			; 00000010H
  00246	8b c1		 mov	 eax, ecx
$LN5@NextLog2:

; 1203 : 	y = x >> 8; if(y) {n +=  8; x = y;}

  00248	8b c8		 mov	 ecx, eax
  0024a	c1 e9 08	 shr	 ecx, 8
  0024d	85 c9		 test	 ecx, ecx
  0024f	74 05		 je	 SHORT $LN4@NextLog2
  00251	83 c2 08	 add	 edx, 8
  00254	8b c1		 mov	 eax, ecx
$LN4@NextLog2:

; 1204 : 	y = x >> 4; if(y) {n +=  4; x = y;}

  00256	8b c8		 mov	 ecx, eax
  00258	c1 e9 04	 shr	 ecx, 4
  0025b	85 c9		 test	 ecx, ecx
  0025d	74 05		 je	 SHORT $LN3@NextLog2
  0025f	83 c2 04	 add	 edx, 4
  00262	8b c1		 mov	 eax, ecx
$LN3@NextLog2:

; 1205 : 	y = x >> 2; if(y) {n +=  2; x = y;}

  00264	8b c8		 mov	 ecx, eax
  00266	c1 e9 02	 shr	 ecx, 2
  00269	85 c9		 test	 ecx, ecx
  0026b	74 05		 je	 SHORT $LN2@NextLog2
  0026d	83 c2 02	 add	 edx, 2
  00270	8b c1		 mov	 eax, ecx
$LN2@NextLog2:

; 1206 : 	y = x >> 1; if(y) return n + 2;

  00272	a9 fe ff ff ff	 test	 eax, -2			; fffffffeH
  00277	74 04		 je	 SHORT $LN1@NextLog2
  00279	8d 42 02	 lea	 eax, DWORD PTR [edx+2]

; 1208 : }

  0027c	c3		 ret	 0
$LN1@NextLog2:

; 1207 : 	return n + x;

  0027d	03 c2		 add	 eax, edx
$LN7@NextLog2:

; 1208 : }

  0027f	c3		 ret	 0
?NextLog2@@YAII@Z ENDP					; NextLog2
_TEXT	ENDS
PUBLIC	?GetTxtFileSize@@YAJPAU_iobuf@@@Z		; GetTxtFileSize
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?GetTxtFileSize@@YAJPAU_iobuf@@@Z PROC			; GetTxtFileSize
; _f$ = esi

; 1171 : long GetTxtFileSize(FILE* f) {

  00280	53		 push	 ebx

; 1172 : 	long old_pos = ftell(f);

  00281	56		 push	 esi
  00282	e8 00 00 00 00	 call	 _ftell

; 1173 : 
; 1174 : 	// Seek to the end of file
; 1175 : 	if (fseek(f, 0, SEEK_END))

  00287	6a 02		 push	 2
  00289	6a 00		 push	 0
  0028b	56		 push	 esi
  0028c	8b d8		 mov	 ebx, eax
  0028e	e8 00 00 00 00	 call	 _fseek
  00293	83 c4 10	 add	 esp, 16			; 00000010H
  00296	85 c0		 test	 eax, eax
  00298	74 04		 je	 SHORT $LN1@GetTxtFile

; 1176 : 		return 0;

  0029a	33 c0		 xor	 eax, eax
  0029c	5b		 pop	 ebx

; 1182 : }

  0029d	c3		 ret	 0
$LN1@GetTxtFile:
  0029e	57		 push	 edi

; 1177 : 	long size = ftell(f);

  0029f	56		 push	 esi
  002a0	e8 00 00 00 00	 call	 _ftell

; 1178 : 	
; 1179 : 	// Restore saved position
; 1180 : 	fseek(f, old_pos, SEEK_SET);

  002a5	6a 00		 push	 0
  002a7	53		 push	 ebx
  002a8	56		 push	 esi
  002a9	8b f8		 mov	 edi, eax
  002ab	e8 00 00 00 00	 call	 _fseek
  002b0	83 c4 10	 add	 esp, 16			; 00000010H

; 1181 : 	return size;

  002b3	8b c7		 mov	 eax, edi
  002b5	5f		 pop	 edi
  002b6	5b		 pop	 ebx

; 1182 : }

  002b7	c3		 ret	 0
?GetTxtFileSize@@YAJPAU_iobuf@@@Z ENDP			; GetTxtFileSize
; Function compile flags: /Ogtpy
tv165 = 8						; size = 4
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?Hash_Sixtinsensitive_Boosted@@YAIPBDK@Z PROC		; Hash_Sixtinsensitive_Boosted

; 1105 : 	UINT hash = 2166136261;
; 1106 : 	UINT hashBUFFER_EAX, hashBUFFER_EDX;
; 1107 : 	const CHAR * p = str;
; 1108 : 
; 1109 : 	// Ox41 = 065 'A' 010 [0 0001]
; 1110 : 	// Ox5A = 090 'Z' 010 [1 1010]
; 1111 : 	// Ox61 = 097 'a' 011 [0 0001]
; 1112 : 	// Ox7A = 122 'z' 011 [1 1010]
; 1113 : 
; 1114 : 	// Reduce the number of multiplications by unrolling the loop
; 1115 : 	for(; wrdlen >= 12; wrdlen -= 12, p += 12) {

  002c0	8b 54 24 08	 mov	 edx, DWORD PTR _wrdlen$[esp-4]
  002c4	8b 4c 24 04	 mov	 ecx, DWORD PTR _str$[esp-4]
  002c8	53		 push	 ebx
  002c9	56		 push	 esi
  002ca	57		 push	 edi
  002cb	bb c5 9d 1c 81	 mov	 ebx, -2128831035	; 811c9dc5H
  002d0	83 fa 0c	 cmp	 edx, 12			; 0000000cH
  002d3	0f 82 ae 00 00
	00		 jb	 $LN6@Hash_Sixti
  002d9	b8 ab aa aa aa	 mov	 eax, -1431655765	; aaaaaaabH
  002de	f7 e2		 mul	 edx
  002e0	c1 ea 03	 shr	 edx, 3
  002e3	89 54 24 10	 mov	 DWORD PTR tv165[esp+8], edx
  002e7	55		 push	 ebp
  002e8	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL8@Hash_Sixti:

; 1116 : 		//hashBUFFER_AX = (*(DWORD*)(p+0)&0xFFFF);
; 1117 : 		hashBUFFER_EAX = (*(DWORD*)(p+0)&0x1F1F1F1F);
; 1118 : 		hashBUFFER_EDX = (*(DWORD*)(p+4)&0x1F1F1F1F);
; 1119 : 		//hashBUFFER_EBX = (*(DWORD*)(p+8)&0x1F1F1F1F);
; 1120 : 
; 1121 : 		//hashBUFFER_BL = (*(p+8)&0x1F);
; 1122 : 		//hashBUFFER_BH = (*(p+9)&0x1F);
; 1123 : 		//hashBUFFER_BL2 = (*(p+10)&0x1F);
; 1124 : 		//hashBUFFER_BH2 = (*(p+11)&0x1F);
; 1125 : 
; 1126 : 		//12bytes-in-8bytes or 96bits-to-60bits
; 1127 : 		// Two times next:
; 1128 : 		//6bytes-in-4bytes or 48bits-to-30bits
; 1129 : 		// Two times next:
; 1130 : 		//3bytes-in-2bytes or 24bits-to-15bits
; 1131 : 		//EAX                     BL          BH
; 1132 : 		//[5bit][3bit][5bit][3bit][5bit][3bit][5bit][3bit]
; 1133 : 		//       5th[0..15]  13th[0..15]
; 1134 : 		//       BL lower 3  BL higher 2bits
; 1135 : 		// OR or XOR no difference
; 1136 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ (((*(p+8)&0x1F)&0x07)<<5); // BL lower 3bits of 5bits
; 1137 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ (((*(p+8)&0x1F)&0x18)<<(2+8)); // BL higher 2bits of 5bits
; 1138 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ (((*(p+9)&0x1F)&0x07)<<(5+16)); // BH lower 3bits of 5bits
; 1139 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ (((*(p+9)&0x1F)&0x18)<<((2+8)+16)); // BH higher 2bits of 5bits
; 1140 : 		hash = ((hash ^ hashBUFFER_EAX)<<5) - (hash ^ hashBUFFER_EAX);
; 1141 : 		hashBUFFER_EDX = hashBUFFER_EDX ^ (((*(p+10)&0x1F)&0x07)<<5); // BL lower 3bits of 5bits
; 1142 : 		hashBUFFER_EDX = hashBUFFER_EDX ^ (((*(p+10)&0x1F)&0x18)<<(2+8)); // BL higher 2bits of 5bits
; 1143 : 		hashBUFFER_EDX = hashBUFFER_EDX ^ (((*(p+11)&0x1F)&0x07)<<(5+16)); // BH lower 3bits of 5bits
; 1144 : 		hashBUFFER_EDX = hashBUFFER_EDX ^ (((*(p+11)&0x1F)&0x18)<<((2+8)+16)); // BH higher 2bits of 5bits
; 1145 : 		hash = ((hash ^ hashBUFFER_EDX)<<5) - (hash ^ hashBUFFER_EDX);		

  002f0	0f be 71 09	 movsx	 esi, BYTE PTR [ecx+9]
  002f4	0f be 79 08	 movsx	 edi, BYTE PTR [ecx+8]
  002f8	8b c6		 mov	 eax, esi
  002fa	83 e6 07	 and	 esi, 7
  002fd	83 e0 18	 and	 eax, 24			; 00000018H
  00300	0f be 69 0b	 movsx	 ebp, BYTE PTR [ecx+11]
  00304	c1 e0 05	 shl	 eax, 5
  00307	33 c6		 xor	 eax, esi
  00309	0f be 51 0a	 movsx	 edx, BYTE PTR [ecx+10]
  0030d	c1 e0 0b	 shl	 eax, 11			; 0000000bH
  00310	8b f7		 mov	 esi, edi
  00312	83 e6 18	 and	 esi, 24			; 00000018H
  00315	33 c6		 xor	 eax, esi
  00317	8b 31		 mov	 esi, DWORD PTR [ecx]
  00319	81 e6 1f 1f 1f
	1f		 and	 esi, 522133279		; 1f1f1f1fH
  0031f	c1 e0 05	 shl	 eax, 5
  00322	83 e7 07	 and	 edi, 7
  00325	33 c7		 xor	 eax, edi
  00327	c1 e0 05	 shl	 eax, 5
  0032a	33 c6		 xor	 eax, esi
  0032c	33 c3		 xor	 eax, ebx
  0032e	8b f0		 mov	 esi, eax
  00330	c1 e6 05	 shl	 esi, 5
  00333	2b f0		 sub	 esi, eax
  00335	8b c6		 mov	 eax, esi
  00337	83 6c 24 18 0c	 sub	 DWORD PTR _wrdlen$[esp+12], 12 ; 0000000cH
  0033c	8b f5		 mov	 esi, ebp
  0033e	83 e6 18	 and	 esi, 24			; 00000018H
  00341	c1 e6 05	 shl	 esi, 5
  00344	8b fa		 mov	 edi, edx
  00346	83 e5 07	 and	 ebp, 7
  00349	33 f5		 xor	 esi, ebp
  0034b	c1 e6 0b	 shl	 esi, 11			; 0000000bH
  0034e	83 e2 07	 and	 edx, 7
  00351	83 e7 18	 and	 edi, 24			; 00000018H
  00354	33 f7		 xor	 esi, edi
  00356	c1 e6 05	 shl	 esi, 5
  00359	33 f2		 xor	 esi, edx
  0035b	8b 51 04	 mov	 edx, DWORD PTR [ecx+4]
  0035e	81 e2 1f 1f 1f
	1f		 and	 edx, 522133279		; 1f1f1f1fH
  00364	c1 e6 05	 shl	 esi, 5
  00367	33 c6		 xor	 eax, esi
  00369	33 c2		 xor	 eax, edx
  0036b	8b d0		 mov	 edx, eax
  0036d	c1 e2 05	 shl	 edx, 5
  00370	2b d0		 sub	 edx, eax
  00372	83 c1 0c	 add	 ecx, 12			; 0000000cH
  00375	83 6c 24 14 01	 sub	 DWORD PTR tv165[esp+12], 1
  0037a	8b da		 mov	 ebx, edx
  0037c	0f 85 6e ff ff
	ff		 jne	 $LL8@Hash_Sixti
  00382	8b 54 24 18	 mov	 edx, DWORD PTR _wrdlen$[esp+12]
  00386	5d		 pop	 ebp
$LN6@Hash_Sixti:

; 1146 :     //31:   12170359  11983592  11991947  11997376  12005131|  11983592 [2251734]
; 1147 : 	}
; 1148 : 	/*
; 1149 : 	// Post-Variant #1:
; 1150 : 	for(; wrdlen; wrdlen--, p++) {
; 1151 : 		hash = ((hash ^ (*p&0x1F))<<5) - (hash ^ (*p&0x1F));
; 1152 : 	}
; 1153 : 	*/
; 1154 : 	// Post-Variant #2:
; 1155 : 	for(; wrdlen >= sizeof(DWORD); wrdlen -= sizeof(DWORD), p += sizeof(DWORD)) {

  00387	83 fa 04	 cmp	 edx, 4
  0038a	72 2a		 jb	 SHORT $LN3@Hash_Sixti
  0038c	8b f2		 mov	 esi, edx
  0038e	c1 ee 02	 shr	 esi, 2
$LL5@Hash_Sixti:

; 1156 : 		hash = ((hash ^ (*(DWORD*)(p)&0x1F1F1F1F))<<5) - (hash ^ (*(DWORD*)(p)&0x1F1F1F1F));

  00391	8b 01		 mov	 eax, DWORD PTR [ecx]
  00393	8b f8		 mov	 edi, eax
  00395	81 e7 1f 1f 1f
	ff		 and	 edi, -14737633		; ff1f1f1fH
  0039b	33 fb		 xor	 edi, ebx
  0039d	25 1f 1f 1f 1f	 and	 eax, 522133279		; 1f1f1f1fH
  003a2	33 c3		 xor	 eax, ebx
  003a4	c1 e7 05	 shl	 edi, 5
  003a7	2b f8		 sub	 edi, eax
  003a9	83 ea 04	 sub	 edx, 4
  003ac	83 c1 04	 add	 ecx, 4
  003af	83 ee 01	 sub	 esi, 1
  003b2	8b df		 mov	 ebx, edi
  003b4	75 db		 jne	 SHORT $LL5@Hash_Sixti
$LN3@Hash_Sixti:

; 1157 : 	}
; 1158 : 	if (wrdlen & sizeof(WORD)) {

  003b6	f6 c2 02	 test	 dl, 2
  003b9	74 16		 je	 SHORT $LN2@Hash_Sixti

; 1159 : 		hash = ((hash ^ (*(WORD*)p&0x1F1F))<<5) - (hash ^ (*(WORD*)p&0x1F1F));

  003bb	0f b7 01	 movzx	 eax, WORD PTR [ecx]
  003be	25 1f 1f 00 00	 and	 eax, 7967		; 00001f1fH
  003c3	33 c3		 xor	 eax, ebx
  003c5	8b f0		 mov	 esi, eax
  003c7	c1 e6 05	 shl	 esi, 5
  003ca	2b f0		 sub	 esi, eax
  003cc	8b de		 mov	 ebx, esi

; 1160 : 		p += sizeof(WORD);

  003ce	83 c1 02	 add	 ecx, 2
$LN2@Hash_Sixti:

; 1161 : 	}
; 1162 : 	if (wrdlen & 1) 

  003d1	f6 c2 01	 test	 dl, 1
  003d4	74 11		 je	 SHORT $LN1@Hash_Sixti

; 1163 : 		hash = ((hash ^ (*p&0x1F))<<5) - (hash ^ (*p&0x1F));

  003d6	0f be 01	 movsx	 eax, BYTE PTR [ecx]
  003d9	83 e0 1f	 and	 eax, 31			; 0000001fH
  003dc	33 c3		 xor	 eax, ebx
  003de	8b c8		 mov	 ecx, eax
  003e0	c1 e1 05	 shl	 ecx, 5
  003e3	2b c8		 sub	 ecx, eax
  003e5	8b d9		 mov	 ebx, ecx
$LN1@Hash_Sixti:

; 1164 : 
; 1165 : 	return (hash>>16) ^ hash;

  003e7	8b c3		 mov	 eax, ebx
  003e9	5f		 pop	 edi
  003ea	c1 e8 10	 shr	 eax, 16			; 00000010H
  003ed	5e		 pop	 esi
  003ee	33 c3		 xor	 eax, ebx
  003f0	5b		 pop	 ebx

; 1166 : }

  003f1	c3		 ret	 0
?Hash_Sixtinsensitive_Boosted@@YAIPBDK@Z ENDP		; Hash_Sixtinsensitive_Boosted
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?Hash_Sixtinsensitive@@YAIPBDK@Z PROC			; Hash_Sixtinsensitive

; 1036 : { 

  00400	53		 push	 ebx
  00401	55		 push	 ebp

; 1037 : 	UINT hash = 2166136261;
; 1038 : 	UINT hashBUFFER_EAX, hashBUFFER_BH, hashBUFFER_BL;
; 1039 : 	const CHAR * p = str;
; 1040 : 
; 1041 : 	// Ox41 = 065 'A' 010 [0 0001]
; 1042 : 	// Ox5A = 090 'Z' 010 [1 1010]
; 1043 : 	// Ox61 = 097 'a' 011 [0 0001]
; 1044 : 	// Ox7A = 122 'z' 011 [1 1010]
; 1045 : 
; 1046 : 	// Reduce the number of multiplications by unrolling the loop
; 1047 : 	for(; wrdlen >= 6; wrdlen -= 6, p += 6) {

  00402	8b 6c 24 10	 mov	 ebp, DWORD PTR _wrdlen$[esp+4]
  00406	57		 push	 edi
  00407	8b 7c 24 10	 mov	 edi, DWORD PTR _str$[esp+8]
  0040b	bb c5 9d 1c 81	 mov	 ebx, -2128831035	; 811c9dc5H
  00410	83 fd 06	 cmp	 ebp, 6
  00413	72 5c		 jb	 SHORT $LN4@Hash_Sixti@2
  00415	b8 ab aa aa aa	 mov	 eax, -1431655765	; aaaaaaabH
  0041a	f7 e5		 mul	 ebp
  0041c	c1 ea 02	 shr	 edx, 2
  0041f	56		 push	 esi
$LL6@Hash_Sixti@2:

; 1048 : 		//hashBUFFER_AX = (*(DWORD*)(p+0)&0xFFFF);
; 1049 : 		hashBUFFER_EAX = (*(DWORD*)(p+0)&0x1F1F1F1F);
; 1050 : 		hashBUFFER_BL = (*(p+4)&0x1F);
; 1051 : 		hashBUFFER_BH = (*(p+5)&0x1F);

  00420	0f be 77 05	 movsx	 esi, BYTE PTR [edi+5]
  00424	0f be 4f 04	 movsx	 ecx, BYTE PTR [edi+4]
  00428	83 e6 1f	 and	 esi, 31			; 0000001fH

; 1052 : 		//6bytes-in-4bytes or 48bits-to-30bits
; 1053 : 		// Two times next:
; 1054 : 		//3bytes-in-2bytes or 24bits-to-15bits
; 1055 : 		//EAX                     BL          BH
; 1056 : 		//[5bit][3bit][5bit][3bit][5bit][3bit][5bit][3bit]
; 1057 : 		//       5th[0..15]  13th[0..15]
; 1058 : 		//       BL lower 3  BL higher 2bits
; 1059 : 		// OR or XOR no difference
; 1060 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ ((hashBUFFER_BL&0x07)<<5); // BL lower 3bits of 5bits
; 1061 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ ((hashBUFFER_BL&0x18)<<(2+8)); // BL higher 2bits of 5bits
; 1062 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ ((hashBUFFER_BH&0x07)<<(5+16)); // BH lower 3bits of 5bits
; 1063 : 		hashBUFFER_EAX = hashBUFFER_EAX ^ ((hashBUFFER_BH&0x18)<<((2+8)+16)); // BH higher 2bits of 5bits
; 1064 : 		//hash = (hash ^ hashBUFFER_EAX)*1607; //What a mess: <<7 becomes imul but <<5 not!?
; 1065 : 		hash = ((hash ^ hashBUFFER_EAX)<<5) - (hash ^ hashBUFFER_EAX);

  0042b	8b c6		 mov	 eax, esi
  0042d	83 e0 18	 and	 eax, 24			; 00000018H
  00430	c1 e0 05	 shl	 eax, 5
  00433	83 e1 1f	 and	 ecx, 31			; 0000001fH
  00436	83 e6 07	 and	 esi, 7
  00439	33 c6		 xor	 eax, esi
  0043b	8b f1		 mov	 esi, ecx
  0043d	c1 e0 0b	 shl	 eax, 11			; 0000000bH
  00440	83 e1 07	 and	 ecx, 7
  00443	83 e6 18	 and	 esi, 24			; 00000018H
  00446	33 c6		 xor	 eax, esi
  00448	c1 e0 05	 shl	 eax, 5
  0044b	33 c1		 xor	 eax, ecx
  0044d	8b 0f		 mov	 ecx, DWORD PTR [edi]
  0044f	81 e1 1f 1f 1f
	1f		 and	 ecx, 522133279		; 1f1f1f1fH
  00455	c1 e0 05	 shl	 eax, 5
  00458	33 c1		 xor	 eax, ecx
  0045a	33 c3		 xor	 eax, ebx
  0045c	8b c8		 mov	 ecx, eax
  0045e	c1 e1 05	 shl	 ecx, 5
  00461	2b c8		 sub	 ecx, eax
  00463	83 ed 06	 sub	 ebp, 6
  00466	83 c7 06	 add	 edi, 6
  00469	83 ea 01	 sub	 edx, 1
  0046c	8b d9		 mov	 ebx, ecx
  0046e	75 b0		 jne	 SHORT $LL6@Hash_Sixti@2
  00470	5e		 pop	 esi
$LN4@Hash_Sixti@2:

; 1066 : 		//1607:[2118599]
; 1067 : 		// 127:[2121081]
; 1068 : 		//  31:[2139242]
; 1069 : 		//  17:[2150803]
; 1070 : 		//   7:[2166336]
; 1071 : 		//   5:[2183044]
; 1072 : 		//8191:[2200477]
; 1073 : 		//   3:[2205095]
; 1074 : 		// 257:[2206188]
; 1075 : 	}
; 1076 : 	// Post-Variant #1:
; 1077 : 	for(; wrdlen; wrdlen--, p++) {

  00471	85 ed		 test	 ebp, ebp
  00473	74 17		 je	 SHORT $LN1@Hash_Sixti@2
$LL3@Hash_Sixti@2:

; 1078 : 		hash = ((hash ^ (*p&0x1F))<<5) - (hash ^ (*p&0x1F));

  00475	0f be 07	 movsx	 eax, BYTE PTR [edi]
  00478	83 e0 1f	 and	 eax, 31			; 0000001fH
  0047b	33 c3		 xor	 eax, ebx
  0047d	8b d0		 mov	 edx, eax
  0047f	c1 e2 05	 shl	 edx, 5
  00482	2b d0		 sub	 edx, eax
  00484	4d		 dec	 ebp
  00485	47		 inc	 edi
  00486	8b da		 mov	 ebx, edx
  00488	85 ed		 test	 ebp, ebp
  0048a	75 e9		 jne	 SHORT $LL3@Hash_Sixti@2
$LN1@Hash_Sixti@2:

; 1079 : 	}
; 1080 : 	/*
; 1081 : 	// Post-Variant #2:
; 1082 : 	for(; wrdlen >= 2; wrdlen -= 2, p += 2) {
; 1083 : 	hash = ((hash ^ (*(DWORD*)p&0xFFFF))<<5) - (hash ^ (*(DWORD*)p&0xFFFF));
; 1084 : 	}
; 1085 : 	if (wrdlen & 1) 
; 1086 : 	hash = ((hash ^ *p)<<5) - (hash ^ *p);
; 1087 : 	*/
; 1088 : 	/*
; 1089 : 	// Post-Variant #3:
; 1090 : 	for(; wrdlen >= 4; wrdlen -= 4, p += 4) {
; 1091 : 	hash = ((hash ^ *(DWORD*)p)<<5) - (hash ^ *(DWORD*)p);
; 1092 : 	}
; 1093 : 	if (wrdlen & 2) {
; 1094 : 	hash = ((hash ^ (*(WORD*)p))<<5) - (hash ^ (*(WORD*)p));
; 1095 : 	p++;p++;
; 1096 : 	}
; 1097 : 	if (wrdlen & 1) 
; 1098 : 	hash = ((hash ^ *p)<<5) - (hash ^ *p);
; 1099 : 	*/
; 1100 : 	return (hash>>16) ^ hash;

  0048c	8b c3		 mov	 eax, ebx
  0048e	5f		 pop	 edi
  0048f	c1 e8 10	 shr	 eax, 16			; 00000010H
  00492	5d		 pop	 ebp
  00493	33 c3		 xor	 eax, ebx
  00495	5b		 pop	 ebx

; 1101 : }

  00496	c3		 ret	 0
?Hash_Sixtinsensitive@@YAIPBDK@Z ENDP			; Hash_Sixtinsensitive
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?FNV1A_Hash_Jesteress@@YAIPBDK@Z PROC			; FNV1A_Hash_Jesteress

; 1006 : 	const UINT PRIME = 709607;
; 1007 : 	UINT hash32 = 2166136261;
; 1008 : 	const char *p = str;
; 1009 : 
; 1010 : 	// Idea comes from Igor Pavlov's 7zCRC, thanks.
; 1011 : /*
; 1012 : 	for(; wrdlen && ((unsigned)(ptrdiff_t)p&3); wrdlen -= 1, p++) {
; 1013 : 		hash32 = (hash32 ^ *p) * PRIME;
; 1014 : 	}
; 1015 : */
; 1016 : 	for(; wrdlen >= 2*sizeof(DWORD); wrdlen -= 2*sizeof(DWORD), p += 2*sizeof(DWORD)) {

  004a0	8b 54 24 08	 mov	 edx, DWORD PTR _wrdlen$[esp-4]
  004a4	8b 44 24 04	 mov	 eax, DWORD PTR _str$[esp-4]
  004a8	56		 push	 esi
  004a9	b9 c5 9d 1c 81	 mov	 ecx, -2128831035	; 811c9dc5H
  004ae	83 fa 08	 cmp	 edx, 8
  004b1	72 2b		 jb	 SHORT $LN4@FNV1A_Hash
  004b3	8b f2		 mov	 esi, edx
  004b5	c1 ee 03	 shr	 esi, 3
  004b8	57		 push	 edi
  004b9	8d a4 24 00 00
	00 00		 npad	 7
$LL6@FNV1A_Hash:

; 1017 : 		hash32 = (hash32 ^ (ROL(*(DWORD *)p,5)^*(DWORD *)(p+4))) * PRIME;		

  004c0	8b 38		 mov	 edi, DWORD PTR [eax]
  004c2	c1 c7 05	 rol	 edi, 5
  004c5	33 78 04	 xor	 edi, DWORD PTR [eax+4]
  004c8	83 ea 08	 sub	 edx, 8
  004cb	33 f9		 xor	 edi, ecx
  004cd	69 ff e7 d3 0a
	00		 imul	 edi, 709607		; 000ad3e7H
  004d3	83 c0 08	 add	 eax, 8
  004d6	83 ee 01	 sub	 esi, 1
  004d9	8b cf		 mov	 ecx, edi
  004db	75 e3		 jne	 SHORT $LL6@FNV1A_Hash
  004dd	5f		 pop	 edi
$LN4@FNV1A_Hash:

; 1018 : 	}
; 1019 : 	// Cases: 0,1,2,3,4,5,6,7
; 1020 : 	if (wrdlen & sizeof(DWORD)) {

  004de	f6 c2 04	 test	 dl, 4
  004e1	74 0f		 je	 SHORT $LN3@FNV1A_Hash

; 1021 : 		hash32 = (hash32 ^ *(DWORD*)p) * PRIME;

  004e3	8b 30		 mov	 esi, DWORD PTR [eax]
  004e5	33 f1		 xor	 esi, ecx
  004e7	69 f6 e7 d3 0a
	00		 imul	 esi, 709607		; 000ad3e7H
  004ed	8b ce		 mov	 ecx, esi

; 1022 : 		p += sizeof(DWORD);

  004ef	83 c0 04	 add	 eax, 4
$LN3@FNV1A_Hash:

; 1023 : 	}
; 1024 : 	if (wrdlen & sizeof(WORD)) {

  004f2	f6 c2 02	 test	 dl, 2
  004f5	74 10		 je	 SHORT $LN2@FNV1A_Hash

; 1025 : 		hash32 = (hash32 ^ *(WORD*)p) * PRIME;

  004f7	0f b7 30	 movzx	 esi, WORD PTR [eax]
  004fa	33 f1		 xor	 esi, ecx
  004fc	69 f6 e7 d3 0a
	00		 imul	 esi, 709607		; 000ad3e7H
  00502	8b ce		 mov	 ecx, esi

; 1026 : 		p += sizeof(WORD);

  00504	83 c0 02	 add	 eax, 2
$LN2@FNV1A_Hash:
  00507	5e		 pop	 esi

; 1027 : 	}
; 1028 : 	if (wrdlen & 1) 

  00508	f6 c2 01	 test	 dl, 1
  0050b	74 0d		 je	 SHORT $LN1@FNV1A_Hash

; 1029 : 		hash32 = (hash32 ^ *p) * PRIME;

  0050d	0f be 00	 movsx	 eax, BYTE PTR [eax]
  00510	33 c1		 xor	 eax, ecx
  00512	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  00518	8b c8		 mov	 ecx, eax
$LN1@FNV1A_Hash:

; 1030 : 	
; 1031 : 	return hash32 ^ (hash32 >> 16);

  0051a	8b c1		 mov	 eax, ecx
  0051c	c1 e8 10	 shr	 eax, 16			; 00000010H
  0051f	33 c1		 xor	 eax, ecx

; 1032 : }

  00521	c3		 ret	 0
?FNV1A_Hash_Jesteress@@YAIPBDK@Z ENDP			; FNV1A_Hash_Jesteress
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?FNV1A_Hash_Jester@@YAIPBDK@Z PROC			; FNV1A_Hash_Jester

; 974  : 	const UINT PRIME = 709607;
; 975  : 	UINT hash32 = 2166136261;
; 976  : 	const char *p = str;
; 977  : 
; 978  : 	// Idea comes from Igor Pavlov's 7zCRC, thanks.
; 979  : /*
; 980  : 	for(; wrdlen && ((unsigned)(ptrdiff_t)p&3); wrdlen -= 1, p++) {
; 981  : 		hash32 = (hash32 ^ *p) * PRIME;
; 982  : 	}
; 983  : */
; 984  : 	for(; wrdlen >= 2*sizeof(DWORD); wrdlen -= 2*sizeof(DWORD), p += 2*sizeof(DWORD)) {

  00530	8b 54 24 08	 mov	 edx, DWORD PTR _wrdlen$[esp-4]
  00534	8b 44 24 04	 mov	 eax, DWORD PTR _str$[esp-4]
  00538	56		 push	 esi
  00539	b9 c5 9d 1c 81	 mov	 ecx, -2128831035	; 811c9dc5H
  0053e	83 fa 08	 cmp	 edx, 8
  00541	72 2e		 jb	 SHORT $LN4@FNV1A_Hash@2
  00543	8b f2		 mov	 esi, edx
  00545	c1 ee 03	 shr	 esi, 3
  00548	57		 push	 edi
  00549	8d a4 24 00 00
	00 00		 npad	 7
$LL6@FNV1A_Hash@2:

; 985  : 		hash32 = (hash32 ^ *(DWORD *)p) * PRIME;

  00550	8b 38		 mov	 edi, DWORD PTR [eax]
  00552	33 f9		 xor	 edi, ecx
  00554	69 ff e7 d3 0a
	00		 imul	 edi, 709607		; 000ad3e7H

; 986  : 		hash32 = (hash32 ^ *(DWORD *)(p+4)) * PRIME;

  0055a	33 78 04	 xor	 edi, DWORD PTR [eax+4]
  0055d	83 ea 08	 sub	 edx, 8
  00560	69 ff e7 d3 0a
	00		 imul	 edi, 709607		; 000ad3e7H
  00566	83 c0 08	 add	 eax, 8
  00569	83 ee 01	 sub	 esi, 1
  0056c	8b cf		 mov	 ecx, edi
  0056e	75 e0		 jne	 SHORT $LL6@FNV1A_Hash@2
  00570	5f		 pop	 edi
$LN4@FNV1A_Hash@2:

; 987  : 	}
; 988  : 	// Cases: 0,1,2,3,4,5,6,7
; 989  : 	if (wrdlen & sizeof(DWORD)) {

  00571	f6 c2 04	 test	 dl, 4
  00574	74 0f		 je	 SHORT $LN3@FNV1A_Hash@2

; 990  : 		hash32 = (hash32 ^ *(DWORD*)p) * PRIME;

  00576	8b 30		 mov	 esi, DWORD PTR [eax]
  00578	33 f1		 xor	 esi, ecx
  0057a	69 f6 e7 d3 0a
	00		 imul	 esi, 709607		; 000ad3e7H
  00580	8b ce		 mov	 ecx, esi

; 991  : 		p += sizeof(DWORD);

  00582	83 c0 04	 add	 eax, 4
$LN3@FNV1A_Hash@2:

; 992  : 	}
; 993  : 	if (wrdlen & sizeof(WORD)) {

  00585	f6 c2 02	 test	 dl, 2
  00588	74 10		 je	 SHORT $LN2@FNV1A_Hash@2

; 994  : 		hash32 = (hash32 ^ *(WORD*)p) * PRIME;

  0058a	0f b7 30	 movzx	 esi, WORD PTR [eax]
  0058d	33 f1		 xor	 esi, ecx
  0058f	69 f6 e7 d3 0a
	00		 imul	 esi, 709607		; 000ad3e7H
  00595	8b ce		 mov	 ecx, esi

; 995  : 		p += sizeof(WORD);

  00597	83 c0 02	 add	 eax, 2
$LN2@FNV1A_Hash@2:
  0059a	5e		 pop	 esi

; 996  : 	}
; 997  : 	if (wrdlen & 1) 

  0059b	f6 c2 01	 test	 dl, 1
  0059e	74 0d		 je	 SHORT $LN1@FNV1A_Hash@2

; 998  : 		hash32 = (hash32 ^ *p) * PRIME;

  005a0	0f be 00	 movsx	 eax, BYTE PTR [eax]
  005a3	33 c1		 xor	 eax, ecx
  005a5	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  005ab	8b c8		 mov	 ecx, eax
$LN1@FNV1A_Hash@2:

; 999  : 	
; 1000 : 	return hash32 ^ (hash32 >> 16);

  005ad	8b c1		 mov	 eax, ecx
  005af	c1 e8 10	 shr	 eax, 16			; 00000010H
  005b2	33 c1		 xor	 eax, ecx

; 1001 : }

  005b4	c3		 ret	 0
?FNV1A_Hash_Jester@@YAIPBDK@Z ENDP			; FNV1A_Hash_Jester
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?FNV1A_Hash_WHIZ@@YAIPBDK@Z PROC			; FNV1A_Hash_WHIZ

; 939  : 	const UINT PRIME = 709607;//15607;
; 940  : 
; 941  : //Whiz 107:   10517484  10506006  10516230  10521979  10498682|  10498682 [2162779]
; 942  : //Whiz 113:   10639939  10497081  10501382  10491759  10509496|  10491759 [2145878] !
; 943  : //Whiz 167:   10642142  10494859  10498245  10546216  10514032|  10494859 [2153301]
; 944  : //Whiz 197:   10640694  10494344  10481432  10485134  10514380|  10481432 [2155048]
; 945  : //Whiz 607:   10533478  10562420  10607113  10543554  10563058|  10533478 [2156392]
; 946  : //Whiz 1607:   10702972  10581596  10605821  10620855  10576937|  10576937 [2189360]
; 947  : //Whiz 1777:   10629381  10531970  10538870  10537019  10565007|  10531970 [2164572]
; 948  : //Whiz 2087:   10615378  10541706  10517062  10555783  10515463|  10515463 [2152011]
; 949  : //Whiz 2357:   10642049  10552602  10584649  10490162  10524046|  10490162 [2145307]
; 950  : //Whiz 15607:   10701001  10545813  10513176  10509870  10520269|  10509870 [2138234] !
; 951  : //Whiz 16607:   10665426  10542887  10547560  10548654  10562791|  10542887 [2148125]
; 952  : //Whiz 37607:   10685093  10523184  10511143  10517122  10525008|  10511143 [2142681]
; 953  : //Whiz 70607:   10712369  10537747  10536670  10542325  10516454|  10516454 [2139261]
; 954  : //Whiz 709607: [2138053]
; 955  : 
; 956  : 	UINT hash32 = 2166136261;
; 957  : 	const char *p = str;
; 958  : 
; 959  : 	for(; wrdlen >= sizeof(DWORD); wrdlen -= sizeof(DWORD), p += sizeof(DWORD)) {

  005c0	8b 54 24 08	 mov	 edx, DWORD PTR _wrdlen$[esp-4]
  005c4	8b 44 24 04	 mov	 eax, DWORD PTR _str$[esp-4]
  005c8	56		 push	 esi
  005c9	b9 c5 9d 1c 81	 mov	 ecx, -2128831035	; 811c9dc5H
  005ce	83 fa 04	 cmp	 edx, 4
  005d1	72 25		 jb	 SHORT $LN3@FNV1A_Hash@3
  005d3	8b f2		 mov	 esi, edx
  005d5	c1 ee 02	 shr	 esi, 2
  005d8	57		 push	 edi
  005d9	8d a4 24 00 00
	00 00		 npad	 7
$LL5@FNV1A_Hash@3:

; 960  : 		hash32 = (hash32 ^ *(DWORD *)p) * PRIME;

  005e0	8b 38		 mov	 edi, DWORD PTR [eax]
  005e2	33 f9		 xor	 edi, ecx
  005e4	69 ff e7 d3 0a
	00		 imul	 edi, 709607		; 000ad3e7H
  005ea	83 ea 04	 sub	 edx, 4
  005ed	83 c0 04	 add	 eax, 4
  005f0	83 ee 01	 sub	 esi, 1
  005f3	8b cf		 mov	 ecx, edi
  005f5	75 e9		 jne	 SHORT $LL5@FNV1A_Hash@3
  005f7	5f		 pop	 edi
$LN3@FNV1A_Hash@3:

; 961  : 	}
; 962  : 	if (wrdlen & sizeof(WORD)) {

  005f8	f6 c2 02	 test	 dl, 2
  005fb	74 10		 je	 SHORT $LN2@FNV1A_Hash@3

; 963  : 		hash32 = (hash32 ^ *(WORD*)p) * PRIME;

  005fd	0f b7 30	 movzx	 esi, WORD PTR [eax]
  00600	33 f1		 xor	 esi, ecx
  00602	69 f6 e7 d3 0a
	00		 imul	 esi, 709607		; 000ad3e7H
  00608	8b ce		 mov	 ecx, esi

; 964  : 		p += sizeof(WORD);

  0060a	83 c0 02	 add	 eax, 2
$LN2@FNV1A_Hash@3:
  0060d	5e		 pop	 esi

; 965  : 	}
; 966  : 	if (wrdlen & 1) 

  0060e	f6 c2 01	 test	 dl, 1
  00611	74 0d		 je	 SHORT $LN1@FNV1A_Hash@3

; 967  : 		hash32 = (hash32 ^ *p) * PRIME;

  00613	0f be 00	 movsx	 eax, BYTE PTR [eax]
  00616	33 c1		 xor	 eax, ecx
  00618	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  0061e	8b c8		 mov	 ecx, eax
$LN1@FNV1A_Hash@3:

; 968  : 
; 969  : 	return hash32 ^ (hash32 >> 16);

  00620	8b c1		 mov	 eax, ecx
  00622	c1 e8 10	 shr	 eax, 16			; 00000010H
  00625	33 c1		 xor	 eax, ecx

; 970  : }

  00627	c3		 ret	 0
?FNV1A_Hash_WHIZ@@YAIPBDK@Z ENDP			; FNV1A_Hash_WHIZ
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?HashFNV1A_Nefertiti@@YAIPBDK@Z PROC			; HashFNV1A_Nefertiti

; 879  : 	//const UINT PRIME = 31;
; 880  : 	UINT hash = 2166136261;
; 881  : 	const CHAR * p = str;

  00630	8b 54 24 04	 mov	 edx, DWORD PTR _str$[esp-4]
  00634	53		 push	 ebx

; 882  : 	/*
; 883  : 	// Reduce the number of multiplications by unrolling the loop
; 884  : 	for (SIZE_T ndwords = wrdlen / sizeof(DWORD); ndwords; --ndwords) {
; 885  : 	//hash = (hash ^ *(DWORD*)p) * PRIME;
; 886  : 	hash = ((hash ^ *(DWORD*)p)<<5) - (hash ^ *(DWORD*)p);
; 887  : 
; 888  : 	p += sizeof(DWORD);
; 889  : 	}
; 890  : 	*/
; 891  : 	for(; wrdlen >= 4; wrdlen -= 4, p += 4) {

  00635	8b 5c 24 0c	 mov	 ebx, DWORD PTR _wrdlen$[esp]
  00639	b9 c5 9d 1c 81	 mov	 ecx, -2128831035	; 811c9dc5H
  0063e	83 fb 04	 cmp	 ebx, 4
  00641	72 24		 jb	 SHORT $LN3@HashFNV1A_
  00643	56		 push	 esi
  00644	8b f3		 mov	 esi, ebx
  00646	c1 ee 02	 shr	 esi, 2
  00649	8d a4 24 00 00
	00 00		 npad	 7
$LL5@HashFNV1A_:

; 892  : 		hash = ((hash ^ *(DWORD*)p)<<5) - (hash ^ *(DWORD*)p);

  00650	8b 02		 mov	 eax, DWORD PTR [edx]
  00652	33 c1		 xor	 eax, ecx
  00654	8b c8		 mov	 ecx, eax
  00656	c1 e1 05	 shl	 ecx, 5
  00659	2b c8		 sub	 ecx, eax
  0065b	83 eb 04	 sub	 ebx, 4
  0065e	83 c2 04	 add	 edx, 4
  00661	83 ee 01	 sub	 esi, 1
  00664	75 ea		 jne	 SHORT $LL5@HashFNV1A_
  00666	5e		 pop	 esi
$LN3@HashFNV1A_:

; 893  : 	}
; 894  : 
; 895  : 	// Process the remaining bytes
; 896  : 	/*
; 897  : 	for (SIZE_T i = 0; i < (wrdlen & (sizeof(DWORD) - 1)); i++) {
; 898  : 	//hash = (hash ^ *p++) * PRIME;
; 899  : 	hash = ((hash ^ *p)<<5) - (hash ^ *p);
; 900  : 	p++;
; 901  : 	}
; 902  : 	*/
; 903  : 	if (wrdlen & 2) {

  00667	f6 c3 02	 test	 bl, 2
  0066a	74 0f		 je	 SHORT $LN2@HashFNV1A_

; 904  : 		hash = ((hash ^ *(WORD*)p)<<5) - (hash ^ *(WORD*)p);

  0066c	0f b7 02	 movzx	 eax, WORD PTR [edx]
  0066f	33 c1		 xor	 eax, ecx
  00671	8b c8		 mov	 ecx, eax
  00673	c1 e1 05	 shl	 ecx, 5
  00676	2b c8		 sub	 ecx, eax

; 905  : 		p++;p++;

  00678	83 c2 02	 add	 edx, 2
$LN2@HashFNV1A_:

; 906  : 	}
; 907  : 	if (wrdlen & 1) 

  0067b	f6 c3 01	 test	 bl, 1
  0067e	5b		 pop	 ebx
  0067f	74 0e		 je	 SHORT $LN1@HashFNV1A_

; 908  : 		hash = ((hash ^ *p)<<5) - (hash ^ *p);

  00681	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00684	33 c1		 xor	 eax, ecx
  00686	8b d0		 mov	 edx, eax
  00688	c1 e2 05	 shl	 edx, 5
  0068b	2b d0		 sub	 edx, eax
  0068d	8b ca		 mov	 ecx, edx
$LN1@HashFNV1A_:

; 909  : 
; 910  : 	return (hash>>16) ^ hash;

  0068f	8b c1		 mov	 eax, ecx
  00691	c1 e8 10	 shr	 eax, 16			; 00000010H
  00694	33 c1		 xor	 eax, ecx

; 911  : }

  00696	c3		 ret	 0
?HashFNV1A_Nefertiti@@YAIPBDK@Z ENDP			; HashFNV1A_Nefertiti
; Function compile flags: /Ogtpy
_hashAlfalfa$ = -16					; size = 4
tv184 = -12						; size = 4
_hashQWORD$ = -8					; size = 8
_key$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?HashAlfalfa_QWORD@@YAIPBDK@Z PROC			; HashAlfalfa_QWORD

; 860  : {

  006a0	55		 push	 ebp
  006a1	8b ec		 mov	 ebp, esp
  006a3	83 e4 f8	 and	 esp, -8			; fffffff8H
  006a6	83 ec 14	 sub	 esp, 20			; 00000014H

; 861  : 	UINT64 hashQWORD;
; 862  : 	UINT hashAlfalfa = 7;
; 863  : 	
; 864  : 	for(; wrdlen >= 8; wrdlen -= 8, key += 8) {

  006a9	8b 45 0c	 mov	 eax, DWORD PTR _wrdlen$[ebp]
  006ac	8b 55 08	 mov	 edx, DWORD PTR _key$[ebp]
  006af	53		 push	 ebx
  006b0	56		 push	 esi
  006b1	b9 07 00 00 00	 mov	 ecx, 7
  006b6	57		 push	 edi
  006b7	89 4c 24 10	 mov	 DWORD PTR _hashAlfalfa$[esp+32], ecx
  006bb	83 f8 08	 cmp	 eax, 8
  006be	0f 82 be 00 00
	00		 jb	 $LN4@HashAlfalf
  006c4	c1 e8 03	 shr	 eax, 3
  006c7	89 44 24 14	 mov	 DWORD PTR tv184[esp+32], eax
  006cb	eb 03 8d 49 00	 npad	 5
$LL6@HashAlfalf:

; 865  : 		hashQWORD=*(unsigned long long*)key;

  006d0	8b 42 04	 mov	 eax, DWORD PTR [edx+4]
  006d3	8b 0a		 mov	 ecx, DWORD PTR [edx]

; 866  : 		hashAlfalfa = (53) * ((53) * hashAlfalfa + ((hashQWORD>>0)&0xFF) ) + ((hashQWORD>>8)&0xFF);
; 867  : 		hashAlfalfa = (53) * ((53) * hashAlfalfa + ((hashQWORD>>16)&0xFF) ) + ((hashQWORD>>24)&0xFF);

  006d5	8b f8		 mov	 edi, eax
  006d7	8b f1		 mov	 esi, ecx
  006d9	0f ac fe 10	 shrd	 esi, edi, 16
  006dd	81 e6 ff 00 00
	00		 and	 esi, 255		; 000000ffH
  006e3	c1 ef 10	 shr	 edi, 16			; 00000010H

; 868  : 		hashAlfalfa = (53) * ((53) * hashAlfalfa + ((hashQWORD>>32)&0xFF) ) + ((hashQWORD>>40)&0xFF);
; 869  : 		hashAlfalfa = (53) * ((53) * hashAlfalfa + ((hashQWORD>>48)&0xFF) ) + ((hashQWORD>>56)&0xFF);

  006e6	6b f6 35	 imul	 esi, 53			; 00000035H
  006e9	8b d8		 mov	 ebx, eax
  006eb	8b f9		 mov	 edi, ecx
  006ed	0f ac df 18	 shrd	 edi, ebx, 24
  006f1	81 e7 ff 00 00
	00		 and	 edi, 255		; 000000ffH
  006f7	03 f7		 add	 esi, edi
  006f9	6b f6 35	 imul	 esi, 53			; 00000035H
  006fc	0f b6 f8	 movzx	 edi, al
  006ff	03 f7		 add	 esi, edi
  00701	6b f6 35	 imul	 esi, 53			; 00000035H
  00704	8b f8		 mov	 edi, eax
  00706	c1 ef 08	 shr	 edi, 8
  00709	81 e7 ff 00 00
	00		 and	 edi, 255		; 000000ffH
  0070f	03 f7		 add	 esi, edi
  00711	6b f6 35	 imul	 esi, 53			; 00000035H
  00714	8b f8		 mov	 edi, eax
  00716	c1 ef 10	 shr	 edi, 16			; 00000010H
  00719	81 e7 ff 00 00
	00		 and	 edi, 255		; 000000ffH
  0071f	03 f7		 add	 esi, edi
  00721	c1 eb 18	 shr	 ebx, 24			; 00000018H
  00724	6b f6 35	 imul	 esi, 53			; 00000035H
  00727	8b d8		 mov	 ebx, eax
  00729	8b f9		 mov	 edi, ecx
  0072b	0f ac df 08	 shrd	 edi, ebx, 8
  0072f	81 e7 ff 00 00
	00		 and	 edi, 255		; 000000ffH
  00735	69 ff a9 4f 19
	29		 imul	 edi, 689524649		; 29194fa9H
  0073b	89 44 24 1c	 mov	 DWORD PTR _hashQWORD$[esp+36], eax
  0073f	c1 e8 18	 shr	 eax, 24			; 00000018H
  00742	25 ff 00 00 00	 and	 eax, 255		; 000000ffH
  00747	03 f7		 add	 esi, edi
  00749	03 f0		 add	 esi, eax
  0074b	0f b6 c1	 movzx	 eax, cl
  0074e	8b 4c 24 10	 mov	 ecx, DWORD PTR _hashAlfalfa$[esp+32]
  00752	69 c0 03 82 c2
	7d		 imul	 eax, 2109899267		; 7dc28203H
  00758	69 c9 9f ea 44
	09		 imul	 ecx, 155511455		; 0944ea9fH
  0075e	2b f0		 sub	 esi, eax
  00760	8b 45 0c	 mov	 eax, DWORD PTR _wrdlen$[ebp]
  00763	2b f1		 sub	 esi, ecx
  00765	83 e8 08	 sub	 eax, 8
  00768	c1 eb 08	 shr	 ebx, 8
  0076b	83 c2 08	 add	 edx, 8
  0076e	83 6c 24 14 01	 sub	 DWORD PTR tv184[esp+32], 1
  00773	8b ce		 mov	 ecx, esi
  00775	89 74 24 10	 mov	 DWORD PTR _hashAlfalfa$[esp+32], esi
  00779	89 45 0c	 mov	 DWORD PTR _wrdlen$[ebp], eax
  0077c	0f 85 4e ff ff
	ff		 jne	 $LL6@HashAlfalf
$LN4@HashAlfalf:

; 870  : 	}
; 871  : 	for(; wrdlen; wrdlen--, key++)

  00782	85 c0		 test	 eax, eax
  00784	74 0e		 je	 SHORT $LN1@HashAlfalf
$LL3@HashAlfalf:

; 872  : 		hashAlfalfa = (53) * hashAlfalfa + *key;

  00786	0f be 32	 movsx	 esi, BYTE PTR [edx]
  00789	6b c9 35	 imul	 ecx, 53			; 00000035H
  0078c	48		 dec	 eax
  0078d	03 ce		 add	 ecx, esi
  0078f	42		 inc	 edx
  00790	85 c0		 test	 eax, eax
  00792	75 f2		 jne	 SHORT $LL3@HashAlfalf
$LN1@HashAlfalf:

; 873  : 	return hashAlfalfa ^ (hashAlfalfa >> 16);
; 874  : }

  00794	5f		 pop	 edi
  00795	8b c1		 mov	 eax, ecx
  00797	c1 e8 10	 shr	 eax, 16			; 00000010H
  0079a	5e		 pop	 esi
  0079b	33 c1		 xor	 eax, ecx
  0079d	5b		 pop	 ebx
  0079e	8b e5		 mov	 esp, ebp
  007a0	5d		 pop	 ebp
  007a1	c3		 ret	 0
?HashAlfalfa_QWORD@@YAIPBDK@Z ENDP			; HashAlfalfa_QWORD
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?HashAlfalfa_DWORD@@YAIPBDK@Z PROC			; HashAlfalfa_DWORD

; 845  : {

  007b0	53		 push	 ebx

; 846  : 	SIZE_T i, j;
; 847  : 	UINT hash = 7;
; 848  : 	for(i = 0; i < (wrdlen & -(INT_PTR)sizeof(DWORD)); i += sizeof(DWORD)) {

  007b1	8b 5c 24 0c	 mov	 ebx, DWORD PTR _wrdlen$[esp]
  007b5	56		 push	 esi
  007b6	8b f3		 mov	 esi, ebx
  007b8	33 d2		 xor	 edx, edx
  007ba	83 e6 fc	 and	 esi, -4			; fffffffcH
  007bd	57		 push	 edi
  007be	8b 7c 24 10	 mov	 edi, DWORD PTR _key$[esp+8]
  007c2	b9 07 00 00 00	 mov	 ecx, 7
  007c7	76 44		 jbe	 SHORT $LN4@HashAlfalf@2
  007c9	55		 push	 ebp
  007ca	8d 9b 00 00 00
	00		 npad	 6
$LL6@HashAlfalf@2:

; 849  : 		DWORD x = *(DWORD*)(key + i);

  007d0	8b 04 3a	 mov	 eax, DWORD PTR [edx+edi]

; 850  : 		hash = (53) * ((53) * hash + ((x>>0)&0xFF) ) + ((x>>8)&0xFF);
; 851  : 		hash = (53) * ((53) * hash + ((x>>16)&0xFF) ) + ((x>>24)&0xFF);

  007d3	6b c9 35	 imul	 ecx, 53			; 00000035H
  007d6	0f b6 e8	 movzx	 ebp, al
  007d9	03 e9		 add	 ebp, ecx
  007db	6b ed 35	 imul	 ebp, 53			; 00000035H
  007de	8b c8		 mov	 ecx, eax
  007e0	c1 e9 08	 shr	 ecx, 8
  007e3	81 e1 ff 00 00
	00		 and	 ecx, 255		; 000000ffH
  007e9	03 e9		 add	 ebp, ecx
  007eb	6b ed 35	 imul	 ebp, 53			; 00000035H
  007ee	8b c8		 mov	 ecx, eax
  007f0	c1 e9 10	 shr	 ecx, 16			; 00000010H
  007f3	81 e1 ff 00 00
	00		 and	 ecx, 255		; 000000ffH
  007f9	03 e9		 add	 ebp, ecx
  007fb	6b ed 35	 imul	 ebp, 53			; 00000035H
  007fe	c1 e8 18	 shr	 eax, 24			; 00000018H
  00801	03 e8		 add	 ebp, eax
  00803	83 c2 04	 add	 edx, 4
  00806	8b cd		 mov	 ecx, ebp
  00808	3b d6		 cmp	 edx, esi
  0080a	72 c4		 jb	 SHORT $LL6@HashAlfalf@2
  0080c	5d		 pop	 ebp
$LN4@HashAlfalf@2:

; 852  : 	}
; 853  : 	for(j = 0; j < (wrdlen & (sizeof(DWORD) - 1)); j++) {

  0080d	33 c0		 xor	 eax, eax
  0080f	83 e3 03	 and	 ebx, 3
  00812	8b f3		 mov	 esi, ebx
  00814	76 10		 jbe	 SHORT $LN1@HashAlfalf@2
  00816	03 d7		 add	 edx, edi
$LL3@HashAlfalf@2:

; 854  : 		hash = (53) * hash + key[i+j];

  00818	0f be 3c 02	 movsx	 edi, BYTE PTR [edx+eax]
  0081c	6b c9 35	 imul	 ecx, 53			; 00000035H
  0081f	40		 inc	 eax
  00820	03 cf		 add	 ecx, edi
  00822	3b c6		 cmp	 eax, esi
  00824	72 f2		 jb	 SHORT $LL3@HashAlfalf@2
$LN1@HashAlfalf@2:
  00826	5f		 pop	 edi

; 855  : 	}
; 856  : 	return hash ^ (hash >> 16);

  00827	8b c1		 mov	 eax, ecx
  00829	c1 e8 10	 shr	 eax, 16			; 00000010H
  0082c	5e		 pop	 esi
  0082d	33 c1		 xor	 eax, ecx
  0082f	5b		 pop	 ebx

; 857  : }

  00830	c3		 ret	 0
?HashAlfalfa_DWORD@@YAIPBDK@Z ENDP			; HashAlfalfa_DWORD
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?HashAlfalfa_HALF@@YAIPBDK@Z PROC			; HashAlfalfa_HALF

; 826  : {

  00840	53		 push	 ebx
  00841	55		 push	 ebp

; 827  : 	UINT hash = 12;
; 828  : 	UINT hashBUFFER;
; 829  : 	SIZE_T i;
; 830  : 	for(i = 0; i < (wrdlen & -4); i += 4) {

  00842	8b 6c 24 10	 mov	 ebp, DWORD PTR _wrdlen$[esp+4]
  00846	56		 push	 esi
  00847	8b dd		 mov	 ebx, ebp
  00849	33 d2		 xor	 edx, edx
  0084b	83 e3 fc	 and	 ebx, -4			; fffffffcH
  0084e	57		 push	 edi
  0084f	8b 7c 24 14	 mov	 edi, DWORD PTR _key$[esp+12]
  00853	b9 0c 00 00 00	 mov	 ecx, 12			; 0000000cH
  00858	76 44		 jbe	 SHORT $LN4@HashAlfalf@3
  0085a	8d 9b 00 00 00
	00		 npad	 6
$LL6@HashAlfalf@3:

; 831  : 		//hash = (( ((hash<<5)-hash) + key[i] )<<5) - ( ((hash<<5)-hash) + key[i] ) + (key[i+1]);
; 832  : 		hashBUFFER = ((hash<<5)-hash) + key[i];
; 833  : 		hash = (( hashBUFFER )<<5) - ( hashBUFFER ) + (key[i+1]);
; 834  : 		//hash = (( ((hash<<5)-hash) + key[i+2] )<<5) - ( ((hash<<5)-hash) + key[i+2] ) + (key[i+3]);
; 835  : 		hashBUFFER = ((hash<<5)-hash) + key[i+2];
; 836  : 		hash = (( hashBUFFER )<<5) - ( hashBUFFER ) + (key[i+3]);

  00860	0f be 34 17	 movsx	 esi, BYTE PTR [edi+edx]
  00864	8b c1		 mov	 eax, ecx
  00866	c1 e0 05	 shl	 eax, 5
  00869	2b c1		 sub	 eax, ecx
  0086b	0f be 4c 17 01	 movsx	 ecx, BYTE PTR [edi+edx+1]
  00870	03 f0		 add	 esi, eax
  00872	8b c6		 mov	 eax, esi
  00874	c1 e0 05	 shl	 eax, 5
  00877	2b c6		 sub	 eax, esi
  00879	03 c1		 add	 eax, ecx
  0087b	8b c8		 mov	 ecx, eax
  0087d	c1 e1 05	 shl	 ecx, 5
  00880	2b c8		 sub	 ecx, eax
  00882	0f be 44 17 02	 movsx	 eax, BYTE PTR [edi+edx+2]
  00887	03 c8		 add	 ecx, eax
  00889	8b c1		 mov	 eax, ecx
  0088b	c1 e0 05	 shl	 eax, 5
  0088e	2b c1		 sub	 eax, ecx
  00890	0f be 4c 17 03	 movsx	 ecx, BYTE PTR [edi+edx+3]
  00895	83 c2 04	 add	 edx, 4
  00898	03 c8		 add	 ecx, eax
  0089a	3b d3		 cmp	 edx, ebx
  0089c	72 c2		 jb	 SHORT $LL6@HashAlfalf@3
$LN4@HashAlfalf@3:

; 837  : 	}
; 838  : 	for(SIZE_T j = 0; j < (wrdlen & 3); j += 1) {

  0089e	33 c0		 xor	 eax, eax
  008a0	83 e5 03	 and	 ebp, 3
  008a3	8b f5		 mov	 esi, ebp
  008a5	76 1d		 jbe	 SHORT $LN1@HashAlfalf@3
  008a7	03 d7		 add	 edx, edi
  008a9	8d a4 24 00 00
	00 00		 npad	 7
$LL3@HashAlfalf@3:

; 839  : 		hash = ((hash<<5)-hash) + key[i+j];

  008b0	0f be 3c 02	 movsx	 edi, BYTE PTR [edx+eax]
  008b4	8b d9		 mov	 ebx, ecx
  008b6	c1 e3 05	 shl	 ebx, 5
  008b9	2b d9		 sub	 ebx, ecx
  008bb	03 fb		 add	 edi, ebx
  008bd	40		 inc	 eax
  008be	8b cf		 mov	 ecx, edi
  008c0	3b c6		 cmp	 eax, esi
  008c2	72 ec		 jb	 SHORT $LL3@HashAlfalf@3
$LN1@HashAlfalf@3:
  008c4	5f		 pop	 edi
  008c5	5e		 pop	 esi

; 840  : 	}
; 841  : 	return hash ^ (hash >> 16);

  008c6	8b c1		 mov	 eax, ecx
  008c8	c1 e8 10	 shr	 eax, 16			; 00000010H
  008cb	5d		 pop	 ebp
  008cc	33 c1		 xor	 eax, ecx
  008ce	5b		 pop	 ebx

; 842  : }

  008cf	c3		 ret	 0
?HashAlfalfa_HALF@@YAIPBDK@Z ENDP			; HashAlfalfa_HALF
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?HashAlfalfa@@YAIPBDK@Z PROC				; HashAlfalfa

; 815  : {

  008d0	53		 push	 ebx

; 816  : 	UINT hash = 7;
; 817  : 	for (SIZE_T i = 0; i < (wrdlen & -2); i += 2) {

  008d1	8b 5c 24 0c	 mov	 ebx, DWORD PTR _wrdlen$[esp]
  008d5	8b cb		 mov	 ecx, ebx
  008d7	83 e1 fe	 and	 ecx, -2			; fffffffeH
  008da	56		 push	 esi
  008db	8b 74 24 0c	 mov	 esi, DWORD PTR _key$[esp+4]
  008df	ba 07 00 00 00	 mov	 edx, 7
  008e4	76 24		 jbe	 SHORT $LN2@HashAlfalf@4
  008e6	49		 dec	 ecx
  008e7	d1 e9		 shr	 ecx, 1
  008e9	8d 46 01	 lea	 eax, DWORD PTR [esi+1]
  008ec	41		 inc	 ecx
  008ed	57		 push	 edi
  008ee	8b ff		 npad	 2
$LL4@HashAlfalf@4:

; 818  : 		hash = (53) * ((53) * hash + (key[i])) + (key[i+1]);

  008f0	0f be 78 ff	 movsx	 edi, BYTE PTR [eax-1]
  008f4	6b d2 35	 imul	 edx, 53			; 00000035H
  008f7	03 fa		 add	 edi, edx
  008f9	0f be 10	 movsx	 edx, BYTE PTR [eax]
  008fc	6b ff 35	 imul	 edi, 53			; 00000035H
  008ff	03 d7		 add	 edx, edi
  00901	83 c0 02	 add	 eax, 2
  00904	83 e9 01	 sub	 ecx, 1
  00907	75 e7		 jne	 SHORT $LL4@HashAlfalf@4
  00909	5f		 pop	 edi
$LN2@HashAlfalf@4:

; 819  : 	}
; 820  : 	if (wrdlen & 1)

  0090a	f6 c3 01	 test	 bl, 1
  0090d	74 0a		 je	 SHORT $LN1@HashAlfalf@4

; 821  : 		hash = (53) * hash + (key[wrdlen-1]);

  0090f	0f be 44 1e ff	 movsx	 eax, BYTE PTR [esi+ebx-1]
  00914	6b d2 35	 imul	 edx, 53			; 00000035H
  00917	03 d0		 add	 edx, eax
$LN1@HashAlfalf@4:

; 822  : 	return hash ^ (hash >> 16);

  00919	8b c2		 mov	 eax, edx
  0091b	c1 e8 10	 shr	 eax, 16			; 00000010H
  0091e	5e		 pop	 esi
  0091f	33 c2		 xor	 eax, edx
  00921	5b		 pop	 ebx

; 823  : }

  00922	c3		 ret	 0
?HashAlfalfa@@YAIPBDK@Z ENDP				; HashAlfalfa
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?HashAlfalfa_Rollick@@YAIPBDK@Z PROC			; HashAlfalfa_Rollick

; 799  : 	UINT hash = 7;
; 800  : 	const char *p = key;

  00930	8b 4c 24 04	 mov	 ecx, DWORD PTR _key$[esp-4]
  00934	56		 push	 esi

; 801  : 
; 802  : 	for(; wrdlen >= 2*sizeof(DWORD); wrdlen -= 2*sizeof(DWORD), p += 2*sizeof(DWORD)) {

  00935	8b 74 24 0c	 mov	 esi, DWORD PTR _wrdlen$[esp]
  00939	ba 07 00 00 00	 mov	 edx, 7
  0093e	83 fe 08	 cmp	 esi, 8
  00941	72 54		 jb	 SHORT $LN4@HashAlfalf@5
  00943	53		 push	 ebx
  00944	57		 push	 edi
  00945	8b fe		 mov	 edi, esi
  00947	c1 ef 03	 shr	 edi, 3
  0094a	8d 9b 00 00 00
	00		 npad	 6
$LL6@HashAlfalf@5:

; 803  : 		DWORD x = (ROL(*(DWORD *)p,5)^*(DWORD *)(p+4));

  00950	8b 01		 mov	 eax, DWORD PTR [ecx]

; 804  : 		hash = 53 * ( 53 * hash + ((x>>0)&0xFF) ) + ((x>>8)&0xFF);
; 805  : 		hash = 53 * ( 53 * hash + ((x>>16)&0xFF) ) + ((x>>24)&0xFF);

  00952	6b d2 35	 imul	 edx, 53			; 00000035H
  00955	c1 c0 05	 rol	 eax, 5
  00958	33 41 04	 xor	 eax, DWORD PTR [ecx+4]
  0095b	83 ee 08	 sub	 esi, 8
  0095e	0f b6 d8	 movzx	 ebx, al
  00961	03 da		 add	 ebx, edx
  00963	6b db 35	 imul	 ebx, 53			; 00000035H
  00966	8b d0		 mov	 edx, eax
  00968	c1 ea 08	 shr	 edx, 8
  0096b	81 e2 ff 00 00
	00		 and	 edx, 255		; 000000ffH
  00971	03 da		 add	 ebx, edx
  00973	6b db 35	 imul	 ebx, 53			; 00000035H
  00976	8b d0		 mov	 edx, eax
  00978	c1 ea 10	 shr	 edx, 16			; 00000010H
  0097b	81 e2 ff 00 00
	00		 and	 edx, 255		; 000000ffH
  00981	03 da		 add	 ebx, edx
  00983	6b db 35	 imul	 ebx, 53			; 00000035H
  00986	c1 e8 18	 shr	 eax, 24			; 00000018H
  00989	03 d8		 add	 ebx, eax
  0098b	83 c1 08	 add	 ecx, 8
  0098e	83 ef 01	 sub	 edi, 1
  00991	8b d3		 mov	 edx, ebx
  00993	75 bb		 jne	 SHORT $LL6@HashAlfalf@5
  00995	5f		 pop	 edi
  00996	5b		 pop	 ebx
$LN4@HashAlfalf@5:

; 806  : 	}
; 807  : 	for(; wrdlen; wrdlen -= 1, p++) {

  00997	85 f6		 test	 esi, esi
  00999	74 13		 je	 SHORT $LN1@HashAlfalf@5
  0099b	eb 03 8d 49 00	 npad	 5
$LL3@HashAlfalf@5:

; 808  : 	hash = 53 * hash + *p;

  009a0	0f be 01	 movsx	 eax, BYTE PTR [ecx]
  009a3	6b d2 35	 imul	 edx, 53			; 00000035H
  009a6	4e		 dec	 esi
  009a7	03 d0		 add	 edx, eax
  009a9	41		 inc	 ecx
  009aa	85 f6		 test	 esi, esi
  009ac	75 f2		 jne	 SHORT $LL3@HashAlfalf@5
$LN1@HashAlfalf@5:

; 809  : 	}	
; 810  : 	return hash ^ (hash >> 16);

  009ae	8b c2		 mov	 eax, edx
  009b0	c1 e8 10	 shr	 eax, 16			; 00000010H
  009b3	33 c2		 xor	 eax, edx
  009b5	5e		 pop	 esi

; 811  : }

  009b6	c3		 ret	 0
?HashAlfalfa_Rollick@@YAIPBDK@Z ENDP			; HashAlfalfa_Rollick
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?FNV1A_Hash_Peregrine@@YAIPBDK@Z PROC			; FNV1A_Hash_Peregrine

; 766  : {

  009c0	55		 push	 ebp
  009c1	8b ec		 mov	 ebp, esp
  009c3	83 e4 f8	 and	 esp, -8			; fffffff8H
  009c6	51		 push	 ecx

; 767  : 	const UINT PRIME = 709607;//15607;
; 768  : 
; 769  : //Peregrine 1607: [2128779]
; 770  : //Peregrine 15607: [2108149]
; 771  : //Peregrine 16607: [2110112]
; 772  : //Peregrine 709607: [2104754]
; 773  : 
; 774  : 	UINT hash32 = 2166136261;
; 775  : 	const char *p = str;

  009c7	8b 4d 08	 mov	 ecx, DWORD PTR _str$[ebp]
  009ca	53		 push	 ebx

; 776  : 	UINT64 OneAccess;
; 777  : 
; 778  : 	for(; wrdlen >= sizeof(UINT64); wrdlen -= sizeof(UINT64), p += sizeof(UINT64)) {

  009cb	8b 5d 0c	 mov	 ebx, DWORD PTR _wrdlen$[ebp]
  009ce	56		 push	 esi
  009cf	57		 push	 edi
  009d0	ba c5 9d 1c 81	 mov	 edx, -2128831035	; 811c9dc5H
  009d5	83 fb 08	 cmp	 ebx, 8
  009d8	72 28		 jb	 SHORT $LN5@FNV1A_Hash@4
  009da	8b fb		 mov	 edi, ebx
  009dc	c1 ef 03	 shr	 edi, 3
  009df	90		 npad	 1
$LL7@FNV1A_Hash@4:

; 779  : 		// Variant #1:
; 780  : 		//hash32 = (hash32 ^ *(DWORD *)p) * PRIME;
; 781  : 		//hash32 = (hash32 ^ *(DWORD *)(p+4)) * PRIME;
; 782  : 		// Variant #2:
; 783  : 		OneAccess = *(UINT64 *)p;

  009e0	8b 01		 mov	 eax, DWORD PTR [ecx]
  009e2	8b 71 04	 mov	 esi, DWORD PTR [ecx+4]

; 784  : 		hash32 = (hash32 ^ ((OneAccess>>0)&0xFFFFFFFF)) * PRIME;

  009e5	33 c2		 xor	 eax, edx
  009e7	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H

; 785  : 		hash32 = (hash32 ^ ((OneAccess>>32)&0xFFFFFFFF)) * PRIME;  // No need for ANDing but compiler is smart enough to see that.

  009ed	33 c6		 xor	 eax, esi
  009ef	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  009f5	83 eb 08	 sub	 ebx, 8
  009f8	83 c1 08	 add	 ecx, 8
  009fb	83 ef 01	 sub	 edi, 1
  009fe	8b d0		 mov	 edx, eax
  00a00	75 de		 jne	 SHORT $LL7@FNV1A_Hash@4
$LN5@FNV1A_Hash@4:

; 786  : 	}
; 787  : 	for(; wrdlen >= sizeof(WORD); wrdlen -= sizeof(WORD), p += sizeof(WORD)) {

  00a02	83 fb 02	 cmp	 ebx, 2
  00a05	72 21		 jb	 SHORT $LN2@FNV1A_Hash@4
  00a07	8b c3		 mov	 eax, ebx
  00a09	d1 e8		 shr	 eax, 1
  00a0b	eb 03 8d 49 00	 npad	 5
$LL4@FNV1A_Hash@4:

; 788  : 		hash32 = (hash32 ^ *(WORD*)p) * PRIME;		

  00a10	0f b7 31	 movzx	 esi, WORD PTR [ecx]
  00a13	33 f2		 xor	 esi, edx
  00a15	69 f6 e7 d3 0a
	00		 imul	 esi, 709607		; 000ad3e7H
  00a1b	83 eb 02	 sub	 ebx, 2
  00a1e	83 c1 02	 add	 ecx, 2
  00a21	83 e8 01	 sub	 eax, 1
  00a24	8b d6		 mov	 edx, esi
  00a26	75 e8		 jne	 SHORT $LL4@FNV1A_Hash@4
$LN2@FNV1A_Hash@4:

; 789  : 	}
; 790  : 	if (wrdlen & 1) 

  00a28	f6 c3 01	 test	 bl, 1
  00a2b	74 0d		 je	 SHORT $LN1@FNV1A_Hash@4

; 791  : 		hash32 = (hash32 ^ *p) * PRIME;

  00a2d	0f be 01	 movsx	 eax, BYTE PTR [ecx]
  00a30	33 c2		 xor	 eax, edx
  00a32	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  00a38	8b d0		 mov	 edx, eax
$LN1@FNV1A_Hash@4:

; 792  : 
; 793  : 	return hash32 ^ (hash32 >> 16);
; 794  : }

  00a3a	5f		 pop	 edi
  00a3b	8b c2		 mov	 eax, edx
  00a3d	c1 e8 10	 shr	 eax, 16			; 00000010H
  00a40	5e		 pop	 esi
  00a41	33 c2		 xor	 eax, edx
  00a43	5b		 pop	 ebx
  00a44	8b e5		 mov	 esp, ebp
  00a46	5d		 pop	 ebp
  00a47	c3		 ret	 0
?FNV1A_Hash_Peregrine@@YAIPBDK@Z ENDP			; FNV1A_Hash_Peregrine
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_wrdlen$ = 12						; size = 4
?FNV1A_Hash_Smaragd@@YAIPBDK@Z PROC			; FNV1A_Hash_Smaragd

; 735  : 	const UINT PRIME = 709607;//15607;
; 736  :            
; 737  : //Smaragd 1607: [2088443]
; 738  : //Smaragd 15607: [2093321]
; 739  : //Smaragd 16607: [2084267]
; 740  : //Smaragd 709607: [2083208]
; 741  : 
; 742  : 	UINT hash32 = 2166136261;
; 743  : 	const char *p = str;

  00a50	8b 54 24 04	 mov	 edx, DWORD PTR _str$[esp-4]
  00a54	53		 push	 ebx

; 744  : 	UINT OneAccess;
; 745  : 
; 746  : 	for(; wrdlen >= sizeof(UINT); wrdlen -= sizeof(UINT), p += sizeof(UINT)) {

  00a55	8b 5c 24 0c	 mov	 ebx, DWORD PTR _wrdlen$[esp]
  00a59	b9 c5 9d 1c 81	 mov	 ecx, -2128831035	; 811c9dc5H
  00a5e	83 fb 04	 cmp	 ebx, 4
  00a61	72 34		 jb	 SHORT $LN3@FNV1A_Hash@5
  00a63	56		 push	 esi
  00a64	8b f3		 mov	 esi, ebx
  00a66	57		 push	 edi
  00a67	c1 ee 02	 shr	 esi, 2
  00a6a	8d 9b 00 00 00
	00		 npad	 6
$LL5@FNV1A_Hash@5:

; 747  : 		// Variant #1:
; 748  : 		//hash32 = (hash32 ^ *(WORD*)(p+0)) * PRIME;
; 749  : 		//hash32 = (hash32 ^ *(WORD*)(p+2)) * PRIME;
; 750  : 		// Variant #2:
; 751  : 		OneAccess = *(UINT *)p;

  00a70	8b 02		 mov	 eax, DWORD PTR [edx]

; 752  : 		hash32 = (hash32 ^ ((OneAccess>>0)&0xFFFF)) * PRIME;

  00a72	0f b7 f8	 movzx	 edi, ax
  00a75	33 f9		 xor	 edi, ecx
  00a77	69 ff e7 d3 0a
	00		 imul	 edi, 709607		; 000ad3e7H

; 753  : 		hash32 = (hash32 ^ ((OneAccess>>16)&0xFFFF)) * PRIME;  // No need for ANDing but compiler is smart enough to see that.

  00a7d	c1 e8 10	 shr	 eax, 16			; 00000010H
  00a80	33 f8		 xor	 edi, eax
  00a82	69 ff e7 d3 0a
	00		 imul	 edi, 709607		; 000ad3e7H
  00a88	83 eb 04	 sub	 ebx, 4
  00a8b	83 c2 04	 add	 edx, 4
  00a8e	83 ee 01	 sub	 esi, 1
  00a91	8b cf		 mov	 ecx, edi
  00a93	75 db		 jne	 SHORT $LL5@FNV1A_Hash@5
  00a95	5f		 pop	 edi
  00a96	5e		 pop	 esi
$LN3@FNV1A_Hash@5:

; 754  : 	}
; 755  : 	if (wrdlen & sizeof(WORD)) {

  00a97	f6 c3 02	 test	 bl, 2
  00a9a	74 10		 je	 SHORT $LN2@FNV1A_Hash@5

; 756  : 		hash32 = (hash32 ^ *(WORD*)p) * PRIME;

  00a9c	0f b7 02	 movzx	 eax, WORD PTR [edx]
  00a9f	33 c1		 xor	 eax, ecx
  00aa1	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  00aa7	8b c8		 mov	 ecx, eax

; 757  : 		p += sizeof(WORD);

  00aa9	83 c2 02	 add	 edx, 2
$LN2@FNV1A_Hash@5:

; 758  : 	}
; 759  : 	if (wrdlen & 1) 

  00aac	f6 c3 01	 test	 bl, 1
  00aaf	5b		 pop	 ebx
  00ab0	74 0d		 je	 SHORT $LN1@FNV1A_Hash@5

; 760  : 		hash32 = (hash32 ^ *p) * PRIME;

  00ab2	0f be 12	 movsx	 edx, BYTE PTR [edx]
  00ab5	33 d1		 xor	 edx, ecx
  00ab7	69 d2 e7 d3 0a
	00		 imul	 edx, 709607		; 000ad3e7H
  00abd	8b ca		 mov	 ecx, edx
$LN1@FNV1A_Hash@5:

; 761  : 
; 762  : 	return hash32 ^ (hash32 >> 16);

  00abf	8b c1		 mov	 eax, ecx
  00ac1	c1 e8 10	 shr	 eax, 16			; 00000010H
  00ac4	33 c1		 xor	 eax, ecx

; 763  : }

  00ac6	c3		 ret	 0
?FNV1A_Hash_Smaragd@@YAIPBDK@Z ENDP			; FNV1A_Hash_Smaragd
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_len$ = 12						; size = 4
?HashSBox@@YAIPBDK@Z PROC				; HashSBox

; 720  : UINT HashSBox (const CHAR *str, SIZE_T len) {

  00ad0	56		 push	 esi

; 721  :     UINT hash = 0;
; 722  : 	BYTE * t = (BYTE *)str;
; 723  :     for (SIZE_T i = 0; i < len; i++) {

  00ad1	8b 74 24 0c	 mov	 esi, DWORD PTR _len$[esp]
  00ad5	33 c0		 xor	 eax, eax
  00ad7	33 d2		 xor	 edx, edx
  00ad9	85 f6		 test	 esi, esi
  00adb	76 1b		 jbe	 SHORT $LN1@HashSBox
  00add	57		 push	 edi
  00ade	8b 7c 24 0c	 mov	 edi, DWORD PTR _str$[esp+4]
$LL3@HashSBox:

; 724  :         hash ^= sbox[ t[i] ];
; 725  :         hash *= 3;

  00ae2	0f b6 0c 3a	 movzx	 ecx, BYTE PTR [edx+edi]
  00ae6	8b 0c 8d 00 00
	00 00		 mov	 ecx, DWORD PTR _sbox[ecx*4]
  00aed	33 c8		 xor	 ecx, eax
  00aef	42		 inc	 edx
  00af0	8d 04 49	 lea	 eax, DWORD PTR [ecx+ecx*2]
  00af3	3b d6		 cmp	 edx, esi
  00af5	72 eb		 jb	 SHORT $LL3@HashSBox
  00af7	5f		 pop	 edi
$LN1@HashSBox:
  00af8	5e		 pop	 esi

; 726  :     }
; 727  :     return hash;
; 728  : }

  00af9	c3		 ret	 0
?HashSBox@@YAIPBDK@Z ENDP				; HashSBox
; Function compile flags: /Ogtpy
_str$ = 8						; size = 4
_len$ = 12						; size = 4
?HashMaPrime2c@@YAIPBDK@Z PROC				; HashMaPrime2c

; 669  : {

  00b00	56		 push	 esi

; 670  :   UINT hash = (UINT)len;

  00b01	8b 74 24 0c	 mov	 esi, DWORD PTR _len$[esp]

; 671  :   const UINT PRIME_MULT = 1717;
; 672  : 
; 673  :   for (SIZE_T i = 0; i < len; i++, str++) {

  00b05	33 c9		 xor	 ecx, ecx
  00b07	8b c6		 mov	 eax, esi
  00b09	85 f6		 test	 esi, esi
  00b0b	76 28		 jbe	 SHORT $LN1@HashMaPrim
  00b0d	8b 54 24 08	 mov	 edx, DWORD PTR _str$[esp]
  00b11	57		 push	 edi
$LL3@HashMaPrim:

; 674  :       hash ^= sTable[( *(UCHAR*)str + i) & 255];
; 675  :       hash = hash * PRIME_MULT;

  00b12	0f b6 3a	 movzx	 edi, BYTE PTR [edx]
  00b15	03 f9		 add	 edi, ecx
  00b17	81 e7 ff 00 00
	00		 and	 edi, 255		; 000000ffH
  00b1d	0f b6 bf 00 00
	00 00		 movzx	 edi, BYTE PTR _sTable[edi]
  00b24	33 f8		 xor	 edi, eax
  00b26	69 ff b5 06 00
	00		 imul	 edi, 1717		; 000006b5H
  00b2c	41		 inc	 ecx
  00b2d	42		 inc	 edx
  00b2e	8b c7		 mov	 eax, edi
  00b30	3b ce		 cmp	 ecx, esi
  00b32	72 de		 jb	 SHORT $LL3@HashMaPrim
  00b34	5f		 pop	 edi
$LN1@HashMaPrim:
  00b35	5e		 pop	 esi

; 676  :   }
; 677  : 
; 678  :   return hash;
; 679  : }

  00b36	c3		 ret	 0
?HashMaPrime2c@@YAIPBDK@Z ENDP				; HashMaPrime2c
; Function compile flags: /Ogtpy
_s$ = 8						; size = 4
_L$ = 12						; size = 4
?NovakHashUnrolled@@YAIPBDK@Z PROC			; NovakHashUnrolled

; 632  : {

  00b40	53		 push	 ebx

; 633  : 	UINT h = 1;
; 634  : 	BYTE * t = (BYTE *)s;
; 635  : 	for ( SIZE_T i = 0; i < ( L & ~1 ); i += 2 ) {

  00b41	8b 5c 24 0c	 mov	 ebx, DWORD PTR _L$[esp]
  00b45	8b cb		 mov	 ecx, ebx
  00b47	83 e1 fe	 and	 ecx, -2			; fffffffeH
  00b4a	57		 push	 edi
  00b4b	8b 7c 24 0c	 mov	 edi, DWORD PTR _s$[esp+4]
  00b4f	b8 01 00 00 00	 mov	 eax, 1
  00b54	76 32		 jbe	 SHORT $LN2@NovakHashU
  00b56	56		 push	 esi
  00b57	8d 71 ff	 lea	 esi, DWORD PTR [ecx-1]
  00b5a	d1 ee		 shr	 esi, 1
  00b5c	8d 57 01	 lea	 edx, DWORD PTR [edi+1]
  00b5f	46		 inc	 esi
$LL4@NovakHashU:

; 636  : 		h += ( h << 1 ) + rijndaelSBox[ t[ i ] ];
; 637  : 		h += ( h << 1 ) + rijndaelSBox[ t[ i + 1 ] ];

  00b60	0f b6 4a ff	 movzx	 ecx, BYTE PTR [edx-1]
  00b64	0f b6 89 00 00
	00 00		 movzx	 ecx, BYTE PTR _rijndaelSBox[ecx]
  00b6b	8d 04 40	 lea	 eax, DWORD PTR [eax+eax*2]
  00b6e	03 c8		 add	 ecx, eax
  00b70	8d 04 49	 lea	 eax, DWORD PTR [ecx+ecx*2]
  00b73	0f b6 0a	 movzx	 ecx, BYTE PTR [edx]
  00b76	0f b6 89 00 00
	00 00		 movzx	 ecx, BYTE PTR _rijndaelSBox[ecx]
  00b7d	03 c1		 add	 eax, ecx
  00b7f	83 c2 02	 add	 edx, 2
  00b82	83 ee 01	 sub	 esi, 1
  00b85	75 d9		 jne	 SHORT $LL4@NovakHashU
  00b87	5e		 pop	 esi
$LN2@NovakHashU:

; 638  : 	}
; 639  : 	if ( L & 1 )

  00b88	f6 c3 01	 test	 bl, 1
  00b8b	74 13		 je	 SHORT $LN1@NovakHashU

; 640  : 		h += ( h << 1 ) + rijndaelSBox[ t[ L - 1 ] ];

  00b8d	0f b6 54 1f ff	 movzx	 edx, BYTE PTR [edi+ebx-1]
  00b92	0f b6 8a 00 00
	00 00		 movzx	 ecx, BYTE PTR _rijndaelSBox[edx]
  00b99	8d 04 40	 lea	 eax, DWORD PTR [eax+eax*2]
  00b9c	03 c8		 add	 ecx, eax

; 641  : 	return h;

  00b9e	8b c1		 mov	 eax, ecx
$LN1@NovakHashU:
  00ba0	5f		 pop	 edi
  00ba1	5b		 pop	 ebx

; 642  : }

  00ba2	c3		 ret	 0
?NovakHashUnrolled@@YAIPBDK@Z ENDP			; NovakHashUnrolled
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashHanson@@YAIPBDK@Z PROC				; HashHanson

; 589  : 	UINT hash = 0;
; 590  : 	for (UINT i = 0; i < len; i++)

  00bb0	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  00bb4	33 c0		 xor	 eax, eax
  00bb6	33 c9		 xor	 ecx, ecx
  00bb8	85 d2		 test	 edx, edx
  00bba	76 1b		 jbe	 SHORT $LN1@HashHanson
  00bbc	56		 push	 esi
  00bbd	8b 74 24 08	 mov	 esi, DWORD PTR _key$[esp]
  00bc1	57		 push	 edi
$LL3@HashHanson:

; 591  : 		hash = (hash<<1) + scatter[(unsigned char)key[i]];

  00bc2	0f b6 3c 31	 movzx	 edi, BYTE PTR [ecx+esi]
  00bc6	8b 3c bd 00 00
	00 00		 mov	 edi, DWORD PTR _scatter[edi*4]
  00bcd	41		 inc	 ecx
  00bce	8d 04 47	 lea	 eax, DWORD PTR [edi+eax*2]
  00bd1	3b ca		 cmp	 ecx, edx
  00bd3	72 ed		 jb	 SHORT $LL3@HashHanson
  00bd5	5f		 pop	 edi
  00bd6	5e		 pop	 esi
$LN1@HashHanson:

; 592  : 	return hash;
; 593  : }

  00bd7	c3		 ret	 0
?HashHanson@@YAIPBDK@Z ENDP				; HashHanson
; Function compile flags: /Ogtpy
tv538 = 8						; size = 4
tv483 = 8						; size = 4
tv432 = 8						; size = 4
_key$ = 8						; size = 4
_length$ = 12						; size = 4
?HashLookup3@@YAIPBDK@Z PROC				; HashLookup3

; 374  :   UINT a,b,c;                                          /* internal state */
; 375  :   union { const void *ptr; size_t i; } u;
; 376  : 
; 377  :   /* Set up the internal state */
; 378  :   a = b = c = 0xdeadbeef + ((UINT32)length);

  00be0	8b 44 24 08	 mov	 eax, DWORD PTR _length$[esp-4]

; 379  : 
; 380  :   u.ptr = key;
; 381  : 
; 382  :   if ((u.i & 0x3) == 0) {

  00be4	8b 54 24 04	 mov	 edx, DWORD PTR _key$[esp-4]
  00be8	53		 push	 ebx
  00be9	55		 push	 ebp
  00bea	56		 push	 esi
  00beb	8d 98 ef be ad
	de		 lea	 ebx, DWORD PTR [eax-559038737]
  00bf1	57		 push	 edi
  00bf2	8b cb		 mov	 ecx, ebx
  00bf4	8b f3		 mov	 esi, ebx
  00bf6	f6 c2 03	 test	 dl, 3
  00bf9	0f 85 34 01 00
	00		 jne	 $LN55@HashLookup

; 383  :     const UINT32 *k = (const UINT32 *)key;         /* read 32-bit chunks */

  00bff	8b ea		 mov	 ebp, edx

; 384  : 
; 385  :     /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
; 386  :     while (length > 12)

  00c01	83 f8 0c	 cmp	 eax, 12			; 0000000cH
  00c04	0f 86 85 00 00
	00		 jbe	 $LN64@HashLookup
  00c0a	8d 50 f3	 lea	 edx, DWORD PTR [eax-13]
  00c0d	b8 ab aa aa aa	 mov	 eax, -1431655765	; aaaaaaabH
  00c12	f7 e2		 mul	 edx
  00c14	c1 ea 03	 shr	 edx, 3
  00c17	42		 inc	 edx
  00c18	89 54 24 14	 mov	 DWORD PTR tv483[esp+12], edx
  00c1c	8d 64 24 00	 npad	 4
$LL54@HashLookup:

; 387  :     {
; 388  :       a += k[0];
; 389  :       b += k[1];
; 390  :       c += k[2];

  00c20	03 5d 08	 add	 ebx, DWORD PTR [ebp+8]
  00c23	03 4d 04	 add	 ecx, DWORD PTR [ebp+4]

; 391  :       mix(a,b,c);

  00c26	8b 55 00	 mov	 edx, DWORD PTR [ebp]
  00c29	2b d3		 sub	 edx, ebx
  00c2b	03 d6		 add	 edx, esi
  00c2d	8b c3		 mov	 eax, ebx
  00c2f	c1 c0 04	 rol	 eax, 4
  00c32	33 c2		 xor	 eax, edx
  00c34	03 d9		 add	 ebx, ecx
  00c36	2b c8		 sub	 ecx, eax
  00c38	8b f8		 mov	 edi, eax
  00c3a	c1 c7 06	 rol	 edi, 6
  00c3d	33 f9		 xor	 edi, ecx
  00c3f	03 c3		 add	 eax, ebx

; 392  :       length -= 12;

  00c41	83 6c 24 18 0c	 sub	 DWORD PTR _length$[esp+12], 12 ; 0000000cH
  00c46	2b df		 sub	 ebx, edi
  00c48	8b d7		 mov	 edx, edi
  00c4a	c1 c2 08	 rol	 edx, 8
  00c4d	33 d3		 xor	 edx, ebx
  00c4f	03 f8		 add	 edi, eax
  00c51	2b c2		 sub	 eax, edx
  00c53	8b ca		 mov	 ecx, edx
  00c55	c1 c1 10	 rol	 ecx, 16			; 00000010H
  00c58	33 c8		 xor	 ecx, eax
  00c5a	8b f1		 mov	 esi, ecx
  00c5c	03 d7		 add	 edx, edi
  00c5e	8b c6		 mov	 eax, esi
  00c60	c1 c0 13	 rol	 eax, 19			; 00000013H
  00c63	2b fe		 sub	 edi, esi
  00c65	33 c7		 xor	 eax, edi
  00c67	8b c8		 mov	 ecx, eax
  00c69	03 f2		 add	 esi, edx
  00c6b	2b d1		 sub	 edx, ecx
  00c6d	c1 c0 04	 rol	 eax, 4
  00c70	33 c2		 xor	 eax, edx
  00c72	03 ce		 add	 ecx, esi

; 393  :       k += 3;

  00c74	83 c5 0c	 add	 ebp, 12			; 0000000cH
  00c77	83 6c 24 14 01	 sub	 DWORD PTR tv483[esp+12], 1
  00c7c	8b d8		 mov	 ebx, eax
  00c7e	75 a0		 jne	 SHORT $LL54@HashLookup

; 394  :     }
; 395  : 
; 396  :     /*----------------------------- handle the last (probably partial) block */
; 397  :     /* 
; 398  :      * "k[2]&0xffffff" actually reads beyond the end of the string, but
; 399  :      * then masks off the part it's not allowed to read.  Because the
; 400  :      * string is aligned, the masked-off tail is in the same word as the
; 401  :      * rest of the string.  Every machine with memory protection I've seen
; 402  :      * does it on word boundaries, so is OK with this.  But VALGRIND will
; 403  :      * still catch it and complain.  The masking trick does make the hash
; 404  :      * noticably faster for short strings (like English words).
; 405  :      */
; 406  : #ifndef VALGRIND
; 407  : 
; 408  :     switch(length)

  00c80	83 7c 24 18 0c	 cmp	 DWORD PTR _length$[esp+12], 12 ; 0000000cH
  00c85	0f 87 93 03 00
	00		 ja	 $LN14@HashLookup
  00c8b	8b 44 24 18	 mov	 eax, DWORD PTR _length$[esp+12]
$LN64@HashLookup:
  00c8f	ff 24 85 00 00
	00 00		 jmp	 DWORD PTR $LN69@HashLookup[eax*4]
$LN50@HashLookup:

; 409  :     {
; 410  :     case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;

  00c96	03 5d 08	 add	 ebx, DWORD PTR [ebp+8]
$LN46@HashLookup:
  00c99	03 4d 04	 add	 ecx, DWORD PTR [ebp+4]
$LN42@HashLookup:
  00c9c	03 75 00	 add	 esi, DWORD PTR [ebp]
  00c9f	e9 7a 03 00 00	 jmp	 $LN14@HashLookup
$LN49@HashLookup:

; 411  :     case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;

  00ca4	8b 55 08	 mov	 edx, DWORD PTR [ebp+8]
  00ca7	03 4d 04	 add	 ecx, DWORD PTR [ebp+4]
  00caa	81 e2 ff ff ff
	00		 and	 edx, 16777215		; 00ffffffH
  00cb0	03 da		 add	 ebx, edx
  00cb2	03 75 00	 add	 esi, DWORD PTR [ebp]
  00cb5	e9 64 03 00 00	 jmp	 $LN14@HashLookup
$LN48@HashLookup:

; 412  :     case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;

  00cba	0f b7 45 08	 movzx	 eax, WORD PTR [ebp+8]
  00cbe	03 4d 04	 add	 ecx, DWORD PTR [ebp+4]
  00cc1	03 d8		 add	 ebx, eax
  00cc3	03 75 00	 add	 esi, DWORD PTR [ebp]
  00cc6	e9 53 03 00 00	 jmp	 $LN14@HashLookup
$LN47@HashLookup:

; 413  :     case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;

  00ccb	0f b6 55 08	 movzx	 edx, BYTE PTR [ebp+8]
  00ccf	03 4d 04	 add	 ecx, DWORD PTR [ebp+4]
  00cd2	03 da		 add	 ebx, edx
  00cd4	03 75 00	 add	 esi, DWORD PTR [ebp]
  00cd7	e9 42 03 00 00	 jmp	 $LN14@HashLookup
$LN45@HashLookup:

; 414  :     case 8 : b+=k[1]; a+=k[0]; break;
; 415  :     case 7 : b+=k[1]&0xffffff; a+=k[0]; break;

  00cdc	8b 45 04	 mov	 eax, DWORD PTR [ebp+4]
  00cdf	25 ff ff ff 00	 and	 eax, 16777215		; 00ffffffH
  00ce4	03 c8		 add	 ecx, eax
  00ce6	03 75 00	 add	 esi, DWORD PTR [ebp]
  00ce9	e9 30 03 00 00	 jmp	 $LN14@HashLookup
$LN44@HashLookup:

; 416  :     case 6 : b+=k[1]&0xffff; a+=k[0]; break;

  00cee	0f b7 55 04	 movzx	 edx, WORD PTR [ebp+4]
  00cf2	03 ca		 add	 ecx, edx
  00cf4	03 75 00	 add	 esi, DWORD PTR [ebp]
  00cf7	e9 22 03 00 00	 jmp	 $LN14@HashLookup
$LN43@HashLookup:

; 417  :     case 5 : b+=k[1]&0xff; a+=k[0]; break;

  00cfc	0f b6 45 04	 movzx	 eax, BYTE PTR [ebp+4]
  00d00	03 c8		 add	 ecx, eax
  00d02	03 75 00	 add	 esi, DWORD PTR [ebp]
  00d05	e9 14 03 00 00	 jmp	 $LN14@HashLookup
$LN41@HashLookup:

; 418  :     case 4 : a+=k[0]; break;
; 419  :     case 3 : a+=k[0]&0xffffff; break;

  00d0a	8b 55 00	 mov	 edx, DWORD PTR [ebp]
  00d0d	81 e2 ff ff ff
	00		 and	 edx, 16777215		; 00ffffffH
  00d13	e9 04 03 00 00	 jmp	 $LN68@HashLookup
$LN40@HashLookup:

; 420  :     case 2 : a+=k[0]&0xffff; break;

  00d18	0f b7 45 00	 movzx	 eax, WORD PTR [ebp]
  00d1c	03 f0		 add	 esi, eax
  00d1e	e9 fb 02 00 00	 jmp	 $LN14@HashLookup
$LN39@HashLookup:

; 421  :     case 1 : a+=k[0]&0xff; break;

  00d23	0f b6 55 00	 movzx	 edx, BYTE PTR [ebp]
  00d27	e9 f0 02 00 00	 jmp	 $LN68@HashLookup
$LN38@HashLookup:
  00d2c	5f		 pop	 edi
  00d2d	5e		 pop	 esi
  00d2e	5d		 pop	 ebp

; 422  :     case 0 : return c;              /* zero length strings require no mixing */

  00d2f	8b c3		 mov	 eax, ebx
  00d31	5b		 pop	 ebx

; 538  :   return c;
; 539  : } 

  00d32	c3		 ret	 0
$LN55@HashLookup:

; 423  :     }
; 424  : 
; 425  : #else /* make valgrind happy */
; 426  : 
; 427  :     k8 = (const BYTE *)k;
; 428  :     switch(length)
; 429  :     {
; 430  :     case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
; 431  :     case 11: c+=((UINT32)k8[10])<<16;  /* fall through */
; 432  :     case 10: c+=((UINT32)k8[9])<<8;    /* fall through */
; 433  :     case 9 : c+=k8[8];                   /* fall through */
; 434  :     case 8 : b+=k[1]; a+=k[0]; break;
; 435  :     case 7 : b+=((UINT32)k8[6])<<16;   /* fall through */
; 436  :     case 6 : b+=((UINT32)k8[5])<<8;    /* fall through */
; 437  :     case 5 : b+=k8[4];                   /* fall through */
; 438  :     case 4 : a+=k[0]; break;
; 439  :     case 3 : a+=((UINT32)k8[2])<<16;   /* fall through */
; 440  :     case 2 : a+=((UINT32)k8[1])<<8;    /* fall through */
; 441  :     case 1 : a+=k8[0]; break;
; 442  :     case 0 : return c;
; 443  :     }
; 444  : 
; 445  : #endif /* !valgrind */
; 446  : 
; 447  :   } else if ((u.i & 0x1) == 0) {

  00d33	f6 c2 01	 test	 dl, 1
  00d36	0f 85 8f 01 00
	00		 jne	 $LN36@HashLookup

; 448  :     const WORD *k = (const WORD *)key;         /* read 16-bit chunks */

  00d3c	8b ea		 mov	 ebp, edx

; 449  :     const BYTE  *k8;
; 450  : 
; 451  :     /*--------------- all but last block: aligned reads and different mixing */
; 452  :     while (length > 12)

  00d3e	83 f8 0c	 cmp	 eax, 12			; 0000000cH
  00d41	0f 86 b0 00 00
	00		 jbe	 $LN65@HashLookup
  00d47	8d 50 f3	 lea	 edx, DWORD PTR [eax-13]
  00d4a	b8 ab aa aa aa	 mov	 eax, -1431655765	; aaaaaaabH
  00d4f	f7 e2		 mul	 edx
  00d51	c1 ea 03	 shr	 edx, 3
  00d54	42		 inc	 edx
  00d55	89 54 24 14	 mov	 DWORD PTR tv432[esp+12], edx
  00d59	8d a4 24 00 00
	00 00		 npad	 7
$LL35@HashLookup:

; 453  :     {
; 454  :       a += k[0] + (((UINT32)k[1])<<16);
; 455  :       b += k[2] + (((UINT32)k[3])<<16);

  00d60	0f b7 45 06	 movzx	 eax, WORD PTR [ebp+6]
  00d64	0f b7 55 04	 movzx	 edx, WORD PTR [ebp+4]
  00d68	03 d1		 add	 edx, ecx

; 456  :       c += k[4] + (((UINT32)k[5])<<16);

  00d6a	0f b7 4d 08	 movzx	 ecx, WORD PTR [ebp+8]
  00d6e	c1 e0 10	 shl	 eax, 16			; 00000010H
  00d71	8d 3c 02	 lea	 edi, DWORD PTR [edx+eax]
  00d74	0f b7 45 0a	 movzx	 eax, WORD PTR [ebp+10]

; 457  :       mix(a,b,c);

  00d78	0f b7 55 02	 movzx	 edx, WORD PTR [ebp+2]
  00d7c	03 cb		 add	 ecx, ebx
  00d7e	c1 e0 10	 shl	 eax, 16			; 00000010H
  00d81	8d 1c 01	 lea	 ebx, DWORD PTR [ecx+eax]
  00d84	0f b7 4d 00	 movzx	 ecx, WORD PTR [ebp]
  00d88	c1 e2 10	 shl	 edx, 16			; 00000010H
  00d8b	2b d3		 sub	 edx, ebx
  00d8d	03 d6		 add	 edx, esi
  00d8f	03 ca		 add	 ecx, edx
  00d91	8b c3		 mov	 eax, ebx
  00d93	c1 c0 04	 rol	 eax, 4
  00d96	33 c1		 xor	 eax, ecx
  00d98	03 df		 add	 ebx, edi
  00d9a	2b f8		 sub	 edi, eax
  00d9c	8b c8		 mov	 ecx, eax
  00d9e	c1 c1 06	 rol	 ecx, 6
  00da1	33 cf		 xor	 ecx, edi
  00da3	03 c3		 add	 eax, ebx

; 458  :       length -= 12;

  00da5	83 6c 24 18 0c	 sub	 DWORD PTR _length$[esp+12], 12 ; 0000000cH
  00daa	2b d9		 sub	 ebx, ecx
  00dac	8b f9		 mov	 edi, ecx
  00dae	c1 c7 08	 rol	 edi, 8
  00db1	33 fb		 xor	 edi, ebx
  00db3	03 c8		 add	 ecx, eax
  00db5	2b c7		 sub	 eax, edi
  00db7	8b d7		 mov	 edx, edi
  00db9	c1 c2 10	 rol	 edx, 16			; 00000010H
  00dbc	33 d0		 xor	 edx, eax
  00dbe	8b f2		 mov	 esi, edx
  00dc0	03 f9		 add	 edi, ecx
  00dc2	2b ce		 sub	 ecx, esi
  00dc4	8b c6		 mov	 eax, esi
  00dc6	c1 c0 13	 rol	 eax, 19			; 00000013H
  00dc9	33 c8		 xor	 ecx, eax
  00dcb	03 f7		 add	 esi, edi
  00dcd	8b d1		 mov	 edx, ecx
  00dcf	2b f9		 sub	 edi, ecx
  00dd1	c1 c2 04	 rol	 edx, 4
  00dd4	33 d7		 xor	 edx, edi
  00dd6	03 ce		 add	 ecx, esi

; 459  :       k += 6;

  00dd8	83 c5 0c	 add	 ebp, 12			; 0000000cH
  00ddb	83 6c 24 14 01	 sub	 DWORD PTR tv432[esp+12], 1
  00de0	8b da		 mov	 ebx, edx
  00de2	0f 85 78 ff ff
	ff		 jne	 $LL35@HashLookup

; 460  :     }
; 461  : 
; 462  :     /*----------------------------- handle the last (probably partial) block */
; 463  :     k8 = (const BYTE *)k;
; 464  :     switch(length)

  00de8	83 7c 24 18 0c	 cmp	 DWORD PTR _length$[esp+12], 12 ; 0000000cH
  00ded	0f 87 2b 02 00
	00		 ja	 $LN14@HashLookup
  00df3	8b 44 24 18	 mov	 eax, DWORD PTR _length$[esp+12]
$LN65@HashLookup:
  00df7	ff 24 85 00 00
	00 00		 jmp	 DWORD PTR $LN70@HashLookup[eax*4]
$LN31@HashLookup:

; 465  :     {
; 466  :     case 12: c+=k[4]+(((UINT32)k[5])<<16);

  00dfe	0f b7 45 0a	 movzx	 eax, WORD PTR [ebp+10]
  00e02	0f b7 55 08	 movzx	 edx, WORD PTR [ebp+8]
  00e06	c1 e0 10	 shl	 eax, 16			; 00000010H
  00e09	03 d3		 add	 edx, ebx
  00e0b	8d 1c 02	 lea	 ebx, DWORD PTR [edx+eax]

; 467  :              b+=k[2]+(((UINT32)k[3])<<16);

  00e0e	0f b7 45 06	 movzx	 eax, WORD PTR [ebp+6]
  00e12	0f b7 55 04	 movzx	 edx, WORD PTR [ebp+4]
  00e16	c1 e0 10	 shl	 eax, 16			; 00000010H
  00e19	03 d1		 add	 edx, ecx
  00e1b	8d 0c 02	 lea	 ecx, DWORD PTR [edx+eax]
$LN23@HashLookup:

; 468  :              a+=k[0]+(((UINT32)k[1])<<16);

  00e1e	0f b7 45 02	 movzx	 eax, WORD PTR [ebp+2]
  00e22	0f b7 55 00	 movzx	 edx, WORD PTR [ebp]
  00e26	c1 e0 10	 shl	 eax, 16			; 00000010H
  00e29	03 d6		 add	 edx, esi
  00e2b	8d 34 02	 lea	 esi, DWORD PTR [edx+eax]

; 469  :              break;

  00e2e	e9 eb 01 00 00	 jmp	 $LN14@HashLookup
$LN30@HashLookup:

; 470  :     case 11: c+=((UINT32)k8[10])<<16;     /* fall through */

  00e33	0f b6 45 0a	 movzx	 eax, BYTE PTR [ebp+10]
  00e37	c1 e0 10	 shl	 eax, 16			; 00000010H
  00e3a	03 d8		 add	 ebx, eax
$LN29@HashLookup:

; 471  :     case 10: c+=k[4];

  00e3c	0f b7 55 08	 movzx	 edx, WORD PTR [ebp+8]

; 472  :              b+=k[2]+(((UINT32)k[3])<<16);

  00e40	0f b7 45 06	 movzx	 eax, WORD PTR [ebp+6]
  00e44	03 da		 add	 ebx, edx
  00e46	0f b7 55 04	 movzx	 edx, WORD PTR [ebp+4]
  00e4a	c1 e0 10	 shl	 eax, 16			; 00000010H
  00e4d	03 d1		 add	 edx, ecx
  00e4f	8d 0c 02	 lea	 ecx, DWORD PTR [edx+eax]

; 473  :              a+=k[0]+(((UINT32)k[1])<<16);

  00e52	0f b7 45 02	 movzx	 eax, WORD PTR [ebp+2]
  00e56	0f b7 55 00	 movzx	 edx, WORD PTR [ebp]
  00e5a	c1 e0 10	 shl	 eax, 16			; 00000010H
  00e5d	03 d6		 add	 edx, esi
  00e5f	8d 34 02	 lea	 esi, DWORD PTR [edx+eax]

; 474  :              break;

  00e62	e9 b7 01 00 00	 jmp	 $LN14@HashLookup
$LN28@HashLookup:

; 475  :     case 9 : c+=k8[8];                      /* fall through */

  00e67	0f b6 45 08	 movzx	 eax, BYTE PTR [ebp+8]
  00e6b	03 d8		 add	 ebx, eax
$LN27@HashLookup:

; 476  :     case 8 : b+=k[2]+(((UINT32)k[3])<<16);

  00e6d	0f b7 55 06	 movzx	 edx, WORD PTR [ebp+6]
  00e71	0f b7 45 04	 movzx	 eax, WORD PTR [ebp+4]
  00e75	c1 e2 10	 shl	 edx, 16			; 00000010H
  00e78	03 c1		 add	 eax, ecx
  00e7a	8d 0c 10	 lea	 ecx, DWORD PTR [eax+edx]
$LN67@HashLookup:

; 477  :              a+=k[0]+(((UINT32)k[1])<<16);

  00e7d	0f b7 55 02	 movzx	 edx, WORD PTR [ebp+2]
  00e81	0f b7 45 00	 movzx	 eax, WORD PTR [ebp]
  00e85	c1 e2 10	 shl	 edx, 16			; 00000010H
  00e88	03 c6		 add	 eax, esi
  00e8a	8d 34 10	 lea	 esi, DWORD PTR [eax+edx]

; 478  :              break;

  00e8d	e9 8c 01 00 00	 jmp	 $LN14@HashLookup
$LN26@HashLookup:

; 479  :     case 7 : b+=((UINT32)k8[6])<<16;      /* fall through */

  00e92	0f b6 55 06	 movzx	 edx, BYTE PTR [ebp+6]
  00e96	c1 e2 10	 shl	 edx, 16			; 00000010H
  00e99	03 ca		 add	 ecx, edx
$LN25@HashLookup:

; 480  :     case 6 : b+=k[2];

  00e9b	0f b7 45 04	 movzx	 eax, WORD PTR [ebp+4]
  00e9f	03 c8		 add	 ecx, eax

; 481  :              a+=k[0]+(((UINT32)k[1])<<16);
; 482  :              break;

  00ea1	eb da		 jmp	 SHORT $LN67@HashLookup
$LN24@HashLookup:

; 483  :     case 5 : b+=k8[4];                      /* fall through */

  00ea3	0f b6 55 04	 movzx	 edx, BYTE PTR [ebp+4]
  00ea7	03 ca		 add	 ecx, edx

; 484  :     case 4 : a+=k[0]+(((UINT32)k[1])<<16);
; 485  :              break;

  00ea9	e9 70 ff ff ff	 jmp	 $LN23@HashLookup
$LN22@HashLookup:

; 486  :     case 3 : a+=((UINT32)k8[2])<<16;      /* fall through */

  00eae	0f b6 45 02	 movzx	 eax, BYTE PTR [ebp+2]
  00eb2	c1 e0 10	 shl	 eax, 16			; 00000010H
  00eb5	03 f0		 add	 esi, eax
$LN21@HashLookup:

; 487  :     case 2 : a+=k[0];

  00eb7	0f b7 55 00	 movzx	 edx, WORD PTR [ebp]

; 488  :              break;

  00ebb	e9 5c 01 00 00	 jmp	 $LN68@HashLookup
$LN20@HashLookup:

; 489  :     case 1 : a+=k8[0];

  00ec0	0f b6 45 00	 movzx	 eax, BYTE PTR [ebp]
  00ec4	03 f0		 add	 esi, eax

; 490  :              break;

  00ec6	e9 53 01 00 00	 jmp	 $LN14@HashLookup
$LN36@HashLookup:

; 491  :     case 0 : return c;                     /* zero length requires no mixing */
; 492  :     }
; 493  : 
; 494  :   } else {                        /* need to read the key one byte at a time */
; 495  :     const BYTE *k = (const BYTE *)key;

  00ecb	8b fa		 mov	 edi, edx

; 496  : 
; 497  :     /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
; 498  :     while (length > 12)

  00ecd	83 f8 0c	 cmp	 eax, 12			; 0000000cH
  00ed0	0f 86 df 00 00
	00		 jbe	 $LN66@HashLookup
  00ed6	8d 50 f3	 lea	 edx, DWORD PTR [eax-13]
  00ed9	b8 ab aa aa aa	 mov	 eax, -1431655765	; aaaaaaabH
  00ede	f7 e2		 mul	 edx
  00ee0	c1 ea 03	 shr	 edx, 3
  00ee3	42		 inc	 edx
  00ee4	89 54 24 14	 mov	 DWORD PTR tv538[esp+12], edx
  00ee8	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL17@HashLookup:

; 499  :     {
; 500  :       a += k[0];
; 501  :       a += ((UINT32)k[1])<<8;
; 502  :       a += ((UINT32)k[2])<<16;
; 503  :       a += ((UINT32)k[3])<<24;
; 504  :       b += k[4];
; 505  :       b += ((UINT32)k[5])<<8;
; 506  :       b += ((UINT32)k[6])<<16;
; 507  :       b += ((UINT32)k[7])<<24;

  00ef0	0f b6 47 07	 movzx	 eax, BYTE PTR [edi+7]
  00ef4	0f b6 57 06	 movzx	 edx, BYTE PTR [edi+6]
  00ef8	c1 e0 08	 shl	 eax, 8
  00efb	03 c2		 add	 eax, edx
  00efd	0f b6 57 05	 movzx	 edx, BYTE PTR [edi+5]
  00f01	c1 e0 08	 shl	 eax, 8
  00f04	03 c2		 add	 eax, edx
  00f06	0f b6 57 04	 movzx	 edx, BYTE PTR [edi+4]
  00f0a	03 d1		 add	 edx, ecx

; 508  :       c += k[8];
; 509  :       c += ((UINT32)k[9])<<8;
; 510  :       c += ((UINT32)k[10])<<16;
; 511  :       c += ((UINT32)k[11])<<24;

  00f0c	0f b6 4f 0a	 movzx	 ecx, BYTE PTR [edi+10]
  00f10	c1 e0 08	 shl	 eax, 8
  00f13	03 d0		 add	 edx, eax
  00f15	0f b6 47 0b	 movzx	 eax, BYTE PTR [edi+11]
  00f19	c1 e0 08	 shl	 eax, 8
  00f1c	03 c1		 add	 eax, ecx
  00f1e	0f b6 4f 09	 movzx	 ecx, BYTE PTR [edi+9]
  00f22	c1 e0 08	 shl	 eax, 8
  00f25	03 c1		 add	 eax, ecx
  00f27	0f b6 4f 08	 movzx	 ecx, BYTE PTR [edi+8]
  00f2b	03 cb		 add	 ecx, ebx

; 512  :       mix(a,b,c);

  00f2d	0f b6 5f 02	 movzx	 ebx, BYTE PTR [edi+2]
  00f31	c1 e0 08	 shl	 eax, 8
  00f34	8d 2c 01	 lea	 ebp, DWORD PTR [ecx+eax]
  00f37	0f b6 4f 03	 movzx	 ecx, BYTE PTR [edi+3]
  00f3b	c1 e1 08	 shl	 ecx, 8
  00f3e	03 cb		 add	 ecx, ebx
  00f40	0f b6 5f 01	 movzx	 ebx, BYTE PTR [edi+1]
  00f44	c1 e1 08	 shl	 ecx, 8
  00f47	03 cb		 add	 ecx, ebx
  00f49	0f b6 1f	 movzx	 ebx, BYTE PTR [edi]
  00f4c	c1 e1 08	 shl	 ecx, 8
  00f4f	03 cb		 add	 ecx, ebx
  00f51	2b cd		 sub	 ecx, ebp
  00f53	03 ce		 add	 ecx, esi
  00f55	8b c5		 mov	 eax, ebp
  00f57	c1 c0 04	 rol	 eax, 4
  00f5a	33 c1		 xor	 eax, ecx
  00f5c	03 ea		 add	 ebp, edx
  00f5e	2b d0		 sub	 edx, eax
  00f60	8b c8		 mov	 ecx, eax
  00f62	c1 c1 06	 rol	 ecx, 6
  00f65	33 ca		 xor	 ecx, edx

; 513  :       length -= 12;

  00f67	83 6c 24 18 0c	 sub	 DWORD PTR _length$[esp+12], 12 ; 0000000cH
  00f6c	03 c5		 add	 eax, ebp
  00f6e	2b e9		 sub	 ebp, ecx
  00f70	8b d9		 mov	 ebx, ecx
  00f72	c1 c3 08	 rol	 ebx, 8
  00f75	33 dd		 xor	 ebx, ebp
  00f77	03 c8		 add	 ecx, eax
  00f79	2b c3		 sub	 eax, ebx
  00f7b	8b d3		 mov	 edx, ebx
  00f7d	c1 c2 10	 rol	 edx, 16			; 00000010H
  00f80	33 d0		 xor	 edx, eax
  00f82	03 d9		 add	 ebx, ecx
  00f84	8b f2		 mov	 esi, edx
  00f86	2b ce		 sub	 ecx, esi
  00f88	8b c6		 mov	 eax, esi
  00f8a	c1 c0 13	 rol	 eax, 19			; 00000013H
  00f8d	33 c8		 xor	 ecx, eax
  00f8f	03 f3		 add	 esi, ebx
  00f91	8b d1		 mov	 edx, ecx
  00f93	2b d9		 sub	 ebx, ecx
  00f95	c1 c2 04	 rol	 edx, 4
  00f98	33 da		 xor	 ebx, edx
  00f9a	03 ce		 add	 ecx, esi

; 514  :       k += 12;

  00f9c	83 c7 0c	 add	 edi, 12			; 0000000cH
  00f9f	83 6c 24 14 01	 sub	 DWORD PTR tv538[esp+12], 1
  00fa4	0f 85 46 ff ff
	ff		 jne	 $LL17@HashLookup

; 515  :     }
; 516  : 
; 517  :     /*-------------------------------- last block: affect all 32 bits of (c) */
; 518  :     switch(length)                   /* all the case statements fall through */

  00faa	83 7c 24 18 0c	 cmp	 DWORD PTR _length$[esp+12], 12 ; 0000000cH
  00faf	77 6d		 ja	 SHORT $LN14@HashLookup
  00fb1	8b 44 24 18	 mov	 eax, DWORD PTR _length$[esp+12]
$LN66@HashLookup:
  00fb5	ff 24 85 00 00
	00 00		 jmp	 DWORD PTR $LN71@HashLookup[eax*4]
$LN13@HashLookup:

; 519  :     {
; 520  :     case 12: c+=((UINT32)k[11])<<24;

  00fbc	0f b6 47 0b	 movzx	 eax, BYTE PTR [edi+11]
  00fc0	c1 e0 18	 shl	 eax, 24			; 00000018H
  00fc3	03 d8		 add	 ebx, eax
$LN12@HashLookup:

; 521  :     case 11: c+=((UINT32)k[10])<<16;

  00fc5	0f b6 57 0a	 movzx	 edx, BYTE PTR [edi+10]
  00fc9	c1 e2 10	 shl	 edx, 16			; 00000010H
  00fcc	03 da		 add	 ebx, edx
$LN11@HashLookup:

; 522  :     case 10: c+=((UINT32)k[9])<<8;

  00fce	0f b6 47 09	 movzx	 eax, BYTE PTR [edi+9]
  00fd2	c1 e0 08	 shl	 eax, 8
  00fd5	03 d8		 add	 ebx, eax
$LN10@HashLookup:

; 523  :     case 9 : c+=k[8];

  00fd7	0f b6 57 08	 movzx	 edx, BYTE PTR [edi+8]
  00fdb	03 da		 add	 ebx, edx
$LN9@HashLookup:

; 524  :     case 8 : b+=((UINT32)k[7])<<24;

  00fdd	0f b6 47 07	 movzx	 eax, BYTE PTR [edi+7]
  00fe1	c1 e0 18	 shl	 eax, 24			; 00000018H
  00fe4	03 c8		 add	 ecx, eax
$LN8@HashLookup:

; 525  :     case 7 : b+=((UINT32)k[6])<<16;

  00fe6	0f b6 57 06	 movzx	 edx, BYTE PTR [edi+6]
  00fea	c1 e2 10	 shl	 edx, 16			; 00000010H
  00fed	03 ca		 add	 ecx, edx
$LN7@HashLookup:

; 526  :     case 6 : b+=((UINT32)k[5])<<8;

  00fef	0f b6 47 05	 movzx	 eax, BYTE PTR [edi+5]
  00ff3	c1 e0 08	 shl	 eax, 8
  00ff6	03 c8		 add	 ecx, eax
$LN6@HashLookup:

; 527  :     case 5 : b+=k[4];

  00ff8	0f b6 57 04	 movzx	 edx, BYTE PTR [edi+4]
  00ffc	03 ca		 add	 ecx, edx
$LN5@HashLookup:

; 528  :     case 4 : a+=((UINT32)k[3])<<24;

  00ffe	0f b6 47 03	 movzx	 eax, BYTE PTR [edi+3]
  01002	c1 e0 18	 shl	 eax, 24			; 00000018H
  01005	03 f0		 add	 esi, eax
$LN4@HashLookup:

; 529  :     case 3 : a+=((UINT32)k[2])<<16;

  01007	0f b6 57 02	 movzx	 edx, BYTE PTR [edi+2]
  0100b	c1 e2 10	 shl	 edx, 16			; 00000010H
  0100e	03 f2		 add	 esi, edx
$LN3@HashLookup:

; 530  :     case 2 : a+=((UINT32)k[1])<<8;

  01010	0f b6 47 01	 movzx	 eax, BYTE PTR [edi+1]
  01014	c1 e0 08	 shl	 eax, 8
  01017	03 f0		 add	 esi, eax
$LN2@HashLookup:

; 531  :     case 1 : a+=k[0];

  01019	0f b6 17	 movzx	 edx, BYTE PTR [edi]
$LN68@HashLookup:

; 418  :     case 4 : a+=k[0]; break;
; 419  :     case 3 : a+=k[0]&0xffffff; break;

  0101c	03 f2		 add	 esi, edx
$LN14@HashLookup:

; 532  :              break;
; 533  :     case 0 : return c;
; 534  :     }
; 535  :   }
; 536  :  
; 537  :   final(a,b,c);

  0101e	33 d9		 xor	 ebx, ecx
  01020	8b c1		 mov	 eax, ecx
  01022	c1 c0 0e	 rol	 eax, 14			; 0000000eH
  01025	2b d8		 sub	 ebx, eax
  01027	8b c3		 mov	 eax, ebx
  01029	c1 c0 0b	 rol	 eax, 11			; 0000000bH
  0102c	8b d3		 mov	 edx, ebx
  0102e	33 d6		 xor	 edx, esi
  01030	2b d0		 sub	 edx, eax
  01032	33 ca		 xor	 ecx, edx
  01034	8b c2		 mov	 eax, edx
  01036	c1 c0 19	 rol	 eax, 25			; 00000019H
  01039	2b c8		 sub	 ecx, eax
  0103b	33 d9		 xor	 ebx, ecx
  0103d	8b c1		 mov	 eax, ecx
  0103f	c1 c0 10	 rol	 eax, 16			; 00000010H
  01042	2b d8		 sub	 ebx, eax
  01044	8b c3		 mov	 eax, ebx
  01046	8b f8		 mov	 edi, eax
  01048	8b f0		 mov	 esi, eax
  0104a	33 f2		 xor	 esi, edx
  0104c	c1 c7 04	 rol	 edi, 4
  0104f	2b f7		 sub	 esi, edi
  01051	8b d6		 mov	 edx, esi
  01053	c1 c2 0e	 rol	 edx, 14			; 0000000eH
  01056	33 ce		 xor	 ecx, esi
  01058	2b ca		 sub	 ecx, edx
  0105a	5f		 pop	 edi
  0105b	5e		 pop	 esi
  0105c	8b d1		 mov	 edx, ecx
  0105e	c1 c2 18	 rol	 edx, 24			; 00000018H
  01061	33 c1		 xor	 eax, ecx
  01063	5d		 pop	 ebp
  01064	2b c2		 sub	 eax, edx
  01066	5b		 pop	 ebx

; 538  :   return c;
; 539  : } 

  01067	c3		 ret	 0
$LN69@HashLookup:
  01068	00 00 00 00	 DD	 $LN38@HashLookup
  0106c	00 00 00 00	 DD	 $LN39@HashLookup
  01070	00 00 00 00	 DD	 $LN40@HashLookup
  01074	00 00 00 00	 DD	 $LN41@HashLookup
  01078	00 00 00 00	 DD	 $LN42@HashLookup
  0107c	00 00 00 00	 DD	 $LN43@HashLookup
  01080	00 00 00 00	 DD	 $LN44@HashLookup
  01084	00 00 00 00	 DD	 $LN45@HashLookup
  01088	00 00 00 00	 DD	 $LN46@HashLookup
  0108c	00 00 00 00	 DD	 $LN47@HashLookup
  01090	00 00 00 00	 DD	 $LN48@HashLookup
  01094	00 00 00 00	 DD	 $LN49@HashLookup
  01098	00 00 00 00	 DD	 $LN50@HashLookup
$LN70@HashLookup:
  0109c	00 00 00 00	 DD	 $LN38@HashLookup
  010a0	00 00 00 00	 DD	 $LN20@HashLookup
  010a4	00 00 00 00	 DD	 $LN21@HashLookup
  010a8	00 00 00 00	 DD	 $LN22@HashLookup
  010ac	00 00 00 00	 DD	 $LN23@HashLookup
  010b0	00 00 00 00	 DD	 $LN24@HashLookup
  010b4	00 00 00 00	 DD	 $LN25@HashLookup
  010b8	00 00 00 00	 DD	 $LN26@HashLookup
  010bc	00 00 00 00	 DD	 $LN27@HashLookup
  010c0	00 00 00 00	 DD	 $LN28@HashLookup
  010c4	00 00 00 00	 DD	 $LN29@HashLookup
  010c8	00 00 00 00	 DD	 $LN30@HashLookup
  010cc	00 00 00 00	 DD	 $LN31@HashLookup
$LN71@HashLookup:
  010d0	00 00 00 00	 DD	 $LN38@HashLookup
  010d4	00 00 00 00	 DD	 $LN2@HashLookup
  010d8	00 00 00 00	 DD	 $LN3@HashLookup
  010dc	00 00 00 00	 DD	 $LN4@HashLookup
  010e0	00 00 00 00	 DD	 $LN5@HashLookup
  010e4	00 00 00 00	 DD	 $LN6@HashLookup
  010e8	00 00 00 00	 DD	 $LN7@HashLookup
  010ec	00 00 00 00	 DD	 $LN8@HashLookup
  010f0	00 00 00 00	 DD	 $LN9@HashLookup
  010f4	00 00 00 00	 DD	 $LN10@HashLookup
  010f8	00 00 00 00	 DD	 $LN11@HashLookup
  010fc	00 00 00 00	 DD	 $LN12@HashLookup
  01100	00 00 00 00	 DD	 $LN13@HashLookup
?HashLookup3@@YAIPBDK@Z ENDP				; HashLookup3
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashUniversal@@YAIPBDK@Z PROC				; HashUniversal

; 342  : UINT HashUniversal(const CHAR* key, SIZE_T len) {

  01110	56		 push	 esi

; 343  : 	UINT hash = 0, a = 31415, b = 27183;
; 344  : 	for(UINT i = 0; i < len; ++i) {

  01111	8b 74 24 0c	 mov	 esi, DWORD PTR _len$[esp]
  01115	33 c0		 xor	 eax, eax
  01117	33 d2		 xor	 edx, edx
  01119	b9 b7 7a 00 00	 mov	 ecx, 31415		; 00007ab7H
  0111e	85 f6		 test	 esi, esi
  01120	76 29		 jbe	 SHORT $LN1@HashUniver
  01122	53		 push	 ebx
  01123	55		 push	 ebp
  01124	57		 push	 edi
  01125	8b 7c 24 14	 mov	 edi, DWORD PTR _key$[esp+12]
  01129	8d a4 24 00 00
	00 00		 npad	 7
$LL3@HashUniver:

; 345  : 		hash = a * hash + key[i];

  01130	0f be 1c 3a	 movsx	 ebx, BYTE PTR [edx+edi]
  01134	8b e9		 mov	 ebp, ecx

; 346  : 		a *= b;

  01136	69 c9 2f 6a 00
	00		 imul	 ecx, 27183		; 00006a2fH
  0113c	0f af e8	 imul	 ebp, eax
  0113f	03 dd		 add	 ebx, ebp
  01141	42		 inc	 edx
  01142	8b c3		 mov	 eax, ebx
  01144	3b d6		 cmp	 edx, esi
  01146	72 e8		 jb	 SHORT $LL3@HashUniver
  01148	5f		 pop	 edi
  01149	5d		 pop	 ebp
  0114a	5b		 pop	 ebx
$LN1@HashUniver:
  0114b	5e		 pop	 esi

; 347  : 	}
; 348  : 	return hash;
; 349  : }

  0114c	c3		 ret	 0
?HashUniversal@@YAIPBDK@Z ENDP				; HashUniversal
_TEXT	ENDS
PUBLIC	?CRC32Accelerated@@YAIPBDK@Z			; CRC32Accelerated
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?CRC32Accelerated@@YAIPBDK@Z PROC			; CRC32Accelerated

; 325  : 	UINT crc = CRCINIT;
; 326  : 	SIZE_T ndwords = len / sizeof(DWORD);
; 327  : 	for(; ndwords; ndwords--) {

  01150	8b 4c 24 04	 mov	 ecx, DWORD PTR _key$[esp-4]
  01154	53		 push	 ebx
  01155	8b 5c 24 0c	 mov	 ebx, DWORD PTR _len$[esp]
  01159	8b d3		 mov	 edx, ebx
  0115b	c1 ea 02	 shr	 edx, 2
  0115e	83 c8 ff	 or	 eax, -1
  01161	85 d2		 test	 edx, edx
  01163	74 11		 je	 SHORT $LN3@CRC32Accel
  01165	56		 push	 esi
$LL5@CRC32Accel:

; 328  : 		crc = _mm_crc32_u32(crc, *(DWORD*)key);

  01166	8b 31		 mov	 esi, DWORD PTR [ecx]

; 329  : 		key += sizeof(DWORD);

  01168	83 c1 04	 add	 ecx, 4
  0116b	83 ea 01	 sub	 edx, 1
  0116e	f2 0f 38 f1 c6	 crc32	 eax, esi
  01173	75 f1		 jne	 SHORT $LL5@CRC32Accel
  01175	5e		 pop	 esi
$LN3@CRC32Accel:

; 330  : 	}
; 331  : 	if (len & sizeof(WORD)) {

  01176	f6 c3 02	 test	 bl, 2
  01179	74 0c		 je	 SHORT $LN2@CRC32Accel

; 332  : 		crc = _mm_crc32_u16(crc, *(WORD*)key);

  0117b	66 8b 11	 mov	 dx, WORD PTR [ecx]
  0117e	66 f2 0f 38 f1
	c2		 crc32	 eax, dx

; 333  : 		key += sizeof(WORD);

  01184	83 c1 02	 add	 ecx, 2
$LN2@CRC32Accel:

; 334  : 	}
; 335  : 	if (len & sizeof(BYTE))

  01187	f6 c3 01	 test	 bl, 1
  0118a	5b		 pop	 ebx
  0118b	74 07		 je	 SHORT $LN1@CRC32Accel

; 336  : 		crc = _mm_crc32_u8(crc, *key);

  0118d	8a 09		 mov	 cl, BYTE PTR [ecx]
  0118f	f2 0f 38 f0 c1	 crc32	 eax, cl
$LN1@CRC32Accel:

; 337  : 	return crc;
; 338  : }

  01194	c3		 ret	 0
?CRC32Accelerated@@YAIPBDK@Z ENDP			; CRC32Accelerated
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?CRC32@@YAIPBDK@Z PROC					; CRC32

; 301  : 	UINT crc = CRCINIT;
; 302  : 	SIZE_T ndwords = len / sizeof(DWORD);
; 303  : 	for(; ndwords; ndwords--) {

  011a0	8b 54 24 04	 mov	 edx, DWORD PTR _key$[esp-4]
  011a4	53		 push	 ebx
  011a5	8b 5c 24 0c	 mov	 ebx, DWORD PTR _len$[esp]
  011a9	8b cb		 mov	 ecx, ebx
  011ab	c1 e9 02	 shr	 ecx, 2
  011ae	83 c8 ff	 or	 eax, -1
  011b1	56		 push	 esi
  011b2	85 c9		 test	 ecx, ecx
  011b4	74 4a		 je	 SHORT $LN3@CRC32
  011b6	57		 push	 edi
$LL5@CRC32:

; 304  : 		crc ^= *(DWORD*)key;

  011b7	33 02		 xor	 eax, DWORD PTR [edx]

; 305  : 		crc =
; 306  : 			g_crc_precalc[3][(crc      ) & 0xFF] ^
; 307  : 			g_crc_precalc[2][(crc >>  8) & 0xFF] ^
; 308  : 			g_crc_precalc[1][(crc >> 16) & 0xFF] ^
; 309  : 			g_crc_precalc[0][(crc >> 24) & 0xFF];
; 310  : 		key += sizeof(DWORD);

  011b9	83 c2 04	 add	 edx, 4
  011bc	8b f0		 mov	 esi, eax
  011be	c1 ee 10	 shr	 esi, 16			; 00000010H
  011c1	81 e6 ff 00 00
	00		 and	 esi, 255		; 000000ffH
  011c7	8b 34 b5 00 04
	00 00		 mov	 esi, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[esi*4+1024]
  011ce	8b f8		 mov	 edi, eax
  011d0	c1 ef 08	 shr	 edi, 8
  011d3	81 e7 ff 00 00
	00		 and	 edi, 255		; 000000ffH
  011d9	33 34 bd 00 08
	00 00		 xor	 esi, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[edi*4+2048]
  011e0	8b f8		 mov	 edi, eax
  011e2	c1 ef 18	 shr	 edi, 24			; 00000018H
  011e5	33 34 bd 00 00
	00 00		 xor	 esi, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[edi*4]
  011ec	25 ff 00 00 00	 and	 eax, 255		; 000000ffH
  011f1	33 34 85 00 0c
	00 00		 xor	 esi, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[eax*4+3072]
  011f8	83 e9 01	 sub	 ecx, 1
  011fb	8b c6		 mov	 eax, esi
  011fd	75 b8		 jne	 SHORT $LL5@CRC32
  011ff	5f		 pop	 edi
$LN3@CRC32:

; 311  : 	}
; 312  : 	if (len & sizeof(WORD)) {

  01200	f6 c3 02	 test	 bl, 2
  01203	74 2c		 je	 SHORT $LN2@CRC32

; 313  : 		UINT c = crc ^ *(WORD*)key;

  01205	0f b7 0a	 movzx	 ecx, WORD PTR [edx]
  01208	33 c8		 xor	 ecx, eax

; 314  : 		crc = g_crc_precalc[1][(c     ) & 0xFF] ^
; 315  : 			  g_crc_precalc[0][(c >> 8) & 0xFF] ^ (crc >> 16);

  0120a	8b f1		 mov	 esi, ecx
  0120c	c1 ee 08	 shr	 esi, 8
  0120f	81 e6 ff 00 00
	00		 and	 esi, 255		; 000000ffH
  01215	8b 34 b5 00 00
	00 00		 mov	 esi, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[esi*4]
  0121c	81 e1 ff 00 00
	00		 and	 ecx, 255		; 000000ffH
  01222	33 34 8d 00 04
	00 00		 xor	 esi, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[ecx*4+1024]
  01229	c1 e8 10	 shr	 eax, 16			; 00000010H
  0122c	33 c6		 xor	 eax, esi

; 316  : 		key += sizeof(WORD);

  0122e	83 c2 02	 add	 edx, 2
$LN2@CRC32:
  01231	5e		 pop	 esi

; 317  : 	}
; 318  : 	if (len & sizeof(BYTE))

  01232	f6 c3 01	 test	 bl, 1
  01235	5b		 pop	 ebx
  01236	74 15		 je	 SHORT $LN1@CRC32

; 319  : 		crc = g_crc_precalc[0][(crc ^ *key) & 0xFF] ^ (crc >> 8);

  01238	0f be 0a	 movsx	 ecx, BYTE PTR [edx]
  0123b	33 c8		 xor	 ecx, eax
  0123d	81 e1 ff 00 00
	00		 and	 ecx, 255		; 000000ffH
  01243	c1 e8 08	 shr	 eax, 8
  01246	33 04 8d 00 00
	00 00		 xor	 eax, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[ecx*4]
$LN1@CRC32:

; 320  : 	return ~crc;

  0124d	f7 d0		 not	 eax

; 321  : }

  0124f	c3		 ret	 0
?CRC32@@YAIPBDK@Z ENDP					; CRC32
_TEXT	ENDS
PUBLIC	?CRC32Init@@YAXXZ				; CRC32Init
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?CRC32Init@@YAXXZ PROC					; CRC32Init

; 284  : 	for(UINT i = 0; i <= 0xFF; i++) {

  01250	33 d2		 xor	 edx, edx
$LL12@CRC32Init:

; 285  : 		UINT x = i;
; 286  : 		for(UINT j = 0; j < 8; j++)
; 287  : 			x = (x>>1) ^ (CRCPOLY & (-(INT)(x & 1)));

  01252	8b c2		 mov	 eax, edx
  01254	83 e0 01	 and	 eax, 1
  01257	f7 d8		 neg	 eax
  01259	25 20 83 b8 ed	 and	 eax, -306674912		; edb88320H
  0125e	8b ca		 mov	 ecx, edx
  01260	d1 e9		 shr	 ecx, 1
  01262	33 c1		 xor	 eax, ecx
  01264	8b c8		 mov	 ecx, eax
  01266	83 e1 01	 and	 ecx, 1
  01269	f7 d9		 neg	 ecx
  0126b	81 e1 20 83 b8
	ed		 and	 ecx, -306674912		; edb88320H
  01271	d1 e8		 shr	 eax, 1
  01273	33 c8		 xor	 ecx, eax
  01275	8b c1		 mov	 eax, ecx
  01277	83 e0 01	 and	 eax, 1
  0127a	d1 e9		 shr	 ecx, 1
  0127c	f7 d8		 neg	 eax
  0127e	25 20 83 b8 ed	 and	 eax, -306674912		; edb88320H
  01283	33 c1		 xor	 eax, ecx
  01285	8b c8		 mov	 ecx, eax
  01287	83 e1 01	 and	 ecx, 1
  0128a	f7 d9		 neg	 ecx
  0128c	81 e1 20 83 b8
	ed		 and	 ecx, -306674912		; edb88320H
  01292	d1 e8		 shr	 eax, 1
  01294	33 c8		 xor	 ecx, eax
  01296	8b c1		 mov	 eax, ecx
  01298	83 e0 01	 and	 eax, 1
  0129b	d1 e9		 shr	 ecx, 1
  0129d	f7 d8		 neg	 eax
  0129f	25 20 83 b8 ed	 and	 eax, -306674912		; edb88320H
  012a4	33 c1		 xor	 eax, ecx
  012a6	8b c8		 mov	 ecx, eax
  012a8	83 e1 01	 and	 ecx, 1
  012ab	f7 d9		 neg	 ecx
  012ad	81 e1 20 83 b8
	ed		 and	 ecx, -306674912		; edb88320H
  012b3	d1 e8		 shr	 eax, 1
  012b5	33 c8		 xor	 ecx, eax
  012b7	8b c1		 mov	 eax, ecx
  012b9	83 e0 01	 and	 eax, 1
  012bc	d1 e9		 shr	 ecx, 1
  012be	f7 d8		 neg	 eax
  012c0	25 20 83 b8 ed	 and	 eax, -306674912		; edb88320H
  012c5	33 c1		 xor	 eax, ecx
  012c7	8b c8		 mov	 ecx, eax
  012c9	83 e1 01	 and	 ecx, 1
  012cc	f7 d9		 neg	 ecx
  012ce	81 e1 20 83 b8
	ed		 and	 ecx, -306674912		; edb88320H
  012d4	d1 e8		 shr	 eax, 1
  012d6	33 c8		 xor	 ecx, eax

; 288  : 		g_crc_precalc[0][i] = x;

  012d8	89 0c 95 00 00
	00 00		 mov	 DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[edx*4], ecx
  012df	42		 inc	 edx
  012e0	81 fa ff 00 00
	00		 cmp	 edx, 255		; 000000ffH
  012e6	0f 86 66 ff ff
	ff		 jbe	 $LL12@CRC32Init

; 289  : 	}
; 290  : 
; 291  : 	for(UINT i = 0; i <= 0xFF; i++) {

  012ec	b9 00 04 00 00	 mov	 ecx, 1024		; 00000400H
$LL6@CRC32Init:

; 292  : 		UINT c = g_crc_precalc[0][i];

  012f1	8b 81 00 fc ff
	ff		 mov	 eax, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[ecx-1024]

; 293  : 		for(UINT j = 1; j < 4; j++) {
; 294  : 			c = g_crc_precalc[0][c & 0xFF] ^ (c >> 8);

  012f7	8b d0		 mov	 edx, eax
  012f9	81 e2 ff 00 00
	00		 and	 edx, 255		; 000000ffH
  012ff	c1 e8 08	 shr	 eax, 8
  01302	33 04 95 00 00
	00 00		 xor	 eax, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[edx*4]
  01309	83 c1 04	 add	 ecx, 4
  0130c	8b d0		 mov	 edx, eax

; 295  : 			g_crc_precalc[j][i] = c;

  0130e	89 81 fc ff ff
	ff		 mov	 DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[ecx-4], eax
  01314	81 e2 ff 00 00
	00		 and	 edx, 255		; 000000ffH
  0131a	c1 e8 08	 shr	 eax, 8
  0131d	33 04 95 00 00
	00 00		 xor	 eax, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[edx*4]
  01324	8b d0		 mov	 edx, eax
  01326	89 81 fc 03 00
	00		 mov	 DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[ecx+1020], eax
  0132c	81 e2 ff 00 00
	00		 and	 edx, 255		; 000000ffH
  01332	c1 e8 08	 shr	 eax, 8
  01335	33 04 95 00 00
	00 00		 xor	 eax, DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[edx*4]
  0133c	89 81 fc 07 00
	00		 mov	 DWORD PTR ?g_crc_precalc@@3PAY0BAA@IA[ecx+2044], eax
  01342	81 f9 fc 07 00
	00		 cmp	 ecx, 2044		; 000007fcH
  01348	76 a7		 jbe	 SHORT $LL6@CRC32Init

; 296  : 		}
; 297  : 	}
; 298  : }

  0134a	c3		 ret	 0
?CRC32Init@@YAXXZ ENDP					; CRC32Init
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashArashPartow@@YAIPBDK@Z PROC			; HashArashPartow

; 262  : UINT HashArashPartow(const CHAR* key, SIZE_T len) {

  01350	53		 push	 ebx

; 263  : 	UINT hash = 0xAAAAAAAA;
; 264  : 	UINT i    = 0;
; 265  : 
; 266  : 	for(i = 0; i < (len & -2); i += 2) {

  01351	8b 5c 24 0c	 mov	 ebx, DWORD PTR _len$[esp]
  01355	8b d3		 mov	 edx, ebx
  01357	83 e2 fe	 and	 edx, -2			; fffffffeH
  0135a	56		 push	 esi
  0135b	8b 74 24 0c	 mov	 esi, DWORD PTR _key$[esp+4]
  0135f	b8 aa aa aa aa	 mov	 eax, -1431655766	; aaaaaaaaH
  01364	76 3d		 jbe	 SHORT $LN2@HashArashP
  01366	4a		 dec	 edx
  01367	d1 ea		 shr	 edx, 1
  01369	55		 push	 ebp
  0136a	8d 4e 01	 lea	 ecx, DWORD PTR [esi+1]
  0136d	42		 inc	 edx
  0136e	57		 push	 edi
  0136f	90		 npad	 1
$LL4@HashArashP:

; 267  : 		hash ^=   (hash <<  7) ^ (key[i]) ^ (hash >> 3);

  01370	0f be 79 ff	 movsx	 edi, BYTE PTR [ecx-1]
  01374	8b e8		 mov	 ebp, eax
  01376	c1 e5 07	 shl	 ebp, 7
  01379	33 fd		 xor	 edi, ebp
  0137b	8b e8		 mov	 ebp, eax
  0137d	c1 ed 03	 shr	 ebp, 3
  01380	33 fd		 xor	 edi, ebp
  01382	33 c7		 xor	 eax, edi

; 268  :         hash ^= ~((hash << 11) ^ (key[i+1]) ^ (hash >> 5));

  01384	8b f8		 mov	 edi, eax
  01386	c1 e7 0b	 shl	 edi, 11			; 0000000bH
  01389	8b e8		 mov	 ebp, eax
  0138b	c1 ed 05	 shr	 ebp, 5
  0138e	33 fd		 xor	 edi, ebp
  01390	0f be 29	 movsx	 ebp, BYTE PTR [ecx]
  01393	33 fd		 xor	 edi, ebp
  01395	f7 d7		 not	 edi
  01397	33 c7		 xor	 eax, edi
  01399	83 c1 02	 add	 ecx, 2
  0139c	83 ea 01	 sub	 edx, 1
  0139f	75 cf		 jne	 SHORT $LL4@HashArashP
  013a1	5f		 pop	 edi
  013a2	5d		 pop	 ebp
$LN2@HashArashP:

; 269  : 	}
; 270  : 	if(len & 1) {

  013a3	f6 c3 01	 test	 bl, 1
  013a6	74 15		 je	 SHORT $LN1@HashArashP

; 271  : 		hash ^= (hash <<  7) ^ (key[len - 1]) ^ (hash >> 3);

  013a8	0f be 4c 1e ff	 movsx	 ecx, BYTE PTR [esi+ebx-1]
  013ad	8b d0		 mov	 edx, eax
  013af	c1 e2 07	 shl	 edx, 7
  013b2	33 ca		 xor	 ecx, edx
  013b4	8b d0		 mov	 edx, eax
  013b6	c1 ea 03	 shr	 edx, 3
  013b9	33 ca		 xor	 ecx, edx
  013bb	33 c1		 xor	 eax, ecx
$LN1@HashArashP:
  013bd	5e		 pop	 esi
  013be	5b		 pop	 ebx

; 272  : 	}
; 273  : 
; 274  : 	return hash;
; 275  : }

  013bf	c3		 ret	 0
?HashArashPartow@@YAIPBDK@Z ENDP			; HashArashPartow
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashOneAtTime@@YAIPBDK@Z PROC				; HashOneAtTime

; 249  : 	UINT hash, i;
; 250  : 	for(hash=0, i=0; i<len; ++i) {

  013c0	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  013c4	33 c0		 xor	 eax, eax
  013c6	33 c9		 xor	 ecx, ecx
  013c8	85 d2		 test	 edx, edx
  013ca	76 20		 jbe	 SHORT $LN1@HashOneAtT
  013cc	56		 push	 esi
  013cd	8b 74 24 08	 mov	 esi, DWORD PTR _key$[esp]
  013d1	57		 push	 edi
$LL3@HashOneAtT:

; 251  :     	hash += key[i];
; 252  :     	hash += (hash << 10);

  013d2	0f be 3c 31	 movsx	 edi, BYTE PTR [ecx+esi]
  013d6	03 f8		 add	 edi, eax
  013d8	69 ff 01 04 00
	00		 imul	 edi, 1025		; 00000401H
  013de	8b c7		 mov	 eax, edi

; 253  :     	hash ^= (hash >> 6);

  013e0	c1 ef 06	 shr	 edi, 6
  013e3	41		 inc	 ecx
  013e4	33 c7		 xor	 eax, edi
  013e6	3b ca		 cmp	 ecx, edx
  013e8	72 e8		 jb	 SHORT $LL3@HashOneAtT
  013ea	5f		 pop	 edi
  013eb	5e		 pop	 esi
$LN1@HashOneAtT:

; 254  : 	}
; 255  : 	hash += (hash << 3);

  013ec	8d 0c c0	 lea	 ecx, DWORD PTR [eax+eax*8]

; 256  : 	hash ^= (hash >> 11);

  013ef	8b c1		 mov	 eax, ecx
  013f1	c1 e8 0b	 shr	 eax, 11			; 0000000bH
  013f4	33 c1		 xor	 eax, ecx

; 257  : 	hash += (hash << 15);

  013f6	69 c0 01 80 00
	00		 imul	 eax, 32769		; 00008001H

; 258  : 	return hash;
; 259  : }

  013fc	c3		 ret	 0
?HashOneAtTime@@YAIPBDK@Z ENDP				; HashOneAtTime
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashPaulHsieh@@YAIPBDK@Z PROC				; HashPaulHsieh

; 202  : 	UINT hash = (UINT)len, tmp;

  01400	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  01404	8b ca		 mov	 ecx, edx

; 203  : 	if(len == 0) return 0;

  01406	85 d2		 test	 edx, edx
  01408	75 03		 jne	 SHORT $LN9@HashPaulHs
  0140a	33 c0		 xor	 eax, eax

; 243  : 
; 244  : 	return hash;
; 245  : }

  0140c	c3		 ret	 0
$LN9@HashPaulHs:

; 204  : 
; 205  :     SIZE_T rem = len & 3;
; 206  : 	len >>= 2;
; 207  : 
; 208  : 	/* Main loop */
; 209  : 	for(;len > 0; len--) {

  0140d	8b 44 24 04	 mov	 eax, DWORD PTR _key$[esp-4]
  01411	56		 push	 esi
  01412	8b f2		 mov	 esi, edx
  01414	c1 ea 02	 shr	 edx, 2
  01417	83 e6 03	 and	 esi, 3
  0141a	85 d2		 test	 edx, edx
  0141c	76 28		 jbe	 SHORT $LN6@HashPaulHs
  0141e	53		 push	 ebx
  0141f	57		 push	 edi
$LL8@HashPaulHs:

; 210  : 		hash  += *(const WORD*)key;

  01420	0f b7 38	 movzx	 edi, WORD PTR [eax]
  01423	03 cf		 add	 ecx, edi

; 211  : 		tmp    = (*(const WORD*) (key+2) << 11) ^ hash;
; 212  : 		hash   = (hash << 16) ^ tmp;

  01425	0f b7 78 02	 movzx	 edi, WORD PTR [eax+2]
  01429	8b d9		 mov	 ebx, ecx
  0142b	c1 e3 05	 shl	 ebx, 5
  0142e	33 fb		 xor	 edi, ebx
  01430	c1 e7 0b	 shl	 edi, 11			; 0000000bH
  01433	33 cf		 xor	 ecx, edi

; 213  : 		key   += 2 * sizeof (WORD);
; 214  : 		hash  += hash >> 11;

  01435	8b f9		 mov	 edi, ecx
  01437	c1 ef 0b	 shr	 edi, 11			; 0000000bH
  0143a	83 c0 04	 add	 eax, 4
  0143d	03 cf		 add	 ecx, edi
  0143f	83 ea 01	 sub	 edx, 1
  01442	75 dc		 jne	 SHORT $LL8@HashPaulHs
  01444	5f		 pop	 edi
  01445	5b		 pop	 ebx
$LN6@HashPaulHs:

; 215  : 	}
; 216  : 
; 217  : 	/* Handle end cases */
; 218  : 	switch(rem) {

  01446	8b d6		 mov	 edx, esi
  01448	83 ea 01	 sub	 edx, 1
  0144b	5e		 pop	 esi
  0144c	74 3a		 je	 SHORT $LN1@HashPaulHs
  0144e	83 ea 01	 sub	 edx, 1
  01451	74 20		 je	 SHORT $LN2@HashPaulHs
  01453	83 ea 01	 sub	 edx, 1
  01456	75 42		 jne	 SHORT $LN4@HashPaulHs

; 219  : 		case 3:
; 220  : 			hash += *(const WORD*)key;

  01458	0f b7 10	 movzx	 edx, WORD PTR [eax]

; 221  : 			hash ^= hash << 16;
; 222  : 			hash ^= key[sizeof (WORD)] << 18;

  0145b	0f be 40 02	 movsx	 eax, BYTE PTR [eax+2]
  0145f	03 c0		 add	 eax, eax
  01461	03 ca		 add	 ecx, edx
  01463	03 c0		 add	 eax, eax
  01465	33 c1		 xor	 eax, ecx
  01467	c1 e0 10	 shl	 eax, 16			; 00000010H
  0146a	33 c8		 xor	 ecx, eax

; 223  : 			hash += hash >> 11;

  0146c	8b d1		 mov	 edx, ecx
  0146e	c1 ea 0b	 shr	 edx, 11			; 0000000bH

; 224  : 			break;

  01471	eb 25		 jmp	 SHORT $LN15@HashPaulHs
$LN2@HashPaulHs:

; 225  : 		case 2:
; 226  : 			hash += *(const WORD*)key;

  01473	0f b7 00	 movzx	 eax, WORD PTR [eax]
  01476	03 c8		 add	 ecx, eax

; 227  : 			hash ^= hash << 11;

  01478	8b d1		 mov	 edx, ecx
  0147a	c1 e2 0b	 shl	 edx, 11			; 0000000bH
  0147d	33 ca		 xor	 ecx, edx

; 228  : 			hash += hash >> 17;

  0147f	8b c1		 mov	 eax, ecx
  01481	c1 e8 11	 shr	 eax, 17			; 00000011H
  01484	03 c8		 add	 ecx, eax

; 229  : 			break;

  01486	eb 12		 jmp	 SHORT $LN4@HashPaulHs
$LN1@HashPaulHs:

; 230  : 		case 1:
; 231  : 			hash += *key;

  01488	0f be 10	 movsx	 edx, BYTE PTR [eax]
  0148b	03 ca		 add	 ecx, edx

; 232  : 			hash ^= hash << 10;

  0148d	8b c1		 mov	 eax, ecx
  0148f	c1 e0 0a	 shl	 eax, 10			; 0000000aH
  01492	33 c8		 xor	 ecx, eax

; 233  : 			hash += hash >> 1;

  01494	8b d1		 mov	 edx, ecx
  01496	d1 ea		 shr	 edx, 1
$LN15@HashPaulHs:
  01498	03 ca		 add	 ecx, edx
$LN4@HashPaulHs:

; 234  : 	}
; 235  : 
; 236  : 	/* Force "avalanching" of final 127 bits */
; 237  : 	hash ^= hash << 3;

  0149a	8d 04 cd 00 00
	00 00		 lea	 eax, DWORD PTR [ecx*8]
  014a1	33 c8		 xor	 ecx, eax

; 238  : 	hash += hash >> 5;

  014a3	8b d1		 mov	 edx, ecx
  014a5	c1 ea 05	 shr	 edx, 5
  014a8	03 ca		 add	 ecx, edx

; 239  : 	hash ^= hash << 4;

  014aa	8b c1		 mov	 eax, ecx
  014ac	c1 e0 04	 shl	 eax, 4
  014af	33 c8		 xor	 ecx, eax

; 240  : 	hash += hash >> 17;

  014b1	8b d1		 mov	 edx, ecx
  014b3	c1 ea 11	 shr	 edx, 17			; 00000011H
  014b6	03 ca		 add	 ecx, edx

; 241  : 	hash ^= hash << 25;

  014b8	8b c1		 mov	 eax, ecx
  014ba	c1 e0 19	 shl	 eax, 25			; 00000019H
  014bd	33 c8		 xor	 ecx, eax

; 242  : 	hash += hash >> 6;

  014bf	8b c1		 mov	 eax, ecx
  014c1	c1 e8 06	 shr	 eax, 6
  014c4	03 c1		 add	 eax, ecx

; 243  : 
; 244  : 	return hash;
; 245  : }

  014c6	c3		 ret	 0
?HashPaulHsieh@@YAIPBDK@Z ENDP				; HashPaulHsieh
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashMurmur2@@YAIPBDK@Z PROC				; HashMurmur2

; 151  : 	// 'm' and 'r' are mixing constants generated offline.
; 152  : 	// They're not really 'magic', they just happen to work well.
; 153  : 
; 154  : 	const unsigned int m = 0x5bd1e995;
; 155  : 	const int r = 24;
; 156  : 
; 157  : 	// Initialize the hash to a 'random' value
; 158  : 	UINT seed = 0x3FB0BB5F;
; 159  : 	unsigned int h = seed ^ (UINT)len;
; 160  : 
; 161  : 	// Mix 4 bytes at a time into the hash
; 162  : 
; 163  : 	const unsigned char * data = (const unsigned char *)key;

  014d0	8b 54 24 04	 mov	 edx, DWORD PTR _key$[esp-4]
  014d4	56		 push	 esi
  014d5	8b 74 24 0c	 mov	 esi, DWORD PTR _len$[esp]
  014d9	8b ce		 mov	 ecx, esi
  014db	81 f1 5f bb b0
	3f		 xor	 ecx, 1068546911		; 3fb0bb5fH

; 164  : 
; 165  : 	while(len >= 4)

  014e1	83 fe 04	 cmp	 esi, 4
  014e4	72 34		 jb	 SHORT $LN6@HashMurmur
  014e6	53		 push	 ebx
  014e7	57		 push	 edi
  014e8	8b fe		 mov	 edi, esi
  014ea	c1 ef 02	 shr	 edi, 2
  014ed	8d 49 00	 npad	 3
$LL7@HashMurmur:

; 166  : 	{
; 167  : 		unsigned int k = *(unsigned int *)data;
; 168  : 
; 169  : 		k *= m; 

  014f0	8b 02		 mov	 eax, DWORD PTR [edx]

; 170  : 		k ^= k >> r; 
; 171  : 		k *= m; 
; 172  : 		
; 173  : 		h *= m; 

  014f2	69 c9 95 e9 d1
	5b		 imul	 ecx, 1540483477		; 5bd1e995H
  014f8	69 c0 95 e9 d1
	5b		 imul	 eax, 1540483477		; 5bd1e995H
  014fe	8b d8		 mov	 ebx, eax
  01500	c1 eb 18	 shr	 ebx, 24			; 00000018H
  01503	33 d8		 xor	 ebx, eax
  01505	69 db 95 e9 d1
	5b		 imul	 ebx, 1540483477		; 5bd1e995H

; 174  : 		h ^= k;

  0150b	33 cb		 xor	 ecx, ebx

; 175  : 
; 176  : 		data += 4;

  0150d	83 c2 04	 add	 edx, 4

; 177  : 		len -= 4;

  01510	83 ee 04	 sub	 esi, 4
  01513	83 ef 01	 sub	 edi, 1
  01516	75 d8		 jne	 SHORT $LL7@HashMurmur
  01518	5f		 pop	 edi
  01519	5b		 pop	 ebx
$LN6@HashMurmur:

; 178  : 	}
; 179  : 	
; 180  : 	// Handle the last few bytes of the input array
; 181  : 
; 182  : 	switch(len)

  0151a	83 ee 01	 sub	 esi, 1
  0151d	74 1c		 je	 SHORT $LN1@HashMurmur
  0151f	83 ee 01	 sub	 esi, 1
  01522	74 0e		 je	 SHORT $LN2@HashMurmur
  01524	83 ee 01	 sub	 esi, 1
  01527	75 1f		 jne	 SHORT $LN4@HashMurmur

; 183  : 	{
; 184  : 	case 3: h ^= data[2] << 16;

  01529	0f b6 42 02	 movzx	 eax, BYTE PTR [edx+2]
  0152d	c1 e0 10	 shl	 eax, 16			; 00000010H
  01530	33 c8		 xor	 ecx, eax
$LN2@HashMurmur:

; 185  : 	case 2: h ^= data[1] << 8;

  01532	0f b6 42 01	 movzx	 eax, BYTE PTR [edx+1]
  01536	c1 e0 08	 shl	 eax, 8
  01539	33 c8		 xor	 ecx, eax
$LN1@HashMurmur:

; 186  : 	case 1: h ^= data[0];
; 187  : 	        h *= m;

  0153b	0f b6 12	 movzx	 edx, BYTE PTR [edx]
  0153e	33 d1		 xor	 edx, ecx
  01540	69 d2 95 e9 d1
	5b		 imul	 edx, 1540483477		; 5bd1e995H
  01546	8b ca		 mov	 ecx, edx
$LN4@HashMurmur:

; 188  : 	};
; 189  : 
; 190  : 	// Do a few final mixes of the hash to ensure the last few
; 191  : 	// bytes are well-incorporated.
; 192  : 
; 193  : 	h ^= h >> 13;

  01548	8b d1		 mov	 edx, ecx
  0154a	c1 ea 0d	 shr	 edx, 13			; 0000000dH
  0154d	33 d1		 xor	 edx, ecx

; 194  : 	h *= m;

  0154f	69 d2 95 e9 d1
	5b		 imul	 edx, 1540483477		; 5bd1e995H

; 195  : 	h ^= h >> 15;

  01555	8b c2		 mov	 eax, edx
  01557	c1 e8 0f	 shr	 eax, 15			; 0000000fH
  0155a	33 c2		 xor	 eax, edx
  0155c	5e		 pop	 esi

; 196  : 
; 197  : 	return h;
; 198  : } 

  0155d	c3		 ret	 0
?HashMurmur2@@YAIPBDK@Z ENDP				; HashMurmur2
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashFletcher@@YAIPBDK@Z PROC				; HashFletcher

; 110  : 	const USHORT * data = (const USHORT *)key;

  01560	8b 44 24 04	 mov	 eax, DWORD PTR _key$[esp-4]
  01564	57		 push	 edi

; 111  : 	len /= 2;

  01565	8b 7c 24 0c	 mov	 edi, DWORD PTR _len$[esp]
  01569	d1 ef		 shr	 edi, 1

; 112  : 	UINT32 sum1 = 0xFFFF, sum2 = 0xFFFF;

  0156b	b9 ff ff 00 00	 mov	 ecx, 65535		; 0000ffffH
  01570	8b d1		 mov	 edx, ecx

; 113  : 	while (len) {

  01572	74 46		 je	 SHORT $LN4@HashFletch
  01574	53		 push	 ebx
  01575	56		 push	 esi
  01576	eb 08 8d a4 24
	00 00 00 00 90	 npad	 10
$LL5@HashFletch:

; 114  : 		SIZE_T tlen = len > 360 ? 360 : len;

  01580	be 68 01 00 00	 mov	 esi, 360		; 00000168H
  01585	81 ff 68 01 00
	00		 cmp	 edi, 360		; 00000168H
  0158b	77 02		 ja	 SHORT $LN9@HashFletch
  0158d	8b f7		 mov	 esi, edi
$LN9@HashFletch:

; 115  : 		len -= tlen;

  0158f	2b fe		 sub	 edi, esi
$LL3@HashFletch:

; 116  : 		do {
; 117  : 			sum1 += *data++;

  01591	0f b7 18	 movzx	 ebx, WORD PTR [eax]
  01594	03 cb		 add	 ecx, ebx
  01596	83 c0 02	 add	 eax, 2

; 118  : 			sum2 += sum1;

  01599	03 d1		 add	 edx, ecx

; 119  : 		} while (--tlen);

  0159b	83 ee 01	 sub	 esi, 1
  0159e	75 f1		 jne	 SHORT $LL3@HashFletch

; 120  : 		sum1 = (sum1 & 0xffff) + (sum1 >> 16);

  015a0	8b f1		 mov	 esi, ecx
  015a2	c1 ee 10	 shr	 esi, 16			; 00000010H
  015a5	0f b7 c9	 movzx	 ecx, cx
  015a8	03 ce		 add	 ecx, esi

; 121  : 		sum2 = (sum2 & 0xffff) + (sum2 >> 16);

  015aa	8b f2		 mov	 esi, edx
  015ac	0f b7 d2	 movzx	 edx, dx
  015af	c1 ee 10	 shr	 esi, 16			; 00000010H
  015b2	03 d6		 add	 edx, esi
  015b4	85 ff		 test	 edi, edi
  015b6	75 c8		 jne	 SHORT $LL5@HashFletch
  015b8	5e		 pop	 esi
  015b9	5b		 pop	 ebx
$LN4@HashFletch:
  015ba	8b c2		 mov	 eax, edx

; 122  : 	}
; 123  : 	/* Second reduction step to reduce sums to 16 bits */
; 124  : 	sum1 = (sum1 & 0xffff) + (sum1 >> 16);
; 125  : 	sum2 = (sum2 & 0xffff) + (sum2 >> 16);

  015bc	81 e2 00 00 ff
	ff		 and	 edx, -65536		; ffff0000H
  015c2	c1 e0 10	 shl	 eax, 16			; 00000010H
  015c5	03 c2		 add	 eax, edx
  015c7	8b d1		 mov	 edx, ecx
  015c9	0f b7 c9	 movzx	 ecx, cx
  015cc	c1 ea 10	 shr	 edx, 16			; 00000010H
  015cf	03 d1		 add	 edx, ecx

; 126  : 	return sum2 << 16 | sum1;

  015d1	0b c2		 or	 eax, edx
  015d3	5f		 pop	 edi

; 127  : }

  015d4	c3		 ret	 0
?HashFletcher@@YAIPBDK@Z ENDP				; HashFletcher
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashRamakrishna@@YAIPBDK@Z PROC			; HashRamakrishna

; 100  : 	UINT h = 0;
; 101  : 	for(UINT i = 0; i < len; ++i) {

  015e0	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  015e4	33 c0		 xor	 eax, eax
  015e6	33 c9		 xor	 ecx, ecx
  015e8	85 d2		 test	 edx, edx
  015ea	76 23		 jbe	 SHORT $LN1@HashRamakr
  015ec	53		 push	 ebx
  015ed	56		 push	 esi
  015ee	8b 74 24 0c	 mov	 esi, DWORD PTR _key$[esp+4]
  015f2	57		 push	 edi
$LL3@HashRamakr:

; 102  : 		h ^= (h << 5) + (h >> 2) + key[i];

  015f3	0f be 3c 31	 movsx	 edi, BYTE PTR [ecx+esi]
  015f7	8b d8		 mov	 ebx, eax
  015f9	c1 e3 05	 shl	 ebx, 5
  015fc	03 fb		 add	 edi, ebx
  015fe	8b d8		 mov	 ebx, eax
  01600	c1 eb 02	 shr	 ebx, 2
  01603	03 fb		 add	 edi, ebx
  01605	41		 inc	 ecx
  01606	33 c7		 xor	 eax, edi
  01608	3b ca		 cmp	 ecx, edx
  0160a	72 e7		 jb	 SHORT $LL3@HashRamakr
  0160c	5f		 pop	 edi
  0160d	5e		 pop	 esi
  0160e	5b		 pop	 ebx
$LN1@HashRamakr:

; 103  : 	}
; 104  : 	return h;
; 105  : }

  0160f	c3		 ret	 0
?HashRamakrishna@@YAIPBDK@Z ENDP			; HashRamakrishna
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashWeinberger@@YAIPBDK@Z PROC				; HashWeinberger

; 88   : UINT HashWeinberger(const CHAR *key, SIZE_T len) {

  01610	57		 push	 edi

; 89   : 	UINT h = 0, g;
; 90   : 	for(UINT i = 0; i < len; ++i) {

  01611	8b 7c 24 0c	 mov	 edi, DWORD PTR _len$[esp]
  01615	33 c9		 xor	 ecx, ecx
  01617	33 d2		 xor	 edx, edx
  01619	85 ff		 test	 edi, edi
  0161b	76 28		 jbe	 SHORT $LN2@HashWeinbe
  0161d	53		 push	 ebx
  0161e	56		 push	 esi
  0161f	8b 74 24 10	 mov	 esi, DWORD PTR _key$[esp+8]
$LL4@HashWeinbe:

; 91   : 		h = (h << 4) + key[i];

  01623	0f be 04 32	 movsx	 eax, BYTE PTR [edx+esi]
  01627	c1 e1 04	 shl	 ecx, 4
  0162a	03 c8		 add	 ecx, eax

; 92   : 		if(( g = (h & 0xF0000000) ) != 0)

  0162c	8b c1		 mov	 eax, ecx
  0162e	25 00 00 00 f0	 and	 eax, -268435456		; f0000000H
  01633	74 09		 je	 SHORT $LN3@HashWeinbe

; 93   : 			h ^= g >> 24 ^ g;

  01635	8b d8		 mov	 ebx, eax
  01637	c1 eb 18	 shr	 ebx, 24			; 00000018H
  0163a	33 d8		 xor	 ebx, eax
  0163c	33 cb		 xor	 ecx, ebx
$LN3@HashWeinbe:
  0163e	42		 inc	 edx
  0163f	3b d7		 cmp	 edx, edi
  01641	72 e0		 jb	 SHORT $LL4@HashWeinbe
  01643	5e		 pop	 esi
  01644	5b		 pop	 ebx
$LN2@HashWeinbe:

; 94   : 	}
; 95   : 	return h ^ (h >> 16);

  01645	8b c1		 mov	 eax, ecx
  01647	c1 e8 10	 shr	 eax, 16			; 00000010H
  0164a	33 c1		 xor	 eax, ecx
  0164c	5f		 pop	 edi

; 96   : }

  0164d	c3		 ret	 0
?HashWeinberger@@YAIPBDK@Z ENDP				; HashWeinberger
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashFNV1a@@YAIPBDK@Z PROC				; HashFNV1a

; 81   : 	UINT hash = 2166136261;
; 82   : 	for(UINT i = 0; i < len; ++i)

  01650	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  01654	33 c0		 xor	 eax, eax
  01656	b9 c5 9d 1c 81	 mov	 ecx, -2128831035	; 811c9dc5H
  0165b	85 d2		 test	 edx, edx
  0165d	76 26		 jbe	 SHORT $LN1@HashFNV1a
  0165f	56		 push	 esi
  01660	8b 74 24 08	 mov	 esi, DWORD PTR _key$[esp]
  01664	57		 push	 edi
  01665	eb 09 8d a4 24
	00 00 00 00 8b
	ff		 npad	 11
$LL3@HashFNV1a:

; 83   : 		hash = 16777619 * (hash ^ key[i]);

  01670	0f be 3c 30	 movsx	 edi, BYTE PTR [eax+esi]
  01674	33 f9		 xor	 edi, ecx
  01676	69 ff 93 01 00
	01		 imul	 edi, 16777619		; 01000193H
  0167c	40		 inc	 eax
  0167d	8b cf		 mov	 ecx, edi
  0167f	3b c2		 cmp	 eax, edx
  01681	72 ed		 jb	 SHORT $LL3@HashFNV1a
  01683	5f		 pop	 edi
  01684	5e		 pop	 esi
$LN1@HashFNV1a:

; 84   : 	return hash ^ (hash >> 16);

  01685	8b c1		 mov	 eax, ecx
  01687	c1 e8 10	 shr	 eax, 16			; 00000010H
  0168a	33 c1		 xor	 eax, ecx

; 85   : }

  0168c	c3		 ret	 0
?HashFNV1a@@YAIPBDK@Z ENDP				; HashFNV1a
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?Hash65599@@YAIPBDK@Z PROC				; Hash65599

; 73   : 	UINT hash = 0;
; 74   : 	for(UINT i = 0; i < len; ++i)

  01690	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  01694	33 c9		 xor	 ecx, ecx
  01696	33 c0		 xor	 eax, eax
  01698	85 d2		 test	 edx, edx
  0169a	76 19		 jbe	 SHORT $LN1@Hash65599
  0169c	56		 push	 esi
  0169d	8b 74 24 08	 mov	 esi, DWORD PTR _key$[esp]
  016a1	57		 push	 edi
$LL3@Hash65599:

; 75   : 		hash = 65599 * hash + key[i];

  016a2	0f be 3c 30	 movsx	 edi, BYTE PTR [eax+esi]
  016a6	69 c9 3f 00 01
	00		 imul	 ecx, 65599		; 0001003fH
  016ac	40		 inc	 eax
  016ad	03 cf		 add	 ecx, edi
  016af	3b c2		 cmp	 eax, edx
  016b1	72 ef		 jb	 SHORT $LL3@Hash65599
  016b3	5f		 pop	 edi
  016b4	5e		 pop	 esi
$LN1@Hash65599:

; 76   : 	return hash ^ (hash >> 16);

  016b5	8b c1		 mov	 eax, ecx
  016b7	c1 e8 10	 shr	 eax, 16			; 00000010H
  016ba	33 c1		 xor	 eax, ecx

; 77   : }

  016bc	c3		 ret	 0
?Hash65599@@YAIPBDK@Z ENDP				; Hash65599
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?Hash17_unrolled@@YAIPBDK@Z PROC			; Hash17_unrolled

; 58   : UINT Hash17_unrolled(const CHAR *key, SIZE_T len) {

  016c0	53		 push	 ebx

; 59   : 	UINT hash = 1;
; 60   : 	for(UINT i = 0; i < (len & -2); i += 2) {

  016c1	8b 5c 24 0c	 mov	 ebx, DWORD PTR _len$[esp]
  016c5	8b d3		 mov	 edx, ebx
  016c7	83 e2 fe	 and	 edx, -2			; fffffffeH
  016ca	56		 push	 esi
  016cb	8b 74 24 0c	 mov	 esi, DWORD PTR _key$[esp+4]
  016cf	b9 01 00 00 00	 mov	 ecx, 1
  016d4	76 31		 jbe	 SHORT $LN2@Hash17_unr
  016d6	4a		 dec	 edx
  016d7	d1 ea		 shr	 edx, 1
  016d9	55		 push	 ebp
  016da	8d 46 01	 lea	 eax, DWORD PTR [esi+1]
  016dd	42		 inc	 edx
  016de	57		 push	 edi
  016df	90		 npad	 1
$LL4@Hash17_unr:

; 61   : 		hash = 17 * hash + (key[i] - ' ');
; 62   : 		hash = 17 * hash + (key[i+1] - ' ');

  016e0	0f be 78 ff	 movsx	 edi, BYTE PTR [eax-1]
  016e4	8b e9		 mov	 ebp, ecx
  016e6	c1 e5 04	 shl	 ebp, 4
  016e9	03 e9		 add	 ebp, ecx
  016eb	8d 4c 2f e0	 lea	 ecx, DWORD PTR [edi+ebp-32]
  016ef	8b f9		 mov	 edi, ecx
  016f1	c1 e7 04	 shl	 edi, 4
  016f4	03 f9		 add	 edi, ecx
  016f6	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  016f9	83 c0 02	 add	 eax, 2
  016fc	83 ea 01	 sub	 edx, 1
  016ff	8d 4c 0f e0	 lea	 ecx, DWORD PTR [edi+ecx-32]
  01703	75 db		 jne	 SHORT $LL4@Hash17_unr
  01705	5f		 pop	 edi
  01706	5d		 pop	 ebp
$LN2@Hash17_unr:

; 63   : 	}
; 64   : 	if(len & 1)

  01707	f6 c3 01	 test	 bl, 1
  0170a	74 10		 je	 SHORT $LN1@Hash17_unr

; 65   : 		hash = 17 * hash + (key[len-1] - ' ');

  0170c	0f be 54 1e ff	 movsx	 edx, BYTE PTR [esi+ebx-1]
  01711	8b c1		 mov	 eax, ecx
  01713	c1 e0 04	 shl	 eax, 4
  01716	03 c1		 add	 eax, ecx
  01718	8d 4c 02 e0	 lea	 ecx, DWORD PTR [edx+eax-32]
$LN1@Hash17_unr:

; 66   : 	return hash ^ (hash >> 16);

  0171c	8b c1		 mov	 eax, ecx
  0171e	c1 e8 10	 shr	 eax, 16			; 00000010H
  01721	5e		 pop	 esi
  01722	33 c1		 xor	 eax, ecx
  01724	5b		 pop	 ebx

; 67   : }

  01725	c3		 ret	 0
?Hash17_unrolled@@YAIPBDK@Z ENDP			; Hash17_unrolled
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashKernighanRitchie@@YAIPBDK@Z PROC			; HashKernighanRitchie

; 51   : 	UINT hash = 0;
; 52   : 	for(UINT i = 0; i < len; ++i)

  01730	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  01734	33 c0		 xor	 eax, eax
  01736	33 c9		 xor	 ecx, ecx
  01738	85 d2		 test	 edx, edx
  0173a	76 1e		 jbe	 SHORT $LN1@HashKernig
  0173c	53		 push	 ebx
  0173d	56		 push	 esi
  0173e	8b 74 24 0c	 mov	 esi, DWORD PTR _key$[esp+4]
  01742	57		 push	 edi
$LL3@HashKernig:

; 53   : 		hash = 31 * hash + key[i];

  01743	0f be 3c 31	 movsx	 edi, BYTE PTR [ecx+esi]
  01747	8b d8		 mov	 ebx, eax
  01749	c1 e3 05	 shl	 ebx, 5
  0174c	2b d8		 sub	 ebx, eax
  0174e	03 fb		 add	 edi, ebx
  01750	41		 inc	 ecx
  01751	8b c7		 mov	 eax, edi
  01753	3b ca		 cmp	 ecx, edx
  01755	72 ec		 jb	 SHORT $LL3@HashKernig
  01757	5f		 pop	 edi
  01758	5e		 pop	 esi
  01759	5b		 pop	 ebx
$LN1@HashKernig:

; 54   : 	return hash;
; 55   : }

  0175a	c3		 ret	 0
?HashKernighanRitchie@@YAIPBDK@Z ENDP			; HashKernighanRitchie
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashLarson@@YAIPBDK@Z PROC				; HashLarson

; 43   : 	UINT hash = 0;
; 44   : 	for(UINT i = 0; i < len; ++i)

  01760	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  01764	33 c9		 xor	 ecx, ecx
  01766	33 c0		 xor	 eax, eax
  01768	85 d2		 test	 edx, edx
  0176a	76 16		 jbe	 SHORT $LN1@HashLarson
  0176c	56		 push	 esi
  0176d	8b 74 24 08	 mov	 esi, DWORD PTR _key$[esp]
  01771	57		 push	 edi
$LL3@HashLarson:

; 45   : 		hash = 101 * hash + key[i];

  01772	0f be 3c 30	 movsx	 edi, BYTE PTR [eax+esi]
  01776	6b c9 65	 imul	 ecx, 101		; 00000065H
  01779	40		 inc	 eax
  0177a	03 cf		 add	 ecx, edi
  0177c	3b c2		 cmp	 eax, edx
  0177e	72 f2		 jb	 SHORT $LL3@HashLarson
  01780	5f		 pop	 edi
  01781	5e		 pop	 esi
$LN1@HashLarson:

; 46   : 	return hash ^ (hash >> 16);

  01782	8b c1		 mov	 eax, ecx
  01784	c1 e8 10	 shr	 eax, 16			; 00000010H
  01787	33 c1		 xor	 eax, ecx

; 47   : }

  01789	c3		 ret	 0
?HashLarson@@YAIPBDK@Z ENDP				; HashLarson
; Function compile flags: /Ogtpy
_key$ = 8						; size = 4
_len$ = 12						; size = 4
?HashBernstein@@YAIPBDK@Z PROC				; HashBernstein

; 35   : 	UINT hash = 5381;
; 36   : 	for(UINT i = 0; i < len; ++i)

  01790	8b 54 24 08	 mov	 edx, DWORD PTR _len$[esp-4]
  01794	33 c0		 xor	 eax, eax
  01796	b9 05 15 00 00	 mov	 ecx, 5381		; 00001505H
  0179b	85 d2		 test	 edx, edx
  0179d	76 1e		 jbe	 SHORT $LN1@HashBernst
  0179f	53		 push	 ebx
  017a0	56		 push	 esi
  017a1	8b 74 24 0c	 mov	 esi, DWORD PTR _key$[esp+4]
  017a5	57		 push	 edi
$LL3@HashBernst:

; 37   : 		hash = 33 * hash + key[i];

  017a6	0f be 3c 30	 movsx	 edi, BYTE PTR [eax+esi]
  017aa	8b d9		 mov	 ebx, ecx
  017ac	c1 e3 05	 shl	 ebx, 5
  017af	03 d9		 add	 ebx, ecx
  017b1	03 fb		 add	 edi, ebx
  017b3	40		 inc	 eax
  017b4	8b cf		 mov	 ecx, edi
  017b6	3b c2		 cmp	 eax, edx
  017b8	72 ec		 jb	 SHORT $LL3@HashBernst
  017ba	5f		 pop	 edi
  017bb	5e		 pop	 esi
  017bc	5b		 pop	 ebx
$LN1@HashBernst:

; 38   : 	return hash ^ (hash >> 16);

  017bd	8b c1		 mov	 eax, ecx
  017bf	c1 e8 10	 shr	 eax, 16			; 00000010H
  017c2	33 c1		 xor	 eax, ecx

; 39   : }

  017c4	c3		 ret	 0
?HashBernstein@@YAIPBDK@Z ENDP				; HashBernstein
_TEXT	ENDS
PUBLIC	?TabulateHeader@@YAXXZ				; TabulateHeader
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?TabulateHeader@@YAXXZ PROC				; TabulateHeader

; 1553 : void TabulateHeader(void) {

  017d0	56		 push	 esi
  017d1	57		 push	 edi

; 1554 : 	printf("%20c  ", ' ');

  017d2	6a 20		 push	 32			; 00000020H
  017d4	68 00 00 00 00	 push	 OFFSET $SG-43
  017d9	e8 00 00 00 00	 call	 _printf

; 1555 : 	SIZE_T table_size = g_table_size;

  017de	8b 35 00 00 00
	00		 mov	 esi, DWORD PTR ?g_table_size@@3KA ; g_table_size
  017e4	83 c4 08	 add	 esp, 8
  017e7	bf 08 00 00 00	 mov	 edi, 8
  017ec	8d 64 24 00	 npad	 4
$LL3@TabulateHe:

; 1556 : 	for (UINT k = 0; k < TABULATE_STEPS; k++) {
; 1557 : 		printf(" %8d", NextLog2(table_size));

  017f0	83 fe 01	 cmp	 esi, 1
  017f3	77 04		 ja	 SHORT $LN11@TabulateHe
  017f5	8b c6		 mov	 eax, esi
  017f7	eb 4d		 jmp	 SHORT $LN12@TabulateHe
$LN11@TabulateHe:
  017f9	8d 46 ff	 lea	 eax, DWORD PTR [esi-1]
  017fc	8b c8		 mov	 ecx, eax
  017fe	c1 e9 10	 shr	 ecx, 16			; 00000010H
  01801	33 d2		 xor	 edx, edx
  01803	85 c9		 test	 ecx, ecx
  01805	74 07		 je	 SHORT $LN10@TabulateHe
  01807	ba 10 00 00 00	 mov	 edx, 16			; 00000010H
  0180c	8b c1		 mov	 eax, ecx
$LN10@TabulateHe:
  0180e	8b c8		 mov	 ecx, eax
  01810	c1 e9 08	 shr	 ecx, 8
  01813	85 c9		 test	 ecx, ecx
  01815	74 05		 je	 SHORT $LN9@TabulateHe
  01817	83 c2 08	 add	 edx, 8
  0181a	8b c1		 mov	 eax, ecx
$LN9@TabulateHe:
  0181c	8b c8		 mov	 ecx, eax
  0181e	c1 e9 04	 shr	 ecx, 4
  01821	85 c9		 test	 ecx, ecx
  01823	74 05		 je	 SHORT $LN8@TabulateHe
  01825	83 c2 04	 add	 edx, 4
  01828	8b c1		 mov	 eax, ecx
$LN8@TabulateHe:
  0182a	8b c8		 mov	 ecx, eax
  0182c	c1 e9 02	 shr	 ecx, 2
  0182f	85 c9		 test	 ecx, ecx
  01831	74 05		 je	 SHORT $LN7@TabulateHe
  01833	83 c2 02	 add	 edx, 2
  01836	8b c1		 mov	 eax, ecx
$LN7@TabulateHe:
  01838	a9 fe ff ff ff	 test	 eax, -2			; fffffffeH
  0183d	74 05		 je	 SHORT $LN6@TabulateHe
  0183f	8d 42 02	 lea	 eax, DWORD PTR [edx+2]
  01842	eb 02		 jmp	 SHORT $LN12@TabulateHe
$LN6@TabulateHe:
  01844	03 c2		 add	 eax, edx
$LN12@TabulateHe:
  01846	50		 push	 eax
  01847	68 00 00 00 00	 push	 OFFSET $SG-44
  0184c	e8 00 00 00 00	 call	 _printf
  01851	83 c4 08	 add	 esp, 8

; 1558 : 		table_size /= 2;

  01854	d1 ee		 shr	 esi, 1
  01856	83 ef 01	 sub	 edi, 1
  01859	75 95		 jne	 SHORT $LL3@TabulateHe

; 1559 : 	}
; 1560 : 	printf("\n");

  0185b	68 00 00 00 00	 push	 OFFSET $SG-45
  01860	e8 00 00 00 00	 call	 _printf
  01865	83 c4 04	 add	 esp, 4
  01868	5f		 pop	 edi
  01869	5e		 pop	 esi

; 1561 : }

  0186a	c3		 ret	 0
?TabulateHeader@@YAXXZ ENDP				; TabulateHeader
_TEXT	ENDS
PUBLIC	?BenchmarkHashFunction@@YAXP6AIPBDK@Z0@Z	; BenchmarkHashFunction
EXTRN	__aulldiv:PROC
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv69 = -20						; size = 4
_min_time$ = -16					; size = 8
_start$77656 = -8					; size = 8
_hash_func$ = 8						; size = 4
?BenchmarkHashFunction@@YAXP6AIPBDK@Z0@Z PROC		; BenchmarkHashFunction
; _name$ = eax

; 1502 : void BenchmarkHashFunction( HASH_FUNC hash_func, const CHAR* name ) {

  01870	83 ec 14	 sub	 esp, 20			; 00000014H
  01873	53		 push	 ebx
  01874	55		 push	 ebp
  01875	56		 push	 esi
  01876	57		 push	 edi

; 1503 : 	printf("%20s: ", name);

  01877	50		 push	 eax
  01878	68 00 00 00 00	 push	 OFFSET $SG-15
  0187d	e8 00 00 00 00	 call	 _printf
  01882	83 c4 08	 add	 esp, 8

; 1504 : 	UINT64 min_time = (UINT64)-1;

  01885	83 cd ff	 or	 ebp, -1
  01888	89 6c 24 14	 mov	 DWORD PTR _min_time$[esp+36], ebp
  0188c	c7 44 24 10 05
	00 00 00	 mov	 DWORD PTR tv69[esp+36], 5
$LL10@BenchmarkH:

; 1506 : 		InitHashTable();

  01894	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_table_size@@3KA ; g_table_size
  0189a	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  0189f	8d 14 8d 00 00
	00 00		 lea	 edx, DWORD PTR [ecx*4]
  018a6	52		 push	 edx
  018a7	33 f6		 xor	 esi, esi
  018a9	56		 push	 esi
  018aa	50		 push	 eax
  018ab	89 35 00 00 00
	00		 mov	 DWORD PTR ?g_next_free_chain@@3IA, esi ; g_next_free_chain
  018b1	e8 00 00 00 00	 call	 _memset
  018b6	83 c4 0c	 add	 esp, 12			; 0000000cH

; 1507 : 		UINT64 start = GetRDTSC();

  018b9	33 c0		 xor	 eax, eax
  018bb	0f a2		 cpuid
  018bd	0f 31		 rdtsc
  018bf	8b f8		 mov	 edi, eax

; 1508 : 
; 1509 : 		for(UINT i = 0; i < g_lines_count; ++i)

  018c1	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  018c6	89 54 24 20	 mov	 DWORD PTR _start$77656[esp+40], edx
  018ca	85 c0		 test	 eax, eax
  018cc	76 28		 jbe	 SHORT $LN5@BenchmarkH
  018ce	8b ff		 npad	 2
$LL7@BenchmarkH:
  018d0	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines

; 1510 : 			Lookup(g_lines[i].line, g_lines[i].len, hash_func, TRUE);

  018d5	8b 4c 24 28	 mov	 ecx, DWORD PTR _hash_func$[esp+32]
  018d9	8b 14 f0	 mov	 edx, DWORD PTR [eax+esi*8]
  018dc	8b 5c f0 04	 mov	 ebx, DWORD PTR [eax+esi*8+4]
  018e0	6a 01		 push	 1
  018e2	51		 push	 ecx
  018e3	52		 push	 edx
  018e4	e8 00 00 00 00	 call	 ?Lookup@@YAHPBDKP6AI0K@ZH@Z ; Lookup
  018e9	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  018ee	46		 inc	 esi
  018ef	83 c4 0c	 add	 esp, 12			; 0000000cH
  018f2	3b f0		 cmp	 esi, eax
  018f4	72 da		 jb	 SHORT $LL7@BenchmarkH
$LN5@BenchmarkH:

; 1511 : 		
; 1512 : 		for(UINT i = 0; i < g_lines_count; ++i)

  018f6	33 f6		 xor	 esi, esi
  018f8	85 c0		 test	 eax, eax
  018fa	76 25		 jbe	 SHORT $LN2@BenchmarkH
$LN4@BenchmarkH:
  018fc	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines

; 1513 : 			Lookup(g_lines[i].line, g_lines[i].len, hash_func, FALSE);

  01901	8b 4c 24 28	 mov	 ecx, DWORD PTR _hash_func$[esp+32]
  01905	8b 14 f0	 mov	 edx, DWORD PTR [eax+esi*8]
  01908	8b 5c f0 04	 mov	 ebx, DWORD PTR [eax+esi*8+4]
  0190c	6a 00		 push	 0
  0190e	51		 push	 ecx
  0190f	52		 push	 edx
  01910	e8 00 00 00 00	 call	 ?Lookup@@YAHPBDKP6AI0K@ZH@Z ; Lookup
  01915	46		 inc	 esi
  01916	83 c4 0c	 add	 esp, 12			; 0000000cH
  01919	3b 35 00 00 00
	00		 cmp	 esi, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  0191f	72 db		 jb	 SHORT $LN4@BenchmarkH
$LN2@BenchmarkH:

; 1514 : 
; 1515 : 		UINT64 time = GetRDTSC() - start;

  01921	33 c0		 xor	 eax, eax
  01923	0f a2		 cpuid
  01925	0f 31		 rdtsc
  01927	2b c7		 sub	 eax, edi
  01929	1b 54 24 20	 sbb	 edx, DWORD PTR _start$77656[esp+40]

; 1516 : 		printf("%10I64d", (time + 500) / 1000);

  0192d	6a 00		 push	 0
  0192f	8b f2		 mov	 esi, edx
  01931	8b f8		 mov	 edi, eax
  01933	05 f4 01 00 00	 add	 eax, 500		; 000001f4H
  01938	8b ce		 mov	 ecx, esi
  0193a	68 e8 03 00 00	 push	 1000			; 000003e8H
  0193f	83 d1 00	 adc	 ecx, 0
  01942	51		 push	 ecx
  01943	50		 push	 eax
  01944	e8 00 00 00 00	 call	 __aulldiv
  01949	52		 push	 edx
  0194a	50		 push	 eax
  0194b	68 00 00 00 00	 push	 OFFSET $SG-16
  01950	e8 00 00 00 00	 call	 _printf
  01955	83 c4 0c	 add	 esp, 12			; 0000000cH

; 1517 : 		if(time < min_time)

  01958	3b f5		 cmp	 esi, ebp
  0195a	77 0e		 ja	 SHORT $LN9@BenchmarkH
  0195c	72 06		 jb	 SHORT $LN33@BenchmarkH
  0195e	3b 7c 24 14	 cmp	 edi, DWORD PTR _min_time$[esp+36]
  01962	73 06		 jae	 SHORT $LN9@BenchmarkH
$LN33@BenchmarkH:

; 1518 : 			min_time = time;

  01964	89 7c 24 14	 mov	 DWORD PTR _min_time$[esp+36], edi
  01968	8b ee		 mov	 ebp, esi
$LN9@BenchmarkH:

; 1505 : 	for(UINT k = 0; k < 5; k++) {

  0196a	83 6c 24 10 01	 sub	 DWORD PTR tv69[esp+36], 1
  0196f	0f 85 1f ff ff
	ff		 jne	 $LL10@BenchmarkH

; 1519 : 	}
; 1520 : 	printf("|%10I64d", (min_time + 500) / 1000);

  01975	8b 44 24 14	 mov	 eax, DWORD PTR _min_time$[esp+36]
  01979	6a 00		 push	 0
  0197b	05 f4 01 00 00	 add	 eax, 500		; 000001f4H
  01980	68 e8 03 00 00	 push	 1000			; 000003e8H
  01985	83 d5 00	 adc	 ebp, 0
  01988	55		 push	 ebp
  01989	50		 push	 eax
  0198a	e8 00 00 00 00	 call	 __aulldiv
  0198f	52		 push	 edx
  01990	50		 push	 eax
  01991	68 00 00 00 00	 push	 OFFSET $SG-17
  01996	e8 00 00 00 00	 call	 _printf

; 1521 : 	printf(" [%8d]\n", CountCollisions(g_lines_count));

  0199b	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_table_size@@3KA ; g_table_size
  019a1	83 c4 0c	 add	 esp, 12			; 0000000cH
  019a4	33 d2		 xor	 edx, edx
  019a6	33 c0		 xor	 eax, eax
  019a8	85 c9		 test	 ecx, ecx
  019aa	76 12		 jbe	 SHORT $LN20@BenchmarkH
  019ac	8b 35 00 00 00
	00		 mov	 esi, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
$LL22@BenchmarkH:
  019b2	83 3c 86 00	 cmp	 DWORD PTR [esi+eax*4], 0
  019b6	74 01		 je	 SHORT $LN21@BenchmarkH
  019b8	42		 inc	 edx
$LN21@BenchmarkH:
  019b9	40		 inc	 eax
  019ba	3b c1		 cmp	 eax, ecx
  019bc	72 f4		 jb	 SHORT $LL22@BenchmarkH
$LN20@BenchmarkH:
  019be	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  019c3	2b c2		 sub	 eax, edx
  019c5	50		 push	 eax
  019c6	68 00 00 00 00	 push	 OFFSET $SG-18
  019cb	e8 00 00 00 00	 call	 _printf
  019d0	83 c4 08	 add	 esp, 8

; 1522 : }

  019d3	5f		 pop	 edi
  019d4	5e		 pop	 esi
  019d5	5d		 pop	 ebp
  019d6	5b		 pop	 ebx
  019d7	83 c4 14	 add	 esp, 20			; 00000014H
  019da	c3		 ret	 0
?BenchmarkHashFunction@@YAXP6AIPBDK@Z0@Z ENDP		; BenchmarkHashFunction
_TEXT	ENDS
PUBLIC	__real@3ff0cccccccccccd
PUBLIC	__real@3fee666666666666
PUBLIC	?TabulateQuality@@YAXP6AIPBDK@Z0@Z		; TabulateQuality
;	COMDAT __real@3ff0cccccccccccd
CONST	SEGMENT
__real@3ff0cccccccccccd DQ 03ff0cccccccccccdr	; 1.05
CONST	ENDS
;	COMDAT __real@3fee666666666666
CONST	SEGMENT
__real@3fee666666666666 DQ 03fee666666666666r	; 0.95
; Function compile flags: /Ogtpy
CONST	ENDS
_TEXT	SEGMENT
?TabulateQuality@@YAXP6AIPBDK@Z0@Z PROC			; TabulateQuality
; _hash_func$ = edi
; _name$ = eax

; 1395 : void TabulateQuality( HASH_FUNC hash_func, const CHAR* name ) {

  019e0	53		 push	 ebx
  019e1	56		 push	 esi

; 1396 : 	printf("%20s: ", name);

  019e2	50		 push	 eax
  019e3	68 00 00 00 00	 push	 OFFSET $SG-13
  019e8	e8 00 00 00 00	 call	 _printf

; 1397 : 
; 1398 : 	InitHashTable();

  019ed	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_table_size@@3KA ; g_table_size
  019f3	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  019f8	8d 14 8d 00 00
	00 00		 lea	 edx, DWORD PTR [ecx*4]
  019ff	52		 push	 edx
  01a00	33 f6		 xor	 esi, esi
  01a02	56		 push	 esi
  01a03	50		 push	 eax
  01a04	89 35 00 00 00
	00		 mov	 DWORD PTR ?g_next_free_chain@@3IA, esi ; g_next_free_chain
  01a0a	e8 00 00 00 00	 call	 _memset
  01a0f	83 c4 14	 add	 esp, 20			; 00000014H

; 1399 : 	for(UINT i = 0; i < g_lines_count; ++i)

  01a12	39 35 00 00 00
	00		 cmp	 DWORD PTR ?g_lines_count@@3KA, esi ; g_lines_count
  01a18	76 27		 jbe	 SHORT $LN4@TabulateQu
  01a1a	8d 9b 00 00 00
	00		 npad	 6
$LL6@TabulateQu:
  01a20	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines

; 1400 : 		Lookup(g_lines[i].line, g_lines[i].len, hash_func, TRUE);

  01a25	8b 0c f0	 mov	 ecx, DWORD PTR [eax+esi*8]
  01a28	8b 5c f0 04	 mov	 ebx, DWORD PTR [eax+esi*8+4]
  01a2c	6a 01		 push	 1
  01a2e	57		 push	 edi
  01a2f	51		 push	 ecx
  01a30	e8 00 00 00 00	 call	 ?Lookup@@YAHPBDKP6AI0K@ZH@Z ; Lookup
  01a35	46		 inc	 esi
  01a36	83 c4 0c	 add	 esp, 12			; 0000000cH
  01a39	3b 35 00 00 00
	00		 cmp	 esi, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  01a3f	72 df		 jb	 SHORT $LL6@TabulateQu
$LN4@TabulateQu:

; 1401 : 	double quality = CountQuality(g_lines_count);

  01a41	e8 00 00 00 00	 call	 ?CountQuality@@YANI@Z	; CountQuality

; 1402 : 	char mark = ' ';
; 1403 : 	if (quality < 0.95)

  01a46	dd 05 00 00 00
	00		 fld	 QWORD PTR __real@3fee666666666666
  01a4c	d8 d9		 fcomp	 ST(1)
  01a4e	b1 20		 mov	 cl, 32			; 00000020H
  01a50	df e0		 fnstsw	 ax
  01a52	f6 c4 41	 test	 ah, 65			; 00000041H
  01a55	75 04		 jne	 SHORT $LN3@TabulateQu

; 1404 : 		mark = '+';

  01a57	b1 2b		 mov	 cl, 43			; 0000002bH
  01a59	eb 11		 jmp	 SHORT $LN1@TabulateQu
$LN3@TabulateQu:

; 1405 : 	else if (quality > 1.05)

  01a5b	dd 05 00 00 00
	00		 fld	 QWORD PTR __real@3ff0cccccccccccd
  01a61	d8 d9		 fcomp	 ST(1)
  01a63	df e0		 fnstsw	 ax
  01a65	f6 c4 05	 test	 ah, 5
  01a68	7a 02		 jp	 SHORT $LN1@TabulateQu

; 1406 : 		mark = '!';

  01a6a	b1 21		 mov	 cl, 33			; 00000021H
$LN1@TabulateQu:

; 1407 : 	printf(" %8.3f %c\n", quality, mark);

  01a6c	0f be d1	 movsx	 edx, cl
  01a6f	52		 push	 edx
  01a70	83 ec 08	 sub	 esp, 8
  01a73	dd 1c 24	 fstp	 QWORD PTR [esp]
  01a76	68 00 00 00 00	 push	 OFFSET $SG-14
  01a7b	e8 00 00 00 00	 call	 _printf
  01a80	83 c4 10	 add	 esp, 16			; 00000010H

; 1408 : }

  01a83	5e		 pop	 esi
  01a84	5b		 pop	 ebx
  01a85	c3		 ret	 0
?TabulateQuality@@YAXP6AIPBDK@Z0@Z ENDP			; TabulateQuality
_TEXT	ENDS
PUBLIC	?AllocateHashTable@@YAXXZ			; AllocateHashTable
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?AllocateHashTable@@YAXXZ PROC				; AllocateHashTable

; 1335 : 	g_table = (CHAIN **)malloc(g_table_size * sizeof(CHAIN *));

  01a90	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_table_size@@3KA ; g_table_size
  01a95	8d 0c 85 00 00
	00 00		 lea	 ecx, DWORD PTR [eax*4]
  01a9c	51		 push	 ecx
  01a9d	e8 00 00 00 00	 call	 _malloc
  01aa2	83 c4 04	 add	 esp, 4
  01aa5	a3 00 00 00 00	 mov	 DWORD PTR ?g_table@@3PAPAUCHAIN@@A, eax ; g_table

; 1336 : 	if (!g_table)

  01aaa	85 c0		 test	 eax, eax
  01aac	75 14		 jne	 SHORT $LN2@AllocateHa

; 1337 : 		Die("Not enough memory");

  01aae	68 00 00 00 00	 push	 OFFSET $SG-11
  01ab3	e8 00 00 00 00	 call	 _puts
  01ab8	83 c4 04	 add	 esp, 4
  01abb	6a 01		 push	 1
  01abd	e8 00 00 00 00	 call	 _exit
$LN11@AllocateHa:
$LN2@AllocateHa:

; 1338 : 	g_chains = (CHAIN*)malloc(g_lines_count * sizeof(CHAIN));

  01ac2	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  01ac8	8d 04 d5 00 00
	00 00		 lea	 eax, DWORD PTR [edx*8]
  01acf	50		 push	 eax
  01ad0	e8 00 00 00 00	 call	 _malloc
  01ad5	83 c4 04	 add	 esp, 4
  01ad8	a3 00 00 00 00	 mov	 DWORD PTR ?g_chains@@3PAUCHAIN@@A, eax ; g_chains

; 1339 : 	if (!g_chains)

  01add	85 c0		 test	 eax, eax
  01adf	75 14		 jne	 SHORT $LN1@AllocateHa

; 1340 : 		Die("Not enough memory");

  01ae1	68 00 00 00 00	 push	 OFFSET $SG-12
  01ae6	e8 00 00 00 00	 call	 _puts
  01aeb	83 c4 04	 add	 esp, 4
  01aee	6a 01		 push	 1
  01af0	e8 00 00 00 00	 call	 _exit
$LN12@AllocateHa:
$LN1@AllocateHa:

; 1341 : }

  01af5	c3		 ret	 0
$LN10@AllocateHa:
?AllocateHashTable@@YAXXZ ENDP				; AllocateHashTable
_TEXT	ENDS
PUBLIC	?SetTableSize@@YAXII@Z				; SetTableSize
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_table_bits_factor$ = 8					; size = 4
?SetTableSize@@YAXII@Z PROC				; SetTableSize
; _table_bits$ = ecx

; 1294 : 	if (table_bits == 0)

  01b00	85 c9		 test	 ecx, ecx
  01b02	75 5b		 jne	 SHORT $LN2@SetTableSi

; 1295 : 		table_bits = NextLog2(g_lines_count) + table_bits_factor;

  01b04	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  01b09	83 f8 01	 cmp	 eax, 1
  01b0c	76 4b		 jbe	 SHORT $LN11@SetTableSi
  01b0e	48		 dec	 eax
  01b0f	8b c8		 mov	 ecx, eax
  01b11	c1 e9 10	 shr	 ecx, 16			; 00000010H
  01b14	33 d2		 xor	 edx, edx
  01b16	85 c9		 test	 ecx, ecx
  01b18	74 07		 je	 SHORT $LN9@SetTableSi
  01b1a	ba 10 00 00 00	 mov	 edx, 16			; 00000010H
  01b1f	8b c1		 mov	 eax, ecx
$LN9@SetTableSi:
  01b21	8b c8		 mov	 ecx, eax
  01b23	c1 e9 08	 shr	 ecx, 8
  01b26	85 c9		 test	 ecx, ecx
  01b28	74 05		 je	 SHORT $LN8@SetTableSi
  01b2a	83 c2 08	 add	 edx, 8
  01b2d	8b c1		 mov	 eax, ecx
$LN8@SetTableSi:
  01b2f	8b c8		 mov	 ecx, eax
  01b31	c1 e9 04	 shr	 ecx, 4
  01b34	85 c9		 test	 ecx, ecx
  01b36	74 05		 je	 SHORT $LN7@SetTableSi
  01b38	83 c2 04	 add	 edx, 4
  01b3b	8b c1		 mov	 eax, ecx
$LN7@SetTableSi:
  01b3d	8b c8		 mov	 ecx, eax
  01b3f	c1 e9 02	 shr	 ecx, 2
  01b42	85 c9		 test	 ecx, ecx
  01b44	74 05		 je	 SHORT $LN6@SetTableSi
  01b46	83 c2 02	 add	 edx, 2
  01b49	8b c1		 mov	 eax, ecx
$LN6@SetTableSi:
  01b4b	a9 fe ff ff ff	 test	 eax, -2			; fffffffeH
  01b50	74 05		 je	 SHORT $LN5@SetTableSi
  01b52	8d 42 02	 lea	 eax, DWORD PTR [edx+2]
  01b55	eb 02		 jmp	 SHORT $LN11@SetTableSi
$LN5@SetTableSi:
  01b57	03 c2		 add	 eax, edx
$LN11@SetTableSi:
  01b59	8b 4c 24 04	 mov	 ecx, DWORD PTR _table_bits_factor$[esp-4]
  01b5d	03 c8		 add	 ecx, eax
$LN2@SetTableSi:

; 1296 : 	if (table_bits + sizeof(void *) > sizeof(SIZE_T) * CHAR_BIT)

  01b5f	8d 51 04	 lea	 edx, DWORD PTR [ecx+4]
  01b62	83 fa 20	 cmp	 edx, 32			; 00000020H
  01b65	76 14		 jbe	 SHORT $LN1@SetTableSi

; 1297 : 		Die("table too large (decrease the number of bits or use a 64-bit compiler)");

  01b67	68 00 00 00 00	 push	 OFFSET $SG-10
  01b6c	e8 00 00 00 00	 call	 _puts
  01b71	83 c4 04	 add	 esp, 4
  01b74	6a 01		 push	 1
  01b76	e8 00 00 00 00	 call	 _exit
$LN17@SetTableSi:
$LN1@SetTableSi:

; 1298 : #ifdef USE_PRIME
; 1299 : 	                     // 1  2  4   8  16  32  64  128  256  512  1024  2048  4096  8192
; 1300 : 	UINT closest_prime[] = {2, 2, 5, 11, 17, 37, 67, 131, 257, 521, 1031, 2053, 4099, 8209,
; 1301 : 						    16411, 32771, 65537, 131101, 262147, 524309, 1048583, 2097169,
; 1302 : 							4194319, 8388617, 16777259, 33554467, 67108879,	134217757,
; 1303 : 							268435459, 536870923, 1073741827, 2147483659};
; 1304 : 	g_table_size = closest_prime[ table_bits ];
; 1305 : #else
; 1306 : 	g_table_size = (1 << table_bits);

  01b7b	b8 01 00 00 00	 mov	 eax, 1
  01b80	d3 e0		 shl	 eax, cl
  01b82	a3 00 00 00 00	 mov	 DWORD PTR ?g_table_size@@3KA, eax ; g_table_size

; 1307 : 	g_table_size_mask = g_table_size - 1;

  01b87	48		 dec	 eax
  01b88	a3 00 00 00 00	 mov	 DWORD PTR ?g_table_size_mask@@3KA, eax ; g_table_size_mask

; 1308 : #endif
; 1309 : }

  01b8d	c3		 ret	 0
$LN16@SetTableSi:
?SetTableSize@@YAXII@Z ENDP				; SetTableSize
_TEXT	ENDS
PUBLIC	?ReallocateLines@@YAKK@Z			; ReallocateLines
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
?ReallocateLines@@YAKK@Z PROC				; ReallocateLines
; _allocated_lines$ = eax

; 1233 : 	allocated_lines *= 2;
; 1234 : 	g_lines = (LINE *)realloc(g_lines, allocated_lines * sizeof(LINE));

  01b90	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines
  01b96	56		 push	 esi
  01b97	8b f0		 mov	 esi, eax
  01b99	03 f6		 add	 esi, esi
  01b9b	8d 04 f5 00 00
	00 00		 lea	 eax, DWORD PTR [esi*8]
  01ba2	50		 push	 eax
  01ba3	51		 push	 ecx
  01ba4	e8 00 00 00 00	 call	 _realloc
  01ba9	83 c4 08	 add	 esp, 8
  01bac	a3 00 00 00 00	 mov	 DWORD PTR ?g_lines@@3PAULINE@@A, eax ; g_lines

; 1235 : 	if (!g_lines)

  01bb1	85 c0		 test	 eax, eax
  01bb3	75 14		 jne	 SHORT $LN1@Reallocate

; 1236 : 		Die("Not enough memory");

  01bb5	68 00 00 00 00	 push	 OFFSET $SG-5
  01bba	e8 00 00 00 00	 call	 _puts
  01bbf	83 c4 04	 add	 esp, 4
  01bc2	6a 01		 push	 1
  01bc4	e8 00 00 00 00	 call	 _exit
$LN8@Reallocate:
$LN1@Reallocate:

; 1237 : 	return allocated_lines;

  01bc9	8b c6		 mov	 eax, esi
  01bcb	5e		 pop	 esi

; 1238 : }

  01bcc	c3		 ret	 0
$LN7@Reallocate:
?ReallocateLines@@YAKK@Z ENDP				; ReallocateLines
_TEXT	ENDS
PUBLIC	?TabulateCollisions@@YAXP6AIPBDK@Z0@Z		; TabulateCollisions
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv82 = -8						; size = 4
_original_table_size$ = -4				; size = 4
_hash_func$ = 8						; size = 4
?TabulateCollisions@@YAXP6AIPBDK@Z0@Z PROC		; TabulateCollisions
; _name$ = eax

; 1563 : void TabulateCollisions( HASH_FUNC hash_func, const CHAR* name ) {

  01bd0	83 ec 08	 sub	 esp, 8
  01bd3	53		 push	 ebx
  01bd4	55		 push	 ebp
  01bd5	56		 push	 esi
  01bd6	57		 push	 edi

; 1564 : 	printf("%20s: ", name);

  01bd7	50		 push	 eax
  01bd8	68 00 00 00 00	 push	 OFFSET $SG-46
  01bdd	e8 00 00 00 00	 call	 _printf

; 1565 : 
; 1566 : 	SIZE_T table_size = NextLog2(g_table_size);

  01be2	8b 3d 00 00 00
	00		 mov	 edi, DWORD PTR ?g_table_size@@3KA ; g_table_size
  01be8	83 c4 08	 add	 esp, 8
  01beb	83 ff 01	 cmp	 edi, 1
  01bee	77 10		 ja	 SHORT $LN14@TabulateCo
  01bf0	8b ef		 mov	 ebp, edi

; 1567 : 	SIZE_T original_table_size = table_size;

  01bf2	89 6c 24 14	 mov	 DWORD PTR _original_table_size$[esp+24], ebp
  01bf6	c7 44 24 10 08
	00 00 00	 mov	 DWORD PTR tv82[esp+24], 8
  01bfe	eb 66		 jmp	 SHORT $LN6@TabulateCo

; 1565 : 
; 1566 : 	SIZE_T table_size = NextLog2(g_table_size);

$LN14@TabulateCo:
  01c00	8d 47 ff	 lea	 eax, DWORD PTR [edi-1]
  01c03	8b c8		 mov	 ecx, eax
  01c05	c1 e9 10	 shr	 ecx, 16			; 00000010H
  01c08	33 d2		 xor	 edx, edx
  01c0a	85 c9		 test	 ecx, ecx
  01c0c	74 07		 je	 SHORT $LN13@TabulateCo
  01c0e	ba 10 00 00 00	 mov	 edx, 16			; 00000010H
  01c13	8b c1		 mov	 eax, ecx
$LN13@TabulateCo:
  01c15	8b c8		 mov	 ecx, eax
  01c17	c1 e9 08	 shr	 ecx, 8
  01c1a	85 c9		 test	 ecx, ecx
  01c1c	74 05		 je	 SHORT $LN12@TabulateCo
  01c1e	83 c2 08	 add	 edx, 8
  01c21	8b c1		 mov	 eax, ecx
$LN12@TabulateCo:
  01c23	8b c8		 mov	 ecx, eax
  01c25	c1 e9 04	 shr	 ecx, 4
  01c28	85 c9		 test	 ecx, ecx
  01c2a	74 05		 je	 SHORT $LN11@TabulateCo
  01c2c	83 c2 04	 add	 edx, 4
  01c2f	8b c1		 mov	 eax, ecx
$LN11@TabulateCo:
  01c31	8b c8		 mov	 ecx, eax
  01c33	c1 e9 02	 shr	 ecx, 2
  01c36	85 c9		 test	 ecx, ecx
  01c38	74 05		 je	 SHORT $LN10@TabulateCo
  01c3a	83 c2 02	 add	 edx, 2
  01c3d	8b c1		 mov	 eax, ecx
$LN10@TabulateCo:
  01c3f	8d 6a 02	 lea	 ebp, DWORD PTR [edx+2]
  01c42	a9 fe ff ff ff	 test	 eax, -2			; fffffffeH
  01c47	75 03		 jne	 SHORT $LN15@TabulateCo
  01c49	8d 2c 02	 lea	 ebp, DWORD PTR [edx+eax]
$LN15@TabulateCo:

; 1567 : 	SIZE_T original_table_size = table_size;

  01c4c	89 6c 24 14	 mov	 DWORD PTR _original_table_size$[esp+24], ebp
  01c50	c7 44 24 10 08
	00 00 00	 mov	 DWORD PTR tv82[esp+24], 8
  01c58	eb 0c		 jmp	 SHORT $LN6@TabulateCo
  01c5a	8d 9b 00 00 00
	00		 npad	 6
$LL31@TabulateCo:
  01c60	8b 3d 00 00 00
	00		 mov	 edi, DWORD PTR ?g_table_size@@3KA ; g_table_size
$LN6@TabulateCo:

; 1568 : 	for (UINT k = 0; k < TABULATE_STEPS; k++) {
; 1569 : 		InitHashTable();

  01c66	8b 1d 00 00 00
	00		 mov	 ebx, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  01c6c	8d 0c bd 00 00
	00 00		 lea	 ecx, DWORD PTR [edi*4]
  01c73	51		 push	 ecx
  01c74	33 f6		 xor	 esi, esi
  01c76	56		 push	 esi
  01c77	53		 push	 ebx
  01c78	89 35 00 00 00
	00		 mov	 DWORD PTR ?g_next_free_chain@@3IA, esi ; g_next_free_chain
  01c7e	e8 00 00 00 00	 call	 _memset

; 1570 : 		for(UINT i = 0; i < g_lines_count; ++i)

  01c83	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  01c88	83 c4 0c	 add	 esp, 12			; 0000000cH
  01c8b	85 c0		 test	 eax, eax
  01c8d	76 33		 jbe	 SHORT $LN1@TabulateCo
  01c8f	90		 npad	 1
$LL3@TabulateCo:
  01c90	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines

; 1571 : 			Lookup(g_lines[i].line, g_lines[i].len, hash_func, TRUE);

  01c95	8b 54 24 1c	 mov	 edx, DWORD PTR _hash_func$[esp+20]
  01c99	8b 0c f0	 mov	 ecx, DWORD PTR [eax+esi*8]
  01c9c	8b 5c f0 04	 mov	 ebx, DWORD PTR [eax+esi*8+4]
  01ca0	6a 01		 push	 1
  01ca2	52		 push	 edx
  01ca3	51		 push	 ecx
  01ca4	e8 00 00 00 00	 call	 ?Lookup@@YAHPBDKP6AI0K@ZH@Z ; Lookup
  01ca9	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  01cae	46		 inc	 esi
  01caf	83 c4 0c	 add	 esp, 12			; 0000000cH
  01cb2	3b f0		 cmp	 esi, eax
  01cb4	72 da		 jb	 SHORT $LL3@TabulateCo
  01cb6	8b 3d 00 00 00
	00		 mov	 edi, DWORD PTR ?g_table_size@@3KA ; g_table_size
  01cbc	8b 1d 00 00 00
	00		 mov	 ebx, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
$LN1@TabulateCo:

; 1572 : 		printf(" %8d", CountCollisions(g_lines_count));

  01cc2	33 d2		 xor	 edx, edx
  01cc4	33 c9		 xor	 ecx, ecx
  01cc6	85 ff		 test	 edi, edi
  01cc8	76 12		 jbe	 SHORT $LN20@TabulateCo
  01cca	8d 9b 00 00 00
	00		 npad	 6
$LL22@TabulateCo:
  01cd0	83 3c 8b 00	 cmp	 DWORD PTR [ebx+ecx*4], 0
  01cd4	74 01		 je	 SHORT $LN21@TabulateCo
  01cd6	42		 inc	 edx
$LN21@TabulateCo:
  01cd7	41		 inc	 ecx
  01cd8	3b cf		 cmp	 ecx, edi
  01cda	72 f4		 jb	 SHORT $LL22@TabulateCo
$LN20@TabulateCo:
  01cdc	2b c2		 sub	 eax, edx
  01cde	50		 push	 eax
  01cdf	68 00 00 00 00	 push	 OFFSET $SG-47
  01ce4	e8 00 00 00 00	 call	 _printf

; 1573 : 		SetTableSize(--table_size, 0);

  01ce9	4d		 dec	 ebp
  01cea	6a 00		 push	 0
  01cec	8b cd		 mov	 ecx, ebp
  01cee	e8 00 00 00 00	 call	 ?SetTableSize@@YAXII@Z	; SetTableSize
  01cf3	83 c4 0c	 add	 esp, 12			; 0000000cH
  01cf6	83 6c 24 10 01	 sub	 DWORD PTR tv82[esp+24], 1
  01cfb	0f 85 5f ff ff
	ff		 jne	 $LL31@TabulateCo

; 1574 : 	}
; 1575 : 	printf("\n");

  01d01	68 00 00 00 00	 push	 OFFSET $SG-48
  01d06	e8 00 00 00 00	 call	 _printf

; 1576 : 	SetTableSize(original_table_size, 0);

  01d0b	8b 4c 24 18	 mov	 ecx, DWORD PTR _original_table_size$[esp+28]
  01d0f	83 c4 04	 add	 esp, 4
  01d12	5f		 pop	 edi
  01d13	5e		 pop	 esi
  01d14	5d		 pop	 ebp
  01d15	5b		 pop	 ebx

; 1577 : }

  01d16	83 c4 08	 add	 esp, 8

; 1576 : 	SetTableSize(original_table_size, 0);

  01d19	c7 44 24 04 00
	00 00 00	 mov	 DWORD PTR _hash_func$[esp-4], 0
  01d21	e9 00 00 00 00	 jmp	 ?SetTableSize@@YAXII@Z	; SetTableSize
?TabulateCollisions@@YAXP6AIPBDK@Z0@Z ENDP		; TabulateCollisions
_TEXT	ENDS
PUBLIC	?ReadTxtFile@@YAXPBDH@Z				; ReadTxtFile
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_allocated_lines$ = -32					; size = 4
_file_size$ = -28					; size = 4
_file$ = -24						; size = 4
_ip$77526 = -20						; size = 17
_use_ip$ = 8						; size = 4
?ReadTxtFile@@YAXPBDH@Z PROC				; ReadTxtFile
; _file_name$ = eax

; 1240 : void ReadTxtFile(const char * file_name, BOOL use_ip) {

  01d30	83 ec 20	 sub	 esp, 32			; 00000020H
  01d33	53		 push	 ebx

; 1241 : 	FILE* file = fopen(file_name, "r");

  01d34	68 00 00 00 00	 push	 OFFSET $SG-6
  01d39	50		 push	 eax
  01d3a	e8 00 00 00 00	 call	 _fopen
  01d3f	8b d8		 mov	 ebx, eax
  01d41	83 c4 08	 add	 esp, 8
  01d44	89 5c 24 0c	 mov	 DWORD PTR _file$[esp+36], ebx

; 1242 : 	if(!file)

  01d48	85 db		 test	 ebx, ebx
  01d4a	75 14		 jne	 SHORT $LN14@ReadTxtFil

; 1243 : 		Die("Can't open the file");

  01d4c	68 00 00 00 00	 push	 OFFSET $SG-7
  01d51	e8 00 00 00 00	 call	 _puts
  01d56	83 c4 04	 add	 esp, 4
  01d59	6a 01		 push	 1
  01d5b	e8 00 00 00 00	 call	 _exit
$LN39@ReadTxtFil:
$LN14@ReadTxtFil:
  01d60	56		 push	 esi
  01d61	57		 push	 edi

; 1244 : 
; 1245 : 	// Allocate g_text
; 1246 : 	long file_size = GetTxtFileSize(file);

  01d62	53		 push	 ebx
  01d63	e8 00 00 00 00	 call	 _ftell
  01d68	6a 02		 push	 2
  01d6a	6a 00		 push	 0
  01d6c	53		 push	 ebx
  01d6d	8b f8		 mov	 edi, eax
  01d6f	e8 00 00 00 00	 call	 _fseek
  01d74	83 c4 10	 add	 esp, 16			; 00000010H
  01d77	85 c0		 test	 eax, eax
  01d79	74 04		 je	 SHORT $LN20@ReadTxtFil
  01d7b	33 f6		 xor	 esi, esi
  01d7d	eb 14		 jmp	 SHORT $LN38@ReadTxtFil
$LN20@ReadTxtFil:
  01d7f	53		 push	 ebx
  01d80	e8 00 00 00 00	 call	 _ftell
  01d85	6a 00		 push	 0
  01d87	57		 push	 edi
  01d88	53		 push	 ebx
  01d89	8b f0		 mov	 esi, eax
  01d8b	e8 00 00 00 00	 call	 _fseek
  01d90	83 c4 10	 add	 esp, 16			; 00000010H
$LN38@ReadTxtFil:

; 1247 : 	g_text = (CHAR*)malloc(file_size * sizeof(CHAR));

  01d93	56		 push	 esi
  01d94	89 74 24 14	 mov	 DWORD PTR _file_size$[esp+48], esi
  01d98	e8 00 00 00 00	 call	 _malloc
  01d9d	8b f8		 mov	 edi, eax
  01d9f	83 c4 04	 add	 esp, 4
  01da2	89 3d 00 00 00
	00		 mov	 DWORD PTR ?g_text@@3PADA, edi ; g_text

; 1248 : 	if (!g_text)

  01da8	85 ff		 test	 edi, edi
  01daa	75 14		 jne	 SHORT $LN13@ReadTxtFil

; 1249 : 		Die("Not enough memory");

  01dac	68 00 00 00 00	 push	 OFFSET $SG-8
  01db1	e8 00 00 00 00	 call	 _puts
  01db6	83 c4 04	 add	 esp, 4
  01db9	6a 01		 push	 1
  01dbb	e8 00 00 00 00	 call	 _exit
$LN40@ReadTxtFil:
$LN13@ReadTxtFil:

; 1250 : 
; 1251 : 	// Allocate g_lines
; 1252 : 	SIZE_T allocated_lines = file_size / 16; // First approximation

  01dc0	8b c6		 mov	 eax, esi
  01dc2	99		 cdq
  01dc3	83 e2 0f	 and	 edx, 15			; 0000000fH
  01dc6	03 c2		 add	 eax, edx
  01dc8	c1 f8 04	 sar	 eax, 4

; 1253 : 	g_lines = (LINE *)malloc(allocated_lines * sizeof(LINE));

  01dcb	8d 0c c5 00 00
	00 00		 lea	 ecx, DWORD PTR [eax*8]
  01dd2	51		 push	 ecx
  01dd3	89 44 24 10	 mov	 DWORD PTR _allocated_lines$[esp+48], eax
  01dd7	e8 00 00 00 00	 call	 _malloc
  01ddc	83 c4 04	 add	 esp, 4
  01ddf	a3 00 00 00 00	 mov	 DWORD PTR ?g_lines@@3PAULINE@@A, eax ; g_lines

; 1254 : 	if (!g_lines)

  01de4	85 c0		 test	 eax, eax
  01de6	75 14		 jne	 SHORT $LN12@ReadTxtFil

; 1255 : 		Die("Not enough memory");

  01de8	68 00 00 00 00	 push	 OFFSET $SG-9
  01ded	e8 00 00 00 00	 call	 _puts
  01df2	83 c4 04	 add	 esp, 4
  01df5	6a 01		 push	 1
  01df7	e8 00 00 00 00	 call	 _exit
$LN41@ReadTxtFil:
$LN12@ReadTxtFil:
  01dfc	55		 push	 ebp

; 1256 : 
; 1257 : 	SIZE_T i = 0;

  01dfd	33 ed		 xor	 ebp, ebp

; 1258 : 
; 1259 : 	// Read the file line-by-line into g_text buffer
; 1260 : 	if(use_ip) {
; 1261 : 		CHAR ip[17];
; 1262 : 		ULONG * ips = (ULONG *)g_text;

  01dff	8b f7		 mov	 esi, edi

; 1263 : 		while( fgets(ip, NUM_OF(ip), file) ) {

  01e01	53		 push	 ebx
  01e02	39 6c 24 38	 cmp	 DWORD PTR _use_ip$[esp+48], ebp
  01e06	74 6e		 je	 SHORT $LN11@ReadTxtFil
  01e08	8d 54 24 20	 lea	 edx, DWORD PTR _ip$77526[esp+52]
  01e0c	6a 11		 push	 17			; 00000011H
  01e0e	52		 push	 edx
  01e0f	e8 00 00 00 00	 call	 _fgets
  01e14	83 c4 0c	 add	 esp, 12			; 0000000cH
  01e17	85 c0		 test	 eax, eax
  01e19	0f 84 cc 00 00
	00		 je	 $LN4@ReadTxtFil
  01e1f	8b 3d 00 00 00
	00		 mov	 edi, DWORD PTR __imp__inet_addr@4
  01e25	8d 5d 04	 lea	 ebx, DWORD PTR [ebp+4]
$LL10@ReadTxtFil:

; 1264 : 			if('\0' == *ip)

  01e28	80 7c 24 1c 00	 cmp	 BYTE PTR _ip$77526[esp+48], 0
  01e2d	74 29		 je	 SHORT $LN31@ReadTxtFil

; 1265 : 				continue;
; 1266 : 			if (i >= allocated_lines)

  01e2f	8b 44 24 10	 mov	 eax, DWORD PTR _allocated_lines$[esp+48]
  01e33	3b e8		 cmp	 ebp, eax
  01e35	72 09		 jb	 SHORT $LN7@ReadTxtFil

; 1267 : 				allocated_lines = ReallocateLines(allocated_lines);

  01e37	e8 00 00 00 00	 call	 ?ReallocateLines@@YAKK@Z ; ReallocateLines
  01e3c	89 44 24 10	 mov	 DWORD PTR _allocated_lines$[esp+48], eax
$LN7@ReadTxtFil:
  01e40	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines

; 1268 : 			g_lines[i].line = (CHAR *)ips;

  01e45	89 34 e8	 mov	 DWORD PTR [eax+ebp*8], esi

; 1269 : 			g_lines[i++].len = sizeof(ULONG);

  01e48	89 5c e8 04	 mov	 DWORD PTR [eax+ebp*8+4], ebx

; 1270 : 			*ips++ = inet_addr(ip);

  01e4c	8d 44 24 1c	 lea	 eax, DWORD PTR _ip$77526[esp+48]
  01e50	50		 push	 eax
  01e51	45		 inc	 ebp
  01e52	ff d7		 call	 edi
  01e54	89 06		 mov	 DWORD PTR [esi], eax
  01e56	03 f3		 add	 esi, ebx
$LN31@ReadTxtFil:
  01e58	8b 4c 24 18	 mov	 ecx, DWORD PTR _file$[esp+48]
  01e5c	51		 push	 ecx
  01e5d	8d 54 24 20	 lea	 edx, DWORD PTR _ip$77526[esp+52]
  01e61	6a 11		 push	 17			; 00000011H
  01e63	52		 push	 edx
  01e64	e8 00 00 00 00	 call	 _fgets
  01e69	83 c4 0c	 add	 esp, 12			; 0000000cH
  01e6c	85 c0		 test	 eax, eax
  01e6e	75 b8		 jne	 SHORT $LL10@ReadTxtFil

; 1271 : 		}
; 1272 : 	} else {

  01e70	8b 5c 24 18	 mov	 ebx, DWORD PTR _file$[esp+48]
  01e74	eb 75		 jmp	 SHORT $LN4@ReadTxtFil
$LN11@ReadTxtFil:

; 1273 : 		CHAR* text = g_text;
; 1274 : 		while( fgets(text, (UINT)(g_text + file_size - text), file) ) {

  01e76	2b fe		 sub	 edi, esi
  01e78	03 7c 24 18	 add	 edi, DWORD PTR _file_size$[esp+52]
  01e7c	57		 push	 edi
  01e7d	56		 push	 esi
  01e7e	e8 00 00 00 00	 call	 _fgets
  01e83	83 c4 0c	 add	 esp, 12			; 0000000cH
  01e86	85 c0		 test	 eax, eax
  01e88	74 61		 je	 SHORT $LN4@ReadTxtFil
  01e8a	8d 9b 00 00 00
	00		 npad	 6
$LL5@ReadTxtFil:

; 1275 : 			SIZE_T len = strlen(text);

  01e90	8b c6		 mov	 eax, esi
  01e92	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL33@ReadTxtFil:
  01e95	8a 08		 mov	 cl, BYTE PTR [eax]
  01e97	40		 inc	 eax
  01e98	84 c9		 test	 cl, cl
  01e9a	75 f9		 jne	 SHORT $LL33@ReadTxtFil
  01e9c	2b c2		 sub	 eax, edx
  01e9e	8b f8		 mov	 edi, eax

; 1276 : 			if(text[len-1] == '\n')

  01ea0	80 7c 37 ff 0a	 cmp	 BYTE PTR [edi+esi-1], 10 ; 0000000aH
  01ea5	75 04		 jne	 SHORT $LN34@ReadTxtFil

; 1277 : 				text[--len] = '\0';

  01ea7	4f		 dec	 edi
  01ea8	88 0c 37	 mov	 BYTE PTR [edi+esi], cl
$LN34@ReadTxtFil:

; 1278 : 			if(0 == len)

  01eab	85 ff		 test	 edi, edi
  01ead	74 22		 je	 SHORT $LN32@ReadTxtFil

; 1279 : 				continue;
; 1280 : 			if (i >= allocated_lines)

  01eaf	8b 44 24 10	 mov	 eax, DWORD PTR _allocated_lines$[esp+48]
  01eb3	3b e8		 cmp	 ebp, eax
  01eb5	72 09		 jb	 SHORT $LN1@ReadTxtFil

; 1281 : 				allocated_lines = ReallocateLines(allocated_lines);

  01eb7	e8 00 00 00 00	 call	 ?ReallocateLines@@YAKK@Z ; ReallocateLines
  01ebc	89 44 24 10	 mov	 DWORD PTR _allocated_lines$[esp+48], eax
$LN1@ReadTxtFil:
  01ec0	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines

; 1282 : 			g_lines[i].line = text;

  01ec5	89 34 e8	 mov	 DWORD PTR [eax+ebp*8], esi

; 1283 : 			g_lines[i++].len = len;

  01ec8	89 7c e8 04	 mov	 DWORD PTR [eax+ebp*8+4], edi
  01ecc	45		 inc	 ebp

; 1284 : 			text += len + 1;

  01ecd	8d 74 37 01	 lea	 esi, DWORD PTR [edi+esi+1]
$LN32@ReadTxtFil:
  01ed1	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_text@@3PADA ; g_text
  01ed6	2b c6		 sub	 eax, esi
  01ed8	03 44 24 14	 add	 eax, DWORD PTR _file_size$[esp+48]
  01edc	53		 push	 ebx
  01edd	50		 push	 eax
  01ede	56		 push	 esi
  01edf	e8 00 00 00 00	 call	 _fgets
  01ee4	83 c4 0c	 add	 esp, 12			; 0000000cH
  01ee7	85 c0		 test	 eax, eax
  01ee9	75 a5		 jne	 SHORT $LL5@ReadTxtFil
$LN4@ReadTxtFil:

; 1285 : 		}
; 1286 : 	}
; 1287 : 	fclose(file);

  01eeb	53		 push	 ebx
  01eec	e8 00 00 00 00	 call	 _fclose
  01ef1	83 c4 04	 add	 esp, 4

; 1288 : 	g_lines_count = i;

  01ef4	89 2d 00 00 00
	00		 mov	 DWORD PTR ?g_lines_count@@3KA, ebp ; g_lines_count
  01efa	5d		 pop	 ebp
  01efb	5f		 pop	 edi
  01efc	5e		 pop	 esi
  01efd	5b		 pop	 ebx

; 1289 : }

  01efe	83 c4 20	 add	 esp, 32			; 00000020H
  01f01	c3		 ret	 0
$LN37@ReadTxtFil:
?ReadTxtFile@@YAXPBDH@Z ENDP				; ReadTxtFile
_TEXT	ENDS
PUBLIC	_main
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_file_name$ = -36					; size = 4
_is_ip$ = -32						; size = 4
_is_collisions$ = -28					; size = 4
_table_bits$ = -24					; size = 4
_is_quality$ = -20					; size = 4
_a$77829 = -16						; size = 16
_argc$ = 8						; size = 4
_argv$ = 12						; size = 4
_main	PROC

; 1581 : int __cdecl main(int argc, char* argv[]) {

  01f10	55		 push	 ebp
  01f11	8b ec		 mov	 ebp, esp
  01f13	83 e4 f8	 and	 esp, -8			; fffffff8H
  01f16	83 ec 24	 sub	 esp, 36			; 00000024H
  01f19	53		 push	 ebx
  01f1a	56		 push	 esi
  01f1b	57		 push	 edi

; 1582 : #if _MSC_VER
; 1583 : 	_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) |
; 1584 : 		_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_DELAY_FREE_MEM_DF);
; 1585 : #endif
; 1586 : 
; 1587 : 	CRC32Init();

  01f1c	e8 00 00 00 00	 call	 ?CRC32Init@@YAXXZ	; CRC32Init

; 1588 : 
; 1589 : 	static const HASH_FUNC func[] = { FNV1A_Hash_Jesteress, FNV1A_Hash_Jester, FNV1A_Hash_Smaragd, FNV1A_Hash_Peregrine, FNV1A_Hash_WHIZ, HashFNV1A_Nefertiti, HashFNV1a,
; 1590 : 		Hash_Sixtinsensitive_Boosted, Hash_Sixtinsensitive,
; 1591 : 		HashAlfalfa_Rollick, HashAlfalfa, HashAlfalfa_HALF, HashAlfalfa_DWORD, HashAlfalfa_QWORD, 
; 1592 : 		HashBernstein, HashKernighanRitchie,
; 1593 : 		Hash17_unrolled, Hash65599, HashUniversal,
; 1594 : 		HashWeinberger, HashLarson,
; 1595 : 		HashPaulHsieh, HashOneAtTime, HashLookup3, HashArashPartow,
; 1596 : 		CRC32, HashRamakrishna, HashFletcher, HashMurmur2, HashHanson,
; 1597 : 		NovakHashUnrolled, HashSBox, HashMaPrime2c,
; 1598 : #ifdef _WIN64
; 1599 : 		HashFNV1A_unrolled8,
; 1600 : #endif
; 1601 : 	};
; 1602 : 	static const CHAR* name[] = { "FNV1A_Jesteress", "FNV1A_Jester", "FNV1A_Smaragd", "FNV1A_Peregrine", "FNV1A_Whiz", "FNV1A_Nefertiti", "FNV-1a", 
; 1603 : 		"Sixtinsensitive+", "Sixtinsensitive",
; 1604 : 		"Alfalfa_Rollick", "Alfalfa", "Alfalfa_HALF", "Alfalfa_DWORD", "Alfalfa_QWORD", 
; 1605 : 		"Bernstein", "K&R",
; 1606 : 		"x17 unrolled", "x65599", "Sedgewick",
; 1607 : 		"Weinberger", "Paul Larson",
; 1608 : 		"Paul Hsieh", "One At Time", "lookup3", "Arash Partow",
; 1609 : 		"CRC-32", "Ramakrishna", "Fletcher", "Murmur2", "Hanson",
; 1610 : 		"Novak unrolled", "SBox", "MaPrime2c",
; 1611 : #ifdef _WIN64
; 1612 : 		"FNV1A_unrolled8",
; 1613 : #endif
; 1614 : 	};
; 1615 : 	assert(NUM_OF(name) == NUM_OF(func));
; 1616 : 
; 1617 : 
; 1618 : #ifdef _DEBUG
; 1619 : 	// Check value from the guide by Ross N. Williams (http://www.ross.net/crc/download/crc_v3.txt)
; 1620 : 	assert( CRC32("123456789", 9) == 0xcbf43926 );
; 1621 : 	// And other values:
; 1622 : 	assert( CRC32("1234567890", 10) == 0x261daee5 );
; 1623 : 	assert( CRC32("1234567890A", 11) == 0x39f95d2 );
; 1624 : 
; 1625 : 	// Check value from http://www.pdl.cmu.edu/mailinglists/ips/mail/msg05931.html
; 1626 : 	CHAR crc_test_vector[32];
; 1627 : 	memset(crc_test_vector, 0xFF, sizeof(crc_test_vector));
; 1628 : 	UINT crc = CRC32Accelerated(crc_test_vector, sizeof(crc_test_vector));
; 1629 : 	assert( _byteswap_ulong(~crc) == 0x43aba862 );
; 1630 : #endif
; 1631 : 
; 1632 : 	BOOL is_ip = FALSE, is_collisions = FALSE, is_quality = FALSE;

  01f21	33 c9		 xor	 ecx, ecx

; 1633 : 	const char * file_name = NULL;
; 1634 : 	UINT table_bits = 0;
; 1635 : 
; 1636 : 	for (int i = 1; i < argc; i++) {

  01f23	bb 01 00 00 00	 mov	 ebx, 1
  01f28	39 5d 08	 cmp	 DWORD PTR _argc$[ebp], ebx
  01f2b	89 4c 24 10	 mov	 DWORD PTR _is_ip$[esp+48], ecx
  01f2f	89 4c 24 14	 mov	 DWORD PTR _is_collisions$[esp+48], ecx
  01f33	89 4c 24 1c	 mov	 DWORD PTR _is_quality$[esp+48], ecx
  01f37	89 4c 24 0c	 mov	 DWORD PTR _file_name$[esp+48], ecx
  01f3b	89 4c 24 18	 mov	 DWORD PTR _table_bits$[esp+48], ecx
  01f3f	0f 8e 05 01 00
	00		 jle	 $LN68@main
  01f45	eb 02		 jmp	 SHORT $LN28@main
$LL81@main:
  01f47	33 c9		 xor	 ecx, ecx
$LN28@main:

; 1637 : 		if (argv[i][0] != '-' && argv[i][0] != '/') {

  01f49	8b 45 0c	 mov	 eax, DWORD PTR _argv$[ebp]
  01f4c	8b 3c 98	 mov	 edi, DWORD PTR [eax+ebx*4]
  01f4f	8a 07		 mov	 al, BYTE PTR [edi]
  01f51	3c 2d		 cmp	 al, 45			; 0000002dH
  01f53	74 17		 je	 SHORT $LN25@main
  01f55	3c 2f		 cmp	 al, 47			; 0000002fH
  01f57	74 13		 je	 SHORT $LN25@main

; 1638 : 			if (file_name != NULL)

  01f59	39 4c 24 0c	 cmp	 DWORD PTR _file_name$[esp+48], ecx
  01f5d	0f 85 fb 00 00
	00		 jne	 $LN63@main

; 1640 : 			file_name = argv[i];

  01f63	89 7c 24 0c	 mov	 DWORD PTR _file_name$[esp+48], edi

; 1641 : 			continue;

  01f67	e9 cc 00 00 00	 jmp	 $LN27@main
$LN25@main:

; 1642 : 		}
; 1643 : 		if (strcmp(argv[i] + 1, "ip") == 0)

  01f6c	8d 77 01	 lea	 esi, DWORD PTR [edi+1]
  01f6f	b9 00 00 00 00	 mov	 ecx, OFFSET $SG-83
  01f74	8b c6		 mov	 eax, esi
$LL69@main:
  01f76	8a 10		 mov	 dl, BYTE PTR [eax]
  01f78	3a 11		 cmp	 dl, BYTE PTR [ecx]
  01f7a	75 1a		 jne	 SHORT $LN70@main
  01f7c	84 d2		 test	 dl, dl
  01f7e	74 12		 je	 SHORT $LN71@main
  01f80	8a 50 01	 mov	 dl, BYTE PTR [eax+1]
  01f83	3a 51 01	 cmp	 dl, BYTE PTR [ecx+1]
  01f86	75 0e		 jne	 SHORT $LN70@main
  01f88	83 c0 02	 add	 eax, 2
  01f8b	83 c1 02	 add	 ecx, 2
  01f8e	84 d2		 test	 dl, dl
  01f90	75 e4		 jne	 SHORT $LL69@main
$LN71@main:
  01f92	33 c0		 xor	 eax, eax
  01f94	eb 05		 jmp	 SHORT $LN72@main
$LN70@main:
  01f96	1b c0		 sbb	 eax, eax
  01f98	83 d8 ff	 sbb	 eax, -1
$LN72@main:
  01f9b	85 c0		 test	 eax, eax
  01f9d	75 0d		 jne	 SHORT $LN23@main

; 1644 : 			is_ip = TRUE;

  01f9f	c7 44 24 10 01
	00 00 00	 mov	 DWORD PTR _is_ip$[esp+48], 1
  01fa7	e9 8c 00 00 00	 jmp	 $LN27@main
$LN23@main:

; 1645 : 		else if (strcmp(argv[i] + 1, "c") == 0)

  01fac	b9 00 00 00 00	 mov	 ecx, OFFSET $SG-84
  01fb1	8b c6		 mov	 eax, esi
$LL73@main:
  01fb3	8a 10		 mov	 dl, BYTE PTR [eax]
  01fb5	3a 11		 cmp	 dl, BYTE PTR [ecx]
  01fb7	75 1a		 jne	 SHORT $LN74@main
  01fb9	84 d2		 test	 dl, dl
  01fbb	74 12		 je	 SHORT $LN75@main
  01fbd	8a 50 01	 mov	 dl, BYTE PTR [eax+1]
  01fc0	3a 51 01	 cmp	 dl, BYTE PTR [ecx+1]
  01fc3	75 0e		 jne	 SHORT $LN74@main
  01fc5	83 c0 02	 add	 eax, 2
  01fc8	83 c1 02	 add	 ecx, 2
  01fcb	84 d2		 test	 dl, dl
  01fcd	75 e4		 jne	 SHORT $LL73@main
$LN75@main:
  01fcf	33 c0		 xor	 eax, eax
  01fd1	eb 05		 jmp	 SHORT $LN76@main
$LN74@main:
  01fd3	1b c0		 sbb	 eax, eax
  01fd5	83 d8 ff	 sbb	 eax, -1
$LN76@main:
  01fd8	85 c0		 test	 eax, eax
  01fda	75 0a		 jne	 SHORT $LN21@main

; 1646 : 			is_collisions = TRUE;

  01fdc	c7 44 24 14 01
	00 00 00	 mov	 DWORD PTR _is_collisions$[esp+48], 1
  01fe4	eb 52		 jmp	 SHORT $LN27@main
$LN21@main:

; 1647 : 		else if (strcmp(argv[i] + 1, "q") == 0)

  01fe6	b9 00 00 00 00	 mov	 ecx, OFFSET $SG-85
  01feb	8b c6		 mov	 eax, esi
  01fed	8d 49 00	 npad	 3
$LL77@main:
  01ff0	8a 10		 mov	 dl, BYTE PTR [eax]
  01ff2	3a 11		 cmp	 dl, BYTE PTR [ecx]
  01ff4	75 1a		 jne	 SHORT $LN78@main
  01ff6	84 d2		 test	 dl, dl
  01ff8	74 12		 je	 SHORT $LN79@main
  01ffa	8a 50 01	 mov	 dl, BYTE PTR [eax+1]
  01ffd	3a 51 01	 cmp	 dl, BYTE PTR [ecx+1]
  02000	75 0e		 jne	 SHORT $LN78@main
  02002	83 c0 02	 add	 eax, 2
  02005	83 c1 02	 add	 ecx, 2
  02008	84 d2		 test	 dl, dl
  0200a	75 e4		 jne	 SHORT $LL77@main
$LN79@main:
  0200c	33 c0		 xor	 eax, eax
  0200e	eb 05		 jmp	 SHORT $LN80@main
$LN78@main:
  02010	1b c0		 sbb	 eax, eax
  02012	83 d8 ff	 sbb	 eax, -1
$LN80@main:
  02015	85 c0		 test	 eax, eax
  02017	75 0a		 jne	 SHORT $LN19@main

; 1648 : 			is_quality = TRUE;

  02019	c7 44 24 1c 01
	00 00 00	 mov	 DWORD PTR _is_quality$[esp+48], 1
  02021	eb 15		 jmp	 SHORT $LN27@main
$LN19@main:

; 1649 : 		else if ('s' == argv[i][1])

  02023	80 3e 73	 cmp	 BYTE PTR [esi], 115	; 00000073H
  02026	75 4a		 jne	 SHORT $LN17@main

; 1650 : 			table_bits = atoi(argv[i] + 2);

  02028	83 c7 02	 add	 edi, 2
  0202b	57		 push	 edi
  0202c	e8 00 00 00 00	 call	 _atoi
  02031	83 c4 04	 add	 esp, 4
  02034	89 44 24 18	 mov	 DWORD PTR _table_bits$[esp+48], eax
$LN27@main:
  02038	43		 inc	 ebx
  02039	3b 5d 08	 cmp	 ebx, DWORD PTR _argc$[ebp]
  0203c	0f 8c 05 ff ff
	ff		 jl	 $LL81@main

; 1653 : 	}
; 1654 : 	
; 1655 : 	if (NULL == file_name)

  02042	8b 44 24 0c	 mov	 eax, DWORD PTR _file_name$[esp+48]
  02046	85 c0		 test	 eax, eax
  02048	75 3c		 jne	 SHORT $LN15@main
$LN68@main:

; 1656 : 		Die("Usage: hash TEXT-FILE [/sBITS] [/ip] [/c]\n"
; 1657 : 			"  /s   The number of bits, e.g. /s16 for a 65536-element table. \n"
; 1658 : 			"       If not given, a default value is used\n"
; 1659 : 			"  /ip  Read IPv4 addresses\n"
; 1660 : 			"  /c   Tabulate collisions\n"
; 1661 : 			"  /q   Hash function quality\n");

  0204a	68 00 00 00 00	 push	 OFFSET $SG-87
  0204f	e8 00 00 00 00	 call	 _puts
  02054	83 c4 04	 add	 esp, 4
  02057	6a 01		 push	 1
  02059	e8 00 00 00 00	 call	 _exit
$LN83@main:
$LN63@main:

; 1639 : 				Die("More than one file name on command line");

  0205e	68 00 00 00 00	 push	 OFFSET $SG-82
  02063	e8 00 00 00 00	 call	 _puts
  02068	83 c4 04	 add	 esp, 4
  0206b	6a 01		 push	 1
  0206d	e8 00 00 00 00	 call	 _exit
$LN84@main:
$LN17@main:

; 1651 : 		else
; 1652 : 			Die("Invalid command-line switch");

  02072	68 00 00 00 00	 push	 OFFSET $SG-86
  02077	e8 00 00 00 00	 call	 _puts
  0207c	83 c4 04	 add	 esp, 4
  0207f	6a 01		 push	 1
  02081	e8 00 00 00 00	 call	 _exit
$LN85@main:
$LN15@main:

; 1662 : 
; 1663 : 	ReadTxtFile(file_name, is_ip);

  02086	8b 4c 24 10	 mov	 ecx, DWORD PTR _is_ip$[esp+48]
  0208a	51		 push	 ecx
  0208b	e8 00 00 00 00	 call	 ?ReadTxtFile@@YAXPBDH@Z	; ReadTxtFile

; 1664 : 	SetTableSize(table_bits, is_collisions ? 4 : 1);

  02090	8b 7c 24 18	 mov	 edi, DWORD PTR _is_collisions$[esp+52]
  02094	8b 4c 24 1c	 mov	 ecx, DWORD PTR _table_bits$[esp+52]
  02098	83 c4 04	 add	 esp, 4
  0209b	8b d7		 mov	 edx, edi
  0209d	f7 da		 neg	 edx
  0209f	1b d2		 sbb	 edx, edx
  020a1	83 e2 03	 and	 edx, 3
  020a4	42		 inc	 edx
  020a5	52		 push	 edx
  020a6	e8 00 00 00 00	 call	 ?SetTableSize@@YAXII@Z	; SetTableSize

; 1665 : 	printf("%d lines read\n"  "%d elements in the table (%d bits)\n",
; 1666 : 		g_lines_count, g_table_size, NextLog2(g_table_size));

  020ab	8b 35 00 00 00
	00		 mov	 esi, DWORD PTR ?g_table_size@@3KA ; g_table_size
  020b1	83 c4 04	 add	 esp, 4
  020b4	83 fe 01	 cmp	 esi, 1
  020b7	77 04		 ja	 SHORT $LN43@main
  020b9	8b c6		 mov	 eax, esi
  020bb	eb 4d		 jmp	 SHORT $LN44@main
$LN43@main:
  020bd	8d 46 ff	 lea	 eax, DWORD PTR [esi-1]
  020c0	8b c8		 mov	 ecx, eax
  020c2	c1 e9 10	 shr	 ecx, 16			; 00000010H
  020c5	33 d2		 xor	 edx, edx
  020c7	85 c9		 test	 ecx, ecx
  020c9	74 07		 je	 SHORT $LN42@main
  020cb	ba 10 00 00 00	 mov	 edx, 16			; 00000010H
  020d0	8b c1		 mov	 eax, ecx
$LN42@main:
  020d2	8b c8		 mov	 ecx, eax
  020d4	c1 e9 08	 shr	 ecx, 8
  020d7	85 c9		 test	 ecx, ecx
  020d9	74 05		 je	 SHORT $LN41@main
  020db	83 c2 08	 add	 edx, 8
  020de	8b c1		 mov	 eax, ecx
$LN41@main:
  020e0	8b c8		 mov	 ecx, eax
  020e2	c1 e9 04	 shr	 ecx, 4
  020e5	85 c9		 test	 ecx, ecx
  020e7	74 05		 je	 SHORT $LN40@main
  020e9	83 c2 04	 add	 edx, 4
  020ec	8b c1		 mov	 eax, ecx
$LN40@main:
  020ee	8b c8		 mov	 ecx, eax
  020f0	c1 e9 02	 shr	 ecx, 2
  020f3	85 c9		 test	 ecx, ecx
  020f5	74 05		 je	 SHORT $LN39@main
  020f7	83 c2 02	 add	 edx, 2
  020fa	8b c1		 mov	 eax, ecx
$LN39@main:
  020fc	a9 fe ff ff ff	 test	 eax, -2			; fffffffeH
  02101	74 05		 je	 SHORT $LN38@main
  02103	8d 42 02	 lea	 eax, DWORD PTR [edx+2]
  02106	eb 02		 jmp	 SHORT $LN44@main
$LN38@main:
  02108	03 c2		 add	 eax, edx
$LN44@main:
  0210a	50		 push	 eax
  0210b	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  02110	56		 push	 esi
  02111	50		 push	 eax
  02112	68 00 00 00 00	 push	 OFFSET $SG-88
  02117	e8 00 00 00 00	 call	 _printf

; 1667 : 	AllocateHashTable();

  0211c	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_table_size@@3KA ; g_table_size
  02122	8d 14 8d 00 00
	00 00		 lea	 edx, DWORD PTR [ecx*4]
  02129	52		 push	 edx
  0212a	e8 00 00 00 00	 call	 _malloc
  0212f	83 c4 14	 add	 esp, 20			; 00000014H
  02132	a3 00 00 00 00	 mov	 DWORD PTR ?g_table@@3PAPAUCHAIN@@A, eax ; g_table
  02137	85 c0		 test	 eax, eax
  02139	75 14		 jne	 SHORT $LN47@main
  0213b	68 00 00 00 00	 push	 OFFSET $SG-11
  02140	e8 00 00 00 00	 call	 _puts
  02145	83 c4 04	 add	 esp, 4
  02148	6a 01		 push	 1
  0214a	e8 00 00 00 00	 call	 _exit
$LN86@main:
$LN47@main:
  0214f	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_lines_count@@3KA ; g_lines_count
  02154	8d 0c c5 00 00
	00 00		 lea	 ecx, DWORD PTR [eax*8]
  0215b	51		 push	 ecx
  0215c	e8 00 00 00 00	 call	 _malloc
  02161	83 c4 04	 add	 esp, 4
  02164	a3 00 00 00 00	 mov	 DWORD PTR ?g_chains@@3PAUCHAIN@@A, eax ; g_chains
  02169	85 c0		 test	 eax, eax
  0216b	75 14		 jne	 SHORT $LN46@main
  0216d	68 00 00 00 00	 push	 OFFSET $SG-12
  02172	e8 00 00 00 00	 call	 _puts
  02177	83 c4 04	 add	 esp, 4
  0217a	6a 01		 push	 1
  0217c	e8 00 00 00 00	 call	 _exit
$LN87@main:
$LN46@main:

; 1668 : 
; 1669 : 	if (is_collisions) {

  02181	85 ff		 test	 edi, edi
  02183	74 30		 je	 SHORT $LN14@main

; 1670 : 		TabulateHeader();

  02185	e8 00 00 00 00	 call	 ?TabulateHeader@@YAXXZ	; TabulateHeader

; 1671 : 		for (UINT i = 0; i < NUM_OF(func); i++)

  0218a	33 f6		 xor	 esi, esi
  0218c	8d 64 24 00	 npad	 4
$LL13@main:

; 1672 : 			TabulateCollisions(func[i], name[i]);

  02190	8b 96 00 00 00
	00		 mov	 edx, DWORD PTR ?func@?1??main@@9@4QBQ6AIPBDK@ZB[esi]
  02196	8b 86 00 00 00
	00		 mov	 eax, DWORD PTR ?name@?1??main@@9@4PAPBDA[esi]
  0219c	52		 push	 edx
  0219d	e8 00 00 00 00	 call	 ?TabulateCollisions@@YAXP6AIPBDK@Z0@Z ; TabulateCollisions
  021a2	83 c6 04	 add	 esi, 4
  021a5	83 c4 04	 add	 esp, 4
  021a8	81 fe 84 00 00
	00		 cmp	 esi, 132		; 00000084H
  021ae	72 e0		 jb	 SHORT $LL13@main
  021b0	e9 7f 00 00 00	 jmp	 $LN1@main
$LN14@main:

; 1673 : 	} else if (is_quality) {
; 1674 : 		for (UINT i = 0; i < NUM_OF(func); i++)

  021b5	33 f6		 xor	 esi, esi
  021b7	39 74 24 1c	 cmp	 DWORD PTR _is_quality$[esp+48], esi
  021bb	74 23		 je	 SHORT $LL4@main
  021bd	8d 49 00	 npad	 3
$LL8@main:

; 1675 : 			TabulateQuality(func[i], name[i]);

  021c0	8b 86 00 00 00
	00		 mov	 eax, DWORD PTR ?name@?1??main@@9@4PAPBDA[esi]
  021c6	8b be 00 00 00
	00		 mov	 edi, DWORD PTR ?func@?1??main@@9@4QBQ6AIPBDK@ZB[esi]
  021cc	e8 00 00 00 00	 call	 ?TabulateQuality@@YAXP6AIPBDK@Z0@Z ; TabulateQuality
  021d1	83 c6 04	 add	 esi, 4
  021d4	81 fe 84 00 00
	00		 cmp	 esi, 132		; 00000084H
  021da	72 e4		 jb	 SHORT $LL8@main
  021dc	eb 56		 jmp	 SHORT $LN1@main
  021de	8b ff		 npad	 2
$LL4@main:

; 1676 : 	} else {
; 1677 : 		// Run the benchmarks
; 1678 : 		//PrintTestWords(func + 6, name + 6, NUM_OF(func) - 6);
; 1679 : 		for (UINT i = 0; i < NUM_OF(func); i++)
; 1680 : 			BenchmarkHashFunction(func[i], name[i]);

  021e0	8b 86 00 00 00
	00		 mov	 eax, DWORD PTR ?func@?1??main@@9@4QBQ6AIPBDK@ZB[esi]
  021e6	50		 push	 eax
  021e7	8b 86 00 00 00
	00		 mov	 eax, DWORD PTR ?name@?1??main@@9@4PAPBDA[esi]
  021ed	e8 00 00 00 00	 call	 ?BenchmarkHashFunction@@YAXP6AIPBDK@Z0@Z ; BenchmarkHashFunction
  021f2	83 c6 04	 add	 esi, 4
  021f5	83 c4 04	 add	 esp, 4
  021f8	81 fe 84 00 00
	00		 cmp	 esi, 132		; 00000084H
  021fe	72 e0		 jb	 SHORT $LL4@main

; 1681 : 
; 1682 : #if _MSC_VER
; 1683 : 		// Test CRC32 in hardware if available
; 1684 : 		int a[4];
; 1685 : 		__cpuid(a, 1);

  02200	33 c9		 xor	 ecx, ecx
  02202	b8 01 00 00 00	 mov	 eax, 1
  02207	0f a2		 cpuid
  02209	8d 74 24 20	 lea	 esi, DWORD PTR _a$77829[esp+48]
  0220d	89 06		 mov	 DWORD PTR [esi], eax
  0220f	89 5e 04	 mov	 DWORD PTR [esi+4], ebx
  02212	89 4e 08	 mov	 DWORD PTR [esi+8], ecx
  02215	89 56 0c	 mov	 DWORD PTR [esi+12], edx

; 1686 : 		if (a[2] & (1 << 20))

  02218	f7 44 24 28 00
	00 10 00	 test	 DWORD PTR _a$77829[esp+56], 1048576 ; 00100000H
  02220	74 12		 je	 SHORT $LN1@main

; 1687 : 			BenchmarkHashFunction(CRC32Accelerated, "iSCSI CRC");

  02222	68 00 00 00 00	 push	 OFFSET ?CRC32Accelerated@@YAIPBDK@Z ; CRC32Accelerated
  02227	b8 00 00 00 00	 mov	 eax, OFFSET $SG-89
  0222c	e8 00 00 00 00	 call	 ?BenchmarkHashFunction@@YAXP6AIPBDK@Z0@Z ; BenchmarkHashFunction
  02231	83 c4 04	 add	 esp, 4
$LN1@main:

; 1688 : #endif
; 1689 : 	}
; 1690 : 
; 1691 : 	FreeTxtFile();

  02234	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_lines@@3PAULINE@@A ; g_lines
  0223a	51		 push	 ecx
  0223b	e8 00 00 00 00	 call	 _free
  02240	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR ?g_text@@3PADA ; g_text
  02246	83 c4 04	 add	 esp, 4
  02249	52		 push	 edx
  0224a	e8 00 00 00 00	 call	 _free

; 1692 : 	FreeHashTable();

  0224f	a1 00 00 00 00	 mov	 eax, DWORD PTR ?g_table@@3PAPAUCHAIN@@A ; g_table
  02254	83 c4 04	 add	 esp, 4
  02257	50		 push	 eax
  02258	e8 00 00 00 00	 call	 _free
  0225d	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR ?g_chains@@3PAUCHAIN@@A ; g_chains
  02263	83 c4 04	 add	 esp, 4
  02266	51		 push	 ecx
  02267	e8 00 00 00 00	 call	 _free
  0226c	83 c4 04	 add	 esp, 4

; 1693 : 	return 0;
; 1694 : }

  0226f	5f		 pop	 edi
  02270	5e		 pop	 esi
  02271	33 c0		 xor	 eax, eax
  02273	5b		 pop	 ebx
  02274	8b e5		 mov	 esp, ebp
  02276	5d		 pop	 ebp
  02277	c3		 ret	 0
$LN82@main:
_main	ENDP
_TEXT	ENDS
END
