joyce8/EMBER2024-capa huggingface dataset:
Function at 0x1801549a0
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 [0x18028ab2c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18028cb94], r8d
jle 0x180154a97
lea rcx, [0x18028cb94]
call fcn.1801d1cb0
cmp dword [0x18028cb94], 0xffffffff
jne 0x180154a97
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180154a7e
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180154a21
mov rdx, r11
test rax, rax
je 0x180154a60
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 0x180154a40
cmp r9d, 0x3369e751
je 0x180154a6b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180154a10
jmp 0x180154a7e
lea r8, str.m_iPing
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
lea eax, [r11 - 0x330]
mov dword [0x18028cb98], eax
lea rcx, [0x18028cb94]
call fcn.1801d1c44
lea eax, [rbx*8]
cdqe
movsxd rdx, dword [0x18028cb98]
add rax, rdi
mov rax, qword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x180157730
Capabilities:
Hash data using fnv

Disassembly:
sub rsp, 0x48
movss xmm1, dword [0x18025e130]
mov r10, rdx
test r9b, r9b
je 0x180157752
movss xmm0, dword [rdx + 8]
addss xmm0, xmm1
movss dword [rdx + 8], xmm0
movss xmm0, dword [rdx + 8]
movss xmm3, dword [r8 + 0x2c]
movss xmm4, dword [r8 + 0x24]
addss xmm3, xmm1
movss xmm1, dword [rdx + 4]
movss xmm5, dword [r8 + 0x28]
movss xmm2, dword [rdx]
subss xmm1, xmm5
subss xmm2, xmm4
subss xmm0, xmm3
mulss xmm1, xmm1
mulss xmm0, xmm0
mulss xmm2, xmm2
addss xmm2, xmm1
addss xmm2, xmm0
movss xmm0, dword [0x180287678]
mulss xmm0, xmm0
comiss xmm0, xmm2
ja 0x1801578fb
mov r9, qword [0x1802876f0]
movabs r11, 0x100000001b3
movabs rax, 0xcbf29ce484222325
movzx edx, r8b
xor rdx, rax
mov rax, r8
imul rdx, r11
sar rax, 8
movzx ecx, al
mov rax, r8
xor rdx, rcx
sar rax, 0x10
imul rdx, r11
movzx ecx, al
mov rax, r8
xor rdx, rcx
sar rax, 0x18
imul rdx, r11
movzx ecx, al
mov rax, r8
xor rdx, rcx
sar rax, 0x20
imul rdx, r11
movzx ecx, al
mov rax, r8
xor rdx, rcx
sar rax, 0x28
imul rdx, r11
movzx ecx, al
mov rax, r8
xor rdx, rcx
sar rax, 0x30
imul rdx, r11
movzx ecx, al
mov rax, r8
xor rdx, rcx
sar rax, 0x38
imul rdx, r11
movzx ecx, al
xor rdx, rcx
mov rcx, qword [r9 + 0x240]
imul rdx, r11
and rcx, rdx
mov rdx, qword [r9 + 0x228]
add rcx, rcx
mov rax, qword [rdx + rcx*8 + 8]
cmp rax, qword [r9 + 0x218]
je 0x180157885
mov rcx, qword [rdx + rcx*8]
cmp r8, qword [rax + 0x10]
je 0x180157887
cmp rax, rcx
je 0x180157885
mov rax, qword [rax + 8]
cmp r8, qword [rax + 0x10]
jne 0x180157874
jmp 0x180157887
xor eax, eax
test rax, rax
jne 0x180157893
mov rax, qword [r9 + 0x218]
cmp rax, qword [r9 + 0x218]
jne 0x1801578fb
movss xmm0, dword [0x180287680]
mulss xmm0, xmm0
comiss xmm2, xmm0
ja 0x1801578fb
movss xmm0, dword [r10]
lea r8, [rsp + 0x20]
movss xmm1, dword [r10 + 4]
lea rdx, [rsp + 0x30]
movss dword [rsp + 0x30], xmm0
movss xmm0, dword [r10 + 8]
movss dword [rsp + 0x38], xmm0
movss dword [rsp + 0x20], xmm4
movss dword [rsp + 0x24], xmm5
movss dword [rsp + 0x28], xmm3
movss dword [rsp + 0x34], xmm1
call fcn.180165b30
test al, al
setne al
add rsp, 0x48
ret
xor al, al
add rsp, 0x48
ret
Function at 0x18015b3b0
Capabilities:
Hash data using fnv

Disassembly:
movzx r8d, byte [rdx]
mov r9, rcx
movabs rcx, 0x100000001b3
movabs rax, 0xcbf29ce484222325
xor r8, rax
mov r10, rdx
movzx eax, byte [rdx + 1]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 2]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 3]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 4]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 5]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 6]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 7]
mov rdx, qword [r9 + 0x30]
imul r8, rcx
xor r8, rax
imul r8, rcx
and rdx, r8
shl rdx, 4
add rdx, qword [r9 + 0x18]
mov rax, qword [rdx + 8]
cmp rax, qword [r9 + 8]
je 0x18015b45d
mov rcx, qword [r10]
mov rdx, qword [rdx]
cmp rcx, qword [rax + 0x10]
je 0x18015b45f
cmp rax, rdx
je 0x18015b45d
mov rax, qword [rax + 8]
cmp rcx, qword [rax + 0x10]
jne 0x18015b447
test rax, rax
setne al
ret
xor eax, eax
test rax, rax
setne al
ret
Function at 0x18015d380
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
movzx r9d, byte [r8 + 0x10]
mov r10, rcx
movabs rcx, 0x100000001b3
movabs rax, 0xcbf29ce484222325
xor r9, rax
mov rdi, rdx
movzx eax, byte [r8 + 0x11]
mov rdx, qword [r10 + 0x30]
imul r9, rcx
xor r9, rax
movzx eax, byte [r8 + 0x12]
imul r9, rcx
xor r9, rax
movzx eax, byte [r8 + 0x13]
imul r9, rcx
xor r9, rax
movzx eax, byte [r8 + 0x14]
imul r9, rcx
xor r9, rax
movzx eax, byte [r8 + 0x15]
imul r9, rcx
xor r9, rax
movzx eax, byte [r8 + 0x16]
imul r9, rcx
xor r9, rax
movzx eax, byte [r8 + 0x17]
imul r9, rcx
xor r9, rax
imul r9, rcx
and rdx, r9
shl rdx, 4
add rdx, qword [r10 + 0x18]
mov rax, qword [rdx]
cmp qword [rdx + 8], r8
jne 0x18015d438
cmp rax, r8
jne 0x18015d42e
mov rax, qword [r10 + 8]
mov qword [rdx], rax
mov qword [rdx + 8], rax
jmp 0x18015d443
mov rax, qword [r8 + 8]
mov qword [rdx + 8], rax
jmp 0x18015d443
cmp rax, r8
jne 0x18015d443
mov rax, qword [r8]
mov qword [rdx], rax
mov rbx, qword [r8]
mov edx, 0x20
dec qword [r10 + 0x10]
mov rcx, r8
mov rax, qword [r8 + 8]
mov qword [rax], rbx
mov rax, qword [r8 + 8]
mov qword [rbx + 8], rax
call fcn.1801d1c00
mov qword [rdi], rbx
mov rax, rdi
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x18015f080
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rsi
push rdi
push r14
push r15
sub rsp, 0x20
mov qword [rsp + 0x50], rbp
mov rsi, rcx
lea rbp, [r8 - 1]
mov qword [rsp + 0x58], r12
sar rbp, 1
mov r14, r9
mov qword [rsp + 0x60], r13
mov r13, r8
mov rbx, rdx
mov r15, rdx
mov rcx, rdx
cmp rdx, rbp
jge 0x18015f0f5
nop dword [rax]
lea rdi, [rcx + rcx]
mov r8, qword [rsi + rdi*8 + 8]
lea rcx, [rsp + 0x70]
mov rdx, qword [rsi + rdi*8 + 0x10]
call fcn.1801555b0
movzx ecx, al
xor rcx, 1
inc rcx
add rcx, rdi
mov rax, qword [rsi + rcx*8]
mov qword [rsi + rbx*8], rax
mov rbx, rcx
cmp rcx, rbp
jl 0x18015f0c0
cmp rcx, rbp
mov rbp, qword [rsp + 0x50]
jne 0x18015f112
test r13b, 1
jne 0x18015f112
mov rax, qword [rsi + r13*8 - 8]
mov qword [rsi + rbx*8], rax
lea rbx, [r13 - 1]
mov rax, qword [rsp + 0x70]
mov r13, qword [rsp + 0x60]
mov r12, qword [rsp + 0x58]
mov qword [rsp + 0x70], rax
cmp r15, rbx
jge 0x18015f16f
nop dword [rax + rax]
mov r8, qword [r14]
lea rdi, [rbx - 1]
sar rdi, 1
lea rcx, [rsp + 0x70]
mov rdx, qword [rsi + rdi*8]
call fcn.1801555b0
test al, al
je 0x18015f16f
mov rax, qword [rsi + rdi*8]
mov qword [rsi + rbx*8], rax
mov rbx, rdi
cmp r15, rdi
jl 0x18015f130
mov rax, qword [r14]
mov qword [rsi + rdi*8], rax
add rsp, 0x20
pop r15
pop r14
pop rdi
pop rsi
pop rbx
ret
mov rax, qword [r14]
mov qword [rsi + rbx*8], rax
add rsp, 0x20
pop r15
pop r14
pop rdi
pop rsi
pop rbx
ret
Function at 0x18015f660
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 0x18015f6f2
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.18015dfb0
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 0x18015f6a0
cmp r10, rbp
mov rbp, qword [rsp + 0x50]
jne 0x18015f725
test r14b, 1
jne 0x18015f725
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 0x18015f785
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.18015dfb0
test al, al
je 0x18015f785
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 0x18015f740
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 0x18015ff50
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rsi
push rdi
push r14
push r15
sub rsp, 0x20
mov qword [rsp + 0x50], rbp
mov rsi, rcx
lea rbp, [r8 - 1]
mov qword [rsp + 0x58], r12
sar rbp, 1
mov r14, r9
mov qword [rsp + 0x60], r13
mov r13, r8
mov rbx, rdx
mov r15, rdx
mov rcx, rdx
cmp rdx, rbp
jge 0x18015ffc5
nop dword [rax]
lea rdi, [rcx + rcx]
mov r8, qword [rsi + rdi*8 + 8]
lea rcx, [rsp + 0x70]
mov rdx, qword [rsi + rdi*8 + 0x10]
call fcn.180159d40
movzx ecx, al
xor rcx, 1
inc rcx
add rcx, rdi
mov rax, qword [rsi + rcx*8]
mov qword [rsi + rbx*8], rax
mov rbx, rcx
cmp rcx, rbp
jl 0x18015ff90
cmp rcx, rbp
mov rbp, qword [rsp + 0x50]
jne 0x18015ffe2
test r13b, 1
jne 0x18015ffe2
mov rax, qword [rsi + r13*8 - 8]
mov qword [rsi + rbx*8], rax
lea rbx, [r13 - 1]
mov rax, qword [rsp + 0x70]
mov r13, qword [rsp + 0x60]
mov r12, qword [rsp + 0x58]
mov qword [rsp + 0x70], rax
cmp r15, rbx
jge 0x18016003f
nop dword [rax + rax]
mov r8, qword [r14]
lea rdi, [rbx - 1]
sar rdi, 1
lea rcx, [rsp + 0x70]
mov rdx, qword [rsi + rdi*8]
call fcn.180159d40
test al, al
je 0x18016003f
mov rax, qword [rsi + rdi*8]
mov qword [rsi + rbx*8], rax
mov rbx, rdi
cmp r15, rdi
jl 0x180160000
mov rax, qword [r14]
mov qword [rsi + rdi*8], rax
add rsp, 0x20
pop r15
pop r14
pop rdi
pop rsi
pop rbx
ret
mov rax, qword [r14]
mov qword [rsi + rbx*8], rax
add rsp, 0x20
pop r15
pop r14
pop rdi
pop rsi
pop rbx
ret

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

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
xor ebx, ebx
mov rcx, qword [0x180284eb0]
movsxd rax, dword [rcx + 3]
mov rdi, qword [rax + rcx + 7]
test rdi, rdi
je 0x180160714
mov ecx, dword [0x18028ab2c]
mov rax, qword gs:[0x58]
mov edx, 4
mov rax, qword [rax + rcx*8]
mov ecx, dword [rdx + rax]
cmp dword [0x18028cc10], ecx
jle 0x1801606ff
lea rcx, [0x18028cc10]
call fcn.1801d1cb0
cmp dword [0x18028cc10], 0xffffffff
jne 0x1801606ff
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
test rax, rax
je 0x1801606ed
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], 0
jne 0x180160691
mov rdx, rbx
test rax, rax
je 0x1801606d0
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 0x1801606b0
cmp r9d, 0xf1c5030f
je 0x1801606db
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160680
jmp 0x1801606ed
lea r8, str.m_nGameType
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov ebx, eax
mov dword [0x18028cc0c], ebx
lea rcx, [0x18028cc10]
call fcn.1801d1c44
movsxd rax, dword [0x18028cc0c]
mov eax, dword [rax + rdi]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
mov eax, ebx
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x180160c80
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18028ab2c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18028cc4c], edx
jle 0x180160d61
lea rcx, [0x18028cc4c]
call fcn.1801d1cb0
cmp dword [0x18028cc4c], 0xffffffff
jne 0x180160d61
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180160d4e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180160cf2
mov rdx, r11
test rax, rax
je 0x180160d30
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 0x180160d10
cmp r9d, 0x5e12f1f1
je 0x180160d3b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160ce1
jmp 0x180160d4e
lea r8, str.m_iNumControlPoints
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
mov dword [0x18028cc18], r11d
lea rcx, [0x18028cc4c]
call fcn.1801d1c44
movsxd rax, dword [0x18028cc18]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18028ab2c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18028cc28], edx
jle 0x180160e61
lea rcx, [0x18028cc28]
call fcn.1801d1cb0
cmp dword [0x18028cc28], 0xffffffff
jne 0x180160e61
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180160e4e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180160df2
mov rdx, r11
test rax, rax
je 0x180160e30
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 0x180160e10
cmp r9d, 0x5e12f1f1
je 0x180160e3b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160de1
jmp 0x180160e4e
lea r8, str.m_bPlayingMiniRounds
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
mov dword [0x18028cc54], r11d
lea rcx, [0x18028cc28]
call fcn.1801d1c44
movsxd rax, dword [0x18028cc54]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180160e80
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 [0x18028ab2c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18028cc50], r8d
jle 0x180160f71
lea rcx, [0x18028cc50]
call fcn.1801d1cb0
cmp dword [0x18028cc50], 0xffffffff
jne 0x180160f71
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180160f5e
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180160f01
mov rdx, r11
test rax, rax
je 0x180160f40
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 0x180160f20
cmp r9d, 0x5e12f1f1
je 0x180160f4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180160ef0
jmp 0x180160f5e
lea r8, str.m_iOwner
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
mov dword [0x18028cc48], r11d
lea rcx, [0x18028cc50]
call fcn.1801d1c44
movsxd rcx, dword [0x18028cc48]
add rcx, rdi
lea rax, [rcx + rbx*4]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x180161310
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
lea ebx, [rdx + r8*8]
lea eax, [r9 + rbx*2]
add ebx, eax
mov rdi, qword [0x1802a33a8]
mov ecx, dword [0x18028ab2c]
mov rax, qword gs:[0x58]
mov edx, 4
mov rax, qword [rax + rcx*8]
mov ecx, dword [rdx + rax]
cmp dword [0x18028cc58], ecx
jle 0x180161401
lea rcx, [0x18028cc58]
call fcn.1801d1cb0
cmp dword [0x18028cc58], 0xffffffff
jne 0x180161401
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801613ee
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180161394
mov rdx, r11
test rax, rax
je 0x1801613d0
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801613b0
cmp r9d, 0x5e12f1f1
je 0x1801613db
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180161383
jmp 0x1801613ee
lea r8, str.m_iPreviousPoints
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
mov dword [0x18028cc24], r11d
lea rcx, [0x18028cc58]
call fcn.1801d1c44
movsxd rdx, ebx
movsxd rax, dword [0x18028cc24]
add rax, rdi
mov eax, dword [rax + rdx*4]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x180161c40
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18028ab2c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18028cc5c], edx
jle 0x180161d21
lea rcx, [0x18028cc5c]
call fcn.1801d1cb0
cmp dword [0x18028cc5c], 0xffffffff
jne 0x180161d21
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180161d0e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180161cb2
mov rdx, r11
test rax, rax
je 0x180161cf0
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 0x180161cd0
cmp r9d, 0x9dc483b8
je 0x180161cfb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180161ca1
jmp 0x180161d0e
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
mov dword [0x18028cc60], r11d
lea rcx, [0x18028cc5c]
call fcn.1801d1c44
movsxd rax, dword [0x18028cc60]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rdx
mov ecx, dword [0x18028ab2c]
mov rax, qword gs:[0x58]
mov edx, 4
mov rax, qword [rax + rcx*8]
mov ecx, dword [rdx + rax]
cmp dword [0x1802a3460], ecx
jle 0x180161e21
lea rcx, [0x1802a3460]
call fcn.1801d1cb0
cmp dword [0x1802a3460], 0xffffffff
jne 0x180161e21
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180161e0e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180161db2
mov rdx, r11
test rax, rax
je 0x180161df0
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 0x180161dd0
cmp r9d, 0x33faa6b2
je 0x180161dfb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180161da1
jmp 0x180161e0e
lea r8, str.m_nFlagStatus
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
mov dword [0x1802a347c], r11d
lea rcx, [0x1802a3460]
call fcn.1801d1c44
movsxd rax, dword [0x1802a347c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180162b20
Capabilities:
Hash data using fnv

Disassembly:
movzx eax, byte [rcx]
lea r8, [rcx + 1]
xor eax, 0x811c9dc5
imul edx, eax, 0x1000193
movzx eax, byte [r8]
xor eax, edx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 1]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 2]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 3]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 4]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 5]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 6]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 7]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 8]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 9]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 0xa]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 0xb]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 0xc]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 0xd]
xor eax, ecx
imul ecx, eax, 0x1000193
movzx eax, byte [r8 + 0xe]
xor ecx, eax
imul eax, ecx, 0x1000193
ret

Function at 0x180163930
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rdi
mov r11, rcx
movzx eax, dl
xor eax, 0x811c9dc5
mov rdi, rdx
imul r9d, eax, 0x1000193
mov rbx, r8
mov rax, rdx
shr rax, 8
movzx eax, al
xor r9d, eax
mov rax, rdx
shr rax, 0x10
movzx eax, al
imul r10d, r9d, 0x1000193
mov r9d, dword [r11 + 0x10]
xor r10d, eax
mov rax, rdi
shr rax, 0x18
movzx eax, al
imul edx, r10d, 0x1000193
mov r10, qword [r11 + 8]
xor edx, eax
mov rax, rdi
shr rax, 0x20
movzx eax, al
imul ecx, edx, 0x1000193
xor ecx, eax
mov rax, rdi
shr rax, 0x28
movzx eax, al
imul edx, ecx, 0x1000193
xor edx, eax
mov rax, rdi
shr rax, 0x30
movzx eax, al
imul ecx, edx, 0x1000193
xor ecx, eax
mov rax, rdi
shr rax, 0x38
imul ecx, ecx, 0x1000193
xor ecx, eax
movzx eax, r8b
imul ecx, ecx, 0x1000193
xor ecx, eax
mov rax, r8
shr rax, 8
movzx eax, al
imul edx, ecx, 0x1000193
xor edx, eax
mov rax, r8
shr rax, 0x10
movzx eax, al
imul ecx, edx, 0x1000193
xor ecx, eax
mov rax, r8
shr rax, 0x18
movzx eax, al
imul edx, ecx, 0x1000193
xor edx, eax
mov rax, r8
shr rax, 0x20
movzx eax, al
imul ecx, edx, 0x1000193
xor ecx, eax
mov rax, r8
shr rax, 0x28
movzx eax, al
imul edx, ecx, 0x1000193
xor edx, eax
mov rax, r8
shr rax, 0x30
movzx eax, al
imul ecx, edx, 0x1000193
xor edx, edx
xor ecx, eax
mov rax, r8
shr rax, 0x38
imul ecx, ecx, 0x1000193
xor ecx, eax
imul eax, ecx, 0x1000193
div r9d
nop word [rax + rax]
mov ecx, edx
shl rcx, 5
add rcx, r10
mov r8, qword [rcx]
test r8, r8
jne 0x180163a87
cmp qword [rcx + 8], r8
je 0x180163a9f
cmp r8, rdi
jne 0x180163a92
cmp qword [rcx + 8], rbx
je 0x180163aac
lea eax, [rdx + 1]
xor edx, edx
cmp eax, r9d
cmovne edx, eax
jmp 0x180163a70
xor eax, eax
mov rbx, qword [rsp + 8]
mov rdi, qword [rsp + 0x10]
ret
mov rbx, qword [rsp + 8]
mov rax, rcx
mov rdi, qword [rsp + 0x10]
ret
Function at 0x1801644e0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18028ab2c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18028cc7c], edx
jle 0x1801645c1
lea rcx, [0x18028cc7c]
call fcn.1801d1cb0
cmp dword [0x18028cc7c], 0xffffffff
jne 0x1801645c1
mov rcx, qword [0x18028c720]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801645ae
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180164552
mov rdx, r11
test rax, rax
je 0x180164590
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 0x180164570
cmp r9d, 0x80133484
je 0x18016459b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180164541
jmp 0x1801645ae
lea r8, str.m_iAmmoRockets
mov rdx, qword [r10 + 0x18]
call fcn.1801d1920
mov r11d, eax
mov dword [0x18028cc78], r11d
lea rcx, [0x18028cc7c]
call fcn.1801d1c44
movsxd rax, dword [0x18028cc78]
add rax, rbx
add rsp, 0x20
pop rbx
ret