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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d040], edx
jle 0x180140d41
lea rcx, [0x18022d040]
call fcn.18017f85c
cmp dword [0x18022d040], 0xffffffff
jne 0x180140d41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140d2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140cd2
mov rdx, r11
test rax, rax
je 0x180140d10
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 0x180140cf0
cmp r9d, 0x7a1c884e
je 0x180140d1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140cc1
jmp 0x180140d2e
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cfe4], r11d
lea rcx, [0x18022d040]
call fcn.18017f7f0
movsxd rax, dword [0x18022cfe4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf68], edx
jle 0x180140e41
lea rcx, [0x18022cf68]
call fcn.18017f85c
cmp dword [0x18022cf68], 0xffffffff
jne 0x180140e41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140e2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140dd2
mov rdx, r11
test rax, rax
je 0x180140e10
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 0x180140df0
cmp r9d, 0x7a1c884e
je 0x180140e1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140dc1
jmp 0x180140e2e
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cfa4], r11d
lea rcx, [0x18022cf68]
call fcn.18017f7f0
movsxd rax, dword [0x18022cfa4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180140e60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cfb0], edx
jle 0x180140f41
lea rcx, [0x18022cfb0]
call fcn.18017f85c
cmp dword [0x18022cfb0], 0xffffffff
jne 0x180140f41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140f2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140ed2
mov rdx, r11
test rax, rax
je 0x180140f10
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 0x180140ef0
cmp r9d, 0x7a1c884e
je 0x180140f1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140ec1
jmp 0x180140f2e
lea r8, str.m_vecPunchAngle
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d038], r11d
lea rcx, [0x18022cfb0]
call fcn.18017f7f0
movsxd rax, dword [0x18022d038]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d04c], edx
jle 0x180141041
lea rcx, [0x18022d04c]
call fcn.18017f85c
cmp dword [0x18022d04c], 0xffffffff
jne 0x180141041
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014102e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140fd2
mov rdx, r11
test rax, rax
je 0x180141010
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 0x180140ff0
cmp r9d, 0x7a1c884e
je 0x18014101b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140fc1
jmp 0x18014102e
lea r8, str.m_vecPunchAngleVel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf7c], r11d
lea rcx, [0x18022d04c]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf7c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141060
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d048], edx
jle 0x180141141
lea rcx, [0x18022d048]
call fcn.18017f85c
cmp dword [0x18022d048], 0xffffffff
jne 0x180141141
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014112e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801410d2
mov rdx, r11
test rax, rax
je 0x180141110
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 0x1801410f0
cmp r9d, 0x7a1c884e
je 0x18014111b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801410c1
jmp 0x18014112e
lea r8, str.m_vecBaseVelocity
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d018], r11d
lea rcx, [0x18022d048]
call fcn.18017f7f0
movsxd rax, dword [0x18022d018]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d068], edx
jle 0x180141244
lea rcx, [0x18022d068]
call fcn.18017f85c
cmp dword [0x18022d068], 0xffffffff
jne 0x180141244
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014122e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801411d2
mov rdx, r11
test rax, rax
je 0x180141210
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 0x1801411f0
cmp r9d, 0x7a1c884e
je 0x18014121b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801411c1
jmp 0x18014122e
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 0xc]
mov dword [0x18022cfc8], eax
lea rcx, [0x18022d068]
call fcn.18017f7f0
movsxd rax, dword [0x18022cfc8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141260
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d074], edx
jle 0x180141344
lea rcx, [0x18022d074]
call fcn.18017f85c
cmp dword [0x18022d074], 0xffffffff
jne 0x180141344
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014132e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801412d2
mov rdx, r11
test rax, rax
je 0x180141310
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 0x1801412f0
cmp r9d, 0x7a1c884e
je 0x18014131b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801412c1
jmp 0x18014132e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x18022cfd4], eax
lea rcx, [0x18022d074]
call fcn.18017f7f0
movsxd rax, dword [0x18022cfd4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cfbc], edx
jle 0x180141444
lea rcx, [0x18022cfbc]
call fcn.18017f85c
cmp dword [0x18022cfbc], 0xffffffff
jne 0x180141444
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014142e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801413d2
mov rdx, r11
test rax, rax
je 0x180141410
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 0x1801413f0
cmp r9d, 0x7a1c884e
je 0x18014141b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801413c1
jmp 0x18014142e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x18022cf74], eax
lea rcx, [0x18022cfbc]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf74]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141460
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf6c], edx
jle 0x180141544
lea rcx, [0x18022cf6c]
call fcn.18017f85c
cmp dword [0x18022cf6c], 0xffffffff
jne 0x180141544
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014152e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801414d2
mov rdx, r11
test rax, rax
je 0x180141510
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 0x1801414f0
cmp r9d, 0x7a1c884e
je 0x18014151b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801414c1
jmp 0x18014152e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x18022d004], eax
lea rcx, [0x18022cf6c]
call fcn.18017f7f0
movsxd rax, dword [0x18022d004]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf80], edx
jle 0x180141644
lea rcx, [0x18022cf80]
call fcn.18017f85c
cmp dword [0x18022cf80], 0xffffffff
jne 0x180141644
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014162e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801415d2
mov rdx, r11
test rax, rax
je 0x180141610
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 0x1801415f0
cmp r9d, 0x7a1c884e
je 0x18014161b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801415c1
jmp 0x18014162e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x18022cf78], eax
lea rcx, [0x18022cf80]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf78]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141660
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf8c], edx
jle 0x180141744
lea rcx, [0x18022cf8c]
call fcn.18017f85c
cmp dword [0x18022cf8c], 0xffffffff
jne 0x180141744
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014172e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801416d2
mov rdx, r11
test rax, rax
je 0x180141710
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 0x1801416f0
cmp r9d, 0x7a1c884e
je 0x18014171b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801416c1
jmp 0x18014172e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x18022d054], eax
lea rcx, [0x18022cf8c]
call fcn.18017f7f0
movsxd rax, dword [0x18022d054]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d00c], edx
jle 0x180141844
lea rcx, [0x18022d00c]
call fcn.18017f85c
cmp dword [0x18022d00c], 0xffffffff
jne 0x180141844
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014182e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801417d2
mov rdx, r11
test rax, rax
je 0x180141810
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 0x1801417f0
cmp r9d, 0x7a1c884e
je 0x18014181b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801417c1
jmp 0x18014182e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x18022d034], eax
lea rcx, [0x18022d00c]
call fcn.18017f7f0
movsxd rax, dword [0x18022d034]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141860
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cfb4], edx
jle 0x180141944
lea rcx, [0x18022cfb4]
call fcn.18017f85c
cmp dword [0x18022cfb4], 0xffffffff
jne 0x180141944
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014192e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801418d2
mov rdx, r11
test rax, rax
je 0x180141910
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 0x1801418f0
cmp r9d, 0x7a1c884e
je 0x18014191b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801418c1
jmp 0x18014192e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x18022cfec], eax
lea rcx, [0x18022cfb4]
call fcn.18017f7f0
movsxd rax, dword [0x18022cfec]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d010], edx
jle 0x180141a41
lea rcx, [0x18022d010]
call fcn.18017f85c
cmp dword [0x18022d010], 0xffffffff
jne 0x180141a41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141a2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801419d2
mov rdx, r11
test rax, rax
je 0x180141a10
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 0x1801419f0
cmp r9d, 0x7c5cc931
je 0x180141a1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801419c1
jmp 0x180141a2e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf88], r11d
lea rcx, [0x18022d010]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf88]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141a60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cfc0], edx
jle 0x180141b41
lea rcx, [0x18022cfc0]
call fcn.18017f85c
cmp dword [0x18022cfc0], 0xffffffff
jne 0x180141b41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141b2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141ad2
mov rdx, r11
test rax, rax
je 0x180141b10
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 0x180141af0
cmp r9d, 0x7c5cc931
je 0x180141b1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141ac1
jmp 0x180141b2e
lea r8, str.m_bJumping
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cfd8], r11d
lea rcx, [0x18022cfc0]
call fcn.18017f7f0
movsxd rax, dword [0x18022cfd8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cfe0], edx
jle 0x180141c41
lea rcx, [0x18022cfe0]
call fcn.18017f85c
cmp dword [0x18022cfe0], 0xffffffff
jne 0x180141c41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141c2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141bd2
mov rdx, r11
test rax, rax
je 0x180141c10
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 0x180141bf0
cmp r9d, 0x7c5cc931
je 0x180141c1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141bc1
jmp 0x180141c2e
lea r8, str.m_iAirDash
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d028], r11d
lea rcx, [0x18022cfe0]
call fcn.18017f7f0
movsxd rax, dword [0x18022d028]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141c60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cffc], edx
jle 0x180141d41
lea rcx, [0x18022cffc]
call fcn.18017f85c
cmp dword [0x18022cffc], 0xffffffff
jne 0x180141d41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141d2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141cd2
mov rdx, r11
test rax, rax
je 0x180141d10
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 0x180141cf0
cmp r9d, 0x7c5cc931
je 0x180141d1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141cc1
jmp 0x180141d2e
lea r8, str.m_nAirDucked
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d050], r11d
lea rcx, [0x18022cffc]
call fcn.18017f7f0
movsxd rax, dword [0x18022d050]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d024], edx
jle 0x180141e41
lea rcx, [0x18022d024]
call fcn.18017f85c
cmp dword [0x18022d024], 0xffffffff
jne 0x180141e41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141e2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141dd2
mov rdx, r11
test rax, rax
je 0x180141e10
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 0x180141df0
cmp r9d, 0x7c5cc931
je 0x180141e1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141dc1
jmp 0x180141e2e
lea r8, str.m_flHypeMeter
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d030], r11d
lea rcx, [0x18022d024]
call fcn.18017f7f0
movsxd rax, dword [0x18022d030]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141e60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cfdc], edx
jle 0x180141f41
lea rcx, [0x18022cfdc]
call fcn.18017f85c
cmp dword [0x18022cfdc], 0xffffffff
jne 0x180141f41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141f2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141ed2
mov rdx, r11
test rax, rax
je 0x180141f10
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 0x180141ef0
cmp r9d, 0x7c5cc931
je 0x180141f1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141ec1
jmp 0x180141f2e
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d000], r11d
lea rcx, [0x18022cfdc]
call fcn.18017f7f0
movsxd rax, dword [0x18022d000]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cfb8], edx
jle 0x180142041
lea rcx, [0x18022cfb8]
call fcn.18017f85c
cmp dword [0x18022cfb8], 0xffffffff
jne 0x180142041
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014202e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141fd2
mov rdx, r11
test rax, rax
je 0x180142010
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 0x180141ff0
cmp r9d, 0x7c5cc931
je 0x18014201b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141fc1
jmp 0x18014202e
lea r8, str.m_flCurrentTauntMoveSpeed
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d06c], r11d
lea rcx, [0x18022cfb8]
call fcn.18017f7f0
movsxd rax, dword [0x18022d06c]
add rax, rbx
add rsp, 0x20
pop rbx
ret