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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180233f9c], edx
jle 0x180134b71
lea rcx, [0x180233f9c]
call fcn.180183aac
cmp dword [0x180233f9c], 0xffffffff
jne 0x180134b71
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180134b5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180134b02
mov rdx, r11
test rax, rax
je 0x180134b40
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 0x180134b20
cmp r9d, 0x7a1c884e
je 0x180134b4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180134af1
jmp 0x180134b5e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180233f74], r11d
lea rcx, [0x180233f9c]
call fcn.180183a40
movsxd rax, dword [0x180233f74]
cmp byte [rax + rbx], 1
seta al
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180233fbc], edx
jle 0x180134c74
lea rcx, [0x180233fbc]
call fcn.180183aac
cmp dword [0x180233fbc], 0xffffffff
jne 0x180134c74
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180134c5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180134c02
mov rdx, r11
test rax, rax
je 0x180134c40
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 0x180134c20
cmp r9d, 0x7c5cc931
je 0x180134c4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180134bf1
jmp 0x180134c5e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 - 4]
mov dword [0x180233f80], eax
lea rcx, [0x180233fbc]
call fcn.180183a40
movsxd rax, dword [0x180233f80]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180134c90
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 [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180233fb0], r8d
jle 0x180134d81
lea rcx, [0x180233fb0]
call fcn.180183aac
cmp dword [0x180233fb0], 0xffffffff
jne 0x180134d81
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180134d6e
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180134d11
mov rdx, r11
test rax, rax
je 0x180134d50
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 0x180134d30
cmp r9d, 0x3369e751
je 0x180134d5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180134d00
jmp 0x180134d6e
lea r8, str.m_iPing
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180233f7c], r11d
lea rcx, [0x180233fb0]
call fcn.180183a40
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x180233f7c]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x180137f20
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x18], rbx
push rsi
push rdi
push r12
push r14
push r15
sub rsp, 0x20
mov qword [rsp + 0x50], rbp
mov r15, r9
lea rbp, [r8 - 1]
mov qword [rsp + 0x58], r13
sar rbp, 1
mov r14, r8
mov rsi, rdx
mov rdi, rcx
mov r12, rdx
mov r10, rdx
cmp rdx, rbp
jge 0x180137fb2
nop dword [rax]
lea rbx, [r10 + r10]
lea rax, [rbx + 2]
lea rax, [rax + rax*2]
lea rdx, [rdi + rax*4]
lea r8, [rdx - 0xc]
lea rcx, [rsp + 0x70]
call fcn.180137a20
movzx eax, al
lea rcx, [rsi + rsi*2]
xor rax, 1
lea r10, [rbx + 1]
add r10, rax
mov rsi, r10
lea rdx, [r10 + r10*2]
mov eax, dword [rdi + rdx*4]
mov dword [rdi + rcx*4], eax
mov eax, dword [rdi + rdx*4 + 4]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [rdi + rdx*4 + 8]
mov dword [rdi + rcx*4 + 8], eax
cmp r10, rbp
jl 0x180137f60
cmp r10, rbp
mov rbp, qword [rsp + 0x50]
jne 0x180137fe5
test r14b, 1
jne 0x180137fe5
lea rcx, [rsi + rsi*2]
lea rdx, [r14 + r14*2]
mov eax, dword [rdi + rdx*4 - 0xc]
lea rsi, [r14 - 1]
mov dword [rdi + rcx*4], eax
mov eax, dword [rdi + rdx*4 - 8]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [rdi + rdx*4 - 4]
mov dword [rdi + rcx*4 + 8], eax
mov rax, qword [rsp + 0x70]
mov r13, qword [rsp + 0x58]
mov qword [rsp + 0x70], rax
cmp r12, rsi
jge 0x180138045
nop dword [rax]
lea rbx, [rsi - 1]
mov r8, r15
sar rbx, 1
lea rcx, [rsp + 0x70]
lea rax, [rbx + rbx*2]
lea r14, [rdi + rax*4]
mov rdx, r14
call fcn.180137a20
test al, al
je 0x180138045
mov eax, dword [r14]
lea rcx, [rsi + rsi*2]
mov dword [rdi + rcx*4], eax
mov rsi, rbx
mov eax, dword [r14 + 4]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [r14 + 8]
mov dword [rdi + rcx*4 + 8], eax
cmp r12, rbx
jl 0x180138000
mov eax, dword [r15]
lea rcx, [rsi + rsi*2]
mov rbx, qword [rsp + 0x60]
mov dword [rdi + rcx*4], eax
mov eax, dword [r15 + 4]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [r15 + 8]
mov dword [rdi + rcx*4 + 8], eax
add rsp, 0x20
pop r15
pop r14
pop r12
pop rdi
pop rsi
ret
Function at 0x18013cae0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
test rdx, rdx
je 0x18013cd5d
mov qword [rsp + 8], rcx
push rbx
push rsi
push r15
mov eax, 0x13b0
call fcn.180185990
sub rsp, rax
mov r15, r9
mov qword [rsp + 0x13d8], rdi
mov rsi, r8
mov rbx, rdx
call fcn.18013c930
mov rcx, rbx
call fcn.1800a78c0
cmp byte [rax], 0
jne 0x18013cbce
mov rcx, rbx
call fcn.1800a7bd0
mov ecx, dword [rax]
shr ecx, 0xd
test cl, 1
jne 0x18013cbce
mov edi, dword [0x18023d824]
lea rcx, [rbx + 0x10]
mov rax, qword [rcx]
shr edi, 1
and dil, 1
call qword [rax + 0x10]
test rax, rax
je 0x18013cbb7
cmp dword [rax + 0x28], 0xf7
jne 0x18013cbb7
mov rcx, rbx
call fcn.1800b5b40
mov rcx, qword [0x180233ba8]
mov eax, dword [rax]
mov rdx, qword [rcx]
mov dword [rsp + 0x13d0], eax
mov r8, qword [rdx + 0x20]
lea rdx, [rsp + 0x13d0]
call r8
test rax, rax
jne 0x18013cb9c
mov rcx, rbx
call fcn.1800a8b60
test byte [rax], 1
je 0x18013cbb7
mov rcx, rbx
call fcn.1800a8b60
mov ecx, dword [rax]
shr ecx, 1
test cl, 1
je 0x18013cbb7
test byte [rsi + 0x28], 4
jne 0x18013cbb7
mov al, 1
jmp 0x18013cbb9
xor al, al
test dil, dil
je 0x18013cbc6
test al, al
je 0x18013cbc6
mov al, 1
jmp 0x18013cbc8
xor al, al
mov byte [0x18022f695], al
mov ecx, dword [0x18023d6a4]
sub ecx, 1
je 0x18013ccda
sub ecx, 1
je 0x18013cbfa
cmp ecx, 1
jne 0x18013cce6
mov dword [0x180233e9c], 0x16
jmp 0x18013cce6
cmp dword [0x180233e9c], 0
jne 0x18013cce6
mov edi, dword [0x18023d62c]
mov qword [rsp + 0x13e0], r14
mov r14d, dword [0x18023d628]
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov dword [rsp + 0x13a4], 0xffffffff
mov edx, 1
mov dword [rsp + 0x24], eax
nop word [rax + rax]
mov ecx, eax
shr ecx, 0x1e
xor ecx, eax
imul eax, ecx, 0x6c078965
add eax, edx
mov dword [rsp + rdx*4 + 0x24], eax
inc rdx
cmp rdx, 0x270
jb 0x18013cc40
btc r14d, 0x1f
mov dword [rsp + 0x20], 0x270
btc edi, 0x1f
lea rcx, [rsp + 0x20]
sub edi, r14d
cmp edi, 0xffffffff
jne 0x18013cc86
call fcn.180181420
mov ecx, eax
jmp 0x18013ccc8
inc edi
call fcn.180181420
mov ecx, eax
mov esi, edi
imul rcx, rsi
cmp ecx, edi
jae 0x18013ccc4
mov eax, edi
xor edx, edx
neg eax
div edi
mov edi, edx
cmp ecx, edx
jae 0x18013ccc4
nop word [rax + rax]
lea rcx, [rsp + 0x20]
call fcn.180181420
mov ecx, eax
imul rcx, rsi
cmp ecx, edi
jb 0x18013ccb0
shr rcx, 0x20
lea eax, [r14 + rcx]
mov r14, qword [rsp + 0x13e0]
btc eax, 0x1f
jmp 0x18013cce0
mov eax, dword [0x18023d8a4]
mov dword [0x180233e9c], eax
mov rdx, rbx
call fcn.18013c710
mov rdi, qword [rsp + 0x13d8]
test al, al
jne 0x18013cd48
mov rcx, rbx
call fcn.1800adf10
movss xmm0, dword [rax]
movss dword [0x18022f688], xmm0
movss xmm1, dword [rax + 4]
movss dword [0x18022f68c], xmm1
movss xmm0, dword [rax + 8]
xor eax, eax
mov dword [0x180233e9c], eax
mov dword [0x180233e98], eax
mov byte [0x18022f695], al
movss dword [0x18022f690], xmm0
add rsp, 0x13b0
pop r15
pop rsi
pop rbx
ret
inc dword [0x180233e98]
mov byte [r15], 0
add rsp, 0x13b0
pop r15
pop rsi
pop rbx
ret
Function at 0x18013ec90
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
mov ebx, edx
mov rdi, rcx
mov r8d, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180233ffc], r8d
jle 0x18013ed81
lea rcx, [0x180233ffc]
call fcn.180183aac
cmp dword [0x180233ffc], 0xffffffff
jne 0x18013ed81
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013ed6e
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013ed11
mov rdx, r11
test rax, rax
je 0x18013ed50
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 0x18013ed30
cmp r9d, 0x3369e751
je 0x18013ed5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013ed00
jmp 0x18013ed6e
lea r8, str.m_iTeam
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180233fdc], r11d
lea rcx, [0x180233ffc]
call fcn.180183a40
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x180233fdc]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

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

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
movsxd rbx, edx
mov rdi, rcx
mov r8d, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180233fd4], r8d
jle 0x18013eea1
lea rcx, [0x180233fd4]
call fcn.180183aac
cmp dword [0x180233fd4], 0xffffffff
jne 0x18013eea1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013ee8e
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013ee31
mov rdx, r11
test rax, rax
je 0x18013ee70
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 0x18013ee50
cmp r9d, 0x3369e751
je 0x18013ee7b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013ee20
jmp 0x18013ee8e
lea r8, str.m_bValid
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180233fe0], r11d
lea rcx, [0x180233fd4]
call fcn.180183a40
movsxd rax, dword [0x180233fe0]
add rax, rdi
movzx eax, byte [rbx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x18013eec0
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 rsi, r8
mov rbx, rdx
mov rdx, qword [rdx + 0x10]
test rdx, rdx
je 0x18013ef87
lea rdi, [rcx + 0x90]
mov r10, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013eefb
mov r10, qword [rbx]
xor ecx, ecx
movabs r9, 0xcbf29ce484222325
test rdx, rdx
je 0x18013ef34
movabs r8, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [r10 + rcx]
xor r9, rax
imul r9, r8
inc rcx
cmp rcx, rdx
jb 0x18013ef20
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180094450
cmp qword [rax + 8], 0
je 0x18013ef87
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180129280
mov rax, qword [rax]
movsd xmm0, qword [rax + 0x30]
movsd qword [rsi], xmm0
mov eax, dword [rax + 0x38]
mov dword [rsi + 8], eax
mov rcx, rbx
call fcn.180090ac0
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
mov rcx, rbx
call fcn.180090ac0
xor al, al
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x18013f1e0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 0x18], r8
mov dword [rsp + 0x10], edx
push rbp
push rbx
push rsi
push rdi
push r12
push r14
push r15
lea rbp, [rsp - 0x10]
sub rsp, 0x110
mov r14, r8
mov r15, rcx
mov r12, qword [rbp + 0x70]
test edx, edx
je 0x18013f462
add rcx, 0x50
lea r8, [rbp + 0x58]
lea rdx, [rsp + 0x30]
call fcn.180129510
mov rsi, qword [rax]
mov rax, qword [rsi + 0x18]
mov rcx, qword [rsi + 0x20]
cmp rax, rcx
je 0x18013f462
nop word [rax + rax]
mov r10, rax
cmp qword [rax + 0x18], 0xf
jbe 0x18013f24d
mov r10, qword [rax]
mov rdx, 0xffffffffffffffff
mov r11d, 0x811c9dc5
nop word [rax + rax]
inc rdx
cmp byte [r10 + rdx], 0
jne 0x18013f260
xor r9d, r9d
test rdx, rdx
je 0x18013f2aa
nop dword [rax]
nop word [rax + rax]
movsx r8d, byte [r10 + r9]
xor r8d, r11d
imul r11d, r8d, 0x1000193
inc r9
cmp r9, rdx
jb 0x18013f280
test r11d, r11d
jne 0x18013f2aa
add rax, 0x20
cmp rax, rcx
jne 0x18013f240
jmp 0x18013f462
mov rdi, rcx
lea rbx, [rax + 0x20]
cmp rbx, rcx
je 0x18013f2d5
nop word [rax + rax]
lea rcx, [rbx - 0x20]
mov rdx, rbx
call fcn.180090660
add rbx, 0x20
cmp rbx, rdi
jne 0x18013f2c0
mov rcx, qword [rsi + 0x20]
sub rcx, 0x20
call fcn.180090ac0
add qword [rsi + 0x20], 0xffffffffffffffe0
mov byte [r15 + 0x129], 1
cmp qword [r12 + 0x10], 0
je 0x18013f462
mov dword [rsp + 0x30], 0xffffffff
mov rdx, r14
lea rcx, [rbp - 0x58]
call fcn.180090730
lea r8, [rsp + 0x30]
mov rdx, rax
mov rcx, r15
call fcn.18013eec0
test al, al
je 0x18013f462
lea rax, [rbp - 0x30]
mov qword [rsp + 0x70], rax
mov rdx, r14
lea rcx, [rbp - 0x30]
call fcn.180090730
mov rbx, rax
lea rax, [rbp - 0x58]
mov qword [rbp - 0x38], rax
lea rax, str._b:02X:02X:02X:02X
mov qword [rsp + 0x40], rax
mov qword [rsp + 0x48], 0x19
movzx ecx, byte [rsp + 0x30]
mov dword [rbp - 0x68], ecx
movabs rax, 0x2000000000000000
mov qword [rsp + 0x78], rax
movzx eax, byte [rsp + 0x31]
mov dword [rbp - 0x64], eax
movabs rax, 0x2000000000000004
mov qword [rbp - 0x80], rax
movzx eax, byte [rsp + 0x32]
mov dword [rbp - 0x60], eax
movabs rax, 0x2000000000000008
mov qword [rbp - 0x78], rax
movzx eax, byte [rsp + 0x33]
mov dword [rbp - 0x5c], eax
movabs rax, 0x200000000000000c
mov qword [rbp - 0x70], rax
mov qword [rsp + 0x30], 4
lea rax, [rsp + 0x78]
mov qword [rsp + 0x38], rax
movaps xmm0, xmmword [rsp + 0x30]
movdqa xmmword [rsp + 0x30], xmm0
movaps xmm1, xmmword [rsp + 0x40]
movdqa xmmword [rsp + 0x40], xmm1
lea r8, [rsp + 0x30]
lea rdx, [rsp + 0x40]
lea rcx, [rbp - 0x58]
call fcn.1800cc930
nop
lea rax, [rsp + 0x50]
mov qword [rsp + 0x40], rax
mov qword [rsp + 0x58], 0
mov qword [rsp + 0x60], 7
mov qword [rsp + 0x68], 0xf
mov rax, qword [str.Removed]
mov dword [rsp + 0x50], eax
movzx eax, word [0x1802037b4]
mov word [rsp + 0x54], ax
movzx eax, byte [0x1802037b6]
mov byte [rsp + 0x56], al
mov byte [rsp + 0x57], 0
mov rdx, r12
lea rcx, [rbp - 0x10]
call fcn.180090730
nop
mov qword [rsp + 0x20], rbx
lea r9, [rbp - 0x58]
lea r8, [rsp + 0x50]
mov rdx, rax
call fcn.1801344b0
nop
mov rcx, r14
call fcn.180090ac0
nop
mov rcx, r12
call fcn.180090ac0
add rsp, 0x110
pop r15
pop r14
pop r12
pop rdi
pop rsi
pop rbx
pop rbp
ret
Function at 0x18013f490
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 0x18013f4c6
mov rcx, r8
call fcn.180090ac0
xor al, al
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
cmp qword [r8 + 0x18], 0xf
jbe 0x18013f4d0
mov r8, qword [r8]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
nop dword [rax]
inc rcx
cmp byte [r8 + rcx], 0
jne 0x18013f4e0
xor edx, edx
test rcx, rcx
je 0x18013f515
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 0x18013f500
lea rbp, [r9 + 0x50]
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180129510
mov rcx, qword [rax]
mov r10, qword [rcx + 0x20]
mov rbx, qword [rcx + 0x18]
cmp rbx, r10
je 0x18013f596
nop dword [rax + rax]
mov r8, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013f54d
mov r8, qword [rbx]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop word [rax + rax]
inc rax
cmp byte [r8 + rax], 0
jne 0x18013f560
xor edx, edx
test rax, rax
je 0x18013f588
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013f571
cmp edi, r9d
je 0x18013f596
add rbx, 0x20
cmp rbx, r10
jne 0x18013f540
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180129510
mov rcx, qword [rax]
cmp rbx, qword [rcx + 0x20]
setne bl
mov rcx, rsi
call fcn.180090ac0
movzx eax, bl
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
Function at 0x180141880
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234008], edx
jle 0x180141961
lea rcx, [0x180234008]
call fcn.180183aac
cmp dword [0x180234008], 0xffffffff
jne 0x180141961
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014194e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801418f2
mov rdx, r11
test rax, rax
je 0x180141930
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 0x180141910
cmp r9d, 0x9dc483b8
je 0x18014193b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801418e1
jmp 0x18014194e
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x18023400c], r11d
lea rcx, [0x180234008]
call fcn.180183a40
movsxd rax, dword [0x18023400c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180234014], edx
jle 0x180141a64
lea rcx, [0x180234014]
call fcn.180183aac
cmp dword [0x180234014], 0xffffffff
jne 0x180141a64
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141a4e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801419f2
mov rdx, r11
test rax, rax
je 0x180141a30
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 0x180141a10
cmp r9d, 0x7c5cc931
je 0x180141a3b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801419e1
jmp 0x180141a4e
lea r8, str.m_hItem
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
lea eax, [r11 - 0x58]
mov dword [0x180234010], eax
lea rcx, [0x180234014]
call fcn.180183a40
movsxd rax, dword [0x180234010]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141a80
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 [0x180242c90]
imul r9, rdx
xor r9, rax
imul r9, rdx
mov rdx, qword [0x180242c78]
and rcx, r9
add rcx, rcx
mov rax, qword [rdx + rcx*8 + 8]
cmp rax, qword [0x180242c68]
je 0x180141b65
mov rcx, qword [rdx + rcx*8]
cmp r8, qword [rax + 0x10]
je 0x180141b67
cmp rax, rcx
je 0x180141b65
mov rax, qword [rax + 8]
cmp rdi, qword [rax + 0x10]
jne 0x180141b54
jmp 0x180141b67
xor eax, eax
test rax, rax
je 0x180141c63
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, [0x180242c60]
movaps xmmword [rsp + 0x40], xmm8
mov qword [rsp + 0x80], rdi
call fcn.1801434f0
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.1800a8a60
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.1800bcb20
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 0x180143810
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340c4], edx
jle 0x1801438f1
lea rcx, [0x1802340c4]
call fcn.180183aac
cmp dword [0x1802340c4], 0xffffffff
jne 0x1801438f1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801438de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143882
mov rdx, r11
test rax, rax
je 0x1801438c0
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 0x1801438a0
cmp r9d, 0x7a1c884e
je 0x1801438cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143871
jmp 0x1801438de
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x180234050], r11d
lea rcx, [0x1802340c4]
call fcn.180183a40
movsxd rax, dword [0x180234050]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023228c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802340d8], edx
jle 0x1801439f1
lea rcx, [0x1802340d8]
call fcn.180183aac
cmp dword [0x1802340d8], 0xffffffff
jne 0x1801439f1
mov rcx, qword [0x180233b80]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801439de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143982
mov rdx, r11
test rax, rax
je 0x1801439c0
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 0x1801439a0
cmp r9d, 0x7a1c884e
je 0x1801439cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143971
jmp 0x1801439de
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.180183640
mov r11d, eax
mov dword [0x1802340d0], r11d
lea rcx, [0x1802340d8]
call fcn.180183a40
movsxd rax, dword [0x1802340d0]
add rax, rbx
add rsp, 0x20
pop rbx
ret