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

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x18], rbp
mov qword [rsp + 0x20], rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0xa0
mov r14, rdx
mov rdi, rcx
xor r15d, r15d
test byte [rdx + 0x28], 6
je 0x18013ff7b
xorps xmm0, xmm0
movups xmmword [rcx], xmm0
mov qword [rcx + 0x10], 7
mov qword [rcx + 0x18], 0xf
mov rax, qword [0x18024d2e0]
mov dword [rcx], eax
movzx eax, word [0x18024d2e4]
mov word [rcx + 4], ax
movzx eax, byte [0x18024d2e6]
mov byte [rcx + 6], al
mov byte [rcx + 7], r15b
jmp 0x180140140
lea rdx, str.default
test r8b, r8b
je 0x18013ff91
call fcn.180099e50
jmp 0x180140140
lea rcx, [rsp + 0x38]
call fcn.180099e50
nop
movabs r13, 0xcbf29ce484222325
movabs r12, 0x100000001b3
lea r8, [rsp + 0x38]
mov rsi, qword [rsp + 0x38]
movups xmm1, xmmword [rsp + 0x48]
movdqa xmm0, xmm1
psrldq xmm0, 8
movq rbp, xmm0
cmp rbp, 0xf
cmova r8, rsi
mov ebx, 0x811c9dc5
mov rdx, 0xffffffffffffffff
inc rdx
cmp byte [r8 + rdx], 0
jne 0x18013ffe1
mov rax, r15
test rdx, rdx
je 0x180140015
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 0x180140000
mov rax, qword [0x18024d2e0]
test al, al
jne 0x180140027
mov eax, 0x811c9dc5
jmp 0x180140047
movsx ecx, al
xor ecx, 0x811c9dc5
imul edx, ecx, 0x1000193
lea rcx, [0x18024d2e1]
call fcn.1800ea660
movups xmm1, xmmword [rsp + 0x48]
cmp ebx, eax
je 0x18014012f
lea rcx, [r14 + 0x50]
lea r8, [rsp + 0x38]
cmp rbp, 0xf
cmova r8, rsi
mov r9, r13
mov rdx, r15
movq r10, xmm1
test r10, r10
je 0x180140084
movzx eax, byte [r8 + rdx]
xor r9, rax
imul r9, r12
inc rdx
cmp rdx, r10
jb 0x180140070
lea r8, [rsp + 0x38]
lea rdx, [rsp + 0x28]
call fcn.18009dcd0
cmp qword [rax + 8], 0
jne 0x18014012f
lea rdx, [rsp + 0x38]
lea rcx, [rsp + 0x58]
call fcn.180099e50
mov r8, rax
lea rdx, [rsp + 0x78]
call fcn.1800eb6b0
mov rbx, rax
lea rax, [rsp + 0x38]
cmp rax, rbx
je 0x180140120
mov rdx, qword [rsp + 0x50]
cmp rdx, 0xf
jbe 0x180140100
inc rdx
mov rcx, qword [rsp + 0x38]
mov rax, rcx
cmp rdx, 0x1000
jb 0x1801400fb
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
ja 0x180140164
call fcn.180199c38
movups xmm0, xmmword [rbx]
movups xmmword [rsp + 0x38], xmm0
movups xmm0, xmmword [rbx + 0x10]
movups xmmword [rsp + 0x48], xmm0
mov qword [rbx + 0x10], r15
mov qword [rbx + 0x18], 0xf
mov byte [rbx], 0
lea rcx, [rsp + 0x78]
call fcn.18009a190
jmp 0x18013ffb0
movups xmm0, xmmword [rsp + 0x38]
movups xmmword [rdi], xmm0
movups xmm0, xmmword [rsp + 0x48]
movups xmmword [rdi + 0x10], xmm0
mov rax, rdi
lea r11, [rsp + 0xa0]
mov rbx, qword [r11 + 0x30]
mov rbp, qword [r11 + 0x40]
mov rsi, qword [r11 + 0x48]
mov rsp, r11
pop r15
pop r14
pop r13
pop r12
pop rdi
ret
call fcn.1801afdbc
nop
int3
Function at 0x180140170
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.180099e50
nop
xor r13d, r13d
nop word [rax + rax]
lea rdx, [rbp - 0x39]
lea rcx, [rbp - 0x19]
call fcn.180099e50
mov r8, rax
lea rdx, [rbp + 7]
call fcn.1800eb6b0
mov rbx, rax
lea rax, [rbp - 0x39]
cmp rax, rbx
je 0x18014023e
mov rdx, qword [rbp - 0x21]
cmp rdx, 0xf
jbe 0x180140210
inc rdx
mov rcx, qword [rbp - 0x39]
mov rax, rcx
cmp rdx, 0x1000
jb 0x18014020b
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
ja 0x18014038d
call fcn.180199c38
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.18009a190
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 0x180140270
mov rax, r13
test rdx, rdx
je 0x1801402a5
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 0x180140290
mov rax, qword [0x18024d2e0]
test al, al
jne 0x1801402b7
mov eax, 0x811c9dc5
jmp 0x1801402d2
movsx ecx, al
xor ecx, 0x811c9dc5
imul edx, ecx, 0x1000193
lea rcx, [0x18024d2e1]
call fcn.1800ea660
cmp ebx, eax
lea rbx, [r14 + 0x50]
je 0x180140341
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 0x180140326
movabs r13, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [rdx + rcx]
xor r9, rax
imul r9, r13
inc rcx
cmp rcx, r8
jb 0x180140310
xor r13d, r13d
lea r8, [rbp - 0x39]
lea rdx, [rbp - 0x49]
mov rcx, rbx
call fcn.18009dcd0
cmp qword [rax + 8], 0
je 0x1801401b0
lea r8, [rbp - 0x39]
lea rdx, [rbp - 0x49]
mov rcx, rbx
call fcn.1800ee440
mov rcx, qword [rax]
movups xmm0, xmmword [rcx + 0x30]
movups xmmword [r12], xmm0
lea rcx, [rbp - 0x39]
call fcn.18009a190
nop
mov rcx, r15
call fcn.18009a190
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 fcn.1801afdbc
nop
int3
Function at 0x180141cc0
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 0x180141ceb
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 0x180141d00
xor ebx, ebx
mov edx, ebx
test rcx, rcx
je 0x180141d35
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 0x180141d20
mov edx, 0xc10bf213
lea rcx, [0x180254b99]
call fcn.1800ea660
mov edx, eax
cmp ebp, eax
jne 0x180141d50
mov al, 1
jmp 0x180141da9
cmp qword [r15 + 0x18], 0xf
mov rcx, r15
jbe 0x180141d60
mov rcx, qword [r15]
nop dword [rax]
inc rdi
cmp byte [rcx + rdi], bl
jne 0x180141d60
test rdi, rdi
je 0x180141d84
nop dword [rax]
movsx eax, byte [rcx + rbx]
inc rbx
xor eax, esi
imul esi, eax, 0x1000193
cmp rbx, rdi
jb 0x180141d70
cmp esi, edx
jne 0x180141d8c
xor al, al
jmp 0x180141da9
mov eax, dword [r14 + 0x24]
cmp eax, dword [r15 + 0x24]
je 0x180141d9b
setg al
jmp 0x180141da9
mov rdx, r15
mov rcx, r14
call fcn.18010e830
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 0x180142e30
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 0x180142e5b
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 0x180142e70
xor ebx, ebx
mov edx, ebx
test rcx, rcx
je 0x180142ea5
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 0x180142e90
mov edx, 0xcb0c01d1
lea rcx, [0x18020b3dd]
call fcn.1800ea660
mov edx, eax
cmp ebp, eax
je 0x180142f08
cmp qword [r15 + 0x18], 0xf
mov rcx, r15
jbe 0x180142ed0
mov rcx, qword [r15]
nop dword [rax]
inc rdi
cmp byte [rcx + rdi], bl
jne 0x180142ed0
test rdi, rdi
je 0x180142ef4
nop dword [rax]
movsx eax, byte [rcx + rbx]
inc rbx
xor eax, esi
imul esi, eax, 0x1000193
cmp rbx, rdi
jb 0x180142ee0
cmp esi, edx
je 0x180142f37
cmp byte [r14 + 0x48], 0
movzx eax, byte [r15 + 0x48]
je 0x180142f23
test al, al
jne 0x180142f27
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 0x180142f37
mov rdx, r15
mov rcx, r14
call fcn.18010e830
shr al, 7
jmp 0x180142f0a
xor al, al
jmp 0x180142f0a
Function at 0x1801436e0
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 0x180143788
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.180141cc0
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.180099d80
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 0x180143720
mov rax, qword [rsp + 0x70]
cmp r15, rbp
mov r15, qword [rsp + 0x68]
jne 0x1801437d1
test al, 1
jne 0x1801437d1
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.180099d80
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 0x18014382f
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.180141cc0
test al, al
je 0x18014382f
lea rdi, [rsi + rsi*2]
mov rdx, rbp
shl rdi, 4
add rdi, r14
mov rcx, rdi
call fcn.180099d80
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 0x1801437e0
lea rbx, [rsi + rsi*2]
mov rdx, r13
shl rbx, 4
add rbx, r14
mov rcx, rbx
call fcn.180099d80
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 0x180143a20
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 0x180143ad4
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.180142e30
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.180099d80
mov rax, qword [rdi + 0x20]
lea rdx, [rdi + 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180099d80
movzx eax, byte [rdi + 0x48]
mov rsi, r15
mov byte [rbx + 0x48], al
cmp r15, rbp
jl 0x180143a60
mov rax, qword [rsp + 0x70]
cmp r15, rbp
mov r15, qword [rsp + 0x68]
jne 0x180143b25
test al, 1
jne 0x180143b25
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.180099d80
mov rax, qword [rdi - 0x30]
lea rdx, [rdi - 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180099d80
movzx eax, byte [rdi - 8]
mov rsi, qword [rsp + 0x60]
mov byte [rbx + 0x48], al
cmp r12, rsi
jge 0x180143b8b
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.180142e30
test al, al
je 0x180143b8b
lea rdi, [rsi + rsi*4]
mov rdx, rbp
shl rdi, 4
add rdi, r14
mov rcx, rdi
call fcn.180099d80
mov rax, qword [rbp + 0x20]
lea rdx, [rbp + 0x28]
lea rcx, [rdi + 0x28]
mov qword [rdi + 0x20], rax
call fcn.180099d80
movzx eax, byte [rbp + 0x48]
mov rsi, rbx
mov byte [rdi + 0x48], al
cmp r12, rbx
jl 0x180143b30
lea rbx, [rsi + rsi*4]
mov rdx, r13
shl rbx, 4
add rbx, r14
mov rcx, rbx
call fcn.180099d80
mov rax, qword [r13 + 0x20]
lea rdx, [r13 + 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180099d80
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 0x180146c80
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297564], edx
jle 0x180146d61
lea rcx, [0x180297564]
call fcn.180199ce8
cmp dword [0x180297564], 0xffffffff
jne 0x180146d61
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180146d4e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180146cf2
mov rdx, r11
test rax, rax
je 0x180146d30
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 0x180146d10
cmp r9d, 0x7a1c884e
je 0x180146d3b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180146ce1
jmp 0x180146d4e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x180297544], r11d
lea rcx, [0x180297564]
call fcn.180199c7c
movsxd rax, dword [0x180297544]
cmp byte [rax + rbx], 1
seta al
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297584], edx
jle 0x180146e64
lea rcx, [0x180297584]
call fcn.180199ce8
cmp dword [0x180297584], 0xffffffff
jne 0x180146e64
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180146e4e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180146df2
mov rdx, r11
test rax, rax
je 0x180146e30
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 0x180146e10
cmp r9d, 0x7c5cc931
je 0x180146e3b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180146de1
jmp 0x180146e4e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 - 4]
mov dword [0x18029754c], eax
lea rcx, [0x180297584]
call fcn.180199c7c
movsxd rax, dword [0x18029754c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180146e80
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 [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180297578], r8d
jle 0x180146f71
lea rcx, [0x180297578]
call fcn.180199ce8
cmp dword [0x180297578], 0xffffffff
jne 0x180146f71
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180146f5e
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180146f01
mov rdx, r11
test rax, rax
je 0x180146f40
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 0x180146f20
cmp r9d, 0x3369e751
je 0x180146f4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180146ef0
jmp 0x180146f5e
lea r8, str.m_iPing
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x180297550], r11d
lea rcx, [0x180297578]
call fcn.180199c7c
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x180297550]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x18014a1f0
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 0x18014a282
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.180149cf0
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 0x18014a230
cmp r10, rbp
mov rbp, qword [rsp + 0x50]
jne 0x18014a2b5
test r14b, 1
jne 0x18014a2b5
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 0x18014a315
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.180149cf0
test al, al
je 0x18014a315
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 0x18014a2d0
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 0x18014ee40
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
test rdx, rdx
je 0x18014f0ad
mov qword [rsp + 8], rcx
push rbx
push rsi
push r15
mov eax, 0x13b0
call fcn.1801c89b0
sub rsp, rax
mov r15, r9
mov qword [rsp + 0x13d8], rdi
mov rsi, r8
mov rbx, rdx
call fcn.18014eca0
mov rax, qword [rbx]
mov rcx, rbx
call qword [rax + 0x410]
test al, al
je 0x18014ef29
mov rcx, rbx
call fcn.1800be180
mov ecx, dword [rax]
shr ecx, 0xd
test cl, 1
jne 0x18014ef29
mov edi, dword [0x1802a1704]
mov rcx, rbx
mov rax, qword [rbx]
shr edi, 1
and dil, 1
call qword [rax + 0x418]
test al, al
je 0x18014ef12
mov rcx, rbx
call fcn.1800cc2d0
mov rcx, qword [0x180297150]
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 0x18014eef7
mov rcx, rbx
call fcn.1800bf150
test byte [rax], 1
je 0x18014ef12
mov rcx, rbx
call fcn.1800bf150
mov ecx, dword [rax]
shr ecx, 1
test cl, 1
je 0x18014ef12
test byte [rsi + 0x28], 4
jne 0x18014ef12
mov al, 1
jmp 0x18014ef14
xor al, al
test dil, dil
je 0x18014ef21
test al, al
je 0x18014ef21
mov al, 1
jmp 0x18014ef23
xor al, al
mov byte [0x180291445], al
mov ecx, dword [0x1802a1584]
sub ecx, 1
je 0x18014f02a
sub ecx, 1
je 0x18014ef55
cmp ecx, 1
jne 0x18014f036
mov dword [0x180297440], 0x16
jmp 0x18014f036
cmp dword [0x180297440], 0
jne 0x18014f036
mov edi, dword [0x1802a150c]
mov qword [rsp + 0x13e0], r14
mov r14d, dword [0x1802a1508]
call fcn.18019d524
mov dword [rsp + 0x24], eax
mov edx, 1
mov dword [rsp + 0x13a4], 0xffffffff
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 0x18014ef90
btc r14d, 0x1f
mov dword [rsp + 0x20], 0x270
btc edi, 0x1f
lea rcx, [rsp + 0x20]
sub edi, r14d
cmp edi, 0xffffffff
jne 0x18014efd6
call fcn.180197650
mov ecx, eax
jmp 0x18014f018
inc edi
call fcn.180197650
mov ecx, eax
mov esi, edi
imul rcx, rsi
cmp ecx, edi
jae 0x18014f014
mov eax, edi
xor edx, edx
neg eax
div edi
mov edi, edx
cmp ecx, edx
jae 0x18014f014
nop word [rax + rax]
lea rcx, [rsp + 0x20]
call fcn.180197650
mov ecx, eax
imul rcx, rsi
cmp ecx, edi
jb 0x18014f000
shr rcx, 0x20
lea eax, [r14 + rcx]
mov r14, qword [rsp + 0x13e0]
btc eax, 0x1f
jmp 0x18014f030
mov eax, dword [0x1802a1784]
mov dword [0x180297440], eax
mov rdx, rbx
call fcn.18014ea80
mov rdi, qword [rsp + 0x13d8]
test al, al
jne 0x18014f098
mov rcx, rbx
call fcn.1800c44c0
movss xmm0, dword [rax]
movss dword [0x180291438], xmm0
movss xmm1, dword [rax + 4]
movss dword [0x18029143c], xmm1
movss xmm0, dword [rax + 8]
xor eax, eax
mov dword [0x180297440], eax
mov dword [0x18029743c], eax
mov byte [0x180291445], al
movss dword [0x180291440], xmm0
add rsp, 0x13b0
pop r15
pop rsi
pop rbx
ret
inc dword [0x18029743c]
mov byte [r15], 0
add rsp, 0x13b0
pop r15
pop rsi
pop rbx
ret
Function at 0x180150f20
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 [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x1802975c4], r8d
jle 0x180151011
lea rcx, [0x1802975c4]
call fcn.180199ce8
cmp dword [0x1802975c4], 0xffffffff
jne 0x180151011
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180150ffe
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180150fa1
mov rdx, r11
test rax, rax
je 0x180150fe0
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 0x180150fc0
cmp r9d, 0x3369e751
je 0x180150feb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180150f90
jmp 0x180150ffe
lea r8, str.m_iTeam
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802975a4], r11d
lea rcx, [0x1802975c4]
call fcn.180199c7c
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x1802975a4]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x180151040
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 [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18029759c], r8d
jle 0x180151131
lea rcx, [0x18029759c]
call fcn.180199ce8
cmp dword [0x18029759c], 0xffffffff
jne 0x180151131
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015111e
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801510c1
mov rdx, r11
test rax, rax
je 0x180151100
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 0x1801510e0
cmp r9d, 0x3369e751
je 0x18015110b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801510b0
jmp 0x18015111e
lea r8, str.m_bValid
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802975a8], r11d
lea rcx, [0x18029759c]
call fcn.180199c7c
movsxd rax, dword [0x1802975a8]
add rax, rdi
movzx eax, byte [rbx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret