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

Disassembly:
mov qword [rsp + 8], rcx
sub rsp, 0x18
test byte [0x180276048], 6
je 0x18014847c
mov eax, 0xffffffff
add rsp, 0x18
ret
test dl, dl
je 0x18014848b
mov eax, dword [0x1802612b4]
add rsp, 0x18
ret
mov edx, dword [0x1802612b4]
mov dword [rsp + 0x20], edx
cmp edx, 0xffffffff
je 0x1801485ba
mov r11, qword [0x180276068]
mov r10, qword [0x1802629f8]
mov r9, qword [0x1802629f0]
mov qword [rsp + 0x28], rbx
mov rbx, qword [0x180276090]
mov qword [rsp + 0x30], rbp
movabs rbp, 0x100000001b3
mov qword [rsp + 0x10], rsi
movabs rsi, 0xe38e38e38e38e39
mov qword [rsp + 8], rdi
mov rdi, qword [0x180276078]
mov qword [rsp], r14
movabs r14, 0xcbf29ce484222325
nop word [rax + rax]
movzx eax, byte [rsp + 0x21]
movzx ecx, dl
xor rcx, r14
imul rcx, rbp
xor rcx, rax
movzx eax, byte [rsp + 0x22]
imul rcx, rbp
xor rcx, rax
movzx eax, byte [rsp + 0x23]
imul rcx, rbp
xor rcx, rax
imul rcx, rbp
and rcx, rbx
add rcx, rcx
mov rax, qword [rdi + rcx*8 + 8]
cmp rax, r11
je 0x180148557
mov rcx, qword [rdi + rcx*8]
cmp edx, dword [rax + 0x10]
je 0x180148559
cmp rax, rcx
je 0x180148557
mov rax, qword [rax + 8]
cmp edx, dword [rax + 0x10]
jne 0x180148547
jmp 0x180148559
xor eax, eax
test rax, rax
jne 0x1801485a2
cmp edx, 0xffffffff
jle 0x18014859d
movsxd r8, edx
mov rcx, r10
sub rcx, r9
mov rax, rsi
imul rcx
sar rdx, 2
mov rax, rdx
shr rax, 0x3f
add rdx, rax
cmp r8, rdx
jae 0x18014859d
lea rax, [r8 + r8*8]
mov edx, dword [r9 + rax*8 + 0x44]
mov dword [rsp + 0x20], edx
cmp edx, 0xffffffff
jne 0x180148500
jmp 0x1801485a2
mov edx, 0xffffffff
mov rdi, qword [rsp + 8]
mov rsi, qword [rsp + 0x10]
mov rbp, qword [rsp + 0x30]
mov rbx, qword [rsp + 0x28]
mov r14, qword [rsp]
mov eax, edx
add rsp, 0x18
ret
Function at 0x180148f00
Capabilities:
Hash data using fnv

Disassembly:
sub rsp, 0x18
test byte [rcx + 0x28], 6
je 0x180148f14
mov eax, 0xffffffff
add rsp, 0x18
ret
test dl, dl
je 0x180148f23
mov eax, dword [0x1802612b4]
add rsp, 0x18
ret
mov edx, dword [0x1802612b4]
mov dword [rsp + 0x20], edx
cmp edx, 0xffffffff
je 0x18014904a
mov r11, qword [rcx + 0x70]
mov r10, qword [0x1802629f8]
mov r9, qword [0x1802629f0]
mov qword [rsp + 0x28], rbx
mov rbx, qword [rcx + 0x58]
mov qword [rsp + 0x30], rbp
movabs rbp, 0x100000001b3
mov qword [rsp + 0x10], rsi
movabs rsi, 0xe38e38e38e38e39
mov qword [rsp + 8], rdi
mov rdi, qword [rcx + 0x48]
mov qword [rsp], r14
movabs r14, 0xcbf29ce484222325
nop word [rax + rax]
movzx eax, byte [rsp + 0x21]
movzx ecx, dl
xor rcx, r14
imul rcx, rbp
xor rcx, rax
movzx eax, byte [rsp + 0x22]
imul rcx, rbp
xor rcx, rax
movzx eax, byte [rsp + 0x23]
imul rcx, rbp
xor rcx, rax
imul rcx, rbp
and rcx, r11
add rcx, rcx
mov rax, qword [rbx + rcx*8 + 8]
cmp rax, rdi
je 0x180148fe7
mov rcx, qword [rbx + rcx*8]
cmp edx, dword [rax + 0x10]
je 0x180148fe9
cmp rax, rcx
je 0x180148fe7
mov rax, qword [rax + 8]
cmp edx, dword [rax + 0x10]
jne 0x180148fd7
jmp 0x180148fe9
xor eax, eax
test rax, rax
jne 0x180149032
cmp edx, 0xffffffff
jle 0x18014902d
movsxd r8, edx
mov rcx, r10
sub rcx, r9
mov rax, rsi
imul rcx
sar rdx, 2
mov rax, rdx
shr rax, 0x3f
add rdx, rax
cmp r8, rdx
jae 0x18014902d
lea rax, [r8 + r8*8]
mov edx, dword [r9 + rax*8 + 0x44]
mov dword [rsp + 0x20], edx
cmp edx, 0xffffffff
jne 0x180148f90
jmp 0x180149032
mov edx, 0xffffffff
mov rdi, qword [rsp + 8]
mov rsi, qword [rsp + 0x10]
mov rbp, qword [rsp + 0x30]
mov rbx, qword [rsp + 0x28]
mov r14, qword [rsp]
mov eax, edx
add rsp, 0x18
ret
Function at 0x180149060
Capabilities:
Hash data using fnv

Disassembly:
sub rsp, 0x18
test byte [rcx + 0x28], 6
je 0x180149074
mov eax, 0xffffffff
add rsp, 0x18
ret
test dl, dl
je 0x180149083
mov eax, dword [0x1802612b4]
add rsp, 0x18
ret
mov edx, dword [0x1802612b4]
mov dword [rsp + 0x20], edx
cmp edx, 0xffffffff
je 0x1801491aa
mov r11, qword [rcx + 0x80]
mov r10, qword [0x1802629f8]
mov r9, qword [0x1802629f0]
mov qword [rsp + 0x28], rbx
mov rbx, qword [rcx + 0x68]
mov qword [rsp + 0x30], rbp
movabs rbp, 0x100000001b3
mov qword [rsp + 0x10], rsi
movabs rsi, 0xe38e38e38e38e39
mov qword [rsp + 8], rdi
mov rdi, qword [rcx + 0x58]
mov qword [rsp], r14
movabs r14, 0xcbf29ce484222325
nop dword [rax]
movzx eax, byte [rsp + 0x21]
movzx ecx, dl
xor rcx, r14
imul rcx, rbp
xor rcx, rax
movzx eax, byte [rsp + 0x22]
imul rcx, rbp
xor rcx, rax
movzx eax, byte [rsp + 0x23]
imul rcx, rbp
xor rcx, rax
imul rcx, rbp
and rcx, r11
add rcx, rcx
mov rax, qword [rbx + rcx*8 + 8]
cmp rax, rdi
je 0x180149147
mov rcx, qword [rbx + rcx*8]
cmp edx, dword [rax + 0x10]
je 0x180149149
cmp rax, rcx
je 0x180149147
mov rax, qword [rax + 8]
cmp edx, dword [rax + 0x10]
jne 0x180149137
jmp 0x180149149
xor eax, eax
test rax, rax
jne 0x180149192
cmp edx, 0xffffffff
jle 0x18014918d
movsxd r8, edx
mov rcx, r10
sub rcx, r9
mov rax, rsi
imul rcx
sar rdx, 2
mov rax, rdx
shr rax, 0x3f
add rdx, rax
cmp r8, rdx
jae 0x18014918d
lea rax, [r8 + r8*8]
mov edx, dword [r9 + rax*8 + 0x44]
mov dword [rsp + 0x20], edx
cmp edx, 0xffffffff
jne 0x1801490f0
jmp 0x180149192
mov edx, 0xffffffff
mov rdi, qword [rsp + 8]
mov rsi, qword [rsp + 0x10]
mov rbp, qword [rsp + 0x30]
mov rbx, qword [rsp + 0x28]
mov r14, qword [rsp]
mov eax, edx
add rsp, 0x18
ret
Function at 0x18014c020
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r13
push r14
push r15
sub rsp, 0x20
cmp qword [rdx + 0x20], 0xf
lea r9, [rdx + 8]
mov r13, r8
mov r15, rdx
jbe 0x18014c053
mov r9, qword [rdx + 8]
mov esi, 0x811c9dc5
mov rdi, 0xffffffffffffffff
mov ebp, esi
mov rcx, rdi
inc rcx
cmp byte [r9 + rcx], 0
jne 0x18014c064
xor ebx, ebx
mov edx, ebx
test rcx, rcx
je 0x18014c095
nop word [rax + rax]
movsx eax, byte [rdx + r9]
inc rdx
xor eax, ebp
imul ebp, eax, 0x1000193
cmp rdx, rcx
jb 0x18014c080
mov edx, 0xcb0c01d1
lea rcx, [0x1801e429d]
call fcn.1800f5960
mov r8d, eax
cmp ebp, eax
je 0x18014c0f9
cmp qword [r13 + 0x20], 0xf
lea rdx, [r13 + 8]
mov rcx, rdx
jbe 0x18014c0c0
mov rcx, qword [rdx]
nop
inc rdi
cmp byte [rcx + rdi], bl
jne 0x18014c0c0
test rdi, rdi
je 0x18014c0e4
nop dword [rax]
movsx eax, byte [rbx + rcx]
inc rbx
xor eax, esi
imul esi, eax, 0x1000193
cmp rbx, rdi
jb 0x18014c0d0
cmp esi, r8d
je 0x18014c12c
cmp byte [r15 + 0x48], 0
movzx eax, byte [r13 + 0x48]
je 0x18014c11a
test al, al
jne 0x18014c11e
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rbp, qword [rsp + 0x48]
mov rsi, qword [rsp + 0x50]
mov rdi, qword [rsp + 0x58]
add rsp, 0x20
pop r15
pop r14
pop r13
ret
test al, al
jne 0x18014c12c
lea rcx, [r15 + 8]
call fcn.18010c360
shr al, 7
jmp 0x18014c0fb
xor al, al
jmp 0x18014c0fb
Function at 0x18014d060
Capabilities:
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0x20
lea r15, [r8 - 1]
mov r14, r9
sar r15, 1
mov r13, r8
mov rdi, rdx
mov rbp, rcx
mov r12, rdx
mov rsi, rdx
cmp rdx, r15
jge 0x18014d131
nop
add rsi, rsi
imul rax, rsi, 0x38
mov ecx, dword [rax + rbp + 0x9c]
cmp ecx, dword [rax + rbp + 0x64]
je 0x18014d0b9
setg cl
jmp 0x18014d0d2
lea rdx, [rbp + 0x40]
lea rcx, [rbp + 0x78]
add rdx, rax
add rcx, rax
call fcn.18010c360
movzx ecx, al
shr cl, 7
movzx eax, cl
xor rax, 1
inc rax
add rsi, rax
imul rdx, rsi, 0x38
imul rcx, rdi, 0x38
mov rax, qword [rdx + rbp]
lea rbx, [rdx + rbp]
lea rdx, [rbx + 8]
lea rdi, [rcx + rbp]
mov qword [rcx + rbp], rax
lea rcx, [rdi + 8]
call fcn.18009fee0
mov eax, dword [rbx + 0x28]
mov dword [rdi + 0x28], eax
mov eax, dword [rbx + 0x2c]
mov dword [rdi + 0x2c], eax
movzx eax, byte [rbx + 0x30]
mov byte [rdi + 0x30], al
movzx eax, byte [rbx + 0x31]
mov byte [rdi + 0x31], al
movzx eax, byte [rbx + 0x32]
mov byte [rdi + 0x32], al
mov rdi, rsi
cmp rsi, r15
jl 0x18014d0a0
cmp rsi, r15
jne 0x18014d187
test r13b, 1
jne 0x18014d187
imul rcx, r13, 0x38
imul rdx, rdi, 0x38
mov rax, qword [rcx + rbp - 0x38]
lea rbx, [rcx + rbp]
lea rdi, [rdx + rbp]
mov qword [rdx + rbp], rax
lea rdx, [rbx - 0x30]
lea rcx, [rdi + 8]
call fcn.18009fee0
mov eax, dword [rbx - 0x10]
mov dword [rdi + 0x28], eax
mov eax, dword [rbx - 0xc]
mov dword [rdi + 0x2c], eax
movzx eax, byte [rbx - 8]
mov byte [rdi + 0x30], al
movzx eax, byte [rbx - 7]
mov byte [rdi + 0x31], al
movzx eax, byte [rbx - 6]
mov byte [rdi + 0x32], al
lea rdi, [r13 - 1]
cmp r12, rdi
jge 0x18014d205
nop dword [rax]
lea rsi, [rdi - 1]
sar rsi, 1
imul rbx, rsi, 0x38
add rbx, rbp
mov eax, dword [rbx + 0x2c]
cmp eax, dword [r14 + 0x2c]
je 0x18014d1ac
setg al
jmp 0x18014d1bc
lea rdx, [r14 + 8]
lea rcx, [rbx + 8]
call fcn.18010c360
shr al, 7
test al, al
je 0x18014d205
mov rax, qword [rbx]
lea rdx, [rbx + 8]
imul rcx, rdi, 0x38
lea rdi, [rcx + rbp]
mov qword [rcx + rbp], rax
lea rcx, [rdi + 8]
call fcn.18009fee0
mov eax, dword [rbx + 0x28]
mov dword [rdi + 0x28], eax
mov eax, dword [rbx + 0x2c]
mov dword [rdi + 0x2c], eax
movzx eax, byte [rbx + 0x30]
mov byte [rdi + 0x30], al
movzx eax, byte [rbx + 0x31]
mov byte [rdi + 0x31], al
movzx eax, byte [rbx + 0x32]
mov byte [rdi + 0x32], al
mov rdi, rsi
cmp r12, rsi
jl 0x18014d190
mov rax, qword [r14]
lea rdx, [r14 + 8]
imul rcx, rdi, 0x38
lea rdi, [rcx + rbp]
mov qword [rcx + rbp], rax
lea rcx, [rdi + 8]
call fcn.18009fee0
mov eax, dword [r14 + 0x28]
mov rbx, qword [rsp + 0x50]
mov rbp, qword [rsp + 0x58]
mov rsi, qword [rsp + 0x60]
mov dword [rdi + 0x28], eax
mov eax, dword [r14 + 0x2c]
mov dword [rdi + 0x2c], eax
movzx eax, byte [r14 + 0x30]
mov byte [rdi + 0x30], al
movzx eax, byte [r14 + 0x31]
mov byte [rdi + 0x31], al
movzx eax, byte [r14 + 0x32]
mov byte [rdi + 0x32], al
add rsp, 0x20
pop r15
pop r14
pop r13
pop r12
pop rdi
ret
Function at 0x18014d270
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x18], r8
push rbx
push rbp
push rsi
push rdi
push r13
push r14
push r15
sub rsp, 0x20
mov qword [rsp + 0x68], r12
mov rbp, rcx
lea rcx, [r8 - 1]
mov r15, r9
mov r12, rcx
mov qword [rsp + 0x60], rcx
sar r12, 1
mov rax, r8
mov rsi, rdx
mov r13, rdx
mov r14, rdx
cmp rdx, r12
jge 0x18014d324
nop
lea rbx, [r14 + r14]
lea rdx, [rbx + 2]
lea rdx, [rdx + rdx*4]
shl rdx, 4
add rdx, rbp
lea r8, [rdx - 0x50]
call fcn.18014c020
movzx r14d, al
xor r14, 1
inc r14
add r14, rbx
lea rbx, [rsi + rsi*4]
shl rbx, 4
add rbx, rbp
lea rdi, [r14 + r14*4]
shl rdi, 4
add rdi, rbp
lea rcx, [rbx + 8]
mov rax, qword [rdi]
lea rdx, [rdi + 8]
mov qword [rbx], rax
call fcn.18009fee0
lea rdx, [rdi + 0x28]
lea rcx, [rbx + 0x28]
call fcn.18009fee0
movzx eax, byte [rdi + 0x48]
mov rsi, r14
mov byte [rbx + 0x48], al
cmp r14, r12
jl 0x18014d2b0
mov rax, qword [rsp + 0x70]
cmp r14, r12
mov r12, qword [rsp + 0x68]
jne 0x18014d375
test al, 1
jne 0x18014d375
lea rdi, [rax + rax*4]
lea rbx, [rsi + rsi*4]
shl rdi, 4
add rdi, rbp
shl rbx, 4
add rbx, rbp
mov rax, qword [rdi - 0x50]
lea rdx, [rdi - 0x48]
lea rcx, [rbx + 8]
mov qword [rbx], rax
call fcn.18009fee0
lea rdx, [rdi - 0x28]
lea rcx, [rbx + 0x28]
call fcn.18009fee0
movzx eax, byte [rdi - 8]
mov rsi, qword [rsp + 0x60]
mov byte [rbx + 0x48], al
cmp r13, rsi
jge 0x18014d3dc
nop word [rax + rax]
lea rbx, [rsi - 1]
mov r8, r15
sar rbx, 1
lea r14, [rbx + rbx*4]
shl r14, 4
add r14, rbp
mov rdx, r14
call fcn.18014c020
test al, al
je 0x18014d3dc
mov rax, qword [r14]
lea rdi, [rsi + rsi*4]
shl rdi, 4
lea rdx, [r14 + 8]
add rdi, rbp
lea rcx, [rdi + 8]
mov qword [rdi], rax
call fcn.18009fee0
lea rdx, [r14 + 0x28]
lea rcx, [rdi + 0x28]
call fcn.18009fee0
movzx eax, byte [r14 + 0x48]
mov rsi, rbx
mov byte [rdi + 0x48], al
cmp r13, rbx
jl 0x18014d380
mov rax, qword [r15]
lea rbx, [rsi + rsi*4]
shl rbx, 4
lea rdx, [r15 + 8]
add rbx, rbp
lea rcx, [rbx + 8]
mov qword [rbx], rax
call fcn.18009fee0
lea rdx, [r15 + 0x28]
lea rcx, [rbx + 0x28]
call fcn.18009fee0
movzx eax, byte [r15 + 0x48]
mov byte [rbx + 0x48], al
add rsp, 0x20
pop r15
pop r14
pop r13
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x180151610
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x180265dfc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180267b6c], edx
jle 0x1801516f1
lea rcx, [0x180267b6c]
call fcn.1801b3c6c
cmp dword [0x180267b6c], 0xffffffff
jne 0x1801516f1
mov rcx, qword [0x1802676e0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801516de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180151682
mov rdx, r11
test rax, rax
je 0x1801516c0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801516a0
cmp r9d, 0x7a1c884e
je 0x1801516cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180151671
jmp 0x1801516de
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.1801b3800
mov r11d, eax
mov dword [0x180267b4c], r11d
lea rcx, [0x180267b6c]
call fcn.1801b3c00
movsxd rax, dword [0x180267b4c]
cmp byte [rax + rbx], 1
seta al
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x180265dfc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180267b34], edx
jle 0x1801517f1
lea rcx, [0x180267b34]
call fcn.1801b3c6c
cmp dword [0x180267b34], 0xffffffff
jne 0x1801517f1
mov rcx, qword [0x1802676e0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801517de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180151782
mov rdx, r11
test rax, rax
je 0x1801517c0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801517a0
cmp r9d, 0x7c5cc931
je 0x1801517cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180151771
jmp 0x1801517de
lea r8, str.m_bAllowMoveDuringTaunt
mov rdx, qword [r10 + 0x18]
call fcn.1801b3800
mov r11d, eax
mov dword [0x180267b5c], r11d
lea rcx, [0x180267b34]
call fcn.1801b3c00
movsxd rax, dword [0x180267b5c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180151810
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x180265dfc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180267b84], edx
jle 0x1801518f4
lea rcx, [0x180267b84]
call fcn.1801b3c6c
cmp dword [0x180267b84], 0xffffffff
jne 0x1801518f4
mov rcx, qword [0x1802676e0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801518de
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180151882
mov rdx, r11
test rax, rax
je 0x1801518c0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801518a0
cmp r9d, 0x7c5cc931
je 0x1801518cb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180151871
jmp 0x1801518de
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.1801b3800
mov r11d, eax
lea eax, [r11 - 4]
mov dword [0x180267b54], eax
lea rcx, [0x180267b84]
call fcn.1801b3c00
movsxd rax, dword [0x180267b54]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180154f20
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 0x180154fbc
nop dword [rax]
lea rbx, [r10 + r10]
lea rax, [rbx + 2]
lea rax, [rax + rax*2]
lea rdx, [rdi + rax*8]
lea r8, [rdx - 0x18]
lea rcx, [rsp + 0x70]
call fcn.180154880
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*8]
mov dword [rdi + rcx*8], eax
mov eax, dword [rdi + rdx*8 + 4]
mov dword [rdi + rcx*8 + 4], eax
mov eax, dword [rdi + rdx*8 + 8]
mov dword [rdi + rcx*8 + 8], eax
mov rax, qword [rdi + rdx*8 + 0x10]
mov qword [rdi + rcx*8 + 0x10], rax
cmp r10, rbp
jl 0x180154f60
cmp r10, rbp
mov rbp, qword [rsp + 0x50]
jne 0x180154ff9
test r14b, 1
jne 0x180154ff9
lea rcx, [rsi + rsi*2]
lea rdx, [r14 + r14*2]
mov eax, dword [rdi + rdx*8 - 0x18]
lea rsi, [r14 - 1]
mov dword [rdi + rcx*8], eax
mov eax, dword [rdi + rdx*8 - 0x14]
mov dword [rdi + rcx*8 + 4], eax
mov eax, dword [rdi + rdx*8 - 0x10]
mov dword [rdi + rcx*8 + 8], eax
mov rax, qword [rdi + rdx*8 - 8]
mov qword [rdi + rcx*8 + 0x10], rax
mov rax, qword [rsp + 0x70]
mov r13, qword [rsp + 0x58]
mov qword [rsp + 0x70], rax
cmp r12, rsi
jge 0x18015505e
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*8]
mov rdx, r14
call fcn.180154880
test al, al
je 0x18015505e
mov eax, dword [r14]
lea rcx, [rsi + rsi*2]
mov dword [rdi + rcx*8], eax
mov rsi, rbx
mov eax, dword [r14 + 4]
mov dword [rdi + rcx*8 + 4], eax
mov eax, dword [r14 + 8]
mov dword [rdi + rcx*8 + 8], eax
mov rax, qword [r14 + 0x10]
mov qword [rdi + rcx*8 + 0x10], rax
cmp r12, rbx
jl 0x180155010
mov eax, dword [r15]
lea rcx, [rsi + rsi*2]
mov rbx, qword [rsp + 0x60]
mov dword [rdi + rcx*8], eax
mov eax, dword [r15 + 4]
mov dword [rdi + rcx*8 + 4], eax
mov eax, dword [r15 + 8]
mov dword [rdi + rcx*8 + 8], eax
mov rax, qword [r15 + 0x10]
mov qword [rdi + rcx*8 + 0x10], rax
add rsp, 0x20
pop r15
pop r14
pop r12
pop rdi
pop rsi
ret
Function at 0x180158e60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x180265dfc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180267b90], edx
jle 0x180158f41
lea rcx, [0x180267b90]
call fcn.1801b3c6c
cmp dword [0x180267b90], 0xffffffff
jne 0x180158f41
mov rcx, qword [0x1802676e0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180158f2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180158ed2
mov rdx, r11
test rax, rax
je 0x180158f10
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180158ef0
cmp r9d, 0x9dc483b8
je 0x180158f1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180158ec1
jmp 0x180158f2e
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.1801b3800
mov r11d, eax
mov dword [0x180267b94], r11d
lea rcx, [0x180267b90]
call fcn.1801b3c00
movsxd rax, dword [0x180267b94]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180158f60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rsi
push rdi
sub rsp, 0x20
mov rsi, rcx
mov rax, qword [rcx]
mov rdx, qword [rax + 0xd80]
call rdx
test al, al
je 0x180159088
mov edx, dword [0x180265dfc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180267ba8], edx
jle 0x180159061
lea rcx, [0x180267ba8]
call fcn.1801b3c6c
cmp dword [0x180267ba8], 0xffffffff
jne 0x180159061
mov rcx, qword [0x1802676e0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015904e
nop
mov r8, qword [r10 + 0x10]
mov rcx, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rcx
cmp byte [r8 + rcx], r11b
jne 0x180158ff1
mov rdx, r11
test rcx, rcx
je 0x180159030
nop dword [rax]
nop word [rax + rax]
movsx eax, byte [rdx + r8]
xor eax, r9d
imul r9d, eax, 0x1000193
inc rdx
cmp rdx, rcx
jb 0x180159010
cmp r9d, 0x24615a25
je 0x18015903b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180158fe0
jmp 0x18015904e
lea r8, str.m_flEnergy
mov rdx, qword [r10 + 0x18]
call fcn.1801b3800
mov r11d, eax
mov dword [0x180267b9c], r11d
lea rcx, [0x180267ba8]
call fcn.1801b3c00
movsxd rax, dword [0x180267b9c]
vmovss xmm1, dword [rax + rsi]
vxorps xmm0, xmm0, xmm0
vcomiss xmm1, xmm0
seta al
mov rbx, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret
mov rcx, rsi
call fcn.1800da040
mov ebx, dword [rax]
cmp ebx, 0xffffffff
jne 0x18015910c
mov rcx, rsi
call fcn.180158e60
mov rcx, qword [0x180267710]
mov rdx, qword [rcx]
mov r8, qword [rdx + 0x20]
mov eax, dword [rax]
mov dword [rsp + 0x30], eax
lea rdx, [rsp + 0x30]
call r8
mov rdi, rax
test rax, rax
je 0x18015910c
mov rcx, rsi
call fcn.18010d270
mov r8, qword [0x180262648]
mov edx, dword [rax]
mov rcx, rdi
call r8
mov ebx, eax
mov rcx, rsi
call fcn.1800c3d00
xor r11d, r11d
mov ecx, 0x1d
cmp dword [rax], 0x20f
cmove r11d, ecx
cmp ebx, r11d
setg al
mov rbx, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret
test ebx, ebx
setg al
mov rbx, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret
Function at 0x18015a720
Capabilities:
Hash data using fnv

Disassembly:
sub rsp, 0x28
movabs rax, 0xfffffffffffffff
mov r8d, 1
bsr rcx, rax
shlx rax, r8, rcx
cmp rdx, rax
jbe 0x18015a750
lea rcx, str.invalid_hash_bucket_count
call qword [sym.imp.MSVCP140.dll_void___cdecl_std::_Xlength_error_char_const____ptr64_]
int3
lea rax, [rdx - 1]
mov qword [rsp + 0x30], rbx
mov rbx, qword [0x180277458]
or rax, r8
bsr rcx, rax
mov qword [rsp + 0x20], rdi
inc ecx
shlx rdi, r8, rcx
mov r8, rbx
lea rcx, [0x180277468]
lea rdx, [rdi + rdi]
call fcn.1800a0700
mov rax, qword [0x180277458]
lea r9, [rdi - 1]
mov qword [0x180277480], r9
mov qword [0x180277488], rdi
mov rax, qword [rax]
mov rcx, rax
cmp rax, rbx
je 0x18015a8d3
mov qword [rsp + 0x38], rsi
movabs rdi, 0x100000001b3
movabs rsi, 0xcbf29ce484222325
nop word [rax + rax]
movzx edx, byte [rax + 0x11]
movzx r11d, byte [rax + 0x10]
mov rcx, qword [rcx]
xor r11, rsi
imul r11, rdi
xor r11, rdx
movzx edx, byte [rax + 0x12]
imul r11, rdi
xor r11, rdx
movzx edx, byte [rax + 0x13]
imul r11, rdi
xor r11, rdx
imul r11, rdi
and r11, r9
shl r11, 4
add r11, qword [0x180277468]
mov r9, qword [r11]
cmp r9, rbx
jne 0x18015a81f
mov qword [r11], rax
mov qword [r11 + 8], rax
jmp 0x18015a894
mov rdx, qword [r11 + 8]
mov r8d, dword [rax + 0x10]
cmp r8d, dword [rdx + 0x10]
jne 0x18015a85c
mov r10, qword [rdx]
cmp r10, rax
je 0x18015a856
mov r9, qword [rax + 8]
mov qword [r9], rcx
mov r8, qword [rcx + 8]
mov qword [r8], r10
mov rdx, qword [r10 + 8]
mov qword [rdx], rax
mov qword [r10 + 8], r8
mov qword [rcx + 8], r9
mov qword [rax + 8], rdx
mov qword [r11 + 8], rax
jmp 0x18015a894
cmp r9, rdx
je 0x18015a870
mov rdx, qword [rdx + 8]
cmp r8d, dword [rdx + 0x10]
je 0x18015a8a8
cmp r9, rdx
jne 0x18015a861
mov r10, qword [rax + 8]
mov qword [r10], rcx
mov r9, qword [rcx + 8]
mov qword [r9], rdx
mov r8, qword [rdx + 8]
mov qword [r8], rax
mov qword [rdx + 8], r9
mov qword [rcx + 8], r10
mov qword [rax + 8], r8
mov qword [r11], rax
mov rax, rcx
cmp rcx, rbx
je 0x18015a8ce
mov r9, qword [0x180277480]
jmp 0x18015a7d0
mov r10, qword [rdx]
mov r9, qword [rax + 8]
mov qword [r9], rcx
mov r8, qword [rcx + 8]
mov qword [r8], r10
mov rdx, qword [r10 + 8]
mov qword [rdx], rax
mov qword [r10 + 8], r8
mov qword [rcx + 8], r9
mov qword [rax + 8], rdx
jmp 0x18015a894
mov rsi, qword [rsp + 0x38]
mov rbx, qword [rsp + 0x30]
mov rdi, qword [rsp + 0x20]
add rsp, 0x28
ret