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

include listing.inc

INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES

PUBLIC	FNV1A_Hash_Tesla
; Function compile flags: /Ogtpy
; File d:\downloads\_2013_jun-03\fsbench-0.13.3_kaze\src\codecs\sanmayce.c
_TEXT	SEGMENT
str$ = 8
wrdlen$ = 16
FNV1A_Hash_Tesla PROC

; 61   : 	const uint64_t PRIME = 11400714819323198393ULL;
; 62   : 	uint64_t hash64 = 2166136261U; // should be much bigger

  00000	41 b8 c5 9d 1c
	81		 mov	 r8d, -2128831035	; 811c9dc5H
  00006	4c 8b c9	 mov	 r9, rcx

; 63   : 	uint64_t hash64B = 2166136261U; // should be much bigger
; 64   : 	const char *p = str;
; 65   : 	
; 66   : 	for(; wrdlen >= 2*2*2*sizeof(uint32_t); wrdlen -= 2*2*2*sizeof(uint32_t), p += 2*2*2*sizeof(uint32_t)) {

  00009	49 bb b9 7b 4a
	7f b9 79 37 9e	 mov	 r11, -7046029254386353223 ; 9e3779b97f4a7bb9H
  00013	45 8b d0	 mov	 r10d, r8d
  00016	48 83 fa 20	 cmp	 rdx, 32			; 00000020H
  0001a	72 42		 jb	 SHORT $LN6@FNV1A_Hash

; 61   : 	const uint64_t PRIME = 11400714819323198393ULL;
; 62   : 	uint64_t hash64 = 2166136261U; // should be much bigger

  0001c	48 8b ca	 mov	 rcx, rdx
  0001f	48 c1 e9 05	 shr	 rcx, 5

; 63   : 	uint64_t hash64B = 2166136261U; // should be much bigger
; 64   : 	const char *p = str;
; 65   : 	
; 66   : 	for(; wrdlen >= 2*2*2*sizeof(uint32_t); wrdlen -= 2*2*2*sizeof(uint32_t), p += 2*2*2*sizeof(uint32_t)) {

  00023	48 8b c1	 mov	 rax, rcx
  00026	48 6b c0 e0	 imul	 rax, -32		; ffffffffffffffe0H
  0002a	48 03 d0	 add	 rdx, rax
  0002d	0f 1f 00	 npad	 3
$LL8@FNV1A_Hash:

; 67   : 		hash64 = (hash64 ^ (ROL64(*(unsigned long long *)(p+0),5-0)^*(unsigned long long *)(p+8))) * PRIME;

  00030	49 8b 01	 mov	 rax, QWORD PTR [r9]
  00033	49 83 c1 20	 add	 r9, 32			; 00000020H
  00037	48 c1 c0 05	 rol	 rax, 5
  0003b	49 33 41 e8	 xor	 rax, QWORD PTR [r9-24]
  0003f	4c 33 c0	 xor	 r8, rax

; 68   : 		hash64B = (hash64B ^ (ROL64(*(unsigned long long *)(p+8+8),5-0)^*(unsigned long long *)(p+8+8+8))) * PRIME;

  00042	49 8b 41 f0	 mov	 rax, QWORD PTR [r9-16]
  00046	4d 0f af c3	 imul	 r8, r11
  0004a	48 c1 c0 05	 rol	 rax, 5
  0004e	49 33 41 f8	 xor	 rax, QWORD PTR [r9-8]
  00052	4c 33 d0	 xor	 r10, rax
  00055	4d 0f af d3	 imul	 r10, r11
  00059	48 ff c9	 dec	 rcx
  0005c	75 d2		 jne	 SHORT $LL8@FNV1A_Hash
$LN6@FNV1A_Hash:

; 69   : 	}
; 70   : 
; 71   :         hash64 = (hash64 ^ hash64B); // Some mix, the simplest is given, maybe the B-line should be rolled by 32bits before xoring.

  0005e	4d 33 c2	 xor	 r8, r10

; 72   : 
; 73   : 	// Cases: 0,1,2,3,4,5,6,7,... 15,... 31
; 74   : 	if (wrdlen & (2*2*sizeof(uint32_t))) {

  00061	f6 c2 10	 test	 dl, 16
  00064	74 2d		 je	 SHORT $LN5@FNV1A_Hash

; 75   : 		hash64 = (hash64 ^ (ROL(*(uint32_t *)(p+0),5-0)^*(uint32_t *)(p+4))) * PRIME;		

  00066	41 8b 09	 mov	 ecx, DWORD PTR [r9]

; 76   : 		hash64 = (hash64 ^ (ROL(*(uint32_t *)(p+4+4),5-0)^*(uint32_t *)(p+4+4+4))) * PRIME;		

  00069	41 8b 41 04	 mov	 eax, DWORD PTR [r9+4]
  0006d	c1 c1 05	 rol	 ecx, 5
  00070	48 33 c8	 xor	 rcx, rax
  00073	41 8b 41 0c	 mov	 eax, DWORD PTR [r9+12]
  00077	4c 33 c1	 xor	 r8, rcx
  0007a	41 8b 49 08	 mov	 ecx, DWORD PTR [r9+8]
  0007e	4d 0f af c3	 imul	 r8, r11
  00082	c1 c1 05	 rol	 ecx, 5
  00085	4c 33 c1	 xor	 r8, rcx
  00088	4c 33 c0	 xor	 r8, rax
  0008b	4d 0f af c3	 imul	 r8, r11

; 77   : 		p += 2*2*sizeof(uint32_t);

  0008f	49 83 c1 10	 add	 r9, 16
$LN5@FNV1A_Hash:

; 78   : 	}
; 79   : 	if (wrdlen & (2*sizeof(uint32_t))) {

  00093	f6 c2 08	 test	 dl, 8
  00096	74 18		 je	 SHORT $LN4@FNV1A_Hash

; 80   : 		hash64 = (hash64 ^ (ROL(*(uint32_t *)p,5-0)^*(uint32_t *)(p+4))) * PRIME;		

  00098	41 8b 09	 mov	 ecx, DWORD PTR [r9]
  0009b	41 8b 41 04	 mov	 eax, DWORD PTR [r9+4]
  0009f	c1 c1 05	 rol	 ecx, 5
  000a2	48 33 c8	 xor	 rcx, rax
  000a5	4c 33 c1	 xor	 r8, rcx
  000a8	4d 0f af c3	 imul	 r8, r11

; 81   : 		p += 2*sizeof(uint32_t);

  000ac	49 83 c1 08	 add	 r9, 8
$LN4@FNV1A_Hash:

; 82   : 	}
; 83   : 	if (wrdlen & sizeof(uint32_t)) {

  000b0	f6 c2 04	 test	 dl, 4
  000b3	74 0e		 je	 SHORT $LN3@FNV1A_Hash

; 84   : 		hash64 = (hash64 ^ *(uint32_t*)p) * PRIME;

  000b5	41 8b 01	 mov	 eax, DWORD PTR [r9]
  000b8	4c 33 c0	 xor	 r8, rax
  000bb	4d 0f af c3	 imul	 r8, r11

; 85   : 		p += sizeof(uint32_t);

  000bf	49 83 c1 04	 add	 r9, 4
$LN3@FNV1A_Hash:

; 86   : 	}
; 87   : 	if (wrdlen & sizeof(uint16_t)) {

  000c3	f6 c2 02	 test	 dl, 2
  000c6	74 0f		 je	 SHORT $LN2@FNV1A_Hash

; 88   : 		hash64 = (hash64 ^ *(uint16_t*)p) * PRIME;

  000c8	41 0f b7 01	 movzx	 eax, WORD PTR [r9]
  000cc	4c 33 c0	 xor	 r8, rax
  000cf	4d 0f af c3	 imul	 r8, r11

; 89   : 		p += sizeof(uint16_t);

  000d3	49 83 c1 02	 add	 r9, 2
$LN2@FNV1A_Hash:

; 90   : 	}
; 91   : 	if (wrdlen & 1) 

  000d7	f6 c2 01	 test	 dl, 1
  000da	74 0b		 je	 SHORT $LN1@FNV1A_Hash

; 92   : 		hash64 = (hash64 ^ *p) * PRIME;

  000dc	49 0f be 01	 movsx	 rax, BYTE PTR [r9]
  000e0	4c 33 c0	 xor	 r8, rax
  000e3	4d 0f af c3	 imul	 r8, r11
$LN1@FNV1A_Hash:

; 93   : 	
; 94   : 	return hash64 ^ (hash64 >> 32);

  000e7	49 8b c0	 mov	 rax, r8
  000ea	48 c1 e8 20	 shr	 rax, 32			; 00000020H
  000ee	49 33 c0	 xor	 rax, r8

; 95   : }

  000f1	c3		 ret	 0
FNV1A_Hash_Tesla ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_Tesla3
pdata	SEGMENT
$pdata$FNV1A_Hash_Tesla3 DD imagerel $LN15
	DD	imagerel $LN15+60
	DD	imagerel $unwind$FNV1A_Hash_Tesla3
$pdata$0$FNV1A_Hash_Tesla3 DD imagerel $LN15+60
	DD	imagerel $LN15+154
	DD	imagerel $chain$0$FNV1A_Hash_Tesla3
$pdata$1$FNV1A_Hash_Tesla3 DD imagerel $LN15+154
	DD	imagerel $LN15+316
	DD	imagerel $chain$1$FNV1A_Hash_Tesla3
pdata	ENDS
xdata	SEGMENT
$unwind$FNV1A_Hash_Tesla3 DD 010201H
	DD	07002H
$chain$0$FNV1A_Hash_Tesla3 DD 020521H
	DD	023405H
	DD	imagerel $LN15
	DD	imagerel $LN15+60
	DD	imagerel $unwind$FNV1A_Hash_Tesla3
$chain$1$FNV1A_Hash_Tesla3 DD 021H
	DD	imagerel $LN15
	DD	imagerel $LN15+60
	DD	imagerel $unwind$FNV1A_Hash_Tesla3
; Function compile flags: /Ogtpy
xdata	ENDS
_TEXT	SEGMENT
str$ = 16
wrdlen$ = 24
FNV1A_Hash_Tesla3 PROC

; 98   : {

$LN15:
  00100	40 57		 push	 rdi

; 99   : 	const uint64_t PRIME = 11400714819323198393ULL;
; 100  : 	uint64_t hash64 = 2166136261U; // should be much bigger

  00102	41 b9 c5 9d 1c
	81		 mov	 r9d, -2128831035	; 811c9dc5H
  00108	4c 8b d1	 mov	 r10, rcx

; 101  : 	uint64_t hash64B = 2166136261U; // should be much bigger
; 102  : 	const char *p = str;
; 103  :     uint64_t Loop_Counter;
; 104  :     uint64_t Second_Line_Offset;
; 105  : 
; 106  : if (wrdlen >= 2*2*2*sizeof(uint32_t)) {	

  0010b	48 bf b9 7b 4a
	7f b9 79 37 9e	 mov	 rdi, -7046029254386353223 ; 9e3779b97f4a7bb9H
  00115	45 8b d9	 mov	 r11d, r9d
  00118	48 83 fa 20	 cmp	 rdx, 32			; 00000020H
  0011c	72 7c		 jb	 SHORT $LN10@FNV1A_Hash@2

; 107  :     Second_Line_Offset = wrdlen-((wrdlen>>5)+1)*(2*8); // ((wrdlen>>1)>>4)

  0011e	4c 8b c2	 mov	 r8, rdx
  00121	49 c1 e8 05	 shr	 r8, 5
  00125	49 8b c0	 mov	 rax, r8
  00128	48 c1 e0 04	 shl	 rax, 4
  0012c	48 2b d0	 sub	 rdx, rax
  0012f	48 83 ea 10	 sub	 rdx, 16

; 108  :     Loop_Counter = (wrdlen>>5);
; 109  :     Loop_Counter++;

  00133	49 ff c0	 inc	 r8

; 110  :     for(; Loop_Counter; Loop_Counter--, p += 2*2*sizeof(uint32_t)) {

  00136	0f 84 e9 00 00
	00		 je	 $LN1@FNV1A_Hash@2
  0013c	48 89 5c 24 10	 mov	 QWORD PTR [rsp+16], rbx
  00141	4c 8b d2	 mov	 r10, rdx
  00144	48 c7 c3 f8 ff
	ff ff		 mov	 rbx, -8
  0014b	49 f7 da	 neg	 r10
  0014e	48 2b da	 sub	 rbx, rdx
  00151	48 8d 4c 0a 08	 lea	 rcx, QWORD PTR [rdx+rcx+8]
  00156	66 66 0f 1f 84
	00 00 00 00 00	 npad	 10
$LL9@FNV1A_Hash@2:

; 111  : 		hash64 = (hash64 ^ (ROL64(*(uint64_t *)(p+0),5) ^ *(uint64_t *)(p+0+Second_Line_Offset))) * PRIME;        

  00160	48 8b 04 0b	 mov	 rax, QWORD PTR [rbx+rcx]
  00164	48 83 c1 10	 add	 rcx, 16
  00168	48 c1 c0 05	 rol	 rax, 5
  0016c	48 33 41 e8	 xor	 rax, QWORD PTR [rcx-24]
  00170	4c 33 c8	 xor	 r9, rax

; 112  : 		hash64B = (hash64B ^ (ROL64(*(uint64_t *)(p+8+Second_Line_Offset),5) ^ *(uint64_t *)(p+8))) * PRIME;        

  00173	48 8b 41 f0	 mov	 rax, QWORD PTR [rcx-16]
  00177	4c 0f af cf	 imul	 r9, rdi
  0017b	48 c1 c0 05	 rol	 rax, 5
  0017f	49 33 44 0a f0	 xor	 rax, QWORD PTR [r10+rcx-16]
  00184	4c 33 d8	 xor	 r11, rax
  00187	4c 0f af df	 imul	 r11, rdi
  0018b	49 ff c8	 dec	 r8
  0018e	75 d0		 jne	 SHORT $LL9@FNV1A_Hash@2
  00190	48 8b 5c 24 10	 mov	 rbx, QWORD PTR [rsp+16]

; 113  :     }
; 114  : } else {

  00195	e9 8b 00 00 00	 jmp	 $LN1@FNV1A_Hash@2
$LN10@FNV1A_Hash@2:

; 115  : 	// Cases: 0,1,2,3,4,5,6,7,... 15,... 31
; 116  : 	if (wrdlen & (2*2*sizeof(uint32_t))) {

  0019a	f6 c2 10	 test	 dl, 16
  0019d	74 32		 je	 SHORT $LN5@FNV1A_Hash@2

; 117  : 		hash64 = (hash64 ^ (ROL(*(uint32_t *)(p+0),5-0)^*(uint32_t *)(p+4))) * PRIME;		

  0019f	8b 09		 mov	 ecx, DWORD PTR [rcx]

; 118  : 		hash64 = (hash64 ^ (ROL(*(uint32_t *)(p+4+4),5-0)^*(uint32_t *)(p+4+4+4))) * PRIME;		

  001a1	41 8b 42 04	 mov	 eax, DWORD PTR [r10+4]
  001a5	c1 c1 05	 rol	 ecx, 5
  001a8	48 33 c8	 xor	 rcx, rax
  001ab	49 8b c1	 mov	 rax, r9
  001ae	4c 8b c9	 mov	 r9, rcx
  001b1	41 8b 4a 08	 mov	 ecx, DWORD PTR [r10+8]
  001b5	4c 33 c8	 xor	 r9, rax
  001b8	41 8b 42 0c	 mov	 eax, DWORD PTR [r10+12]
  001bc	4c 0f af cf	 imul	 r9, rdi
  001c0	c1 c1 05	 rol	 ecx, 5
  001c3	4c 33 c9	 xor	 r9, rcx
  001c6	4c 33 c8	 xor	 r9, rax
  001c9	4c 0f af cf	 imul	 r9, rdi

; 119  : 		p += 2*2*sizeof(uint32_t);

  001cd	49 83 c2 10	 add	 r10, 16
$LN5@FNV1A_Hash@2:

; 120  : 	}
; 121  : 	if (wrdlen & (2*sizeof(uint32_t))) {

  001d1	f6 c2 08	 test	 dl, 8
  001d4	74 18		 je	 SHORT $LN4@FNV1A_Hash@2

; 122  : 		hash64 = (hash64 ^ (ROL(*(uint32_t *)p,5-0)^*(uint32_t *)(p+4))) * PRIME;		

  001d6	41 8b 0a	 mov	 ecx, DWORD PTR [r10]
  001d9	41 8b 42 04	 mov	 eax, DWORD PTR [r10+4]
  001dd	c1 c1 05	 rol	 ecx, 5
  001e0	48 33 c8	 xor	 rcx, rax
  001e3	4c 33 c9	 xor	 r9, rcx
  001e6	4c 0f af cf	 imul	 r9, rdi

; 123  : 		p += 2*sizeof(uint32_t);

  001ea	49 83 c2 08	 add	 r10, 8
$LN4@FNV1A_Hash@2:

; 124  : 	}
; 125  : 	if (wrdlen & sizeof(uint32_t)) {

  001ee	f6 c2 04	 test	 dl, 4
  001f1	74 0e		 je	 SHORT $LN3@FNV1A_Hash@2

; 126  : 		hash64 = (hash64 ^ *(uint32_t*)p) * PRIME;

  001f3	41 8b 02	 mov	 eax, DWORD PTR [r10]
  001f6	4c 33 c8	 xor	 r9, rax
  001f9	4c 0f af cf	 imul	 r9, rdi

; 127  : 		p += sizeof(uint32_t);

  001fd	49 83 c2 04	 add	 r10, 4
$LN3@FNV1A_Hash@2:

; 128  : 	}
; 129  : 	if (wrdlen & sizeof(uint16_t)) {

  00201	f6 c2 02	 test	 dl, 2
  00204	74 0f		 je	 SHORT $LN2@FNV1A_Hash@2

; 130  : 		hash64 = (hash64 ^ *(uint16_t*)p) * PRIME;

  00206	41 0f b7 02	 movzx	 eax, WORD PTR [r10]
  0020a	4c 33 c8	 xor	 r9, rax
  0020d	4c 0f af cf	 imul	 r9, rdi

; 131  : 		p += sizeof(uint16_t);

  00211	49 83 c2 02	 add	 r10, 2
$LN2@FNV1A_Hash@2:

; 132  : 	}
; 133  : 	if (wrdlen & 1) 

  00215	f6 c2 01	 test	 dl, 1
  00218	74 0b		 je	 SHORT $LN1@FNV1A_Hash@2

; 134  : 		hash64 = (hash64 ^ *p) * PRIME;

  0021a	49 0f be 02	 movsx	 rax, BYTE PTR [r10]
  0021e	4c 33 c8	 xor	 r9, rax
  00221	4c 0f af cf	 imul	 r9, rdi
$LN1@FNV1A_Hash@2:

; 135  : }
; 136  : 	hash64 = (hash64 ^ ROL64(hash64B,5) ) * PRIME;

  00225	49 c1 c3 05	 rol	 r11, 5
  00229	4d 33 d9	 xor	 r11, r9
  0022c	4c 0f af df	 imul	 r11, rdi

; 137  : 	return hash64 ^ (hash64 >> 32);

  00230	49 8b c3	 mov	 rax, r11
  00233	48 c1 e8 20	 shr	 rax, 32			; 00000020H
  00237	49 33 c3	 xor	 rax, r11

; 138  : }

  0023a	5f		 pop	 rdi
  0023b	c3		 ret	 0
FNV1A_Hash_Tesla3 ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_Yoshimura
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
str$ = 8
wrdlen$ = 16
FNV1A_Hash_Yoshimura PROC

; 161  :     const uint32_t PRIME = 709607;
; 162  :     uint32_t hash32 = 2166136261;

  00250	41 b9 c5 9d 1c
	81		 mov	 r9d, -2128831035	; 811c9dc5H
  00256	45 8b c1	 mov	 r8d, r9d

; 163  :     uint32_t hash32B = 2166136261;
; 164  :     const char *p = str;
; 165  :     uint32_t Loop_Counter;
; 166  :     uint32_t Second_Line_Offset;
; 167  : 
; 168  : if (wrdlen >= 2*2*sizeof(uint32_t)) {

  00259	48 83 fa 10	 cmp	 rdx, 16
  0025d	72 74		 jb	 SHORT $LN9@FNV1A_Hash@3

; 169  :     Second_Line_Offset = wrdlen-((wrdlen>>4)+1)*(2*4); // ((wrdlen>>1)>>3)
; 170  :     Loop_Counter = (wrdlen>>4);

  0025f	48 8b c2	 mov	 rax, rdx
  00262	48 c1 e8 04	 shr	 rax, 4

; 171  :     //if (wrdlen%16) Loop_Counter++;
; 172  :     Loop_Counter++;

  00266	44 8d 50 01	 lea	 r10d, DWORD PTR [rax+1]
  0026a	8d 04 c5 08 00
	00 00		 lea	 eax, DWORD PTR [rax*8+8]
  00271	2b d0		 sub	 edx, eax
  00273	48 63 c2	 movsxd	 rax, edx

; 173  :     for(; Loop_Counter; Loop_Counter--, p += 2*sizeof(uint32_t)) {

  00276	45 85 d2	 test	 r10d, r10d
  00279	0f 84 c1 00 00
	00		 je	 $LN1@FNV1A_Hash@3
  0027f	48 8d 54 08 04	 lea	 rdx, QWORD PTR [rax+rcx+4]
  00284	48 8b c8	 mov	 rcx, rax
  00287	49 c7 c3 fc ff
	ff ff		 mov	 r11, -4
  0028e	48 f7 d9	 neg	 rcx
  00291	4c 2b d8	 sub	 r11, rax
  00294	66 66 66 66 0f
	1f 84 00 00 00
	00 00		 npad	 12
$LL8@FNV1A_Hash@3:

; 174  : 		// revision 1:
; 175  : 		//hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        
; 176  : 		//hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+0+Second_Line_Offset),5) ^ *(uint32_t *)(p+4+Second_Line_Offset))) * PRIME;        
; 177  : 		// revision 2:
; 178  : 		hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+0+Second_Line_Offset))) * PRIME;        

  002a0	41 8b 04 13	 mov	 eax, DWORD PTR [r11+rdx]
  002a4	48 83 c2 08	 add	 rdx, 8
  002a8	c1 c0 05	 rol	 eax, 5
  002ab	33 42 f4	 xor	 eax, DWORD PTR [rdx-12]
  002ae	44 33 c0	 xor	 r8d, eax

; 179  : 		hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+4+Second_Line_Offset),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  002b1	8b 42 f8	 mov	 eax, DWORD PTR [rdx-8]
  002b4	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  002bb	c1 c0 05	 rol	 eax, 5
  002be	33 44 11 f8	 xor	 eax, DWORD PTR [rcx+rdx-8]
  002c2	44 33 c8	 xor	 r9d, eax
  002c5	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H
  002cc	41 ff ca	 dec	 r10d
  002cf	75 cf		 jne	 SHORT $LL8@FNV1A_Hash@3

; 180  :     }
; 181  : } else {

  002d1	eb 6d		 jmp	 SHORT $LN1@FNV1A_Hash@3
$LN9@FNV1A_Hash@3:

; 182  :     // Cases: 0,1,2,3,4,5,6,7,...,15
; 183  :     if (wrdlen & 2*sizeof(uint32_t)) {

  002d3	f6 c2 08	 test	 dl, 8
  002d6	74 1c		 je	 SHORT $LN4@FNV1A_Hash@3

; 184  : 		hash32 = (hash32 ^ *(uint32_t*)(p+0)) * PRIME;

  002d8	44 8b 01	 mov	 r8d, DWORD PTR [rcx]
  002db	45 33 c1	 xor	 r8d, r9d

; 185  : 		hash32B = (hash32B ^ *(uint32_t*)(p+4)) * PRIME;

  002de	44 33 49 04	 xor	 r9d, DWORD PTR [rcx+4]
  002e2	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  002e9	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 186  : 		p += 4*sizeof(uint16_t);

  002f0	48 83 c1 08	 add	 rcx, 8
$LN4@FNV1A_Hash@3:

; 187  :     }
; 188  :     // Cases: 0,1,2,3,4,5,6,7
; 189  :     if (wrdlen & sizeof(uint32_t)) {

  002f4	f6 c2 04	 test	 dl, 4
  002f7	74 1f		 je	 SHORT $LN3@FNV1A_Hash@3

; 190  : 		hash32 = (hash32 ^ *(uint16_t*)(p+0)) * PRIME;

  002f9	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  002fc	44 33 c0	 xor	 r8d, eax

; 191  : 		hash32B = (hash32B ^ *(uint16_t*)(p+2)) * PRIME;

  002ff	0f b7 41 02	 movzx	 eax, WORD PTR [rcx+2]
  00303	44 33 c8	 xor	 r9d, eax
  00306	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  0030d	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 192  : 		p += 2*sizeof(uint16_t);

  00314	48 83 c1 04	 add	 rcx, 4
$LN3@FNV1A_Hash@3:

; 193  :     }
; 194  :     if (wrdlen & sizeof(uint16_t)) {

  00318	f6 c2 02	 test	 dl, 2
  0031b	74 11		 je	 SHORT $LN2@FNV1A_Hash@3

; 195  :         hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  0031d	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  00320	44 33 c0	 xor	 r8d, eax
  00323	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 196  :         p += sizeof(uint16_t);

  0032a	48 83 c1 02	 add	 rcx, 2
$LN2@FNV1A_Hash@3:

; 197  :     }
; 198  :     if (wrdlen & 1) 

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

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

  00333	0f be 01	 movsx	 eax, BYTE PTR [rcx]
  00336	44 33 c0	 xor	 r8d, eax
  00339	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN1@FNV1A_Hash@3:

; 200  : }
; 201  :     hash32 = (hash32 ^ ROL(hash32B,5) ) * PRIME;

  00340	41 c1 c1 05	 rol	 r9d, 5
  00344	45 33 c8	 xor	 r9d, r8d
  00347	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 202  :     return hash32 ^ (hash32 >> 16);

  0034e	41 8b c1	 mov	 eax, r9d
  00351	c1 e8 10	 shr	 eax, 16
  00354	41 33 c1	 xor	 eax, r9d

; 203  : }

  00357	c3		 ret	 0
FNV1A_Hash_Yoshimura ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_Jesteress
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
str$ = 8
wrdlen$ = 16
FNV1A_Hash_Jesteress PROC

; 224  :     const uint32_t PRIME = 709607;
; 225  :     uint32_t hash32 = 2166136261;

  00360	41 b8 c5 9d 1c
	81		 mov	 r8d, -2128831035	; 811c9dc5H

; 226  :     const char *p = str;
; 227  : 
; 228  :     // Idea comes from Igor Pavlov's 7zCRC, thanks.
; 229  : /*
; 230  :     for(; wrdlen && ((unsigned)(ptrdiff_t)p&3); wrdlen -= 1, p++) {
; 231  :         hash32 = (hash32 ^ *p) * PRIME;
; 232  :     }
; 233  : */
; 234  :     for(; wrdlen >= 2*sizeof(uint32_t); wrdlen -= 2*sizeof(uint32_t), p += 2*sizeof(uint32_t)) {

  00366	48 83 fa 08	 cmp	 rdx, 8
  0036a	72 2f		 jb	 SHORT $LN4@FNV1A_Hash@4

; 224  :     const uint32_t PRIME = 709607;
; 225  :     uint32_t hash32 = 2166136261;

  0036c	4c 8b ca	 mov	 r9, rdx
  0036f	49 c1 e9 03	 shr	 r9, 3

; 226  :     const char *p = str;
; 227  : 
; 228  :     // Idea comes from Igor Pavlov's 7zCRC, thanks.
; 229  : /*
; 230  :     for(; wrdlen && ((unsigned)(ptrdiff_t)p&3); wrdlen -= 1, p++) {
; 231  :         hash32 = (hash32 ^ *p) * PRIME;
; 232  :     }
; 233  : */
; 234  :     for(; wrdlen >= 2*sizeof(uint32_t); wrdlen -= 2*sizeof(uint32_t), p += 2*sizeof(uint32_t)) {

  00373	49 8b c1	 mov	 rax, r9
  00376	48 6b c0 f8	 imul	 rax, -8
  0037a	48 03 d0	 add	 rdx, rax
  0037d	0f 1f 00	 npad	 3
$LL6@FNV1A_Hash@4:

; 235  :         hash32 = (hash32 ^ (ROL(*(uint32_t *)p,5)^*(uint32_t *)(p+4))) * PRIME;        

  00380	8b 01		 mov	 eax, DWORD PTR [rcx]
  00382	48 83 c1 08	 add	 rcx, 8
  00386	c1 c0 05	 rol	 eax, 5
  00389	33 41 fc	 xor	 eax, DWORD PTR [rcx-4]
  0038c	44 33 c0	 xor	 r8d, eax
  0038f	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00396	49 ff c9	 dec	 r9
  00399	75 e5		 jne	 SHORT $LL6@FNV1A_Hash@4
$LN4@FNV1A_Hash@4:

; 236  :     }
; 237  :     // Cases: 0,1,2,3,4,5,6,7
; 238  :     if (wrdlen & sizeof(uint32_t)) {

  0039b	f6 c2 04	 test	 dl, 4
  0039e	74 0e		 je	 SHORT $LN3@FNV1A_Hash@4

; 239  :         hash32 = (hash32 ^ *(uint32_t*)p) * PRIME;

  003a0	44 33 01	 xor	 r8d, DWORD PTR [rcx]
  003a3	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 240  :         p += sizeof(uint32_t);

  003aa	48 83 c1 04	 add	 rcx, 4
$LN3@FNV1A_Hash@4:

; 241  :     }
; 242  :     if (wrdlen & sizeof(uint16_t)) {

  003ae	f6 c2 02	 test	 dl, 2
  003b1	74 11		 je	 SHORT $LN2@FNV1A_Hash@4

; 243  :         hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  003b3	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  003b6	44 33 c0	 xor	 r8d, eax
  003b9	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 244  :         p += sizeof(uint16_t);

  003c0	48 83 c1 02	 add	 rcx, 2
$LN2@FNV1A_Hash@4:

; 245  :     }
; 246  :     if (wrdlen & 1) 

  003c4	f6 c2 01	 test	 dl, 1
  003c7	74 0d		 je	 SHORT $LN1@FNV1A_Hash@4

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

  003c9	0f be 01	 movsx	 eax, BYTE PTR [rcx]
  003cc	44 33 c0	 xor	 r8d, eax
  003cf	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN1@FNV1A_Hash@4:

; 248  :     
; 249  :     return hash32 ^ (hash32 >> 16);

  003d6	41 8b c0	 mov	 eax, r8d
  003d9	c1 e8 10	 shr	 eax, 16
  003dc	41 33 c0	 xor	 eax, r8d

; 250  : }

  003df	c3		 ret	 0
FNV1A_Hash_Jesteress ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_Meiyan
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
str$ = 8
wrdlen$ = 16
FNV1A_Hash_Meiyan PROC

; 255  :     const uint32_t PRIME = 709607;
; 256  :     uint32_t hash32 = 2166136261;

  003f0	41 b8 c5 9d 1c
	81		 mov	 r8d, -2128831035	; 811c9dc5H

; 257  :     const char *p = str;
; 258  : 
; 259  :     // Idea comes from Igor Pavlov's 7zCRC, thanks.
; 260  : /*
; 261  :     for(; wrdlen && ((unsigned)(ptrdiff_t)p&3); wrdlen -= 1, p++) {
; 262  :         hash32 = (hash32 ^ *p) * PRIME;
; 263  :     }
; 264  : */
; 265  :     for(; wrdlen >= 2*sizeof(uint32_t); wrdlen -= 2*sizeof(uint32_t), p += 2*sizeof(uint32_t)) {

  003f6	48 83 fa 08	 cmp	 rdx, 8
  003fa	72 2f		 jb	 SHORT $LN4@FNV1A_Hash@5

; 255  :     const uint32_t PRIME = 709607;
; 256  :     uint32_t hash32 = 2166136261;

  003fc	4c 8b ca	 mov	 r9, rdx
  003ff	49 c1 e9 03	 shr	 r9, 3

; 257  :     const char *p = str;
; 258  : 
; 259  :     // Idea comes from Igor Pavlov's 7zCRC, thanks.
; 260  : /*
; 261  :     for(; wrdlen && ((unsigned)(ptrdiff_t)p&3); wrdlen -= 1, p++) {
; 262  :         hash32 = (hash32 ^ *p) * PRIME;
; 263  :     }
; 264  : */
; 265  :     for(; wrdlen >= 2*sizeof(uint32_t); wrdlen -= 2*sizeof(uint32_t), p += 2*sizeof(uint32_t)) {

  00403	49 8b c1	 mov	 rax, r9
  00406	48 6b c0 f8	 imul	 rax, -8
  0040a	48 03 d0	 add	 rdx, rax
  0040d	0f 1f 00	 npad	 3
$LL6@FNV1A_Hash@5:

; 266  :         hash32 = (hash32 ^ (ROL(*(uint32_t *)p,5)^*(uint32_t *)(p+4))) * PRIME;        

  00410	8b 01		 mov	 eax, DWORD PTR [rcx]
  00412	48 83 c1 08	 add	 rcx, 8
  00416	c1 c0 05	 rol	 eax, 5
  00419	33 41 fc	 xor	 eax, DWORD PTR [rcx-4]
  0041c	44 33 c0	 xor	 r8d, eax
  0041f	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00426	49 ff c9	 dec	 r9
  00429	75 e5		 jne	 SHORT $LL6@FNV1A_Hash@5
$LN4@FNV1A_Hash@5:

; 267  :     }
; 268  :     // Cases: 0,1,2,3,4,5,6,7
; 269  :     if (wrdlen & sizeof(uint32_t)) {

  0042b	f6 c2 04	 test	 dl, 4
  0042e	74 1f		 je	 SHORT $LN3@FNV1A_Hash@5

; 270  : //		hash32 = (hash32 ^ *(uint32_t*)p) * PRIME;
; 271  : //		p += sizeof(uint32_t);
; 272  : 		hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  00430	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  00433	41 33 c0	 xor	 eax, r8d

; 273  : 		p += sizeof(uint16_t);
; 274  : 		hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  00436	44 0f b7 41 02	 movzx	 r8d, WORD PTR [rcx+2]
  0043b	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  00441	44 33 c0	 xor	 r8d, eax
  00444	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 275  : 		p += sizeof(uint16_t);        

  0044b	48 83 c1 04	 add	 rcx, 4
$LN3@FNV1A_Hash@5:

; 276  :     }
; 277  :     if (wrdlen & sizeof(uint16_t)) {

  0044f	f6 c2 02	 test	 dl, 2
  00452	74 11		 je	 SHORT $LN2@FNV1A_Hash@5

; 278  :         hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  00454	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  00457	44 33 c0	 xor	 r8d, eax
  0045a	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 279  :         p += sizeof(uint16_t);

  00461	48 83 c1 02	 add	 rcx, 2
$LN2@FNV1A_Hash@5:

; 280  :     }
; 281  :     if (wrdlen & 1) 

  00465	f6 c2 01	 test	 dl, 1
  00468	74 0d		 je	 SHORT $LN1@FNV1A_Hash@5

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

  0046a	0f be 01	 movsx	 eax, BYTE PTR [rcx]
  0046d	44 33 c0	 xor	 r8d, eax
  00470	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN1@FNV1A_Hash@5:

; 283  :     
; 284  :     return hash32 ^ (hash32 >> 16);

  00477	41 8b c0	 mov	 eax, r8d
  0047a	c1 e8 10	 shr	 eax, 16
  0047d	41 33 c0	 xor	 eax, r8d

; 285  : }

  00480	c3		 ret	 0
FNV1A_Hash_Meiyan ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_Mantis
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
str$ = 8
wrdlen$ = 16
FNV1A_Hash_Mantis PROC

; 293  : 	const uint32_t PRIME = 709607;
; 294  : 	uint32_t hash32 = 2166136261;

  00490	41 b8 c5 9d 1c
	81		 mov	 r8d, -2128831035	; 811c9dc5H

; 295  : 	const char *p = str;

  00496	4c 8b c9	 mov	 r9, rcx

; 296  : 	// Cases: 0,1,2,3,4,5,6,7
; 297  : 	if (wrdlen & sizeof(uint32_t)) {

  00499	f6 c2 04	 test	 dl, 4
  0049c	74 22		 je	 SHORT $LN7@FNV1A_Hash@6

; 298  : 		hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  0049e	0f b7 01	 movzx	 eax, WORD PTR [rcx]

; 299  : 		p += sizeof(uint16_t);

  004a1	4c 8d 49 02	 lea	 r9, QWORD PTR [rcx+2]
  004a5	41 33 c0	 xor	 eax, r8d

; 300  : 		hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  004a8	45 0f b7 01	 movzx	 r8d, WORD PTR [r9]
  004ac	69 c0 e7 d3 0a
	00		 imul	 eax, 709607		; 000ad3e7H
  004b2	44 33 c0	 xor	 r8d, eax
  004b5	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 301  : 		p += sizeof(uint16_t);

  004bc	49 83 c1 02	 add	 r9, 2
$LN7@FNV1A_Hash@6:

; 302  : 		//wrdlen -= sizeof(uint32_t);
; 303  : 	}
; 304  : 	if (wrdlen & sizeof(uint16_t)) {

  004c0	f6 c2 02	 test	 dl, 2
  004c3	74 12		 je	 SHORT $LN6@FNV1A_Hash@6

; 305  : 		hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  004c5	41 0f b7 01	 movzx	 eax, WORD PTR [r9]
  004c9	44 33 c0	 xor	 r8d, eax
  004cc	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 306  : 		p += sizeof(uint16_t);

  004d3	49 83 c1 02	 add	 r9, 2
$LN6@FNV1A_Hash@6:

; 307  : 		//wrdlen -= sizeof(uint16_t);
; 308  : 	}
; 309  : 	if (wrdlen & 1) {

  004d7	f6 c2 01	 test	 dl, 1
  004da	74 11		 je	 SHORT $LN5@FNV1A_Hash@6

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

  004dc	41 0f be 01	 movsx	 eax, BYTE PTR [r9]
  004e0	44 33 c0	 xor	 r8d, eax
  004e3	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 311  : 		p += sizeof(char);

  004ea	49 ff c1	 inc	 r9
$LN5@FNV1A_Hash@6:

; 312  : 		//wrdlen -= sizeof(char);
; 313  : 	}
; 314  : 		wrdlen -= p-str;

  004ed	49 2b c9	 sub	 rcx, r9
  004f0	48 03 d1	 add	 rdx, rcx

; 315  : // The goal is to avoid the weak range [8, 8+2, 8+1] that is 8..10 in practice 1..15 i.e. 1..8+4+2+1, thus amending FNV1A_Meiyan and FNV1A_Jesteress.
; 316  : // FNV1A_Jesteress: fastest strong
; 317  : // FNV1A_Meiyan   : faster  stronger
; 318  : // FNV1A_Mantis   : fast    strongest
; 319  : 	if (wrdlen) {

  004f3	74 73		 je	 SHORT $LN4@FNV1A_Hash@6

; 320  : 	for(; wrdlen > 2*sizeof(uint32_t); wrdlen -= 2*sizeof(uint32_t), p += 2*sizeof(uint32_t)) {

  004f5	48 83 fa 08	 cmp	 rdx, 8
  004f9	76 32		 jbe	 SHORT $LN1@FNV1A_Hash@6
  004fb	48 8d 4a f7	 lea	 rcx, QWORD PTR [rdx-9]
  004ff	48 c1 e9 03	 shr	 rcx, 3
  00503	48 ff c1	 inc	 rcx
  00506	66 66 0f 1f 84
	00 00 00 00 00	 npad	 10
$LL3@FNV1A_Hash@6:

; 321  : 		hash32 = (hash32 ^ (ROL(*(uint32_t *)p,5)^*(uint32_t *)(p+4))) * PRIME;		

  00510	41 8b 01	 mov	 eax, DWORD PTR [r9]
  00513	49 83 c1 08	 add	 r9, 8
  00517	c1 c0 05	 rol	 eax, 5
  0051a	41 33 41 fc	 xor	 eax, DWORD PTR [r9-4]
  0051e	44 33 c0	 xor	 r8d, eax
  00521	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00528	48 ff c9	 dec	 rcx
  0052b	75 e3		 jne	 SHORT $LL3@FNV1A_Hash@6
$LN1@FNV1A_Hash@6:

; 322  : 	}
; 323  : 		hash32 = (hash32 ^ *(uint16_t*)(p+0*sizeof(uint16_t))) * PRIME;
; 324  : 		hash32 = (hash32 ^ *(uint16_t*)(p+1*sizeof(uint16_t))) * PRIME;
; 325  : 		hash32 = (hash32 ^ *(uint16_t*)(p+2*sizeof(uint16_t))) * PRIME;
; 326  : 		hash32 = (hash32 ^ *(uint16_t*)(p+3*sizeof(uint16_t))) * PRIME;

  0052d	41 0f b7 01	 movzx	 eax, WORD PTR [r9]
  00531	44 33 c0	 xor	 r8d, eax
  00534	41 0f b7 41 02	 movzx	 eax, WORD PTR [r9+2]
  00539	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00540	44 33 c0	 xor	 r8d, eax
  00543	41 0f b7 41 04	 movzx	 eax, WORD PTR [r9+4]
  00548	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  0054f	44 33 c0	 xor	 r8d, eax
  00552	41 0f b7 41 06	 movzx	 eax, WORD PTR [r9+6]
  00557	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  0055e	44 33 c0	 xor	 r8d, eax
  00561	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN4@FNV1A_Hash@6:

; 327  : 	} // Bug Fixed!        
; 328  : 	return hash32 ^ (hash32 >> 16);

  00568	41 8b c0	 mov	 eax, r8d
  0056b	c1 e8 10	 shr	 eax, 16
  0056e	41 33 c0	 xor	 eax, r8d

; 329  : }

  00571	c3		 ret	 0
FNV1A_Hash_Mantis ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_YoshimitsuTRIADiiXMM
pdata	SEGMENT
$pdata$FNV1A_Hash_YoshimitsuTRIADiiXMM DD imagerel $LN23
	DD	imagerel $LN23+370
	DD	imagerel $unwind$FNV1A_Hash_YoshimitsuTRIADiiXMM
$pdata$1$FNV1A_Hash_YoshimitsuTRIADiiXMM DD imagerel $LN23+370
	DD	imagerel $LN23+494
	DD	imagerel $chain$1$FNV1A_Hash_YoshimitsuTRIADiiXMM
$pdata$2$FNV1A_Hash_YoshimitsuTRIADiiXMM DD imagerel $LN23+494
	DD	imagerel $LN23+699
	DD	imagerel $chain$2$FNV1A_Hash_YoshimitsuTRIADiiXMM
pdata	ENDS
xdata	SEGMENT
$unwind$FNV1A_Hash_YoshimitsuTRIADiiXMM DD 052d01H
	DD	01782dH
	DD	026828H
	DD	06204H
$chain$1$FNV1A_Hash_YoshimitsuTRIADiiXMM DD 040a21H
	DD	06740aH
	DD	083405H
	DD	imagerel $LN23
	DD	imagerel $LN23+370
	DD	imagerel $unwind$FNV1A_Hash_YoshimitsuTRIADiiXMM
$chain$2$FNV1A_Hash_YoshimitsuTRIADiiXMM DD 021H
	DD	imagerel $LN23
	DD	imagerel $LN23+370
	DD	imagerel $unwind$FNV1A_Hash_YoshimitsuTRIADiiXMM
xdata	ENDS
CONST	SEGMENT
__xmm@1	DB	0c5H, 09dH, 01cH, 081H, 0c5H, 09dH, 01cH, 081H, 0c5H, 09dH
	DB	01cH, 081H, 0c5H, 09dH, 01cH, 081H
__xmm@0	DB	0e7H, 0d3H, 0aH, 00H, 0e7H, 0d3H, 0aH, 00H, 0e7H, 0d3H, 0aH
	DB	00H, 0e7H, 0d3H, 0aH, 00H
; Function compile flags: /Ogtpy
CONST	ENDS
_TEXT	SEGMENT
hash32xmm$ = 0
str$ = 64
wrdlen$ = 72
FNV1A_Hash_YoshimitsuTRIADiiXMM PROC

; 396  : {

$LN23:
  00580	48 83 ec 38	 sub	 rsp, 56			; 00000038H

; 397  :     const uint32_t PRIME = 709607;
; 398  :     uint32_t hash32 = 2166136261;
; 399  :     uint32_t hash32B = 2166136261;
; 400  :     uint32_t hash32C = 2166136261;
; 401  :     const char *p = str;
; 402  :     uint32_t Loop_Counter;
; 403  :     uint32_t Second_Line_Offset;
; 404  : 
; 405  : #if defined(XMM_KAZE_SSE2) || defined(XMM_KAZE_SSE4) || defined(XMM_KAZE_AVX)
; 406  :     __m128i xmm0;
; 407  :     __m128i xmm1;
; 408  :     __m128i xmm2;
; 409  :     __m128i xmm3;
; 410  :     __m128i xmm4;
; 411  :     __m128i xmm5;
; 412  :     __m128i hash32xmm;
; 413  :     __m128i hash32Bxmm;
; 414  :     __m128i hash32Cxmm;
; 415  :     __m128i PRIMExmm;
; 416  :     hash32xmm = _mm_set1_epi32(2166136261);

  00584	66 0f 6f 25 00
	00 00 00	 movdqa	 xmm4, XMMWORD PTR __xmm@1

; 417  :     hash32Bxmm = _mm_set1_epi32(2166136261);
; 418  :     hash32Cxmm = _mm_set1_epi32(2166136261);
; 419  :     PRIMExmm = _mm_set1_epi32(709607);

  0058c	66 0f 6f 2d 00
	00 00 00	 movdqa	 xmm5, XMMWORD PTR __xmm@0
  00594	41 b9 c5 9d 1c
	81		 mov	 r9d, -2128831035	; 811c9dc5H
  0059a	4c 8b da	 mov	 r11, rdx
  0059d	45 8b c1	 mov	 r8d, r9d
  005a0	45 8b d1	 mov	 r10d, r9d
  005a3	0f 29 74 24 20	 movaps	 XMMWORD PTR [rsp+32], xmm6
  005a8	0f 29 7c 24 10	 movaps	 XMMWORD PTR [rsp+16], xmm7
  005ad	66 0f 6f f4	 movdqa	 xmm6, xmm4
  005b1	66 0f 6f fc	 movdqa	 xmm7, xmm4

; 420  : #endif
; 421  : 
; 422  : #if defined(XMM_KAZE_SSE2) || defined(XMM_KAZE_SSE4) || defined(XMM_KAZE_AVX)
; 423  : if (wrdlen >= 4*24) { // Actually 4*24 is the minimum and not useful, 200++ makes more sense.

  005b5	48 83 fa 60	 cmp	 rdx, 96			; 00000060H
  005b9	0f 82 06 01 00
	00		 jb	 $LN15@FNV1A_Hash@7

; 424  :     Loop_Counter = (wrdlen/(4*24));

  005bf	48 b8 ab aa aa
	aa aa aa aa aa	 mov	 rax, -6148914691236517205 ; aaaaaaaaaaaaaaabH
  005c9	49 f7 e3	 mul	 r11
  005cc	48 c1 ea 06	 shr	 rdx, 6

; 425  :     Loop_Counter++;

  005d0	ff c2		 inc	 edx

; 426  :     Second_Line_Offset = wrdlen-(Loop_Counter)*(4*3*4);

  005d2	8d 04 52	 lea	 eax, DWORD PTR [rdx+rdx*2]
  005d5	c1 e0 04	 shl	 eax, 4
  005d8	44 2b d8	 sub	 r11d, eax

; 427  :     for(; Loop_Counter; Loop_Counter--, p += 4*3*sizeof(uint32_t)) {

  005db	85 d2		 test	 edx, edx
  005dd	0f 84 96 00 00
	00		 je	 $LN12@FNV1A_Hash@7

; 424  :     Loop_Counter = (wrdlen/(4*24));

  005e3	48 83 c1 20	 add	 rcx, 32			; 00000020H
  005e7	66 0f 1f 84 00
	00 00 00 00	 npad	 9
$LL14@FNV1A_Hash@7:

; 428  :     xmm0 = xmmloadu(p+0*16);

  005f0	f3 0f 6f 41 e0	 movdqu	 xmm0, XMMWORD PTR [rcx-32]

; 429  :     xmm1 = xmmloadu(p+0*16+Second_Line_Offset);
; 430  :     xmm2 = xmmloadu(p+1*16);
; 431  :     xmm3 = xmmloadu(p+1*16+Second_Line_Offset);

  005f5	f3 41 0f 6f 54
	0b f0		 movdqu	 xmm2, XMMWORD PTR [r11+rcx-16]

; 432  :     xmm4 = xmmloadu(p+2*16);

  005fc	f3 0f 6f 19	 movdqu	 xmm3, XMMWORD PTR [rcx]
  00600	48 83 c1 30	 add	 rcx, 48			; 00000030H
  00604	ff ca		 dec	 edx

; 433  :     xmm5 = xmmloadu(p+2*16+Second_Line_Offset);
; 434  : #if defined(XMM_KAZE_SSE2)
; 435  :         hash32xmm = _mm_mullo_epi16(_mm_xor_si128(hash32xmm , _mm_xor_si128(_rotl_KAZE128(xmm0,5) , xmm1)) , PRIMExmm);       

  00606	66 0f 6f c8	 movdqa	 xmm1, xmm0
  0060a	66 0f 73 d8 7b	 psrldq	 xmm0, 123		; 0000007bH
  0060f	66 0f 73 f9 05	 pslldq	 xmm1, 5
  00614	66 0f eb c8	 por	 xmm1, xmm0
  00618	f3 41 0f 6f 44
	0b b0		 movdqu	 xmm0, XMMWORD PTR [r11+rcx-80]
  0061f	66 0f ef c8	 pxor	 xmm1, xmm0
  00623	f3 0f 6f 41 c0	 movdqu	 xmm0, XMMWORD PTR [rcx-64]
  00628	66 0f ef e1	 pxor	 xmm4, xmm1

; 436  :         hash32Bxmm = _mm_mullo_epi16(_mm_xor_si128(hash32Bxmm , _mm_xor_si128(_rotl_KAZE128(xmm3,5) , xmm2)) , PRIMExmm);        

  0062c	66 0f 6f ca	 movdqa	 xmm1, xmm2
  00630	66 0f d5 e5	 pmullw	 xmm4, xmm5
  00634	66 0f 73 da 7b	 psrldq	 xmm2, 123		; 0000007bH
  00639	66 0f 73 f9 05	 pslldq	 xmm1, 5
  0063e	66 0f eb ca	 por	 xmm1, xmm2
  00642	66 0f ef c8	 pxor	 xmm1, xmm0
  00646	66 0f ef f1	 pxor	 xmm6, xmm1
  0064a	f3 42 0f 6f 44
	19 d0		 movdqu	 xmm0, XMMWORD PTR [rcx+r11-48]

; 437  :         hash32Cxmm = _mm_mullo_epi16(_mm_xor_si128(hash32Cxmm , _mm_xor_si128(_rotl_KAZE128(xmm4,5) , xmm5)) , PRIMExmm);      

  00651	66 0f 6f cb	 movdqa	 xmm1, xmm3
  00655	66 0f d5 f5	 pmullw	 xmm6, xmm5
  00659	66 0f 73 db 7b	 psrldq	 xmm3, 123		; 0000007bH
  0065e	66 0f 73 f9 05	 pslldq	 xmm1, 5
  00663	66 0f eb cb	 por	 xmm1, xmm3
  00667	66 0f ef c8	 pxor	 xmm1, xmm0
  0066b	66 0f ef f9	 pxor	 xmm7, xmm1
  0066f	66 0f d5 fd	 pmullw	 xmm7, xmm5
  00673	0f 85 77 ff ff
	ff		 jne	 $LL14@FNV1A_Hash@7
$LN12@FNV1A_Hash@7:

; 438  : #else
; 439  :         hash32xmm = _mm_mullo_epi32(_mm_xor_si128(hash32xmm , _mm_xor_si128(_rotl_KAZE128(xmm0,5) , xmm1)) , PRIMExmm);       
; 440  :         hash32Bxmm = _mm_mullo_epi32(_mm_xor_si128(hash32Bxmm , _mm_xor_si128(_rotl_KAZE128(xmm3,5) , xmm2)) , PRIMExmm);        
; 441  :         hash32Cxmm = _mm_mullo_epi32(_mm_xor_si128(hash32Cxmm , _mm_xor_si128(_rotl_KAZE128(xmm4,5) , xmm5)) , PRIMExmm);      
; 442  : #endif
; 443  :     }
; 444  : #if defined(XMM_KAZE_SSE2)
; 445  :     hash32xmm = _mm_mullo_epi16(_mm_xor_si128(hash32xmm , hash32Bxmm) , PRIMExmm);       

  00679	66 0f ef e6	 pxor	 xmm4, xmm6
  0067d	66 0f d5 e5	 pmullw	 xmm4, xmm5

; 446  :     hash32xmm = _mm_mullo_epi16(_mm_xor_si128(hash32xmm , hash32Cxmm) , PRIMExmm);       

  00681	66 0f ef e7	 pxor	 xmm4, xmm7
  00685	66 0f d5 e5	 pmullw	 xmm4, xmm5
  00689	66 0f 7f 24 24	 movdqa	 XMMWORD PTR hash32xmm$[rsp], xmm4

; 447  : #else
; 448  :     hash32xmm = _mm_mullo_epi32(_mm_xor_si128(hash32xmm , hash32Bxmm) , PRIMExmm);       
; 449  :     hash32xmm = _mm_mullo_epi32(_mm_xor_si128(hash32xmm , hash32Cxmm) , PRIMExmm);       
; 450  : #endif
; 451  : 	hash32 = (hash32 ^ hash32xmm.m128i_u32[0]) * PRIME;

  0068e	44 8b 04 24	 mov	 r8d, DWORD PTR hash32xmm$[rsp]
  00692	45 33 c1	 xor	 r8d, r9d

; 452  : 	hash32B = (hash32B ^ hash32xmm.m128i_u32[3]) * PRIME;

  00695	44 33 4c 24 0c	 xor	 r9d, DWORD PTR hash32xmm$[rsp+12]
  0069a	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 453  : 	hash32 = (hash32 ^ hash32xmm.m128i_u32[1]) * PRIME;

  006a1	44 33 44 24 04	 xor	 r8d, DWORD PTR hash32xmm$[rsp+4]
  006a6	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 454  : 	hash32B = (hash32B ^ hash32xmm.m128i_u32[2]) * PRIME;

  006ad	44 33 4c 24 08	 xor	 r9d, DWORD PTR hash32xmm$[rsp+8]
  006b2	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  006b9	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H
  006c0	e9 50 01 00 00	 jmp	 $LN1@FNV1A_Hash@7
$LN15@FNV1A_Hash@7:

; 455  : } else if (wrdlen >= 24)

  006c5	48 83 fa 18	 cmp	 rdx, 24
  006c9	0f 82 ab 00 00
	00		 jb	 $LN10@FNV1A_Hash@7

; 456  : #else
; 457  : if (wrdlen >= 24)
; 458  : #endif
; 459  : {
; 460  :     Loop_Counter = (wrdlen/24);

  006cf	48 b8 ab aa aa
	aa aa aa aa aa	 mov	 rax, -6148914691236517205 ; aaaaaaaaaaaaaaabH
  006d9	49 f7 e3	 mul	 r11
  006dc	48 c1 ea 04	 shr	 rdx, 4

; 461  :     Loop_Counter++;

  006e0	ff c2		 inc	 edx

; 462  :     Second_Line_Offset = wrdlen-(Loop_Counter)*(3*4);

  006e2	8d 04 52	 lea	 eax, DWORD PTR [rdx+rdx*2]
  006e5	c1 e0 02	 shl	 eax, 2
  006e8	44 2b d8	 sub	 r11d, eax
  006eb	49 63 c3	 movsxd	 rax, r11d

; 463  :     for(; Loop_Counter; Loop_Counter--, p += 3*sizeof(uint32_t)) {

  006ee	85 d2		 test	 edx, edx
  006f0	74 7c		 je	 SHORT $LN7@FNV1A_Hash@7
  006f2	48 89 5c 24 40	 mov	 QWORD PTR [rsp+64], rbx
  006f7	48 89 7c 24 30	 mov	 QWORD PTR [rsp+48], rdi
  006fc	4c 8b d8	 mov	 r11, rax
  006ff	bb 04 00 00 00	 mov	 ebx, 4
  00704	48 c7 c7 fc ff
	ff ff		 mov	 rdi, -4
  0070b	49 f7 db	 neg	 r11
  0070e	48 2b d8	 sub	 rbx, rax
  00711	48 2b f8	 sub	 rdi, rax
  00714	48 8d 4c 08 04	 lea	 rcx, QWORD PTR [rax+rcx+4]
  00719	0f 1f 80 00 00
	00 00		 npad	 7
$LL9@FNV1A_Hash@7:

; 464  :         hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+0+Second_Line_Offset))) * PRIME;        

  00720	8b 04 0f	 mov	 eax, DWORD PTR [rdi+rcx]
  00723	48 83 c1 0c	 add	 rcx, 12
  00727	c1 c0 05	 rol	 eax, 5
  0072a	33 41 f0	 xor	 eax, DWORD PTR [rcx-16]
  0072d	44 33 c0	 xor	 r8d, eax

; 465  :         hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+4+Second_Line_Offset),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  00730	8b 41 f4	 mov	 eax, DWORD PTR [rcx-12]
  00733	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  0073a	c1 c0 05	 rol	 eax, 5
  0073d	41 33 44 0b f4	 xor	 eax, DWORD PTR [r11+rcx-12]
  00742	44 33 c8	 xor	 r9d, eax

; 466  :         hash32C = (hash32C ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+8+Second_Line_Offset))) * PRIME;        

  00745	8b 44 0b f4	 mov	 eax, DWORD PTR [rbx+rcx-12]
  00749	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H
  00750	c1 c0 05	 rol	 eax, 5
  00753	33 41 f8	 xor	 eax, DWORD PTR [rcx-8]
  00756	44 33 d0	 xor	 r10d, eax
  00759	45 69 d2 e7 d3
	0a 00		 imul	 r10d, 709607		; 000ad3e7H
  00760	ff ca		 dec	 edx
  00762	75 bc		 jne	 SHORT $LL9@FNV1A_Hash@7
  00764	48 8b 7c 24 30	 mov	 rdi, QWORD PTR [rsp+48]
  00769	48 8b 5c 24 40	 mov	 rbx, QWORD PTR [rsp+64]
$LN7@FNV1A_Hash@7:

; 467  :     }
; 468  :         hash32 = (hash32 ^ ROL(hash32C,5) ) * PRIME;

  0076e	41 c1 c2 05	 rol	 r10d, 5
  00772	45 33 c2	 xor	 r8d, r10d

; 469  : } else {

  00775	e9 94 00 00 00	 jmp	 $LN22@FNV1A_Hash@7
$LN10@FNV1A_Hash@7:

; 470  :     // 1111=15; 10111=23
; 471  :     if (wrdlen & 4*sizeof(uint32_t)) {  

  0077a	f6 c2 10	 test	 dl, 16
  0077d	74 2c		 je	 SHORT $LN5@FNV1A_Hash@7

; 472  :         hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  0077f	44 8b 01	 mov	 r8d, DWORD PTR [rcx]

; 473  :         hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+12))) * PRIME;        

  00782	8b 41 08	 mov	 eax, DWORD PTR [rcx+8]
  00785	41 c1 c0 05	 rol	 r8d, 5
  00789	44 33 41 04	 xor	 r8d, DWORD PTR [rcx+4]
  0078d	45 33 c1	 xor	 r8d, r9d
  00790	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00797	c1 c0 05	 rol	 eax, 5
  0079a	33 41 0c	 xor	 eax, DWORD PTR [rcx+12]
  0079d	44 33 c8	 xor	 r9d, eax
  007a0	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 474  :         p += 8*sizeof(uint16_t);

  007a7	48 83 c1 10	 add	 rcx, 16
$LN5@FNV1A_Hash@7:

; 475  :     }
; 476  :     // Cases: 0,1,2,3,4,5,6,7,...,15
; 477  :     if (wrdlen & 2*sizeof(uint32_t)) {

  007ab	f6 c2 08	 test	 dl, 8
  007ae	74 19		 je	 SHORT $LN4@FNV1A_Hash@7

; 478  :         hash32 = (hash32 ^ *(uint32_t*)(p+0)) * PRIME;

  007b0	44 33 01	 xor	 r8d, DWORD PTR [rcx]

; 479  :         hash32B = (hash32B ^ *(uint32_t*)(p+4)) * PRIME;

  007b3	44 33 49 04	 xor	 r9d, DWORD PTR [rcx+4]
  007b7	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  007be	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 480  :         p += 4*sizeof(uint16_t);

  007c5	48 83 c1 08	 add	 rcx, 8
$LN4@FNV1A_Hash@7:

; 481  :     }
; 482  :     // Cases: 0,1,2,3,4,5,6,7
; 483  :     if (wrdlen & sizeof(uint32_t)) {

  007c9	f6 c2 04	 test	 dl, 4
  007cc	74 1f		 je	 SHORT $LN3@FNV1A_Hash@7

; 484  :         hash32 = (hash32 ^ *(uint16_t*)(p+0)) * PRIME;

  007ce	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  007d1	44 33 c0	 xor	 r8d, eax

; 485  :         hash32B = (hash32B ^ *(uint16_t*)(p+2)) * PRIME;

  007d4	0f b7 41 02	 movzx	 eax, WORD PTR [rcx+2]
  007d8	44 33 c8	 xor	 r9d, eax
  007db	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  007e2	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 486  :         p += 2*sizeof(uint16_t);

  007e9	48 83 c1 04	 add	 rcx, 4
$LN3@FNV1A_Hash@7:

; 487  :     }
; 488  :     if (wrdlen & sizeof(uint16_t)) {

  007ed	f6 c2 02	 test	 dl, 2
  007f0	74 11		 je	 SHORT $LN2@FNV1A_Hash@7

; 489  :         hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  007f2	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  007f5	44 33 c0	 xor	 r8d, eax
  007f8	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 490  :         p += sizeof(uint16_t);

  007ff	48 83 c1 02	 add	 rcx, 2
$LN2@FNV1A_Hash@7:

; 491  :     }
; 492  :     if (wrdlen & 1) 

  00803	f6 c2 01	 test	 dl, 1
  00806	74 0d		 je	 SHORT $LN1@FNV1A_Hash@7

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

  00808	0f be 01	 movsx	 eax, BYTE PTR [rcx]
  0080b	44 33 c0	 xor	 r8d, eax
$LN22@FNV1A_Hash@7:
  0080e	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN1@FNV1A_Hash@7:

; 494  : }
; 495  :     hash32 = (hash32 ^ ROL(hash32B,5) ) * PRIME;
; 496  :     return hash32 ^ (hash32 >> 16);
; 497  : }

  00815	0f 28 74 24 20	 movaps	 xmm6, XMMWORD PTR [rsp+32]
  0081a	0f 28 7c 24 10	 movaps	 xmm7, XMMWORD PTR [rsp+16]
  0081f	41 c1 c1 05	 rol	 r9d, 5
  00823	45 33 c8	 xor	 r9d, r8d
  00826	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H
  0082d	41 8b c1	 mov	 eax, r9d
  00830	c1 e8 10	 shr	 eax, 16
  00833	41 33 c1	 xor	 eax, r9d
  00836	48 83 c4 38	 add	 rsp, 56			; 00000038H
  0083a	c3		 ret	 0
FNV1A_Hash_YoshimitsuTRIADiiXMM ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_Yorikke
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
str$ = 8
wrdlen$ = 16
FNV1A_Hash_Yorikke PROC

; 532  :     const uint32_t PRIME = 709607;
; 533  :     uint32_t hash32 = 2166136261;

  00850	41 b8 c5 9d 1c
	81		 mov	 r8d, -2128831035	; 811c9dc5H

; 534  :     uint32_t hash32B = 2166136261;

  00856	45 8b c8	 mov	 r9d, r8d

; 535  :     const char *p = str;
; 536  : 
; 537  :     for(; wrdlen >= 2*2*sizeof(uint32_t); wrdlen -= 2*2*sizeof(uint32_t), p += 2*2*sizeof(uint32_t)) {

  00859	48 83 fa 10	 cmp	 rdx, 16
  0085d	72 3f		 jb	 SHORT $LN5@FNV1A_Hash@8

; 532  :     const uint32_t PRIME = 709607;
; 533  :     uint32_t hash32 = 2166136261;

  0085f	4c 8b d2	 mov	 r10, rdx
  00862	49 c1 ea 04	 shr	 r10, 4

; 535  :     const char *p = str;
; 536  : 
; 537  :     for(; wrdlen >= 2*2*sizeof(uint32_t); wrdlen -= 2*2*sizeof(uint32_t), p += 2*2*sizeof(uint32_t)) {

  00866	49 8b c2	 mov	 rax, r10
  00869	48 6b c0 f0	 imul	 rax, -16
  0086d	48 03 d0	 add	 rdx, rax
$LL7@FNV1A_Hash@8:

; 538  :         hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  00870	8b 01		 mov	 eax, DWORD PTR [rcx]
  00872	48 83 c1 10	 add	 rcx, 16
  00876	c1 c0 05	 rol	 eax, 5
  00879	33 41 f4	 xor	 eax, DWORD PTR [rcx-12]
  0087c	44 33 c0	 xor	 r8d, eax

; 539  :         hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+12))) * PRIME;        

  0087f	8b 41 f8	 mov	 eax, DWORD PTR [rcx-8]
  00882	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00889	c1 c0 05	 rol	 eax, 5
  0088c	33 41 fc	 xor	 eax, DWORD PTR [rcx-4]
  0088f	44 33 c8	 xor	 r9d, eax
  00892	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H
  00899	49 ff ca	 dec	 r10
  0089c	75 d2		 jne	 SHORT $LL7@FNV1A_Hash@8
$LN5@FNV1A_Hash@8:

; 540  :     }
; 541  : 
; 542  :     // Cases: 0,1,2,3,4,5,6,7,...,15
; 543  :     if (wrdlen & 2*sizeof(uint32_t)) {

  0089e	f6 c2 08	 test	 dl, 8
  008a1	74 19		 je	 SHORT $LN4@FNV1A_Hash@8

; 544  :         hash32 = (hash32 ^ *(uint32_t*)(p+0)) * PRIME;

  008a3	44 33 01	 xor	 r8d, DWORD PTR [rcx]

; 545  :         hash32B = (hash32B ^ *(uint32_t*)(p+4)) * PRIME;

  008a6	44 33 49 04	 xor	 r9d, DWORD PTR [rcx+4]
  008aa	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  008b1	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 546  :         p += 4*sizeof(uint16_t);

  008b8	48 83 c1 08	 add	 rcx, 8
$LN4@FNV1A_Hash@8:

; 547  :     }
; 548  :     // Cases: 0,1,2,3,4,5,6,7
; 549  :     if (wrdlen & sizeof(uint32_t)) {

  008bc	f6 c2 04	 test	 dl, 4
  008bf	74 1f		 je	 SHORT $LN3@FNV1A_Hash@8

; 550  :         hash32 = (hash32 ^ *(uint16_t*)(p+0)) * PRIME;

  008c1	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  008c4	44 33 c0	 xor	 r8d, eax

; 551  :         hash32B = (hash32B ^ *(uint16_t*)(p+2)) * PRIME;

  008c7	0f b7 41 02	 movzx	 eax, WORD PTR [rcx+2]
  008cb	44 33 c8	 xor	 r9d, eax
  008ce	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  008d5	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 552  :         p += 2*sizeof(uint16_t);

  008dc	48 83 c1 04	 add	 rcx, 4
$LN3@FNV1A_Hash@8:

; 553  :     }
; 554  :     if (wrdlen & sizeof(uint16_t)) {

  008e0	f6 c2 02	 test	 dl, 2
  008e3	74 11		 je	 SHORT $LN2@FNV1A_Hash@8

; 555  :         hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  008e5	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  008e8	44 33 c0	 xor	 r8d, eax
  008eb	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 556  :         p += sizeof(uint16_t);

  008f2	48 83 c1 02	 add	 rcx, 2
$LN2@FNV1A_Hash@8:

; 557  :     }
; 558  :     if (wrdlen & 1) 

  008f6	f6 c2 01	 test	 dl, 1
  008f9	74 0d		 je	 SHORT $LN1@FNV1A_Hash@8

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

  008fb	0f be 01	 movsx	 eax, BYTE PTR [rcx]
  008fe	44 33 c0	 xor	 r8d, eax
  00901	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN1@FNV1A_Hash@8:

; 560  : 
; 561  :     hash32 = (hash32 ^ ROL(hash32B,5) ) * PRIME;

  00908	41 c1 c1 05	 rol	 r9d, 5
  0090c	45 33 c8	 xor	 r9d, r8d
  0090f	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 562  :     return hash32 ^ (hash32 >> 16);

  00916	41 8b c1	 mov	 eax, r9d
  00919	c1 e8 10	 shr	 eax, 16
  0091c	41 33 c1	 xor	 eax, r9d

; 563  : }

  0091f	c3		 ret	 0
FNV1A_Hash_Yorikke ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_YoshimitsuTRIAD
pdata	SEGMENT
$pdata$FNV1A_Hash_YoshimitsuTRIAD DD imagerel $LN14
	DD	imagerel $LN14+345
	DD	imagerel $unwind$FNV1A_Hash_YoshimitsuTRIAD
pdata	ENDS
xdata	SEGMENT
$unwind$FNV1A_Hash_YoshimitsuTRIAD DD 020501H
	DD	013405H
; Function compile flags: /Ogtpy
xdata	ENDS
_TEXT	SEGMENT
str$ = 8
wrdlen$ = 16
FNV1A_Hash_YoshimitsuTRIAD PROC

; 565  : {

$LN14:
  00930	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00935	48 8b d9	 mov	 rbx, rcx

; 566  :     const uint32_t PRIME = 709607;
; 567  :     uint32_t hash32 = 2166136261;

  00938	41 b8 c5 9d 1c
	81		 mov	 r8d, -2128831035	; 811c9dc5H
  0093e	4c 8b da	 mov	 r11, rdx

; 568  :     uint32_t hash32B = 2166136261;

  00941	45 8b d0	 mov	 r10d, r8d

; 569  :     uint32_t hash32C = 2166136261;

  00944	41 8b c8	 mov	 ecx, r8d

; 570  :     //uint32_t hash32D = 2166136261;
; 571  :     const char *p = str;

  00947	4c 8b cb	 mov	 r9, rbx

; 572  : 
; 573  :     for(; wrdlen >= 3*2*sizeof(uint32_t); wrdlen -= 3*2*sizeof(uint32_t), p += 3*2*sizeof(uint32_t)) {

  0094a	48 83 fa 18	 cmp	 rdx, 24
  0094e	72 77		 jb	 SHORT $LN6@FNV1A_Hash@9

; 566  :     const uint32_t PRIME = 709607;
; 567  :     uint32_t hash32 = 2166136261;

  00950	48 b8 ab aa aa
	aa aa aa aa aa	 mov	 rax, -6148914691236517205 ; aaaaaaaaaaaaaaabH
  0095a	49 f7 e3	 mul	 r11
  0095d	48 c1 ea 04	 shr	 rdx, 4

; 572  : 
; 573  :     for(; wrdlen >= 3*2*sizeof(uint32_t); wrdlen -= 3*2*sizeof(uint32_t), p += 3*2*sizeof(uint32_t)) {

  00961	48 8b c2	 mov	 rax, rdx
  00964	48 6b c0 e8	 imul	 rax, -24
  00968	4c 03 d8	 add	 r11, rax
  0096b	0f 1f 44 00 00	 npad	 5
$LL9@FNV1A_Hash@9:

; 574  :         hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  00970	41 8b 01	 mov	 eax, DWORD PTR [r9]
  00973	49 83 c1 18	 add	 r9, 24
  00977	c1 c0 05	 rol	 eax, 5
  0097a	41 33 41 ec	 xor	 eax, DWORD PTR [r9-20]
  0097e	44 33 c0	 xor	 r8d, eax

; 575  :         hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+12))) * PRIME;        

  00981	41 8b 41 f0	 mov	 eax, DWORD PTR [r9-16]
  00985	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  0098c	c1 c0 05	 rol	 eax, 5
  0098f	41 33 41 f4	 xor	 eax, DWORD PTR [r9-12]
  00993	44 33 d0	 xor	 r10d, eax

; 576  :         hash32C = (hash32C ^ (ROL(*(uint32_t *)(p+16),5) ^ *(uint32_t *)(p+20))) * PRIME;        

  00996	41 8b 41 f8	 mov	 eax, DWORD PTR [r9-8]
  0099a	45 69 d2 e7 d3
	0a 00		 imul	 r10d, 709607		; 000ad3e7H
  009a1	c1 c0 05	 rol	 eax, 5
  009a4	41 33 41 fc	 xor	 eax, DWORD PTR [r9-4]
  009a8	33 c8		 xor	 ecx, eax
  009aa	69 c9 e7 d3 0a
	00		 imul	 ecx, 709607		; 000ad3e7H
  009b0	48 ff ca	 dec	 rdx
  009b3	75 bb		 jne	 SHORT $LL9@FNV1A_Hash@9

; 577  :         //hash32D = (hash32D ^ (ROL(*(uint32_t *)(p+24),5) ^ *(uint32_t *)(p+28))) * PRIME;        
; 578  : 
; 579  : /*
; 580  : // Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.30319.01 for 80x86 gave this:
; 581  : // 12d-0f4+2= 59 bytes, No CARAMBA anymore.
; 582  : $LL9@FNV1A_Hash@2:
; 583  : 
; 584  : ; 160  :        hash32 = (hash32 ^ (_rotl(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        
; 585  : 
; 586  :   000f4 8b 01        mov     eax, DWORD PTR [ecx]
; 587  :   000f6 c1 c0 05     rol     eax, 5
; 588  :   000f9 33 41 04     xor     eax, DWORD PTR [ecx+4]
; 589  :   000fc 83 eb 18     sub     ebx, 24            ; 00000018H
; 590  :   000ff 33 f0        xor     esi, eax
; 591  : 
; 592  : ; 161  :        hash32B = (hash32B ^ (_rotl(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+12))) * PRIME;        
; 593  : 
; 594  :   00101 8b 41 08     mov     eax, DWORD PTR [ecx+8]
; 595  :   00104 69 f6 e7 d3 0a
; 596  :     00       imul    esi, 709607        ; 000ad3e7H
; 597  :   0010a c1 c0 05     rol     eax, 5
; 598  :   0010d 33 41 0c     xor     eax, DWORD PTR [ecx+12]
; 599  :   00110 83 c1 18     add     ecx, 24            ; 00000018H
; 600  :   00113 33 f8        xor     edi, eax
; 601  : 
; 602  : ; 162  :        hash32C = (hash32C ^ (_rotl(*(uint32_t *)(p+16),5) ^ *(uint32_t *)(p+20))) * PRIME;        
; 603  : 
; 604  :   00115 8b 41 f8     mov     eax, DWORD PTR [ecx-8]
; 605  :   00118 69 ff e7 d3 0a
; 606  :     00       imul    edi, 709607        ; 000ad3e7H
; 607  :   0011e c1 c0 05     rol     eax, 5
; 608  :   00121 33 41 fc     xor     eax, DWORD PTR [ecx-4]
; 609  :   00124 33 e8        xor     ebp, eax
; 610  :   00126 69 ed e7 d3 0a
; 611  :     00       imul    ebp, 709607        ; 000ad3e7H
; 612  :   0012c 4a       dec     edx
; 613  :   0012d 75 c5        jne     SHORT $LL9@FNV1A_Hash@2
; 614  : */
; 615  : 
; 616  : /*
; 617  : // Intel(R) C++ Compiler XE for applications running on IA-32, Version 12.1.1.258 Build 20111011 gave this:
; 618  : // 216a-212f+2= 61 bytes, No CARAMBA anymore.
; 619  : ;;;     for(; wrdlen >= 3*2*sizeof(uint32_t); wrdlen -= 3*2*sizeof(uint32_t), p += 3*2*sizeof(uint32_t)) {
; 620  : 
; 621  :   02127 83 fa 18         cmp edx, 24                            
; 622  :   0212a 72 43            jb .B4.5 ; Prob 10%                    
; 623  :                                 ; LOE eax edx ecx ebx ebp esi edi
; 624  : .B4.2:                          ; Preds .B4.1
; 625  :   0212c 89 34 24         mov DWORD PTR [esp], esi               ;
; 626  :                                 ; LOE eax edx ecx ebx ebp edi
; 627  : .B4.3:                          ; Preds .B4.2 .B4.3
; 628  : 
; 629  : ;;;         hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        
; 630  : 
; 631  :   0212f 8b 31            mov esi, DWORD PTR [ecx]               
; 632  :   02131 83 c2 e8         add edx, -24                           
; 633  :   02134 c1 c6 05         rol esi, 5                             
; 634  :   02137 33 71 04         xor esi, DWORD PTR [4+ecx]             
; 635  :   0213a 33 de            xor ebx, esi                           
; 636  : 
; 637  : ;;;         hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+12))) * PRIME;        
; 638  : 
; 639  :   0213c 8b 71 08         mov esi, DWORD PTR [8+ecx]             
; 640  :   0213f c1 c6 05         rol esi, 5                             
; 641  :   02142 33 71 0c         xor esi, DWORD PTR [12+ecx]            
; 642  :   02145 33 fe            xor edi, esi                           
; 643  : 
; 644  : ;;;         hash32C = (hash32C ^ (ROL(*(uint32_t *)(p+16),5) ^ *(uint32_t *)(p+20))) * PRIME;        
; 645  : 
; 646  :   02147 8b 71 10         mov esi, DWORD PTR [16+ecx]            
; 647  :   0214a c1 c6 05         rol esi, 5                             
; 648  :   0214d 33 71 14         xor esi, DWORD PTR [20+ecx]            
; 649  :   02150 83 c1 18         add ecx, 24                            
; 650  :   02153 33 ee            xor ebp, esi                           
; 651  :   02155 69 db e7 d3 0a 
; 652  :         00               imul ebx, ebx, 709607                  
; 653  :   0215b 69 ff e7 d3 0a 
; 654  :         00               imul edi, edi, 709607                  
; 655  :   02161 69 ed e7 d3 0a 
; 656  :         00               imul ebp, ebp, 709607                  
; 657  :   02167 83 fa 18         cmp edx, 24                            
; 658  :   0216a 73 c3            jae .B4.3 ; Prob 82%                   
; 659  :                                 ; LOE eax edx ecx ebx ebp edi
; 660  : .B4.4:                          ; Preds .B4.3
; 661  :   0216c 8b 34 24         mov esi, DWORD PTR [esp]               ;
; 662  :                                 ; LOE eax edx ecx ebx ebp esi edi
; 663  : .B4.5:                          ; Preds .B4.1 .B4.4
; 664  : */
; 665  : 
; 666  :     }
; 667  :     if (p != str) {

  009b5	4c 3b cb	 cmp	 r9, rbx
  009b8	74 0d		 je	 SHORT $LN6@FNV1A_Hash@9

; 668  :         hash32 = (hash32 ^ ROL(hash32C,5) ) * PRIME;

  009ba	c1 c1 05	 rol	 ecx, 5
  009bd	44 33 c1	 xor	 r8d, ecx
  009c0	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN6@FNV1A_Hash@9:

; 669  :         //hash32B = (hash32B ^ ROL(hash32D,5) ) * PRIME;
; 670  :     }
; 671  : 
; 672  :     // 1111=15; 10111=23
; 673  :     if (wrdlen & 4*sizeof(uint32_t)) {  

  009c7	41 f6 c3 10	 test	 r11b, 16
  009cb	74 2d		 je	 SHORT $LN5@FNV1A_Hash@9

; 674  :         hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  009cd	41 8b 01	 mov	 eax, DWORD PTR [r9]
  009d0	c1 c0 05	 rol	 eax, 5
  009d3	41 33 41 04	 xor	 eax, DWORD PTR [r9+4]
  009d7	44 33 c0	 xor	 r8d, eax

; 675  :         hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+12))) * PRIME;        

  009da	41 8b 41 08	 mov	 eax, DWORD PTR [r9+8]
  009de	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  009e5	c1 c0 05	 rol	 eax, 5
  009e8	41 33 41 0c	 xor	 eax, DWORD PTR [r9+12]
  009ec	44 33 d0	 xor	 r10d, eax
  009ef	45 69 d2 e7 d3
	0a 00		 imul	 r10d, 709607		; 000ad3e7H

; 676  :         p += 8*sizeof(uint16_t);

  009f6	49 83 c1 10	 add	 r9, 16
$LN5@FNV1A_Hash@9:

; 677  :     }
; 678  :     // Cases: 0,1,2,3,4,5,6,7,...,15
; 679  :     if (wrdlen & 2*sizeof(uint32_t)) {

  009fa	41 f6 c3 08	 test	 r11b, 8
  009fe	74 19		 je	 SHORT $LN4@FNV1A_Hash@9

; 680  :         hash32 = (hash32 ^ *(uint32_t*)(p+0)) * PRIME;

  00a00	45 33 01	 xor	 r8d, DWORD PTR [r9]

; 681  :         hash32B = (hash32B ^ *(uint32_t*)(p+4)) * PRIME;

  00a03	45 33 51 04	 xor	 r10d, DWORD PTR [r9+4]
  00a07	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00a0e	45 69 d2 e7 d3
	0a 00		 imul	 r10d, 709607		; 000ad3e7H

; 682  :         p += 4*sizeof(uint16_t);

  00a15	49 83 c1 08	 add	 r9, 8
$LN4@FNV1A_Hash@9:

; 683  :     }
; 684  :     // Cases: 0,1,2,3,4,5,6,7
; 685  :     if (wrdlen & sizeof(uint32_t)) {

  00a19	41 f6 c3 04	 test	 r11b, 4
  00a1d	74 21		 je	 SHORT $LN3@FNV1A_Hash@9

; 686  :         hash32 = (hash32 ^ *(uint16_t*)(p+0)) * PRIME;

  00a1f	41 0f b7 01	 movzx	 eax, WORD PTR [r9]
  00a23	44 33 c0	 xor	 r8d, eax

; 687  :         hash32B = (hash32B ^ *(uint16_t*)(p+2)) * PRIME;

  00a26	41 0f b7 41 02	 movzx	 eax, WORD PTR [r9+2]
  00a2b	44 33 d0	 xor	 r10d, eax
  00a2e	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00a35	45 69 d2 e7 d3
	0a 00		 imul	 r10d, 709607		; 000ad3e7H

; 688  :         p += 2*sizeof(uint16_t);

  00a3c	49 83 c1 04	 add	 r9, 4
$LN3@FNV1A_Hash@9:

; 689  :     }
; 690  :     if (wrdlen & sizeof(uint16_t)) {

  00a40	41 f6 c3 02	 test	 r11b, 2
  00a44	74 12		 je	 SHORT $LN2@FNV1A_Hash@9

; 691  :         hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  00a46	41 0f b7 01	 movzx	 eax, WORD PTR [r9]
  00a4a	44 33 c0	 xor	 r8d, eax
  00a4d	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 692  :         p += sizeof(uint16_t);

  00a54	49 83 c1 02	 add	 r9, 2
$LN2@FNV1A_Hash@9:

; 693  :     }
; 694  :     if (wrdlen & 1) 

  00a58	41 f6 c3 01	 test	 r11b, 1
  00a5c	74 0e		 je	 SHORT $LN1@FNV1A_Hash@9

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

  00a5e	41 0f be 01	 movsx	 eax, BYTE PTR [r9]
  00a62	44 33 c0	 xor	 r8d, eax
  00a65	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN1@FNV1A_Hash@9:

; 696  : 
; 697  :     hash32 = (hash32 ^ ROL(hash32B,5) ) * PRIME;
; 698  :     return hash32 ^ (hash32 >> 16);
; 699  : }

  00a6c	48 8b 5c 24 08	 mov	 rbx, QWORD PTR [rsp+8]
  00a71	41 c1 c2 05	 rol	 r10d, 5
  00a75	45 33 d0	 xor	 r10d, r8d
  00a78	45 69 d2 e7 d3
	0a 00		 imul	 r10d, 709607		; 000ad3e7H
  00a7f	41 8b c2	 mov	 eax, r10d
  00a82	c1 e8 10	 shr	 eax, 16
  00a85	41 33 c2	 xor	 eax, r10d
  00a88	c3		 ret	 0
FNV1A_Hash_YoshimitsuTRIAD ENDP
_TEXT	ENDS
PUBLIC	FNV1A_Hash_YoshimitsuTRIADii
pdata	SEGMENT
$pdata$FNV1A_Hash_YoshimitsuTRIADii DD imagerel $LN16
	DD	imagerel $LN16+68
	DD	imagerel $unwind$FNV1A_Hash_YoshimitsuTRIADii
$pdata$1$FNV1A_Hash_YoshimitsuTRIADii DD imagerel $LN16+68
	DD	imagerel $LN16+194
	DD	imagerel $chain$1$FNV1A_Hash_YoshimitsuTRIADii
$pdata$2$FNV1A_Hash_YoshimitsuTRIADii DD imagerel $LN16+194
	DD	imagerel $LN16+389
	DD	imagerel $chain$2$FNV1A_Hash_YoshimitsuTRIADii
pdata	ENDS
xdata	SEGMENT
$unwind$FNV1A_Hash_YoshimitsuTRIADii DD 010401H
	DD	0204H
$chain$1$FNV1A_Hash_YoshimitsuTRIADii DD 040e21H
	DD	0740eH
	DD	023405H
	DD	imagerel $LN16
	DD	imagerel $LN16+68
	DD	imagerel $unwind$FNV1A_Hash_YoshimitsuTRIADii
$chain$2$FNV1A_Hash_YoshimitsuTRIADii DD 021H
	DD	imagerel $LN16
	DD	imagerel $LN16+68
	DD	imagerel $unwind$FNV1A_Hash_YoshimitsuTRIADii
; Function compile flags: /Ogtpy
xdata	ENDS
_TEXT	SEGMENT
str$ = 16
wrdlen$ = 24
FNV1A_Hash_YoshimitsuTRIADii PROC

; 702  : {

$LN16:
  00a90	48 83 ec 08	 sub	 rsp, 8

; 703  :     const uint32_t PRIME = 709607;
; 704  :     uint32_t hash32 = 2166136261;

  00a94	41 b9 c5 9d 1c
	81		 mov	 r9d, -2128831035	; 811c9dc5H
  00a9a	4c 8b d2	 mov	 r10, rdx
  00a9d	45 8b c1	 mov	 r8d, r9d

; 705  :     uint32_t hash32B = 2166136261;
; 706  :     uint32_t hash32C = 2166136261;

  00aa0	45 8b d9	 mov	 r11d, r9d

; 707  :     const char *p = str;
; 708  :     uint32_t Loop_Counter;
; 709  :     uint32_t Second_Line_Offset;
; 710  : 
; 711  : if (wrdlen >= 24) {

  00aa3	48 83 fa 18	 cmp	 rdx, 24
  00aa7	0f 82 b1 00 00
	00		 jb	 $LN10@FNV1A_Hash@10

; 712  :     Loop_Counter = (wrdlen/24);

  00aad	48 b8 ab aa aa
	aa aa aa aa aa	 mov	 rax, -6148914691236517205 ; aaaaaaaaaaaaaaabH
  00ab7	49 f7 e2	 mul	 r10
  00aba	48 c1 ea 04	 shr	 rdx, 4

; 713  :     Loop_Counter++;

  00abe	ff c2		 inc	 edx

; 714  :     Second_Line_Offset = wrdlen-(Loop_Counter)*(3*4);

  00ac0	8d 04 52	 lea	 eax, DWORD PTR [rdx+rdx*2]
  00ac3	c1 e0 02	 shl	 eax, 2
  00ac6	44 2b d0	 sub	 r10d, eax
  00ac9	49 63 c2	 movsxd	 rax, r10d

; 715  :     for(; Loop_Counter; Loop_Counter--, p += 3*sizeof(uint32_t)) {

  00acc	85 d2		 test	 edx, edx
  00ace	0f 84 7e 00 00
	00		 je	 $LN7@FNV1A_Hash@10

; 712  :     Loop_Counter = (wrdlen/24);

  00ad4	48 89 5c 24 10	 mov	 QWORD PTR [rsp+16], rbx
  00ad9	4c 8d 54 08 04	 lea	 r10, QWORD PTR [rax+rcx+4]
  00ade	48 89 3c 24	 mov	 QWORD PTR [rsp], rdi

; 715  :     for(; Loop_Counter; Loop_Counter--, p += 3*sizeof(uint32_t)) {

  00ae2	48 8b c8	 mov	 rcx, rax
  00ae5	bb 04 00 00 00	 mov	 ebx, 4
  00aea	48 c7 c7 fc ff
	ff ff		 mov	 rdi, -4
  00af1	48 f7 d9	 neg	 rcx
  00af4	48 2b d8	 sub	 rbx, rax
  00af7	48 2b f8	 sub	 rdi, rax
  00afa	66 0f 1f 44 00
	00		 npad	 6
$LL9@FNV1A_Hash@10:

; 716  : 		hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+0+Second_Line_Offset))) * PRIME;        

  00b00	42 8b 04 17	 mov	 eax, DWORD PTR [rdi+r10]
  00b04	49 83 c2 0c	 add	 r10, 12
  00b08	c1 c0 05	 rol	 eax, 5
  00b0b	41 33 42 f0	 xor	 eax, DWORD PTR [r10-16]
  00b0f	44 33 c0	 xor	 r8d, eax

; 717  : 		hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+4+Second_Line_Offset),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  00b12	41 8b 42 f4	 mov	 eax, DWORD PTR [r10-12]
  00b16	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00b1d	c1 c0 05	 rol	 eax, 5
  00b20	42 33 44 11 f4	 xor	 eax, DWORD PTR [rcx+r10-12]
  00b25	44 33 c8	 xor	 r9d, eax

; 718  : 		hash32C = (hash32C ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+8+Second_Line_Offset))) * PRIME;        

  00b28	42 8b 44 13 f4	 mov	 eax, DWORD PTR [rbx+r10-12]
  00b2d	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H
  00b34	c1 c0 05	 rol	 eax, 5
  00b37	41 33 42 f8	 xor	 eax, DWORD PTR [r10-8]
  00b3b	44 33 d8	 xor	 r11d, eax
  00b3e	45 69 db e7 d3
	0a 00		 imul	 r11d, 709607		; 000ad3e7H
  00b45	ff ca		 dec	 edx
  00b47	75 b7		 jne	 SHORT $LL9@FNV1A_Hash@10
  00b49	48 8b 3c 24	 mov	 rdi, QWORD PTR [rsp]
  00b4d	48 8b 5c 24 10	 mov	 rbx, QWORD PTR [rsp+16]
$LN7@FNV1A_Hash@10:

; 719  :     }
; 720  : 		hash32 = (hash32 ^ ROL(hash32C,5) ) * PRIME;

  00b52	41 c1 c3 05	 rol	 r11d, 5
  00b56	45 33 c3	 xor	 r8d, r11d

; 721  : } else {

  00b59	e9 94 00 00 00	 jmp	 $LN15@FNV1A_Hash@10
$LN10@FNV1A_Hash@10:

; 722  :     // 1111=15; 10111=23
; 723  :     if (wrdlen & 4*sizeof(uint32_t)) {	

  00b5e	f6 c2 10	 test	 dl, 16
  00b61	74 2c		 je	 SHORT $LN5@FNV1A_Hash@10

; 724  : 		hash32 = (hash32 ^ (ROL(*(uint32_t *)(p+0),5) ^ *(uint32_t *)(p+4))) * PRIME;        

  00b63	44 8b 01	 mov	 r8d, DWORD PTR [rcx]

; 725  : 		hash32B = (hash32B ^ (ROL(*(uint32_t *)(p+8),5) ^ *(uint32_t *)(p+12))) * PRIME;        

  00b66	8b 41 08	 mov	 eax, DWORD PTR [rcx+8]
  00b69	41 c1 c0 05	 rol	 r8d, 5
  00b6d	44 33 41 04	 xor	 r8d, DWORD PTR [rcx+4]
  00b71	45 33 c1	 xor	 r8d, r9d
  00b74	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00b7b	c1 c0 05	 rol	 eax, 5
  00b7e	33 41 0c	 xor	 eax, DWORD PTR [rcx+12]
  00b81	44 33 c8	 xor	 r9d, eax
  00b84	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 726  : 		p += 8*sizeof(uint16_t);

  00b8b	48 83 c1 10	 add	 rcx, 16
$LN5@FNV1A_Hash@10:

; 727  :     }
; 728  :     // Cases: 0,1,2,3,4,5,6,7,...,15
; 729  :     if (wrdlen & 2*sizeof(uint32_t)) {

  00b8f	f6 c2 08	 test	 dl, 8
  00b92	74 19		 je	 SHORT $LN4@FNV1A_Hash@10

; 730  : 		hash32 = (hash32 ^ *(uint32_t*)(p+0)) * PRIME;

  00b94	44 33 01	 xor	 r8d, DWORD PTR [rcx]

; 731  : 		hash32B = (hash32B ^ *(uint32_t*)(p+4)) * PRIME;

  00b97	44 33 49 04	 xor	 r9d, DWORD PTR [rcx+4]
  00b9b	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00ba2	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 732  : 		p += 4*sizeof(uint16_t);

  00ba9	48 83 c1 08	 add	 rcx, 8
$LN4@FNV1A_Hash@10:

; 733  :     }
; 734  :     // Cases: 0,1,2,3,4,5,6,7
; 735  :     if (wrdlen & sizeof(uint32_t)) {

  00bad	f6 c2 04	 test	 dl, 4
  00bb0	74 1f		 je	 SHORT $LN3@FNV1A_Hash@10

; 736  : 		hash32 = (hash32 ^ *(uint16_t*)(p+0)) * PRIME;

  00bb2	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  00bb5	44 33 c0	 xor	 r8d, eax

; 737  : 		hash32B = (hash32B ^ *(uint16_t*)(p+2)) * PRIME;

  00bb8	0f b7 41 02	 movzx	 eax, WORD PTR [rcx+2]
  00bbc	44 33 c8	 xor	 r9d, eax
  00bbf	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
  00bc6	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 738  : 		p += 2*sizeof(uint16_t);

  00bcd	48 83 c1 04	 add	 rcx, 4
$LN3@FNV1A_Hash@10:

; 739  :     }
; 740  :     if (wrdlen & sizeof(uint16_t)) {

  00bd1	f6 c2 02	 test	 dl, 2
  00bd4	74 11		 je	 SHORT $LN2@FNV1A_Hash@10

; 741  :         hash32 = (hash32 ^ *(uint16_t*)p) * PRIME;

  00bd6	0f b7 01	 movzx	 eax, WORD PTR [rcx]
  00bd9	44 33 c0	 xor	 r8d, eax
  00bdc	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H

; 742  :         p += sizeof(uint16_t);

  00be3	48 83 c1 02	 add	 rcx, 2
$LN2@FNV1A_Hash@10:

; 743  :     }
; 744  :     if (wrdlen & 1) 

  00be7	f6 c2 01	 test	 dl, 1
  00bea	74 0d		 je	 SHORT $LN1@FNV1A_Hash@10

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

  00bec	0f be 01	 movsx	 eax, BYTE PTR [rcx]
  00bef	44 33 c0	 xor	 r8d, eax
$LN15@FNV1A_Hash@10:
  00bf2	45 69 c0 e7 d3
	0a 00		 imul	 r8d, 709607		; 000ad3e7H
$LN1@FNV1A_Hash@10:

; 746  : }
; 747  :     hash32 = (hash32 ^ ROL(hash32B,5) ) * PRIME;

  00bf9	41 c1 c1 05	 rol	 r9d, 5
  00bfd	45 33 c8	 xor	 r9d, r8d
  00c00	45 69 c9 e7 d3
	0a 00		 imul	 r9d, 709607		; 000ad3e7H

; 748  :     return hash32 ^ (hash32 >> 16);

  00c07	41 8b c1	 mov	 eax, r9d
  00c0a	c1 e8 10	 shr	 eax, 16
  00c0d	41 33 c1	 xor	 eax, r9d

; 749  : }

  00c10	48 83 c4 08	 add	 rsp, 8
  00c14	c3		 ret	 0
FNV1A_Hash_YoshimitsuTRIADii ENDP
_TEXT	ENDS
END
