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

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x18], r8
mov dword [rsp + 0x10], edx
push rbp
push rsi
push rdi
sub rsp, 0x30
mov rsi, r8
mov r9, rcx
test edx, edx
jne 0x18013ebb6
mov rcx, r8
call fcn.180092690
xor al, al
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
cmp qword [r8 + 0x18], 0xf
jbe 0x18013ebc0
mov r8, qword [r8]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
nop dword [rax]
inc rcx
cmp byte [r8 + rcx], 0
jne 0x18013ebd0
xor edx, edx
test rcx, rcx
je 0x18013ec05
nop dword [rax]
nop word [rax + rax]
movsx eax, byte [r8 + rdx]
xor eax, edi
imul edi, eax, 0x1000193
inc rdx
cmp rdx, rcx
jb 0x18013ebf0
lea rbp, [r9 + 0x50]
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180128660
mov rcx, qword [rax]
mov r10, qword [rcx + 0x20]
mov rbx, qword [rcx + 0x18]
cmp rbx, r10
je 0x18013ec86
nop dword [rax + rax]
mov r8, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013ec3d
mov r8, qword [rbx]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop word [rax + rax]
inc rax
cmp byte [r8 + rax], 0
jne 0x18013ec50
xor edx, edx
test rax, rax
je 0x18013ec78
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013ec61
cmp edi, r9d
je 0x18013ec86
add rbx, 0x20
cmp rbx, r10
jne 0x18013ec30
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180128660
mov rcx, qword [rax]
cmp rbx, qword [rcx + 0x20]
setne bl
mov rcx, rsi
call fcn.180092690
movzx eax, bl
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
Function at 0x180140ed0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230f68], edx
jle 0x180140fb1
lea rcx, [0x180230f68]
call fcn.18018237c
cmp dword [0x180230f68], 0xffffffff
jne 0x180140fb1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140f9e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140f42
mov rdx, r11
test rax, rax
je 0x180140f80
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 0x180140f60
cmp r9d, 0x9dc483b8
je 0x180140f8b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140f31
jmp 0x180140f9e
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230f6c], r11d
lea rcx, [0x180230f68]
call fcn.180182310
movsxd rax, dword [0x180230f6c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230f74], edx
jle 0x1801410b4
lea rcx, [0x180230f74]
call fcn.18018237c
cmp dword [0x180230f74], 0xffffffff
jne 0x1801410b4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014109e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141042
mov rdx, r11
test rax, rax
je 0x180141080
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 0x180141060
cmp r9d, 0x7c5cc931
je 0x18014108b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141031
jmp 0x18014109e
lea r8, str.m_hItem
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 0x58]
mov dword [0x180230f70], eax
lea rcx, [0x180230f74]
call fcn.180182310
movsxd rax, dword [0x180230f70]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141170
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 0x18], rsi
mov qword [rsp + 8], rcx
push rdi
sub rsp, 0x70
movabs rax, 0xcbf29ce484222325
movzx r9d, r8b
xor r9, rax
mov rsi, rdx
movabs rdx, 0x100000001b3
mov rax, r8
imul r9, rdx
shr rax, 8
mov rdi, r8
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x10
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x18
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x20
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x28
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x30
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x38
mov rcx, qword [0x180240370]
imul r9, rdx
xor r9, rax
imul r9, rdx
mov rdx, qword [0x180240358]
and rcx, r9
add rcx, rcx
mov rax, qword [rdx + rcx*8 + 8]
cmp rax, qword [0x180240348]
je 0x180141255
mov rcx, qword [rdx + rcx*8]
cmp r8, qword [rax + 0x10]
je 0x180141257
cmp rax, rcx
je 0x180141255
mov rax, qword [rax + 8]
cmp rdi, qword [rax + 0x10]
jne 0x180141244
jmp 0x180141257
xor eax, eax
test rax, rax
je 0x180141353
mov qword [rsp + 0x88], rbx
lea r8, [rsp + 0x80]
movaps xmmword [rsp + 0x60], xmm6
lea rdx, [rsp + 0x30]
movaps xmmword [rsp + 0x50], xmm7
lea rcx, [0x180240340]
movaps xmmword [rsp + 0x40], xmm8
mov qword [rsp + 0x80], rdi
call fcn.180142be0
mov rcx, qword [rax]
mov rax, qword [rdi]
movss xmm6, dword [rcx + 0x18]
movss xmm7, dword [rcx + 0x1c]
movss xmm8, dword [rcx + 0x20]
mov rcx, rdi
call qword [rax + 0x48]
mov rcx, rdi
mov rbx, rax
call fcn.1800a9ce0
movss xmm1, dword [rbx + 4]
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x30]
mov qword [rsp + 0x24], 0
mov dword [rsp + 0x20], 0
movss xmm0, dword [rax]
addss xmm0, dword [rbx]
addss xmm1, dword [rax + 4]
subss xmm6, xmm0
movss xmm0, dword [rbx + 8]
addss xmm0, dword [rax + 8]
subss xmm7, xmm1
movss dword [rsp + 0x30], xmm6
subss xmm8, xmm0
movss dword [rsp + 0x34], xmm7
movss dword [rsp + 0x38], xmm8
call fcn.1800bdd70
movss xmm0, dword [rsp + 0x20]
mov rax, rsi
movaps xmm8, xmmword [rsp + 0x40]
movaps xmm7, xmmword [rsp + 0x50]
movaps xmm6, xmmword [rsp + 0x60]
mov rbx, qword [rsp + 0x88]
movss dword [rsi], xmm0
mov byte [rsi + 4], 1
mov rsi, qword [rsp + 0x90]
add rsp, 0x70
pop rdi
ret
mov byte [rsi + 4], 0
mov rax, rsi
mov rsi, qword [rsp + 0x90]
add rsp, 0x70
pop rdi
ret
Function at 0x180142f00
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231020], edx
jle 0x180142fe1
lea rcx, [0x180231020]
call fcn.18018237c
cmp dword [0x180231020], 0xffffffff
jne 0x180142fe1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180142fce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180142f72
mov rdx, r11
test rax, rax
je 0x180142fb0
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 0x180142f90
cmp r9d, 0x7a1c884e
je 0x180142fbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180142f61
jmp 0x180142fce
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230fb0], r11d
lea rcx, [0x180231020]
call fcn.180182310
movsxd rax, dword [0x180230fb0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231038], edx
jle 0x1801430e1
lea rcx, [0x180231038]
call fcn.18018237c
cmp dword [0x180231038], 0xffffffff
jne 0x1801430e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801430ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143072
mov rdx, r11
test rax, rax
je 0x1801430b0
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 0x180143090
cmp r9d, 0x7a1c884e
je 0x1801430bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143061
jmp 0x1801430ce
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x18023102c], r11d
lea rcx, [0x180231038]
call fcn.180182310
movsxd rax, dword [0x18023102c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143100
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fb4], edx
jle 0x1801431e1
lea rcx, [0x180230fb4]
call fcn.18018237c
cmp dword [0x180230fb4], 0xffffffff
jne 0x1801431e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801431ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143172
mov rdx, r11
test rax, rax
je 0x1801431b0
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 0x180143190
cmp r9d, 0x7a1c884e
je 0x1801431bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143161
jmp 0x1801431ce
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230f7c], r11d
lea rcx, [0x180230fb4]
call fcn.180182310
movsxd rax, dword [0x180230f7c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023100c], edx
jle 0x1801432e1
lea rcx, [0x18023100c]
call fcn.18018237c
cmp dword [0x18023100c], 0xffffffff
jne 0x1801432e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801432ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143272
mov rdx, r11
test rax, rax
je 0x1801432b0
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 0x180143290
cmp r9d, 0x7a1c884e
je 0x1801432bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143261
jmp 0x1801432ce
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180231060], r11d
lea rcx, [0x18023100c]
call fcn.180182310
movsxd rax, dword [0x180231060]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143300
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023105c], edx
jle 0x1801433e1
lea rcx, [0x18023105c]
call fcn.18018237c
cmp dword [0x18023105c], 0xffffffff
jne 0x1801433e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801433ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143372
mov rdx, r11
test rax, rax
je 0x1801433b0
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 0x180143390
cmp r9d, 0x7a1c884e
je 0x1801433bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143361
jmp 0x1801433ce
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180231000], r11d
lea rcx, [0x18023105c]
call fcn.180182310
movsxd rax, dword [0x180231000]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230f84], edx
jle 0x1801434e1
lea rcx, [0x180230f84]
call fcn.18018237c
cmp dword [0x180230f84], 0xffffffff
jne 0x1801434e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801434ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143472
mov rdx, r11
test rax, rax
je 0x1801434b0
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 0x180143490
cmp r9d, 0x7a1c884e
je 0x1801434bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143461
jmp 0x1801434ce
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230fc0], r11d
lea rcx, [0x180230f84]
call fcn.180182310
movsxd rax, dword [0x180230fc0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143500
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fcc], edx
jle 0x1801435e1
lea rcx, [0x180230fcc]
call fcn.18018237c
cmp dword [0x180230fcc], 0xffffffff
jne 0x1801435e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801435ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143572
mov rdx, r11
test rax, rax
je 0x1801435b0
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 0x180143590
cmp r9d, 0x7a1c884e
je 0x1801435bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143561
jmp 0x1801435ce
lea r8, str.m_vecPunchAngle
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180231054], r11d
lea rcx, [0x180230fcc]
call fcn.180182310
movsxd rax, dword [0x180231054]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231068], edx
jle 0x1801436e1
lea rcx, [0x180231068]
call fcn.18018237c
cmp dword [0x180231068], 0xffffffff
jne 0x1801436e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801436ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143672
mov rdx, r11
test rax, rax
je 0x1801436b0
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 0x180143690
cmp r9d, 0x7a1c884e
je 0x1801436bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143661
jmp 0x1801436ce
lea r8, str.m_vecPunchAngleVel
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230f98], r11d
lea rcx, [0x180231068]
call fcn.180182310
movsxd rax, dword [0x180230f98]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143700
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231064], edx
jle 0x1801437e1
lea rcx, [0x180231064]
call fcn.18018237c
cmp dword [0x180231064], 0xffffffff
jne 0x1801437e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801437ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143772
mov rdx, r11
test rax, rax
je 0x1801437b0
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 0x180143790
cmp r9d, 0x7a1c884e
je 0x1801437bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143761
jmp 0x1801437ce
lea r8, str.m_vecBaseVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180231034], r11d
lea rcx, [0x180231064]
call fcn.180182310
movsxd rax, dword [0x180231034]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231084], edx
jle 0x1801438e4
lea rcx, [0x180231084]
call fcn.18018237c
cmp dword [0x180231084], 0xffffffff
jne 0x1801438e4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801438ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143872
mov rdx, r11
test rax, rax
je 0x1801438b0
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 0x180143890
cmp r9d, 0x7a1c884e
je 0x1801438bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143861
jmp 0x1801438ce
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 0xc]
mov dword [0x180230fe0], eax
lea rcx, [0x180231084]
call fcn.180182310
movsxd rax, dword [0x180230fe0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143900
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231090], edx
jle 0x1801439e4
lea rcx, [0x180231090]
call fcn.18018237c
cmp dword [0x180231090], 0xffffffff
jne 0x1801439e4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801439ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143972
mov rdx, r11
test rax, rax
je 0x1801439b0
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 0x180143990
cmp r9d, 0x7a1c884e
je 0x1801439bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143961
jmp 0x1801439ce
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x180230fec], eax
lea rcx, [0x180231090]
call fcn.180182310
movsxd rax, dword [0x180230fec]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fdc], edx
jle 0x180143ae4
lea rcx, [0x180230fdc]
call fcn.18018237c
cmp dword [0x180230fdc], 0xffffffff
jne 0x180143ae4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143ace
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143a72
mov rdx, r11
test rax, rax
je 0x180143ab0
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 0x180143a90
cmp r9d, 0x7a1c884e
je 0x180143abb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143a61
jmp 0x180143ace
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x180230f90], eax
lea rcx, [0x180230fdc]
call fcn.180182310
movsxd rax, dword [0x180230f90]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143b00
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230f88], edx
jle 0x180143be4
lea rcx, [0x180230f88]
call fcn.18018237c
cmp dword [0x180230f88], 0xffffffff
jne 0x180143be4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143bce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143b72
mov rdx, r11
test rax, rax
je 0x180143bb0
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 0x180143b90
cmp r9d, 0x7a1c884e
je 0x180143bbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143b61
jmp 0x180143bce
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x180231024], eax
lea rcx, [0x180230f88]
call fcn.180182310
movsxd rax, dword [0x180231024]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230f9c], edx
jle 0x180143ce4
lea rcx, [0x180230f9c]
call fcn.18018237c
cmp dword [0x180230f9c], 0xffffffff
jne 0x180143ce4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143cce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143c72
mov rdx, r11
test rax, rax
je 0x180143cb0
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 0x180143c90
cmp r9d, 0x7a1c884e
je 0x180143cbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143c61
jmp 0x180143cce
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x180230f94], eax
lea rcx, [0x180230f9c]
call fcn.180182310
movsxd rax, dword [0x180230f94]
add rax, rbx
add rsp, 0x20
pop rbx
ret