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

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], r8
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
lea rbp, [rsp - 0x27]
sub rsp, 0x90
mov r15, r8
mov r14, rdx
mov r12, rcx
mov rdx, r8
lea rcx, [rbp - 0x39]
call fcn.180092300
nop
xor r13d, r13d
nop word [rax + rax]
lea rdx, [rbp - 0x39]
lea rcx, [rbp - 0x19]
call fcn.180092300
mov r8, rax
lea rdx, [rbp + 7]
call fcn.1800e1880
mov rbx, rax
lea rax, [rbp - 0x39]
cmp rax, rbx
je 0x18012d1ce
mov rdx, qword [rbp - 0x21]
cmp rdx, 0xf
jbe 0x18012d1a0
inc rdx
mov rcx, qword [rbp - 0x39]
mov rax, rcx
cmp rdx, 0x1000
jb 0x18012d19b
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
ja 0x18012d31d
call fcn.1801822cc
mov qword [rbp - 0x29], r13
mov qword [rbp - 0x21], 0xf
mov byte [rbp - 0x39], 0
movups xmm0, xmmword [rbx]
movups xmmword [rbp - 0x39], xmm0
movups xmm1, xmmword [rbx + 0x10]
movups xmmword [rbp - 0x29], xmm1
mov qword [rbx + 0x10], r13
mov qword [rbx + 0x18], 0xf
mov byte [rbx], 0
lea rcx, [rbp + 7]
call fcn.180092690
lea r8, [rbp - 0x39]
mov rdi, qword [rbp - 0x39]
mov rsi, qword [rbp - 0x21]
cmp rsi, 0xf
cmova r8, rdi
mov ebx, 0x811c9dc5
mov rdx, 0xffffffffffffffff
nop word [rax + rax]
inc rdx
cmp byte [r8 + rdx], 0
jne 0x18012d200
mov rax, r13
test rdx, rdx
je 0x18012d235
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rax]
xor ecx, ebx
imul ebx, ecx, 0x1000193
inc rax
cmp rax, rdx
jb 0x18012d220
mov rax, qword [0x1801f4d88]
test al, al
jne 0x18012d247
mov eax, 0x811c9dc5
jmp 0x18012d262
movsx ecx, al
xor ecx, 0x811c9dc5
imul edx, ecx, 0x1000193
lea rcx, [0x1801f4d89]
call fcn.1800e0810
cmp ebx, eax
lea rbx, [r14 + 0x50]
je 0x18012d2d1
lea rdx, [rbp - 0x39]
cmp rsi, 0xf
cmova rdx, rdi
movabs r9, 0xcbf29ce484222325
mov rcx, r13
mov r8, qword [rbp - 0x29]
test r8, r8
je 0x18012d2b6
movabs r13, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [rdx + rcx]
xor r9, rax
imul r9, r13
inc rcx
cmp rcx, r8
jb 0x18012d2a0
xor r13d, r13d
lea r8, [rbp - 0x39]
lea rdx, [rbp - 0x49]
mov rcx, rbx
call fcn.180096020
cmp qword [rax + 8], 0
je 0x18012d140
lea r8, [rbp - 0x39]
lea rdx, [rbp - 0x49]
mov rcx, rbx
call fcn.1800e46d0
mov rcx, qword [rax]
movups xmm0, xmmword [rcx + 0x30]
movups xmmword [r12], xmm0
lea rcx, [rbp - 0x39]
call fcn.180092690
nop
mov rcx, r15
call fcn.180092690
mov rax, r12
mov rbx, qword [rsp + 0xd8]
add rsp, 0x90
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret
call qword [sym.imp.api_ms_win_crt_runtime_l1_1_0.dll__invalid_parameter_noinfo_noreturn]
nop
int3
Function at 0x18012ec50
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
push rdi
push r14
push r15
sub rsp, 0x20
cmp qword [rdx + 0x18], 0xf
mov r15, r8
mov r14, rdx
mov r9, rdx
jbe 0x18012ec7b
mov r9, qword [rdx]
mov esi, 0x811c9dc5
mov rdi, 0xffffffffffffffff
mov ebp, esi
mov rcx, rdi
nop dword [rax]
inc rcx
cmp byte [r9 + rcx], 0
jne 0x18012ec90
xor ebx, ebx
mov edx, ebx
test rcx, rcx
je 0x18012ecc5
nop dword [rax]
nop word [rax + rax]
movsx eax, byte [r9 + rdx]
inc rdx
xor eax, ebp
imul ebp, eax, 0x1000193
cmp rdx, rcx
jb 0x18012ecb0
mov edx, 0xc10bf213
lea rcx, [0x1801f7cc1]
call fcn.1800e0810
mov edx, eax
cmp ebp, eax
jne 0x18012ece0
mov al, 1
jmp 0x18012ed39
cmp qword [r15 + 0x18], 0xf
mov rcx, r15
jbe 0x18012ecf0
mov rcx, qword [r15]
nop dword [rax]
inc rdi
cmp byte [rcx + rdi], bl
jne 0x18012ecf0
test rdi, rdi
je 0x18012ed14
nop dword [rax]
movsx eax, byte [rcx + rbx]
inc rbx
xor eax, esi
imul esi, eax, 0x1000193
cmp rbx, rdi
jb 0x18012ed00
cmp esi, edx
jne 0x18012ed1c
xor al, al
jmp 0x18012ed39
mov eax, dword [r14 + 0x24]
cmp eax, dword [r15 + 0x24]
je 0x18012ed2b
setg al
jmp 0x18012ed39
mov rdx, r15
mov rcx, r14
call fcn.1800fe540
shr al, 7
mov rbx, qword [rsp + 0x40]
mov rbp, qword [rsp + 0x48]
mov rsi, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
ret
Function at 0x18012fdc0
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
push rdi
push r14
push r15
sub rsp, 0x20
cmp qword [rdx + 0x18], 0xf
mov r15, r8
mov r14, rdx
mov r9, rdx
jbe 0x18012fdeb
mov r9, qword [rdx]
mov esi, 0x811c9dc5
mov rdi, 0xffffffffffffffff
mov ebp, esi
mov rcx, rdi
nop dword [rax]
inc rcx
cmp byte [r9 + rcx], 0
jne 0x18012fe00
xor ebx, ebx
mov edx, ebx
test rcx, rcx
je 0x18012fe35
nop dword [rax]
nop word [rax + rax]
movsx eax, byte [r9 + rdx]
inc rdx
xor eax, ebp
imul ebp, eax, 0x1000193
cmp rdx, rcx
jb 0x18012fe20
mov edx, 0xcb0c01d1
lea rcx, [0x1801b2e89]
call fcn.1800e0810
mov edx, eax
cmp ebp, eax
je 0x18012fe98
cmp qword [r15 + 0x18], 0xf
mov rcx, r15
jbe 0x18012fe60
mov rcx, qword [r15]
nop dword [rax]
inc rdi
cmp byte [rcx + rdi], bl
jne 0x18012fe60
test rdi, rdi
je 0x18012fe84
nop dword [rax]
movsx eax, byte [rcx + rbx]
inc rbx
xor eax, esi
imul esi, eax, 0x1000193
cmp rbx, rdi
jb 0x18012fe70
cmp esi, edx
je 0x18012fec7
cmp byte [r14 + 0x48], 0
movzx eax, byte [r15 + 0x48]
je 0x18012feb3
test al, al
jne 0x18012feb7
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rbp, qword [rsp + 0x48]
mov rsi, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
ret
test al, al
jne 0x18012fec7
mov rdx, r15
mov rcx, r14
call fcn.1800fe540
shr al, 7
jmp 0x18012fe9a
xor al, al
jmp 0x18012fe9a
Function at 0x180130630
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x18], r8
push rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
sub rsp, 0x20
mov r14, rcx
mov qword [rsp + 0x68], r15
lea rcx, [r8 - 1]
mov r13, r9
mov rbp, rcx
mov qword [rsp + 0x60], rcx
sar rbp, 1
mov rax, r8
mov rsi, rdx
mov r12, rdx
mov r15, rdx
cmp rdx, rbp
jge 0x1801306d8
nop
lea rbx, [r15 + r15]
lea rdx, [rbx + 2]
lea rdx, [rdx + rdx*2]
shl rdx, 4
add rdx, r14
lea r8, [rdx - 0x30]
call fcn.18012ec50
movzx r15d, al
xor r15, 1
inc r15
add r15, rbx
lea rbx, [rsi + rsi*2]
shl rbx, 4
add rbx, r14
mov rcx, rbx
lea rdi, [r15 + r15*2]
shl rdi, 4
add rdi, r14
mov rdx, rdi
call fcn.180092230
movsd xmm0, qword [rdi + 0x20]
mov rsi, r15
movsd qword [rbx + 0x20], xmm0
mov eax, dword [rdi + 0x28]
mov dword [rbx + 0x28], eax
cmp r15, rbp
jl 0x180130670
mov rax, qword [rsp + 0x70]
cmp r15, rbp
mov r15, qword [rsp + 0x68]
jne 0x180130721
test al, 1
jne 0x180130721
lea rdi, [rax + rax*2]
shl rdi, 4
lea rbx, [rsi + rsi*2]
shl rbx, 4
lea rdx, [r14 - 0x30]
add rbx, r14
add rdx, rdi
mov rcx, rbx
call fcn.180092230
movsd xmm0, qword [rdi + r14 - 0x10]
mov rsi, qword [rsp + 0x60]
movsd qword [rbx + 0x20], xmm0
mov eax, dword [rdi + r14 - 8]
mov dword [rbx + 0x28], eax
cmp r12, rsi
jge 0x18013077f
nop word [rax + rax]
lea rbx, [rsi - 1]
mov r8, r13
sar rbx, 1
lea rbp, [rbx + rbx*2]
shl rbp, 4
add rbp, r14
mov rdx, rbp
call fcn.18012ec50
test al, al
je 0x18013077f
lea rdi, [rsi + rsi*2]
mov rdx, rbp
shl rdi, 4
add rdi, r14
mov rcx, rdi
call fcn.180092230
movsd xmm0, qword [rbp + 0x20]
mov rsi, rbx
movsd qword [rdi + 0x20], xmm0
mov eax, dword [rbp + 0x28]
mov dword [rdi + 0x28], eax
cmp r12, rbx
jl 0x180130730
lea rbx, [rsi + rsi*2]
mov rdx, r13
shl rbx, 4
add rbx, r14
mov rcx, rbx
call fcn.180092230
movsd xmm0, qword [r13 + 0x20]
movsd qword [rbx + 0x20], xmm0
mov eax, dword [r13 + 0x28]
mov dword [rbx + 0x28], eax
add rsp, 0x20
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x180130970
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 r12
push r13
push r14
sub rsp, 0x20
mov r14, rcx
mov qword [rsp + 0x68], r15
lea rcx, [r8 - 1]
mov r13, r9
mov rbp, rcx
mov qword [rsp + 0x60], rcx
sar rbp, 1
mov rax, r8
mov rsi, rdx
mov r12, rdx
mov r15, rdx
cmp rdx, rbp
jge 0x180130a24
nop
lea rbx, [r15 + r15]
lea rdx, [rbx + 2]
lea rdx, [rdx + rdx*4]
shl rdx, 4
add rdx, r14
lea r8, [rdx - 0x50]
call fcn.18012fdc0
movzx r15d, al
xor r15, 1
inc r15
add r15, rbx
lea rbx, [rsi + rsi*4]
shl rbx, 4
add rbx, r14
mov rcx, rbx
lea rdi, [r15 + r15*4]
shl rdi, 4
add rdi, r14
mov rdx, rdi
call fcn.180092230
mov rax, qword [rdi + 0x20]
lea rdx, [rdi + 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180092230
movzx eax, byte [rdi + 0x48]
mov rsi, r15
mov byte [rbx + 0x48], al
cmp r15, rbp
jl 0x1801309b0
mov rax, qword [rsp + 0x70]
cmp r15, rbp
mov r15, qword [rsp + 0x68]
jne 0x180130a75
test al, 1
jne 0x180130a75
lea rdi, [rax + rax*4]
shl rdi, 4
lea rbx, [rsi + rsi*4]
add rdi, r14
shl rbx, 4
add rbx, r14
mov rcx, rbx
lea rdx, [rdi - 0x50]
call fcn.180092230
mov rax, qword [rdi - 0x30]
lea rdx, [rdi - 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180092230
movzx eax, byte [rdi - 8]
mov rsi, qword [rsp + 0x60]
mov byte [rbx + 0x48], al
cmp r12, rsi
jge 0x180130adb
nop word [rax + rax]
lea rbx, [rsi - 1]
mov r8, r13
sar rbx, 1
lea rbp, [rbx + rbx*4]
shl rbp, 4
add rbp, r14
mov rdx, rbp
call fcn.18012fdc0
test al, al
je 0x180130adb
lea rdi, [rsi + rsi*4]
mov rdx, rbp
shl rdi, 4
add rdi, r14
mov rcx, rdi
call fcn.180092230
mov rax, qword [rbp + 0x20]
lea rdx, [rbp + 0x28]
lea rcx, [rdi + 0x28]
mov qword [rdi + 0x20], rax
call fcn.180092230
movzx eax, byte [rbp + 0x48]
mov rsi, rbx
mov byte [rdi + 0x48], al
cmp r12, rbx
jl 0x180130a80
lea rbx, [rsi + rsi*4]
mov rdx, r13
shl rbx, 4
add rbx, r14
mov rcx, rbx
call fcn.180092230
mov rax, qword [r13 + 0x20]
lea rdx, [r13 + 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180092230
movzx eax, byte [r13 + 0x48]
mov byte [rbx + 0x48], al
add rsp, 0x20
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x180133ca0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230ec0], edx
jle 0x180133d81
lea rcx, [0x180230ec0]
call fcn.18018237c
cmp dword [0x180230ec0], 0xffffffff
jne 0x180133d81
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180133d6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180133d12
mov rdx, r11
test rax, rax
je 0x180133d50
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 0x180133d30
cmp r9d, 0x7a1c884e
je 0x180133d5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180133d01
jmp 0x180133d6e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230efc], r11d
lea rcx, [0x180230ec0]
call fcn.180182310
movsxd rax, dword [0x180230efc]
cmp byte [rax + rbx], 1
seta al
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230ed8], edx
jle 0x180133e84
lea rcx, [0x180230ed8]
call fcn.18018237c
cmp dword [0x180230ed8], 0xffffffff
jne 0x180133e84
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180133e6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180133e12
mov rdx, r11
test rax, rax
je 0x180133e50
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 0x180133e30
cmp r9d, 0x7c5cc931
je 0x180133e5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180133e01
jmp 0x180133e6e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 4]
mov dword [0x180230f04], eax
lea rcx, [0x180230ed8]
call fcn.180182310
movsxd rax, dword [0x180230f04]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180137270
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 0x180137302
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.180136d70
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 0x1801372b0
cmp r10, rbp
mov rbp, qword [rsp + 0x50]
jne 0x180137335
test r14b, 1
jne 0x180137335
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 0x180137395
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.180136d70
test al, al
je 0x180137395
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 0x180137350
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 0x18013c030
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
test rdx, rdx
je 0x18013c2ad
mov qword [rsp + 8], rcx
push rbx
push rsi
push r15
mov eax, 0x13b0
call fcn.1801843c0
sub rsp, rax
mov r15, r9
mov qword [rsp + 0x13d8], rdi
mov rsi, r8
mov rbx, rdx
call fcn.18013be80
mov rcx, rbx
call fcn.1800a8b40
cmp byte [rax], 0
jne 0x18013c11e
mov rcx, rbx
call fcn.1800a8e50
mov ecx, dword [rax]
shr ecx, 0xd
test cl, 1
jne 0x18013c11e
mov edi, dword [0x18023a184]
lea rcx, [rbx + 0x10]
mov rax, qword [rcx]
shr edi, 1
and dil, 1
call qword [rax + 0x10]
test rax, rax
je 0x18013c107
cmp dword [rax + 0x28], 0xf7
jne 0x18013c107
mov rcx, rbx
call fcn.1800b6f10
mov rcx, qword [0x180230b08]
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 0x18013c0ec
mov rcx, rbx
call fcn.1800a9de0
test byte [rax], 1
je 0x18013c107
mov rcx, rbx
call fcn.1800a9de0
mov ecx, dword [rax]
shr ecx, 1
test cl, 1
je 0x18013c107
test byte [rsi + 0x28], 4
jne 0x18013c107
mov al, 1
jmp 0x18013c109
xor al, al
test dil, dil
je 0x18013c116
test al, al
je 0x18013c116
mov al, 1
jmp 0x18013c118
xor al, al
mov byte [0x18022c665], al
mov ecx, dword [0x18023a004]
sub ecx, 1
je 0x18013c22a
sub ecx, 1
je 0x18013c14a
cmp ecx, 1
jne 0x18013c236
mov dword [0x180230df0], 0x16
jmp 0x18013c236
cmp dword [0x180230df0], 0
jne 0x18013c236
mov edi, dword [0x180239f8c]
mov qword [rsp + 0x13e0], r14
mov r14d, dword [0x180239f88]
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 0x18013c190
btc r14d, 0x1f
mov dword [rsp + 0x20], 0x270
btc edi, 0x1f
lea rcx, [rsp + 0x20]
sub edi, r14d
cmp edi, 0xffffffff
jne 0x18013c1d6
call fcn.180180240
mov ecx, eax
jmp 0x18013c218
inc edi
call fcn.180180240
mov ecx, eax
mov esi, edi
imul rcx, rsi
cmp ecx, edi
jae 0x18013c214
mov eax, edi
xor edx, edx
neg eax
div edi
mov edi, edx
cmp ecx, edx
jae 0x18013c214
nop word [rax + rax]
lea rcx, [rsp + 0x20]
call fcn.180180240
mov ecx, eax
imul rcx, rsi
cmp ecx, edi
jb 0x18013c200
shr rcx, 0x20
lea eax, [r14 + rcx]
mov r14, qword [rsp + 0x13e0]
btc eax, 0x1f
jmp 0x18013c230
mov eax, dword [0x18023a204]
mov dword [0x180230df0], eax
mov rdx, rbx
call fcn.18013bc60
mov rdi, qword [rsp + 0x13d8]
test al, al
jne 0x18013c298
mov rcx, rbx
call fcn.1800af2f0
movss xmm0, dword [rax]
movss dword [0x18022c658], xmm0
movss xmm1, dword [rax + 4]
movss dword [0x18022c65c], xmm1
movss xmm0, dword [rax + 8]
xor eax, eax
mov dword [0x180230df0], eax
mov dword [0x180230df8], eax
mov byte [0x18022c665], al
movss dword [0x18022c660], xmm0
add rsp, 0x13b0
pop r15
pop rsi
pop rbx
ret
inc dword [0x180230df8]
mov byte [r15], 0
add rsp, 0x13b0
pop r15
pop rsi
pop rbx
ret
Function at 0x18013e380
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 [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180230f5c], r8d
jle 0x18013e471
lea rcx, [0x180230f5c]
call fcn.18018237c
cmp dword [0x180230f5c], 0xffffffff
jne 0x18013e471
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013e45e
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013e401
mov rdx, r11
test rax, rax
je 0x18013e440
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 0x18013e420
cmp r9d, 0x3369e751
je 0x18013e44b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013e3f0
jmp 0x18013e45e
lea r8, str.m_iTeam
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230f3c], r11d
lea rcx, [0x180230f5c]
call fcn.180182310
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x180230f3c]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x18013e4a0
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 [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180230f34], r8d
jle 0x18013e591
lea rcx, [0x180230f34]
call fcn.18018237c
cmp dword [0x180230f34], 0xffffffff
jne 0x18013e591
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013e57e
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013e521
mov rdx, r11
test rax, rax
je 0x18013e560
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 0x18013e540
cmp r9d, 0x3369e751
je 0x18013e56b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013e510
jmp 0x18013e57e
lea r8, str.m_bValid
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230f40], r11d
lea rcx, [0x180230f34]
call fcn.180182310
movsxd rax, dword [0x180230f40]
add rax, rdi
movzx eax, byte [rbx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x18013e5b0
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 0x18013e677
lea rdi, [rcx + 0x90]
mov r10, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013e5eb
mov r10, qword [rbx]
xor ecx, ecx
movabs r9, 0xcbf29ce484222325
test rdx, rdx
je 0x18013e624
movabs r8, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [r10 + rcx]
xor r9, rax
imul r9, r8
inc rcx
cmp rcx, rdx
jb 0x18013e610
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180096020
cmp qword [rax + 8], 0
je 0x18013e677
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.1801283d0
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.180092690
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
mov rcx, rbx
call fcn.180092690
xor al, al
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x18013e8d0
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 0x18013eb52
add rcx, 0x50
lea r8, [rbp + 0x58]
lea rdx, [rsp + 0x30]
call fcn.180128660
mov rsi, qword [rax]
mov rax, qword [rsi + 0x18]
mov rcx, qword [rsi + 0x20]
cmp rax, rcx
je 0x18013eb52
nop word [rax + rax]
mov r10, rax
cmp qword [rax + 0x18], 0xf
jbe 0x18013e93d
mov r10, qword [rax]
mov rdx, 0xffffffffffffffff
mov r11d, 0x811c9dc5
nop word [rax + rax]
inc rdx
cmp byte [r10 + rdx], 0
jne 0x18013e950
xor r9d, r9d
test rdx, rdx
je 0x18013e99a
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 0x18013e970
test r11d, r11d
jne 0x18013e99a
add rax, 0x20
cmp rax, rcx
jne 0x18013e930
jmp 0x18013eb52
mov rdi, rcx
lea rbx, [rax + 0x20]
cmp rbx, rcx
je 0x18013e9c5
nop word [rax + rax]
lea rcx, [rbx - 0x20]
mov rdx, rbx
call fcn.180092230
add rbx, 0x20
cmp rbx, rdi
jne 0x18013e9b0
mov rcx, qword [rsi + 0x20]
sub rcx, 0x20
call fcn.180092690
add qword [rsi + 0x20], 0xffffffffffffffe0
mov byte [r15 + 0x129], 1
cmp qword [r12 + 0x10], 0
je 0x18013eb52
mov dword [rsp + 0x30], 0xffffffff
mov rdx, r14
lea rcx, [rbp - 0x58]
call fcn.180092300
lea r8, [rsp + 0x30]
mov rdx, rax
mov rcx, r15
call fcn.18013e5b0
test al, al
je 0x18013eb52
lea rax, [rbp - 0x30]
mov qword [rsp + 0x70], rax
mov rdx, r14
lea rcx, [rbp - 0x30]
call fcn.180092300
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.1800cdb90
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 [0x180200d54]
mov word [rsp + 0x54], ax
movzx eax, byte [0x180200d56]
mov byte [rsp + 0x56], al
mov byte [rsp + 0x57], 0
mov rdx, r12
lea rcx, [rbp - 0x10]
call fcn.180092300
nop
mov qword [rsp + 0x20], rbx
lea r9, [rbp - 0x58]
lea r8, [rsp + 0x50]
mov rdx, rax
call fcn.1801336c0
nop
mov rcx, r14
call fcn.180092690
nop
mov rcx, r12
call fcn.180092690
add rsp, 0x110
pop r15
pop r14
pop r12
pop rdi
pop rsi
pop rbx
pop rbp
ret