joyce8/EMBER2024-capa huggingface dataset:
Function at 0x180143150
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235018], edx
jle 0x180143231
lea rcx, [0x180235018]
call fcn.180184cfc
cmp dword [0x180235018], 0xffffffff
jne 0x180143231
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014321e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801431c2
mov rdx, r11
test rax, rax
je 0x180143200
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801431e0
cmp r9d, 0x9dc483b8
je 0x18014320b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801431b1
jmp 0x18014321e
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x18023501c], r11d
lea rcx, [0x180235018]
call fcn.180184c90
movsxd rax, dword [0x18023501c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180143250
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235024], edx
jle 0x180143334
lea rcx, [0x180235024]
call fcn.180184cfc
cmp dword [0x180235024], 0xffffffff
jne 0x180143334
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014331e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801432c2
mov rdx, r11
test rax, rax
je 0x180143300
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801432e0
cmp r9d, 0x7c5cc931
je 0x18014330b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801432b1
jmp 0x18014331e
lea r8, str.m_hItem
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 - 0x58]
mov dword [0x180235020], eax
lea rcx, [0x180235024]
call fcn.180184c90
movsxd rax, dword [0x180235020]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144970
Capabilities:
Hash data using fnv

Disassembly:
movzx r8d, byte [rdx]
mov r9, rcx
movabs rcx, 0x100000001b3
movabs rax, 0xcbf29ce484222325
xor r8, rax
mov r10, rdx
movzx eax, byte [rdx + 1]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 2]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 3]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 4]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 5]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 6]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 7]
mov rdx, qword [r9 + 0x30]
imul r8, rcx
xor r8, rax
imul r8, rcx
and rdx, r8
shl rdx, 4
add rdx, qword [r9 + 0x18]
mov rax, qword [rdx + 8]
cmp rax, qword [r9 + 8]
je 0x180144a1d
mov rcx, qword [r10]
mov rdx, qword [rdx]
cmp rcx, qword [rax + 0x10]
je 0x180144a1f
cmp rax, rdx
je 0x180144a1d
mov rax, qword [rax + 8]
cmp rcx, qword [rax + 0x10]
jne 0x180144a07
test rax, rax
setne al
ret
xor eax, eax
test rax, rax
setne al
ret
Function at 0x180144dd0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350d0], edx
jle 0x180144eb1
lea rcx, [0x1802350d0]
call fcn.180184cfc
cmp dword [0x1802350d0], 0xffffffff
jne 0x180144eb1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144e9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144e42
mov rdx, r11
test rax, rax
je 0x180144e80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180144e60
cmp r9d, 0x7a1c884e
je 0x180144e8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144e31
jmp 0x180144e9e
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x180235064], r11d
lea rcx, [0x1802350d0]
call fcn.180184c90
movsxd rax, dword [0x180235064]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180144ed0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350e8], edx
jle 0x180144fb1
lea rcx, [0x1802350e8]
call fcn.180184cfc
cmp dword [0x1802350e8], 0xffffffff
jne 0x180144fb1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144f9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144f42
mov rdx, r11
test rax, rax
je 0x180144f80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180144f60
cmp r9d, 0x7a1c884e
je 0x180144f8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144f31
jmp 0x180144f9e
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x1802350dc], r11d
lea rcx, [0x1802350e8]
call fcn.180184c90
movsxd rax, dword [0x1802350dc]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144fd0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235060], edx
jle 0x1801450b1
lea rcx, [0x180235060]
call fcn.180184cfc
cmp dword [0x180235060], 0xffffffff
jne 0x1801450b1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014509e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145042
mov rdx, r11
test rax, rax
je 0x180145080
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145060
cmp r9d, 0x7a1c884e
je 0x18014508b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145031
jmp 0x18014509e
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x180235030], r11d
lea rcx, [0x180235060]
call fcn.180184c90
movsxd rax, dword [0x180235030]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x1801450d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350bc], edx
jle 0x1801451b1
lea rcx, [0x1802350bc]
call fcn.180184cfc
cmp dword [0x1802350bc], 0xffffffff
jne 0x1801451b1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014519e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145142
mov rdx, r11
test rax, rax
je 0x180145180
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145160
cmp r9d, 0x7a1c884e
je 0x18014518b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145131
jmp 0x18014519e
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x180235110], r11d
lea rcx, [0x1802350bc]
call fcn.180184c90
movsxd rax, dword [0x180235110]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801451d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023510c], edx
jle 0x1801452b1
lea rcx, [0x18023510c]
call fcn.180184cfc
cmp dword [0x18023510c], 0xffffffff
jne 0x1801452b1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014529e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145242
mov rdx, r11
test rax, rax
je 0x180145280
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145260
cmp r9d, 0x7a1c884e
je 0x18014528b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145231
jmp 0x18014529e
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x1802350b0], r11d
lea rcx, [0x18023510c]
call fcn.180184c90
movsxd rax, dword [0x1802350b0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x1801452d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235034], edx
jle 0x1801453b1
lea rcx, [0x180235034]
call fcn.180184cfc
cmp dword [0x180235034], 0xffffffff
jne 0x1801453b1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014539e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145342
mov rdx, r11
test rax, rax
je 0x180145380
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145360
cmp r9d, 0x7a1c884e
je 0x18014538b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145331
jmp 0x18014539e
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x180235070], r11d
lea rcx, [0x180235034]
call fcn.180184c90
movsxd rax, dword [0x180235070]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801453d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023507c], edx
jle 0x1801454b1
lea rcx, [0x18023507c]
call fcn.180184cfc
cmp dword [0x18023507c], 0xffffffff
jne 0x1801454b1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014549e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145442
mov rdx, r11
test rax, rax
je 0x180145480
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145460
cmp r9d, 0x7a1c884e
je 0x18014548b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145431
jmp 0x18014549e
lea r8, str.m_vecPunchAngle
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x180235104], r11d
lea rcx, [0x18023507c]
call fcn.180184c90
movsxd rax, dword [0x180235104]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x1801454d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235118], edx
jle 0x1801455b1
lea rcx, [0x180235118]
call fcn.180184cfc
cmp dword [0x180235118], 0xffffffff
jne 0x1801455b1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014559e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145542
mov rdx, r11
test rax, rax
je 0x180145580
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145560
cmp r9d, 0x7a1c884e
je 0x18014558b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145531
jmp 0x18014559e
lea r8, str.m_vecPunchAngleVel
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x180235048], r11d
lea rcx, [0x180235118]
call fcn.180184c90
movsxd rax, dword [0x180235048]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801455d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235114], edx
jle 0x1801456b1
lea rcx, [0x180235114]
call fcn.180184cfc
cmp dword [0x180235114], 0xffffffff
jne 0x1801456b1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014569e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145642
mov rdx, r11
test rax, rax
je 0x180145680
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145660
cmp r9d, 0x7a1c884e
je 0x18014568b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145631
jmp 0x18014569e
lea r8, str.m_vecBaseVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x1802350e4], r11d
lea rcx, [0x180235114]
call fcn.180184c90
movsxd rax, dword [0x1802350e4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x1801456d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235134], edx
jle 0x1801457b4
lea rcx, [0x180235134]
call fcn.180184cfc
cmp dword [0x180235134], 0xffffffff
jne 0x1801457b4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014579e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145742
mov rdx, r11
test rax, rax
je 0x180145780
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145760
cmp r9d, 0x7a1c884e
je 0x18014578b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145731
jmp 0x18014579e
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 - 0xc]
mov dword [0x180235094], eax
lea rcx, [0x180235134]
call fcn.180184c90
movsxd rax, dword [0x180235094]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801457d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235140], edx
jle 0x1801458b4
lea rcx, [0x180235140]
call fcn.180184cfc
cmp dword [0x180235140], 0xffffffff
jne 0x1801458b4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014589e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145842
mov rdx, r11
test rax, rax
je 0x180145880
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145860
cmp r9d, 0x7a1c884e
je 0x18014588b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145831
jmp 0x18014589e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x18023509c], eax
lea rcx, [0x180235140]
call fcn.180184c90
movsxd rax, dword [0x18023509c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x1801458d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235088], edx
jle 0x1801459b4
lea rcx, [0x180235088]
call fcn.180184cfc
cmp dword [0x180235088], 0xffffffff
jne 0x1801459b4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014599e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145942
mov rdx, r11
test rax, rax
je 0x180145980
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145960
cmp r9d, 0x7a1c884e
je 0x18014598b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145931
jmp 0x18014599e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x180235040], eax
lea rcx, [0x180235088]
call fcn.180184c90
movsxd rax, dword [0x180235040]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801459d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235038], edx
jle 0x180145ab4
lea rcx, [0x180235038]
call fcn.180184cfc
cmp dword [0x180235038], 0xffffffff
jne 0x180145ab4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145a9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145a42
mov rdx, r11
test rax, rax
je 0x180145a80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145a60
cmp r9d, 0x7a1c884e
je 0x180145a8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145a31
jmp 0x180145a9e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x1802350d4], eax
lea rcx, [0x180235038]
call fcn.180184c90
movsxd rax, dword [0x1802350d4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180145ad0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235050], edx
jle 0x180145bb4
lea rcx, [0x180235050]
call fcn.180184cfc
cmp dword [0x180235050], 0xffffffff
jne 0x180145bb4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145b9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145b42
mov rdx, r11
test rax, rax
je 0x180145b80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145b60
cmp r9d, 0x7a1c884e
je 0x180145b8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145b31
jmp 0x180145b9e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x180235044], eax
lea rcx, [0x180235050]
call fcn.180184c90
movsxd rax, dword [0x180235044]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180145bd0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023505c], edx
jle 0x180145cb4
lea rcx, [0x18023505c]
call fcn.180184cfc
cmp dword [0x18023505c], 0xffffffff
jne 0x180145cb4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145c9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145c42
mov rdx, r11
test rax, rax
je 0x180145c80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145c60
cmp r9d, 0x7a1c884e
je 0x180145c8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145c31
jmp 0x180145c9e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x180235120], eax
lea rcx, [0x18023505c]
call fcn.180184c90
movsxd rax, dword [0x180235120]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180145cd0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350d8], edx
jle 0x180145db4
lea rcx, [0x1802350d8]
call fcn.180184cfc
cmp dword [0x1802350d8], 0xffffffff
jne 0x180145db4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145d9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145d42
mov rdx, r11
test rax, rax
je 0x180145d80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145d60
cmp r9d, 0x7a1c884e
je 0x180145d8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145d31
jmp 0x180145d9e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x180235100], eax
lea rcx, [0x1802350d8]
call fcn.180184c90
movsxd rax, dword [0x180235100]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180145dd0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235080], edx
jle 0x180145eb4
lea rcx, [0x180235080]
call fcn.180184cfc
cmp dword [0x180235080], 0xffffffff
jne 0x180145eb4
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145e9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145e42
mov rdx, r11
test rax, rax
je 0x180145e80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145e60
cmp r9d, 0x7a1c884e
je 0x180145e8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145e31
jmp 0x180145e9e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x1802350b8], eax
lea rcx, [0x180235080]
call fcn.180184c90
movsxd rax, dword [0x1802350b8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180145ed0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023328c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350e0], edx
jle 0x180145fb1
lea rcx, [0x1802350e0]
call fcn.180184cfc
cmp dword [0x1802350e0], 0xffffffff
jne 0x180145fb1
mov rcx, qword [0x180234b88]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145f9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145f42
mov rdx, r11
test rax, rax
je 0x180145f80
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180145f60
cmp r9d, 0x7c5cc931
je 0x180145f8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145f31
jmp 0x180145f9e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180184890
mov r11d, eax
mov dword [0x18023504c], r11d
lea rcx, [0x1802350e0]
call fcn.180184c90
movsxd rax, dword [0x18023504c]
add rax, rbx
add rsp, 0x20
pop rbx
ret