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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802976a8], edx
jle 0x180157374
lea rcx, [0x1802976a8]
call fcn.180199ce8
cmp dword [0x1802976a8], 0xffffffff
jne 0x180157374
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015735e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180157302
mov rdx, r11
test rax, rax
je 0x180157340
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 0x180157320
cmp r9d, 0x7c5cc931
je 0x18015734b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801572f1
jmp 0x18015735e
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 + 4]
mov dword [0x180297608], eax
lea rcx, [0x1802976a8]
call fcn.180199c7c
movsxd rax, dword [0x180297608]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18015d190
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297740], edx
jle 0x18015d271
lea rcx, [0x180297740]
call fcn.180199ce8
cmp dword [0x180297740], 0xffffffff
jne 0x18015d271
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015d25e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18015d202
mov rdx, r11
test rax, rax
je 0x18015d240
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 0x18015d220
cmp r9d, 0x14cce891
je 0x18015d24b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18015d1f1
jmp 0x18015d25e
lea r8, str.m_hLauncher
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x180297730], r11d
lea rcx, [0x180297740]
call fcn.180199c7c
movsxd rax, dword [0x180297730]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297720], edx
jle 0x18015d371
lea rcx, [0x180297720]
call fcn.180199ce8
cmp dword [0x180297720], 0xffffffff
jne 0x18015d371
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015d35e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18015d302
mov rdx, r11
test rax, rax
je 0x18015d340
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 0x18015d320
cmp r9d, 0xd134a6b7
je 0x18015d34b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18015d2f1
jmp 0x18015d35e
lea r8, str.m_hOwner
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x18029773c], r11d
lea rcx, [0x180297720]
call fcn.180199c7c
movsxd rax, dword [0x18029773c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18015d390
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297734], edx
jle 0x18015d471
lea rcx, [0x180297734]
call fcn.180199ce8
cmp dword [0x180297734], 0xffffffff
jne 0x18015d471
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015d45e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18015d402
mov rdx, r11
test rax, rax
je 0x18015d440
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 0x18015d420
cmp r9d, 0xc262c48c
je 0x18015d44b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18015d3f1
jmp 0x18015d45e
lea r8, str.m_bPlacing
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x18029772c], r11d
lea rcx, [0x180297734]
call fcn.180199c7c
movsxd rax, dword [0x18029772c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297728], edx
jle 0x18015d571
lea rcx, [0x180297728]
call fcn.180199ce8
cmp dword [0x180297728], 0xffffffff
jne 0x18015d571
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015d55e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18015d502
mov rdx, r11
test rax, rax
je 0x18015d540
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 0x18015d520
cmp r9d, 0xc262c48c
je 0x18015d54b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18015d4f1
jmp 0x18015d55e
lea r8, str.m_hBuilder
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x180297724], r11d
lea rcx, [0x180297728]
call fcn.180199c7c
movsxd rax, dword [0x180297724]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18015d590
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297738], edx
jle 0x18015d671
lea rcx, [0x180297738]
call fcn.180199ce8
cmp dword [0x180297738], 0xffffffff
jne 0x18015d671
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015d65e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18015d602
mov rdx, r11
test rax, rax
je 0x18015d640
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 0x18015d620
cmp r9d, 0x8d97f7e7
je 0x18015d64b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18015d5f1
jmp 0x18015d65e
lea r8, str.m_hPlayer
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x18029771c], r11d
lea rcx, [0x180297738]
call fcn.180199c7c
movsxd rax, dword [0x18029771c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297760], edx
jle 0x1801601d1
lea rcx, [0x180297760]
call fcn.180199ce8
cmp dword [0x180297760], 0xffffffff
jne 0x1801601d1
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801601be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180160162
mov rdx, r11
test rax, rax
je 0x1801601a0
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 0x180160180
cmp r9d, 0xc262c48c
je 0x1801601ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160151
jmp 0x1801601be
lea r8, str.m_iObjectMode
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x180297774], r11d
lea rcx, [0x180297760]
call fcn.180199c7c
movsxd rax, dword [0x180297774]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801601f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297770], edx
jle 0x1801602d1
lea rcx, [0x180297770]
call fcn.180199ce8
cmp dword [0x180297770], 0xffffffff
jne 0x1801602d1
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801602be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180160262
mov rdx, r11
test rax, rax
je 0x1801602a0
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 0x180160280
cmp r9d, 0xc262c48c
je 0x1801602ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160251
jmp 0x1801602be
lea r8, str.m_bWasMapPlaced
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802977a4], r11d
lea rcx, [0x180297770]
call fcn.180199c7c
movsxd rax, dword [0x1802977a4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801602f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
push r14
sub rsp, 0x20
mov rsi, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov rbx, qword [rax + rdx*8]
mov r14d, 4
xor edi, edi
mov eax, dword [r14 + rbx]
cmp dword [0x180297744], eax
jle 0x1801603cd
lea rcx, [0x180297744]
call fcn.180199ce8
cmp dword [0x180297744], 0xffffffff
jne 0x1801603cd
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
test rax, rax
je 0x1801603b9
mov r8, qword [r10 + 0x10]
mov rcx, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rcx
cmp byte [r8 + rcx], 0
jne 0x180160372
mov rdx, rdi
test rcx, rcx
je 0x1801603b0
nop dword [rax]
nop dword [rax + rax]
movsx eax, byte [r8 + rdx]
xor eax, r9d
imul r9d, eax, 0x1000193
inc rdx
cmp rdx, rcx
jb 0x180160390
cmp r9d, 0xd2a053d5
je 0x1801603e2
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160361
mov eax, edi
mov dword [0x18029779c], eax
lea rcx, [0x180297744]
call fcn.180199c7c
movsxd rax, dword [0x18029779c]
cmp dword [rax + rsi], 6
je 0x1801603f4
xorps xmm0, xmm0
jmp 0x1801604cf
lea r8, str.m_iState
mov rdx, qword [r10 + 0x18]
call fcn.180199880
jmp 0x1801603bb
mov eax, dword [r14 + rbx]
cmp dword [0x180297758], eax
jle 0x1801604af
lea rcx, [0x180297758]
call fcn.180199ce8
cmp dword [0x180297758], 0xffffffff
jne 0x1801604af
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
test rax, rax
je 0x18016049d
mov r8, qword [r10 + 0x10]
mov rcx, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rcx
cmp byte [r8 + rcx], 0
jne 0x180160443
mov rdx, rdi
test rcx, rcx
je 0x180160480
nop word [rax + rax]
movsx eax, byte [r8 + rdx]
xor eax, r9d
imul r9d, eax, 0x1000193
inc rdx
cmp rdx, rcx
jb 0x180160460
cmp r9d, 0xd2a053d5
je 0x18016048b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160432
jmp 0x18016049d
lea r8, str.m_flRechargeTime
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov edi, eax
mov dword [0x180297798], edi
lea rcx, [0x180297758]
call fcn.180199c7c
movsxd rax, dword [0x180297798]
movss xmm0, dword [rax + rsi]
mov rax, qword [0x1802971a8]
subss xmm0, dword [rax + 0xc]
addss xmm0, dword [0x18026312c]
mov rbx, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
mov rdi, qword [rsp + 0x40]
add rsp, 0x20
pop r14
ret
Function at 0x1801604f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297790], edx
jle 0x1801605d1
lea rcx, [0x180297790]
call fcn.180199ce8
cmp dword [0x180297790], 0xffffffff
jne 0x1801605d1
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801605be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180160562
mov rdx, r11
test rax, rax
je 0x1801605a0
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 0x180160580
cmp r9d, 0x33faa6b2
je 0x1801605ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160551
jmp 0x1801605be
lea r8, str.m_nFlagStatus
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x18029775c], r11d
lea rcx, [0x180297790]
call fcn.180199c7c
movsxd rax, dword [0x18029775c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297768], edx
jle 0x1801606d1
lea rcx, [0x180297768]
call fcn.180199ce8
cmp dword [0x180297768], 0xffffffff
jne 0x1801606d1
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801606be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180160662
mov rdx, r11
test rax, rax
je 0x1801606a0
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 0x180160680
cmp r9d, 0x7ee68cd3
je 0x1801606ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160651
jmp 0x1801606be
lea r8, str.m_flChargeLevel
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x18029778c], r11d
lea rcx, [0x180297768]
call fcn.180199c7c
movsxd rax, dword [0x18029778c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801662c0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802977c0], edx
jle 0x1801663a1
lea rcx, [0x1802977c0]
call fcn.180199ce8
cmp dword [0x1802977c0], 0xffffffff
jne 0x1801663a1
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18016638e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180166332
mov rdx, r11
test rax, rax
je 0x180166370
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 0x180166350
cmp r9d, 0x47697bc5
je 0x18016637b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180166321
jmp 0x18016638e
lea r8, str.m_nSequence
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802977b4], r11d
lea rcx, [0x1802977c0]
call fcn.180199c7c
movsxd rax, dword [0x1802977b4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802977bc], edx
jle 0x1801664a1
lea rcx, [0x1802977bc]
call fcn.180199ce8
cmp dword [0x1802977bc], 0xffffffff
jne 0x1801664a1
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18016648e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180166432
mov rdx, r11
test rax, rax
je 0x180166470
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 0x180166450
cmp r9d, 0x47697bc5
je 0x18016647b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180166421
jmp 0x18016648e
lea r8, str.m_flCycle
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802977b0], r11d
lea rcx, [0x1802977bc]
call fcn.180199c7c
movsxd rax, dword [0x1802977b0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801664c0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802977b8], edx
jle 0x1801665a1
lea rcx, [0x1802977b8]
call fcn.180199ce8
cmp dword [0x1802977b8], 0xffffffff
jne 0x1801665a1
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18016658e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180166532
mov rdx, r11
test rax, rax
je 0x180166570
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 0x180166550
cmp r9d, 0x47697bc5
je 0x18016657b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180166521
jmp 0x18016658e
lea r8, str.m_flPoseParameter
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802977ac], r11d
lea rcx, [0x1802977b8]
call fcn.180199c7c
movsxd rax, dword [0x1802977ac]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18016e960
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 0x18016e984
mov r8, qword [rdx]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
inc rcx
cmp byte [r8 + rcx], 0
jne 0x18016e990
xor esi, esi
mov edx, esi
test rcx, rcx
je 0x18016e9c5
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 0x18016e9b0
mov edx, 0xca0c003e
lea rcx, [0x18024cf81]
call fcn.1800ea660
cmp edi, eax
jne 0x18016e9f4
mov rcx, rbx
call fcn.18009a190
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 0x18016ea05
mov rdx, qword [rbx]
movabs r9, 0xcbf29ce484222325
mov rcx, rsi
test r8, r8
je 0x18016ea34
movabs r10, 0x100000001b3
movzx eax, byte [rdx + rcx]
xor r9, rax
imul r9, r10
inc rcx
cmp rcx, r8
jb 0x18016ea21
mov r8, rbx
lea rdx, [rsp + 0x20]
lea rcx, [0x180297a70]
call fcn.18009dcd0
cmp qword [rax + 8], rsi
je 0x18016ea69
mov r8, rbx
lea rdx, [rsp + 0x20]
lea rcx, [0x180297a70]
call fcn.1801707c0
mov rcx, qword [rax]
mov rsi, qword [rcx + 0x30]
mov rcx, rbx
call fcn.18009a190
mov rax, rsi
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x180173d20
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802977d8], edx
jle 0x180173e01
lea rcx, [0x1802977d8]
call fcn.180199ce8
cmp dword [0x1802977d8], 0xffffffff
jne 0x180173e01
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180173dee
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180173d92
mov rdx, r11
test rax, rax
je 0x180173dd0
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 0x180173db0
cmp r9d, 0x7a1c884e
je 0x180173ddb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180173d81
jmp 0x180173dee
lea r8, str.m_iObserverMode
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802977c4], r11d
lea rcx, [0x1802977d8]
call fcn.180199c7c
movsxd rax, dword [0x1802977c4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802977cc], edx
jle 0x180173f01
lea rcx, [0x1802977cc]
call fcn.180199ce8
cmp dword [0x1802977cc], 0xffffffff
jne 0x180173f01
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180173eee
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180173e92
mov rdx, r11
test rax, rax
je 0x180173ed0
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 0x180173eb0
cmp r9d, 0x7a1c884e
je 0x180173edb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180173e81
jmp 0x180173eee
lea r8, str.m_hObserverTarget
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802977d0], r11d
lea rcx, [0x1802977cc]
call fcn.180199c7c
movsxd rax, dword [0x1802977d0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801754a0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802977dc], edx
jle 0x180175581
lea rcx, [0x1802977dc]
call fcn.180199ce8
cmp dword [0x1802977dc], 0xffffffff
jne 0x180175581
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18017556e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180175512
mov rdx, r11
test rax, rax
je 0x180175550
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 0x180175530
cmp r9d, 0x7a1c884e
je 0x18017555b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180175501
jmp 0x18017556e
lea r8, str.m_iFOV
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802977e0], r11d
lea rcx, [0x1802977dc]
call fcn.180199c7c
movsxd rax, dword [0x1802977e0]
add rax, rbx
add rsp, 0x20
pop rbx
ret