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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234054], edx
jle 0x180143af1
lea rcx, [0x180234054]
call fcn.180183aac
cmp dword [0x180234054], 0xffffffff
jne 0x180143af1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143ade
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143a82
mov rdx, r11
test rax, rax
je 0x180143ac0
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 0x180143aa0
cmp r9d, 0x7a1c884e
je 0x180143acb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143a71
jmp 0x180143ade
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x18023401c], r11d
lea rcx, [0x180234054]
call fcn.180183a40
movsxd rax, dword [0x18023401c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340ac], edx
jle 0x180143bf1
lea rcx, [0x1802340ac]
call fcn.180183aac
cmp dword [0x1802340ac], 0xffffffff
jne 0x180143bf1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143bde
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143b82
mov rdx, r11
test rax, rax
je 0x180143bc0
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 0x180143ba0
cmp r9d, 0x7a1c884e
je 0x180143bcb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143b71
jmp 0x180143bde
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180234100], r11d
lea rcx, [0x1802340ac]
call fcn.180183a40
movsxd rax, dword [0x180234100]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143c10
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340fc], edx
jle 0x180143cf1
lea rcx, [0x1802340fc]
call fcn.180183aac
cmp dword [0x1802340fc], 0xffffffff
jne 0x180143cf1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143cde
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143c82
mov rdx, r11
test rax, rax
je 0x180143cc0
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 0x180143ca0
cmp r9d, 0x7a1c884e
je 0x180143ccb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143c71
jmp 0x180143cde
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x1802340a0], r11d
lea rcx, [0x1802340fc]
call fcn.180183a40
movsxd rax, dword [0x1802340a0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234024], edx
jle 0x180143df1
lea rcx, [0x180234024]
call fcn.180183aac
cmp dword [0x180234024], 0xffffffff
jne 0x180143df1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143dde
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143d82
mov rdx, r11
test rax, rax
je 0x180143dc0
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 0x180143da0
cmp r9d, 0x7a1c884e
je 0x180143dcb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143d71
jmp 0x180143dde
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180234060], r11d
lea rcx, [0x180234024]
call fcn.180183a40
movsxd rax, dword [0x180234060]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143e10
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023406c], edx
jle 0x180143ef1
lea rcx, [0x18023406c]
call fcn.180183aac
cmp dword [0x18023406c], 0xffffffff
jne 0x180143ef1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143ede
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143e82
mov rdx, r11
test rax, rax
je 0x180143ec0
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 0x180143ea0
cmp r9d, 0x7a1c884e
je 0x180143ecb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143e71
jmp 0x180143ede
lea r8, str.m_vecPunchAngle
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x1802340f4], r11d
lea rcx, [0x18023406c]
call fcn.180183a40
movsxd rax, dword [0x1802340f4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234108], edx
jle 0x180143ff1
lea rcx, [0x180234108]
call fcn.180183aac
cmp dword [0x180234108], 0xffffffff
jne 0x180143ff1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143fde
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143f82
mov rdx, r11
test rax, rax
je 0x180143fc0
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 0x180143fa0
cmp r9d, 0x7a1c884e
je 0x180143fcb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143f71
jmp 0x180143fde
lea r8, str.m_vecPunchAngleVel
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180234038], r11d
lea rcx, [0x180234108]
call fcn.180183a40
movsxd rax, dword [0x180234038]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144010
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234104], edx
jle 0x1801440f1
lea rcx, [0x180234104]
call fcn.180183aac
cmp dword [0x180234104], 0xffffffff
jne 0x1801440f1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801440de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144082
mov rdx, r11
test rax, rax
je 0x1801440c0
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 0x1801440a0
cmp r9d, 0x7a1c884e
je 0x1801440cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144071
jmp 0x1801440de
lea r8, str.m_vecBaseVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x1802340d4], r11d
lea rcx, [0x180234104]
call fcn.180183a40
movsxd rax, dword [0x1802340d4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234124], edx
jle 0x1801441f4
lea rcx, [0x180234124]
call fcn.180183aac
cmp dword [0x180234124], 0xffffffff
jne 0x1801441f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801441de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144182
mov rdx, r11
test rax, rax
je 0x1801441c0
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 0x1801441a0
cmp r9d, 0x7a1c884e
je 0x1801441cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144171
jmp 0x1801441de
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 - 0xc]
mov dword [0x180234080], eax
lea rcx, [0x180234124]
call fcn.180183a40
movsxd rax, dword [0x180234080]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144210
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234130], edx
jle 0x1801442f4
lea rcx, [0x180234130]
call fcn.180183aac
cmp dword [0x180234130], 0xffffffff
jne 0x1801442f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801442de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144282
mov rdx, r11
test rax, rax
je 0x1801442c0
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 0x1801442a0
cmp r9d, 0x7a1c884e
je 0x1801442cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144271
jmp 0x1801442de
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x180234090], eax
lea rcx, [0x180234130]
call fcn.180183a40
movsxd rax, dword [0x180234090]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023407c], edx
jle 0x1801443f4
lea rcx, [0x18023407c]
call fcn.180183aac
cmp dword [0x18023407c], 0xffffffff
jne 0x1801443f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801443de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144382
mov rdx, r11
test rax, rax
je 0x1801443c0
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 0x1801443a0
cmp r9d, 0x7a1c884e
je 0x1801443cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144371
jmp 0x1801443de
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x180234030], eax
lea rcx, [0x18023407c]
call fcn.180183a40
movsxd rax, dword [0x180234030]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144410
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234028], edx
jle 0x1801444f4
lea rcx, [0x180234028]
call fcn.180183aac
cmp dword [0x180234028], 0xffffffff
jne 0x1801444f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801444de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144482
mov rdx, r11
test rax, rax
je 0x1801444c0
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 0x1801444a0
cmp r9d, 0x7a1c884e
je 0x1801444cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144471
jmp 0x1801444de
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x1802340c0], eax
lea rcx, [0x180234028]
call fcn.180183a40
movsxd rax, dword [0x1802340c0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023403c], edx
jle 0x1801445f4
lea rcx, [0x18023403c]
call fcn.180183aac
cmp dword [0x18023403c], 0xffffffff
jne 0x1801445f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801445de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144582
mov rdx, r11
test rax, rax
je 0x1801445c0
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 0x1801445a0
cmp r9d, 0x7a1c884e
je 0x1801445cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144571
jmp 0x1801445de
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x180234034], eax
lea rcx, [0x18023403c]
call fcn.180183a40
movsxd rax, dword [0x180234034]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144610
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234048], edx
jle 0x1801446f4
lea rcx, [0x180234048]
call fcn.180183aac
cmp dword [0x180234048], 0xffffffff
jne 0x1801446f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801446de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144682
mov rdx, r11
test rax, rax
je 0x1801446c0
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 0x1801446a0
cmp r9d, 0x7a1c884e
je 0x1801446cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144671
jmp 0x1801446de
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x180234110], eax
lea rcx, [0x180234048]
call fcn.180183a40
movsxd rax, dword [0x180234110]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340c8], edx
jle 0x1801447f4
lea rcx, [0x1802340c8]
call fcn.180183aac
cmp dword [0x1802340c8], 0xffffffff
jne 0x1801447f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801447de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144782
mov rdx, r11
test rax, rax
je 0x1801447c0
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 0x1801447a0
cmp r9d, 0x7a1c884e
je 0x1801447cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144771
jmp 0x1801447de
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x1802340f0], eax
lea rcx, [0x1802340c8]
call fcn.180183a40
movsxd rax, dword [0x1802340f0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144810
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234070], edx
jle 0x1801448f4
lea rcx, [0x180234070]
call fcn.180183aac
cmp dword [0x180234070], 0xffffffff
jne 0x1801448f4
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801448de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144882
mov rdx, r11
test rax, rax
je 0x1801448c0
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 0x1801448a0
cmp r9d, 0x7a1c884e
je 0x1801448cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144871
jmp 0x1801448de
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x1802340a8], eax
lea rcx, [0x180234070]
call fcn.180183a40
movsxd rax, dword [0x1802340a8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340cc], edx
jle 0x1801449f1
lea rcx, [0x1802340cc]
call fcn.180183aac
cmp dword [0x1802340cc], 0xffffffff
jne 0x1801449f1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801449de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144982
mov rdx, r11
test rax, rax
je 0x1801449c0
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 0x1801449a0
cmp r9d, 0x7c5cc931
je 0x1801449cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144971
jmp 0x1801449de
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180234044], r11d
lea rcx, [0x1802340cc]
call fcn.180183a40
movsxd rax, dword [0x180234044]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144a10
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234078], edx
jle 0x180144af1
lea rcx, [0x180234078]
call fcn.180183aac
cmp dword [0x180234078], 0xffffffff
jne 0x180144af1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144ade
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144a82
mov rdx, r11
test rax, rax
je 0x180144ac0
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 0x180144aa0
cmp r9d, 0x7c5cc931
je 0x180144acb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144a71
jmp 0x180144ade
lea r8, str.m_bJumping
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180234094], r11d
lea rcx, [0x180234078]
call fcn.180183a40
movsxd rax, dword [0x180234094]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234098], edx
jle 0x180144bf1
lea rcx, [0x180234098]
call fcn.180183aac
cmp dword [0x180234098], 0xffffffff
jne 0x180144bf1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144bde
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144b82
mov rdx, r11
test rax, rax
je 0x180144bc0
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 0x180144ba0
cmp r9d, 0x7c5cc931
je 0x180144bcb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144b71
jmp 0x180144bde
lea r8, str.m_iAirDash
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x1802340e4], r11d
lea rcx, [0x180234098]
call fcn.180183a40
movsxd rax, dword [0x1802340e4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144c10
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340b8], edx
jle 0x180144cf1
lea rcx, [0x1802340b8]
call fcn.180183aac
cmp dword [0x1802340b8], 0xffffffff
jne 0x180144cf1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144cde
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144c82
mov rdx, r11
test rax, rax
je 0x180144cc0
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 0x180144ca0
cmp r9d, 0x7c5cc931
je 0x180144ccb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144c71
jmp 0x180144cde
lea r8, str.m_nAirDucked
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x18023410c], r11d
lea rcx, [0x1802340b8]
call fcn.180183a40
movsxd rax, dword [0x18023410c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340e0], edx
jle 0x180144df1
lea rcx, [0x1802340e0]
call fcn.180183aac
cmp dword [0x1802340e0], 0xffffffff
jne 0x180144df1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144dde
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144d82
mov rdx, r11
test rax, rax
je 0x180144dc0
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 0x180144da0
cmp r9d, 0x7c5cc931
je 0x180144dcb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144d71
jmp 0x180144dde
lea r8, str.m_flHypeMeter
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x1802340ec], r11d
lea rcx, [0x1802340e0]
call fcn.180183a40
movsxd rax, dword [0x1802340ec]
add rax, rbx
add rsp, 0x20
pop rbx
ret