joyce8/EMBER2024-capa huggingface dataset:
Function at 0x180142060
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 [0x18022cfac], edx
jle 0x180142141
lea rcx, [0x18022cfac]
call fcn.18017f85c
cmp dword [0x18022cfac], 0xffffffff
jne 0x180142141
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014212e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801420d2
mov rdx, r11
test rax, rax
je 0x180142110
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 0x1801420f0
cmp r9d, 0x7c5cc931
je 0x18014211b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801420c1
jmp 0x18014212e
lea r8, str.m_flVehicleReverseTime
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cfc4], r11d
lea rcx, [0x18022cfac]
call fcn.18017f7f0
movsxd rax, dword [0x18022cfc4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180142160
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 [0x18022cfa8], edx
jle 0x180142241
lea rcx, [0x18022cfa8]
call fcn.18017f85c
cmp dword [0x18022cfa8], 0xffffffff
jne 0x180142241
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014222e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801421d2
mov rdx, r11
test rax, rax
je 0x180142210
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 0x1801421f0
cmp r9d, 0x7c5cc931
je 0x18014221b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801421c1
jmp 0x18014222e
lea r8, str.m_iKartState
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf5c], r11d
lea rcx, [0x18022cfa8]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf5c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180142260
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 [0x18022cfa0], edx
jle 0x180142344
lea rcx, [0x18022cfa0]
call fcn.18017f85c
cmp dword [0x18022cfa0], 0xffffffff
jne 0x180142344
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014232e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801422d2
mov rdx, r11
test rax, rax
je 0x180142310
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 0x1801422f0
cmp r9d, 0x7c5cc931
je 0x18014231b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801422c1
jmp 0x18014232e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 0x18]
mov dword [0x18022cf9c], eax
lea rcx, [0x18022cfa0]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf9c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180142360
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 [0x18022cf70], edx
jle 0x180142444
lea rcx, [0x18022cf70]
call fcn.18017f85c
cmp dword [0x18022cf70], 0xffffffff
jne 0x180142444
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014242e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801423d2
mov rdx, r11
test rax, rax
je 0x180142410
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 0x1801423f0
cmp r9d, 0x7c5cc931
je 0x18014241b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801423c1
jmp 0x18014242e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 3]
mov dword [0x18022cff8], eax
lea rcx, [0x18022cf70]
call fcn.18017f7f0
movsxd rax, dword [0x18022cff8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180142460
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 [0x18022cfcc], edx
jle 0x180142544
lea rcx, [0x18022cfcc]
call fcn.18017f85c
cmp dword [0x18022cfcc], 0xffffffff
jne 0x180142544
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014252e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801424d2
mov rdx, r11
test rax, rax
je 0x180142510
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 0x1801424f0
cmp r9d, 0x7c5cc931
je 0x18014251b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801424c1
jmp 0x18014252e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 + 1]
mov dword [0x18022cff4], eax
lea rcx, [0x18022cfcc]
call fcn.18017f7f0
movsxd rax, dword [0x18022cff4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180142560
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 [0x18022d020], edx
jle 0x180142644
lea rcx, [0x18022d020]
call fcn.18017f85c
cmp dword [0x18022d020], 0xffffffff
jne 0x180142644
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014262e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801425d2
mov rdx, r11
test rax, rax
je 0x180142610
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 0x1801425f0
cmp r9d, 0x7c5cc931
je 0x18014261b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801425c1
jmp 0x18014262e
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 + 4]
mov dword [0x18022cf84], eax
lea rcx, [0x18022d020]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf84]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180148450
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 [0x18022d0b0], edx
jle 0x180148531
lea rcx, [0x18022d0b0]
call fcn.18017f85c
cmp dword [0x18022d0b0], 0xffffffff
jne 0x180148531
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014851e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801484c2
mov rdx, r11
test rax, rax
je 0x180148500
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 0x1801484e0
cmp r9d, 0x14cce891
je 0x18014850b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801484b1
jmp 0x18014851e
lea r8, str.m_hLauncher
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d0a4], r11d
lea rcx, [0x18022d0b0]
call fcn.18017f7f0
movsxd rax, dword [0x18022d0a4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180148550
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 [0x18022d098], edx
jle 0x180148631
lea rcx, [0x18022d098]
call fcn.18017f85c
cmp dword [0x18022d098], 0xffffffff
jne 0x180148631
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014861e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801485c2
mov rdx, r11
test rax, rax
je 0x180148600
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 0x1801485e0
cmp r9d, 0xd134a6b7
je 0x18014860b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801485b1
jmp 0x18014861e
lea r8, str.m_hOwner
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d0ac], r11d
lea rcx, [0x18022d098]
call fcn.18017f7f0
movsxd rax, dword [0x18022d0ac]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180148650
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 [0x18022d0a0], edx
jle 0x180148731
lea rcx, [0x18022d0a0]
call fcn.18017f85c
cmp dword [0x18022d0a0], 0xffffffff
jne 0x180148731
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014871e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801486c2
mov rdx, r11
test rax, rax
je 0x180148700
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 0x1801486e0
cmp r9d, 0xc262c48c
je 0x18014870b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801486b1
jmp 0x18014871e
lea r8, str.m_hBuilder
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d09c], r11d
lea rcx, [0x18022d0a0]
call fcn.18017f7f0
movsxd rax, dword [0x18022d09c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x180148750
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 [0x18022d0a8], edx
jle 0x180148831
lea rcx, [0x18022d0a8]
call fcn.18017f85c
cmp dword [0x18022d0a8], 0xffffffff
jne 0x180148831
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014881e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801487c2
mov rdx, r11
test rax, rax
je 0x180148800
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 0x1801487e0
cmp r9d, 0x8d97f7e7
je 0x18014880b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801487b1
jmp 0x18014881e
lea r8, str.m_hPlayer
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d094], r11d
lea rcx, [0x18022d0a8]
call fcn.18017f7f0
movsxd rax, dword [0x18022d094]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18014abf0
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 [0x18022d0c4], edx
jle 0x18014acd1
lea rcx, [0x18022d0c4]
call fcn.18017f85c
cmp dword [0x18022d0c4], 0xffffffff
jne 0x18014acd1
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014acbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ac62
mov rdx, r11
test rax, rax
je 0x18014aca0
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 0x18014ac80
cmp r9d, 0xc262c48c
je 0x18014acab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014ac51
jmp 0x18014acbe
lea r8, str.m_iObjectMode
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d0d8], r11d
lea rcx, [0x18022d0c4]
call fcn.18017f7f0
movsxd rax, dword [0x18022d0d8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x18014acf0
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 [0x18022d0d4], edx
jle 0x18014add1
lea rcx, [0x18022d0d4]
call fcn.18017f85c
cmp dword [0x18022d0d4], 0xffffffff
jne 0x18014add1
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014adbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ad62
mov rdx, r11
test rax, rax
je 0x18014ada0
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 0x18014ad80
cmp r9d, 0xc262c48c
je 0x18014adab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014ad51
jmp 0x18014adbe
lea r8, str.m_bWasMapPlaced
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d104], r11d
lea rcx, [0x18022d0d4]
call fcn.18017f7f0
movsxd rax, dword [0x18022d104]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18014adf0
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 [0x18022d0cc], edx
jle 0x18014aed1
lea rcx, [0x18022d0cc]
call fcn.18017f85c
cmp dword [0x18022d0cc], 0xffffffff
jne 0x18014aed1
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014aebe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ae62
mov rdx, r11
test rax, rax
je 0x18014aea0
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 0x18014ae80
cmp r9d, 0x7ee68cd3
je 0x18014aeab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014ae51
jmp 0x18014aebe
lea r8, str.m_flChargeLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d0f4], r11d
lea rcx, [0x18022d0cc]
call fcn.18017f7f0
movsxd rax, dword [0x18022d0f4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
mov ebx, edx
mov rdi, rcx
mov r8d, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18022d0fc], r8d
jle 0x18014b001
lea rcx, [0x18022d0fc]
call fcn.18017f85c
cmp dword [0x18022d0fc], 0xffffffff
jne 0x18014b001
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014afee
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014af91
mov rdx, r11
test rax, rax
je 0x18014afd0
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 0x18014afb0
cmp r9d, 0x3369e751
je 0x18014afdb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014af80
jmp 0x18014afee
lea r8, str.m_iPing
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d0c0], r11d
lea rcx, [0x18022d0fc]
call fcn.18017f7f0
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x18022d0c0]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x18014fe90
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 [0x18022d120], edx
jle 0x18014ff71
lea rcx, [0x18022d120]
call fcn.18017f85c
cmp dword [0x18022d120], 0xffffffff
jne 0x18014ff71
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014ff5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ff02
mov rdx, r11
test rax, rax
je 0x18014ff40
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 0x18014ff20
cmp r9d, 0x47697bc5
je 0x18014ff4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014fef1
jmp 0x18014ff5e
lea r8, str.m_nSequence
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d114], r11d
lea rcx, [0x18022d120]
call fcn.18017f7f0
movsxd rax, dword [0x18022d114]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x18014ff90
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 [0x18022d11c], edx
jle 0x180150071
lea rcx, [0x18022d11c]
call fcn.18017f85c
cmp dword [0x18022d11c], 0xffffffff
jne 0x180150071
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015005e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180150002
mov rdx, r11
test rax, rax
je 0x180150040
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 0x180150020
cmp r9d, 0x47697bc5
je 0x18015004b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014fff1
jmp 0x18015005e
lea r8, str.m_flCycle
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d110], r11d
lea rcx, [0x18022d11c]
call fcn.18017f7f0
movsxd rax, dword [0x18022d110]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180150090
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 [0x18022d118], edx
jle 0x180150171
lea rcx, [0x18022d118]
call fcn.18017f85c
cmp dword [0x18022d118], 0xffffffff
jne 0x180150171
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015015e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180150102
mov rdx, r11
test rax, rax
je 0x180150140
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 0x180150120
cmp r9d, 0x47697bc5
je 0x18015014b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801500f1
jmp 0x18015015e
lea r8, str.m_flPoseParameter
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d10c], r11d
lea rcx, [0x18022d118]
call fcn.18017f7f0
movsxd rax, dword [0x18022d10c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801583b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x10], rdx
push rdi
sub rsp, 0x30
mov rbx, rdx
mov r8, rdx
cmp qword [rdx + 0x18], 0xf
jbe 0x1801583d4
mov r8, qword [rdx]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
inc rcx
cmp byte [r8 + rcx], 0
jne 0x1801583e0
xor esi, esi
mov edx, esi
test rcx, rcx
je 0x180158415
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 0x180158400
mov edx, 0xca0c003e
lea rcx, [0x1801f1911]
call fcn.1800dd4d0
cmp edi, eax
jne 0x180158444
mov rcx, rbx
call fcn.18008f640
xor eax, eax
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
mov r8, qword [rbx + 0x10]
mov rdx, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x180158455
mov rdx, qword [rbx]
movabs r9, 0xcbf29ce484222325
mov rcx, rsi
test r8, r8
je 0x180158484
movabs r10, 0x100000001b3
movzx eax, byte [rdx + rcx]
xor r9, rax
imul r9, r10
inc rcx
cmp rcx, r8
jb 0x180158471
mov r8, rbx
lea rdx, [rsp + 0x20]
lea rcx, [0x18022d3c0]
call fcn.180092ff0
cmp qword [rax + 8], rsi
je 0x1801584b9
mov r8, rbx
lea rdx, [rsp + 0x20]
lea rcx, [0x18022d3c0]
call fcn.18015a190
mov rcx, qword [rax]
mov rsi, qword [rcx + 0x30]
mov rcx, rbx
call fcn.18008f640
mov rax, rsi
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x18015d680
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 [0x18022d138], edx
jle 0x18015d761
lea rcx, [0x18022d138]
call fcn.18017f85c
cmp dword [0x18022d138], 0xffffffff
jne 0x18015d761
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015d74e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18015d6f2
mov rdx, r11
test rax, rax
je 0x18015d730
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 0x18015d710
cmp r9d, 0x7a1c884e
je 0x18015d73b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18015d6e1
jmp 0x18015d74e
lea r8, str.m_iObserverMode
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d124], r11d
lea rcx, [0x18022d138]
call fcn.18017f7f0
movsxd rax, dword [0x18022d124]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x18015d780
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 [0x18022d12c], edx
jle 0x18015d861
lea rcx, [0x18022d12c]
call fcn.18017f85c
cmp dword [0x18022d12c], 0xffffffff
jne 0x18015d861
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015d84e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18015d7f2
mov rdx, r11
test rax, rax
je 0x18015d830
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 0x18015d810
cmp r9d, 0x7a1c884e
je 0x18015d83b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18015d7e1
jmp 0x18015d84e
lea r8, str.m_hObserverTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d130], r11d
lea rcx, [0x18022d12c]
call fcn.18017f7f0
movsxd rax, dword [0x18022d130]
add rax, rbx
add rsp, 0x20
pop rbx
ret