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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af5c], edx
jle 0x18013f791
lea rcx, [0x18022af5c]
call fcn.18017e33c
cmp dword [0x18022af5c], 0xffffffff
jne 0x18013f791
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013f77e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013f722
mov rdx, r11
test rax, rax
je 0x18013f760
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 0x18013f740
cmp r9d, 0x7a1c884e
je 0x18013f76b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013f711
jmp 0x18013f77e
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022aeec], r11d
lea rcx, [0x18022af5c]
call fcn.18017e2d0
movsxd rax, dword [0x18022aeec]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af74], edx
jle 0x18013f891
lea rcx, [0x18022af74]
call fcn.18017e33c
cmp dword [0x18022af74], 0xffffffff
jne 0x18013f891
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013f87e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013f822
mov rdx, r11
test rax, rax
je 0x18013f860
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 0x18013f840
cmp r9d, 0x7a1c884e
je 0x18013f86b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013f811
jmp 0x18013f87e
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022af68], r11d
lea rcx, [0x18022af74]
call fcn.18017e2d0
movsxd rax, dword [0x18022af68]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013f8b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022aee8], edx
jle 0x18013f991
lea rcx, [0x18022aee8]
call fcn.18017e33c
cmp dword [0x18022aee8], 0xffffffff
jne 0x18013f991
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013f97e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013f922
mov rdx, r11
test rax, rax
je 0x18013f960
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 0x18013f940
cmp r9d, 0x7a1c884e
je 0x18013f96b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013f911
jmp 0x18013f97e
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022aeb8], r11d
lea rcx, [0x18022aee8]
call fcn.18017e2d0
movsxd rax, dword [0x18022aeb8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af48], edx
jle 0x18013fa91
lea rcx, [0x18022af48]
call fcn.18017e33c
cmp dword [0x18022af48], 0xffffffff
jne 0x18013fa91
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013fa7e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013fa22
mov rdx, r11
test rax, rax
je 0x18013fa60
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 0x18013fa40
cmp r9d, 0x7a1c884e
je 0x18013fa6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013fa11
jmp 0x18013fa7e
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022af9c], r11d
lea rcx, [0x18022af48]
call fcn.18017e2d0
movsxd rax, dword [0x18022af9c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013fab0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af98], edx
jle 0x18013fb91
lea rcx, [0x18022af98]
call fcn.18017e33c
cmp dword [0x18022af98], 0xffffffff
jne 0x18013fb91
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013fb7e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013fb22
mov rdx, r11
test rax, rax
je 0x18013fb60
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 0x18013fb40
cmp r9d, 0x7a1c884e
je 0x18013fb6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013fb11
jmp 0x18013fb7e
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022af3c], r11d
lea rcx, [0x18022af98]
call fcn.18017e2d0
movsxd rax, dword [0x18022af3c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022aebc], edx
jle 0x18013fc91
lea rcx, [0x18022aebc]
call fcn.18017e33c
cmp dword [0x18022aebc], 0xffffffff
jne 0x18013fc91
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013fc7e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013fc22
mov rdx, r11
test rax, rax
je 0x18013fc60
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 0x18013fc40
cmp r9d, 0x7a1c884e
je 0x18013fc6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013fc11
jmp 0x18013fc7e
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022aef8], r11d
lea rcx, [0x18022aebc]
call fcn.18017e2d0
movsxd rax, dword [0x18022aef8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013fcb0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af04], edx
jle 0x18013fd91
lea rcx, [0x18022af04]
call fcn.18017e33c
cmp dword [0x18022af04], 0xffffffff
jne 0x18013fd91
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013fd7e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013fd22
mov rdx, r11
test rax, rax
je 0x18013fd60
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 0x18013fd40
cmp r9d, 0x7a1c884e
je 0x18013fd6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013fd11
jmp 0x18013fd7e
lea r8, str.m_vecPunchAngle
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022af90], r11d
lea rcx, [0x18022af04]
call fcn.18017e2d0
movsxd rax, dword [0x18022af90]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022afa4], edx
jle 0x18013fe91
lea rcx, [0x18022afa4]
call fcn.18017e33c
cmp dword [0x18022afa4], 0xffffffff
jne 0x18013fe91
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013fe7e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013fe22
mov rdx, r11
test rax, rax
je 0x18013fe60
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 0x18013fe40
cmp r9d, 0x7a1c884e
je 0x18013fe6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013fe11
jmp 0x18013fe7e
lea r8, str.m_vecPunchAngleVel
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022aed0], r11d
lea rcx, [0x18022afa4]
call fcn.18017e2d0
movsxd rax, dword [0x18022aed0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013feb0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022afa0], edx
jle 0x18013ff91
lea rcx, [0x18022afa0]
call fcn.18017e33c
cmp dword [0x18022afa0], 0xffffffff
jne 0x18013ff91
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013ff7e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013ff22
mov rdx, r11
test rax, rax
je 0x18013ff60
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 0x18013ff40
cmp r9d, 0x7a1c884e
je 0x18013ff6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013ff11
jmp 0x18013ff7e
lea r8, str.m_vecBaseVelocity
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022af70], r11d
lea rcx, [0x18022afa0]
call fcn.18017e2d0
movsxd rax, dword [0x18022af70]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022afc0], edx
jle 0x180140094
lea rcx, [0x18022afc0]
call fcn.18017e33c
cmp dword [0x18022afc0], 0xffffffff
jne 0x180140094
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014007e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140022
mov rdx, r11
test rax, rax
je 0x180140060
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 0x180140040
cmp r9d, 0x7a1c884e
je 0x18014006b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140011
jmp 0x18014007e
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 - 0xc]
mov dword [0x18022af1c], eax
lea rcx, [0x18022afc0]
call fcn.18017e2d0
movsxd rax, dword [0x18022af1c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801400b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022afc8], edx
jle 0x180140194
lea rcx, [0x18022afc8]
call fcn.18017e33c
cmp dword [0x18022afc8], 0xffffffff
jne 0x180140194
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014017e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140122
mov rdx, r11
test rax, rax
je 0x180140160
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 0x180140140
cmp r9d, 0x7a1c884e
je 0x18014016b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140111
jmp 0x18014017e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x18022af28], eax
lea rcx, [0x18022afc8]
call fcn.18017e2d0
movsxd rax, dword [0x18022af28]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af14], edx
jle 0x180140294
lea rcx, [0x18022af14]
call fcn.18017e33c
cmp dword [0x18022af14], 0xffffffff
jne 0x180140294
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014027e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140222
mov rdx, r11
test rax, rax
je 0x180140260
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 0x180140240
cmp r9d, 0x7a1c884e
je 0x18014026b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140211
jmp 0x18014027e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x18022aec8], eax
lea rcx, [0x18022af14]
call fcn.18017e2d0
movsxd rax, dword [0x18022aec8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801402b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022aec0], edx
jle 0x180140394
lea rcx, [0x18022aec0]
call fcn.18017e33c
cmp dword [0x18022aec0], 0xffffffff
jne 0x180140394
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014037e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140322
mov rdx, r11
test rax, rax
je 0x180140360
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 0x180140340
cmp r9d, 0x7a1c884e
je 0x18014036b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140311
jmp 0x18014037e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x18022af60], eax
lea rcx, [0x18022aec0]
call fcn.18017e2d0
movsxd rax, dword [0x18022af60]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022aedc], edx
jle 0x180140494
lea rcx, [0x18022aedc]
call fcn.18017e33c
cmp dword [0x18022aedc], 0xffffffff
jne 0x180140494
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014047e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140422
mov rdx, r11
test rax, rax
je 0x180140460
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 0x180140440
cmp r9d, 0x7a1c884e
je 0x18014046b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140411
jmp 0x18014047e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x18022aecc], eax
lea rcx, [0x18022aedc]
call fcn.18017e2d0
movsxd rax, dword [0x18022aecc]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801404b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022aee4], edx
jle 0x180140594
lea rcx, [0x18022aee4]
call fcn.18017e33c
cmp dword [0x18022aee4], 0xffffffff
jne 0x180140594
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014057e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140522
mov rdx, r11
test rax, rax
je 0x180140560
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 0x180140540
cmp r9d, 0x7a1c884e
je 0x18014056b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140511
jmp 0x18014057e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x18022afac], eax
lea rcx, [0x18022aee4]
call fcn.18017e2d0
movsxd rax, dword [0x18022afac]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af64], edx
jle 0x180140694
lea rcx, [0x18022af64]
call fcn.18017e33c
cmp dword [0x18022af64], 0xffffffff
jne 0x180140694
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014067e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140622
mov rdx, r11
test rax, rax
je 0x180140660
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 0x180140640
cmp r9d, 0x7a1c884e
je 0x18014066b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140611
jmp 0x18014067e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x18022af8c], eax
lea rcx, [0x18022af64]
call fcn.18017e2d0
movsxd rax, dword [0x18022af8c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801406b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af08], edx
jle 0x180140794
lea rcx, [0x18022af08]
call fcn.18017e33c
cmp dword [0x18022af08], 0xffffffff
jne 0x180140794
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014077e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140722
mov rdx, r11
test rax, rax
je 0x180140760
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 0x180140740
cmp r9d, 0x7a1c884e
je 0x18014076b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140711
jmp 0x18014077e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x18022af44], eax
lea rcx, [0x18022af08]
call fcn.18017e2d0
movsxd rax, dword [0x18022af44]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af6c], edx
jle 0x180140891
lea rcx, [0x18022af6c]
call fcn.18017e33c
cmp dword [0x18022af6c], 0xffffffff
jne 0x180140891
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014087e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140822
mov rdx, r11
test rax, rax
je 0x180140860
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 0x180140840
cmp r9d, 0x7c5cc931
je 0x18014086b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140811
jmp 0x18014087e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022aed4], r11d
lea rcx, [0x18022af6c]
call fcn.18017e2d0
movsxd rax, dword [0x18022aed4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801408b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af10], edx
jle 0x180140991
lea rcx, [0x18022af10]
call fcn.18017e33c
cmp dword [0x18022af10], 0xffffffff
jne 0x180140991
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014097e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140922
mov rdx, r11
test rax, rax
je 0x180140960
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 0x180140940
cmp r9d, 0x7c5cc931
je 0x18014096b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140911
jmp 0x18014097e
lea r8, str.m_bJumping
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022af2c], r11d
lea rcx, [0x18022af10]
call fcn.18017e2d0
movsxd rax, dword [0x18022af2c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022910c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022af38], edx
jle 0x180140a91
lea rcx, [0x18022af38]
call fcn.18017e33c
cmp dword [0x18022af38], 0xffffffff
jne 0x180140a91
mov rcx, qword [0x18022aa18]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140a7e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140a22
mov rdx, r11
test rax, rax
je 0x180140a60
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 0x180140a40
cmp r9d, 0x7c5cc931
je 0x180140a6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140a11
jmp 0x180140a7e
lea r8, str.m_iAirDash
mov rdx, qword [r10 + 0x18]
call fcn.18017ded0
mov r11d, eax
mov dword [0x18022af80], r11d
lea rcx, [0x18022af38]
call fcn.18017e2d0
movsxd rax, dword [0x18022af80]
add rax, rbx
add rsp, 0x20
pop rbx
ret