joyce8/EMBER2024-capa huggingface dataset:
Function at 0x1801a4a00
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push rdi
push r12
push r13
sub rsp, 0x10
mov qword [rsp + 0x30], rbx
lea r13, [0x180000000]
mov qword [rsp + 0x38], rbp
mov rdi, rdx
mov qword [rsp + 0x40], rsi
mov rax, rcx
mov qword [rsp + 8], r14
xor r12d, r12d
mov qword [rsp], r15
test rdi, rdi
je 0x1801a4a40
cmp rax, rdi
jae 0x1801a4bb8
movzx r8d, byte [rax]
test r8b, r8b
je 0x1801a4bb8
xor ebx, ebx
mov ecx, r8d
shr rcx, 3
mov rdx, rdi
movsx r9, byte [rcx + r13 + 0x41c358]
test r9d, r9d
sete bl
add ebx, r9d
test rdi, rdi
jne 0x1801a4a76
movsxd rdx, ebx
add rdx, rax
xor esi, esi
lea rcx, [rax + 1]
cmp rax, rdx
cmovb esi, r8d
cmp rcx, rdx
jae 0x1801a4a8e
movzx r15d, byte [rcx]
jmp 0x1801a4a91
xor r15b, r15b
lea rcx, [rax + 2]
cmp rcx, rdx
jae 0x1801a4aa0
movzx r14d, byte [rcx]
jmp 0x1801a4aa3
xor r14b, r14b
lea rcx, [rax + 3]
cmp rcx, rdx
jae 0x1801a4ab1
movzx ebp, byte [rcx]
jmp 0x1801a4ab4
xor bpl, bpl
lea r10, [r9*4]
movzx ecx, sil
mov r9d, dword [r10 + r13 + 0x41c7c8]
and r9d, ecx
movzx r8d, r15b
shl r9d, 6
mov ecx, r8d
and ecx, 0x3f
movzx edx, r14b
or r9d, ecx
movzx r11d, bpl
shl r9d, 6
and r8d, 0xc0
mov ecx, edx
and edx, 0xc0
and ecx, 0x3f
or r9d, ecx
mov ecx, r11d
shr r11d, 2
and ecx, 0x3f
or r11d, edx
shl r9d, 6
shr r11d, 2
or r9d, ecx
mov ecx, dword [r10 + r13 + 0x41c7b0]
or r11d, r8d
shr r9d, cl
shr r11d, 2
mov edx, r9d
cmp r9d, dword [r10 + r13 + 0x41c798]
sbb ecx, ecx
and edx, 0xfffff800
and ecx, 0x40
xor r8d, r8d
or r11d, ecx
mov ecx, 0x80
cmp edx, 0xd800
cmove r8d, ecx
xor edx, edx
or r11d, r8d
mov ecx, 0x100
cmp r9d, 0xffff
cmova edx, ecx
mov ecx, dword [r10 + r13 + 0x41c780]
or r11d, edx
xor r11d, 0x2a
sar r11d, cl
test r11d, r11d
je 0x1801a4baa
xor edx, edx
test bpl, bpl
setne dl
xor ecx, ecx
test r14b, r14b
setne cl
add edx, ecx
xor ecx, ecx
test r15b, r15b
setne cl
add edx, ecx
xor ecx, ecx
test sil, sil
setne cl
add edx, ecx
cmp ebx, edx
cmovl edx, ebx
mov ebx, edx
movsxd rcx, ebx
add rax, rcx
inc r12d
jmp 0x1801a4a32
mov r15, qword [rsp]
mov eax, r12d
mov r14, qword [rsp + 8]
mov rsi, qword [rsp + 0x40]
mov rbp, qword [rsp + 0x38]
mov rbx, qword [rsp + 0x30]
add rsp, 0x10
pop r13
pop r12
pop rdi
ret
Function at 0x1801a7a80
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x18], rsi
mov dword [rsp + 0x10], edx
push rdi
sub rsp, 0x20
cmp dword [rcx + 0xf0], 0
mov rsi, rcx
movsxd rdi, edx
jg 0x1801a7ab5
lea rdx, str.Size___0
lea rcx, str._ImGui__Assertion_failed:__s_n
call fcn.1801c11a0
mov rax, qword [rsi + 0xf8]
lea rdx, [0x18041c380]
movsxd r8, dword [rsi + 0xf0]
mov ebx, dword [rax + r8*4 - 4]
not ebx
movzx eax, dil
movzx ecx, bl
xor rcx, rax
shr ebx, 8
movzx eax, byte [rsp + 0x39]
xor ebx, dword [rdx + rcx*4]
movzx ecx, bl
xor rcx, rax
shr ebx, 8
movzx eax, byte [rsp + 0x3a]
xor ebx, dword [rdx + rcx*4]
movzx ecx, bl
xor rcx, rax
shr ebx, 8
movzx eax, byte [rsp + 0x3b]
xor ebx, dword [rdx + rcx*4]
movzx ecx, bl
xor rcx, rax
shr ebx, 8
xor ebx, dword [rdx + rcx*4]
mov rcx, qword [rsi]
not ebx
cmp dword [rcx + 0x3f50], ebx
jne 0x1801a7b30
mov r8, rdi
mov edx, 4
mov ecx, ebx
call fcn.1801be6e0
mov rsi, qword [rsp + 0x40]
mov eax, ebx
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x1801a7b50
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x30
cmp dword [rcx + 0xf0], 0
mov rdi, rdx
mov rbx, rcx
jg 0x1801a7b7c
lea rdx, str.Size___0
lea rcx, str._ImGui__Assertion_failed:__s_n
call fcn.1801c11a0
movss xmm0, dword [rbx + 0x110]
lea r10, [0x18041c380]
movsxd rcx, dword [rbx + 0xf0]
mov rax, qword [rbx + 0xf8]
movss xmm2, dword [rdi]
movss xmm1, dword [rbx + 0x114]
subss xmm2, xmm0
movss xmm3, dword [rdi + 4]
mov r9d, dword [rax + rcx*4 - 4]
subss xmm3, xmm1
movss xmm4, dword [rdi + 8]
not r9d
movzx ecx, r9b
subss xmm4, xmm0
movss xmm0, dword [rdi + 0xc]
shr r9d, 8
subss xmm0, xmm1
movd r8d, xmm2
movss dword [rsp + 0x20], xmm2
movzx eax, byte [rsp + 0x20]
xor rcx, rax
movss dword [rsp + 0x24], xmm3
mov eax, r8d
movss dword [rsp + 0x28], xmm4
shr eax, 8
movzx edx, al
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
movzx ecx, r9b
xor rdx, rcx
shr r9d, 8
shr eax, 0x10
movss dword [rsp + 0x2c], xmm0
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
movzx eax, byte [rsp + 0x24]
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
mov edx, r8d
shr rdx, 0x18
xor rdx, rcx
movd r8d, xmm3
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
xor rcx, rax
shr r9d, 8
mov eax, r8d
shr eax, 8
movzx edx, al
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
movzx ecx, r9b
xor rdx, rcx
shr r9d, 8
shr eax, 0x10
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
movzx eax, byte [rsp + 0x28]
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
mov edx, r8d
shr rdx, 0x18
xor rdx, rcx
movd r8d, xmm4
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
xor rcx, rax
shr r9d, 8
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
shr eax, 8
movzx edx, al
movzx ecx, r9b
mov rbx, qword [rsp + 0x40]
xor rdx, rcx
shr r9d, 8
mov eax, r8d
shr eax, 0x10
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
movzx eax, byte [rsp + 0x2c]
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
mov edx, r8d
shr rdx, 0x18
xor rdx, rcx
movd r8d, xmm0
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
xor rcx, rax
shr r9d, 8
mov eax, r8d
shr eax, 8
movzx edx, al
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
movzx ecx, r9b
xor rdx, rcx
shr r9d, 8
shr eax, 0x10
shr r8, 0x18
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx edx, r9b
shr r9d, 8
xor r8, rdx
xor r9d, dword [r10 + r8*4]
not r9d
mov eax, r9d
add rsp, 0x30
pop rdi
ret
Function at 0x1801abe70
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rbp
mov qword [rsp + 0x20], rsi
push rdi
push r14
push r15
sub rsp, 0x40
mov rdi, qword [0x180ae6e00]
mov ebp, edx
movaps xmmword [rsp + 0x30], xmm6
mov rbx, qword [rdi + 0x3f08]
cmp qword [rbx + 0x1a8], 0
movss xmm0, dword [rbx + 0x250]
movss xmm2, dword [rbx + 0x254]
jne 0x1801abec1
cmp qword [rdi + 0x4b68], 0
je 0x1801abec9
movss xmm0, dword [rbx + 0x220]
movsd xmm3, qword [r8]
xor r15d, r15d
subss xmm0, dword [rbx + 0x100]
subss xmm2, dword [rbx + 0x104]
movss xmm4, dword [0x180425e28]
xorps xmm5, xmm5
ucomiss xmm3, xmm5
mov eax, r15d
mov r8d, 1
mov edx, 2
movsd qword [rsp + 0x60], xmm3
movss xmm1, dword [rsp + 0x64]
cmove eax, r8d
ucomiss xmm1, xmm5
cmove r15d, edx
or r15d, eax
comiss xmm3, xmm5
ja 0x1801abf27
addss xmm0, xmm3
maxss xmm0, xmm4
movaps xmm3, xmm0
comiss xmm1, xmm5
ja 0x1801abf37
addss xmm2, xmm1
movaps xmm1, xmm2
maxss xmm1, xmm4
or dword [rdi + 0x47e8], edx
xor edx, edx
movss dword [rdi + 0x4808], xmm3
movss dword [rdi + 0x480c], xmm1
mov dword [rdi + 0x47f0], r8d
mov r9, qword [rbx + 8]
test rcx, rcx
je 0x1801abf7b
mov dword [rsp + 0x28], ebp
lea r8, str._s__s__08X
mov qword [rsp + 0x20], rcx
lea rcx, [rsp + 0x60]
call fcn.1801a4160
jmp 0x1801abf90
lea r8, str._s__08X
mov dword [rsp + 0x20], ebp
lea rcx, [rsp + 0x60]
call fcn.1801a4160
mov rcx, qword [rsp + 0x60]
xor edx, edx
movss xmm6, dword [rdi + 0x37f8]
mov r8d, 0x1000107
call fcn.1801aee60
mov rsi, qword [rdi + 0x3f08]
movzx r14d, al
movss dword [rdi + 0x37f8], xmm6
cmp word [rsi + 0xc2], 1
mov dword [rsi + 0x80], ebp
mov byte [rsi + 0xd2], r15b
jne 0x1801abfe1
movsd xmm0, qword [rsi + 0x20]
movsd qword [rbx + 0x100], xmm0
mov r9d, ebp
lea rdx, [0x18041d469]
not r9d
lea r10, [0x18041c380]
mov ebx, r9d
mov r8b, 0x23
nop dword [rax + rax]
cmp r8b, 0x23
jne 0x1801ac013
cmp byte [rdx], r8b
jne 0x1801ac013
cmp byte [rdx + 1], r8b
cmove ebx, r9d
movzx ecx, bl
movzx eax, r8b
movzx r8d, byte [rdx]
xor rcx, rax
shr ebx, 8
inc rdx
xor ebx, dword [r10 + rcx*4]
test r8b, r8b
jne 0x1801ac000
not ebx
cmp dword [rdi + 0x3f68], ebx
jne 0x1801ac043
xor edx, edx
xor ecx, ecx
call fcn.1801a7e60
cmp dword [rdi + 0x4900], ebp
jne 0x1801ac088
cmp word [rsi + 0x15c], 0
jne 0x1801ac05e
cmp byte [rsi + 0x162], 0
je 0x1801ac088
xor edx, edx
mov rcx, rsi
call fcn.1801b18c0
xor edx, edx
mov rcx, rsi
call fcn.1801b9290
mov rdx, rsi
mov ecx, ebx
call fcn.1801a7e60
mov eax, dword [rdi + 0x4924]
mov dword [rdi + 0x3f90], eax
mov rbx, qword [rsp + 0x68]
movzx eax, r14b
mov rbp, qword [rsp + 0x70]
mov rsi, qword [rsp + 0x78]
movaps xmm6, xmmword [rsp + 0x30]
add rsp, 0x40
pop r15
pop r14
pop rdi
ret
Function at 0x1801b6e10
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x40
mov rax, qword [0x180acd980]
xor rax, rsp
mov qword [rsp + 0x30], rax
mov rbx, qword [0x180ae6e00]
mov edi, ecx
cmp byte [rbx + 0x4ab1], 0
jne 0x1801b6e71
cmp byte [rbx + 0x4ab2], 0
jne 0x1801b6e71
movsx r9d, word [rbx + 0x5be2]
lea r8, str.Tooltip__02d
mov edx, 0x10
lea rcx, [rsp + 0x20]
call fcn.1801a40e0
test dil, 2
je 0x1801b6f9f
jmp 0x1801b6efc
movss xmm1, dword [rbx + 0x3894]
lea r8, str.Tooltip__02d
movaps xmm0, xmm1
lea rcx, [rsp + 0x20]
mulss xmm0, dword [0x180425e9c]
xor eax, eax
mov edx, 0x10
mulss xmm1, dword [0x180425e78]
addss xmm0, dword [rbx + 0xe00]
addss xmm1, dword [rbx + 0xe04]
mov qword [rbx + 0x4800], rax
mov dword [rbx + 0x47ec], 1
movss dword [rbx + 0x47f8], xmm0
movss dword [rbx + 0x47fc], xmm1
movss xmm0, dword [rbx + 0x38fc]
mulss xmm0, dword [0x180425cac]
or dword [rbx + 0x47e8], 0x41
movss dword [rbx + 0x4848], xmm0
movsx r9d, word [rbx + 0x5be2]
call fcn.1801a40e0
movzx r9d, byte [rsp + 0x20]
lea r8, [rsp + 0x21]
mov r10d, 0xffffffff
mov ecx, r10d
test r9b, r9b
je 0x1801b6f50
lea r11, [0x18041c380]
nop dword [rax]
cmp r9b, 0x23
jne 0x1801b6f33
cmp byte [r8], r9b
jne 0x1801b6f33
cmp byte [r8 + 1], r9b
cmove ecx, r10d
movzx edx, cl
movzx eax, r9b
movzx r9d, byte [r8]
xor rdx, rax
shr ecx, 8
inc r8
xor ecx, dword [r11 + rdx*4]
test r9b, r9b
jne 0x1801b6f20
not ecx
call fcn.1801ac3d0
test rax, rax
je 0x1801b6f9f
cmp byte [rax + 0xb6], 0
je 0x1801b6f9f
mov byte [rax + 0xbb], 1
lea r8, str.Tooltip__02d
mov byte [rax + 0xbd], 1
lea rcx, [rsp + 0x20]
mov byte [rax + 0xd8], 1
mov edx, 0x10
inc word [rbx + 0x5be2]
movsx r9d, word [rbx + 0x5be2]
call fcn.1801a40e0
xor edx, edx
lea rcx, [rsp + 0x20]
mov r8d, 0x20c0347
call fcn.1801aee60
mov al, 1
mov rcx, qword [rsp + 0x30]
xor rcx, rsp
call fcn.180342780
mov rbx, qword [rsp + 0x50]
add rsp, 0x40
pop rdi
ret
Function at 0x1801bd020
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 0x18], rbx
mov qword [rsp + 0x20], rdi
push r14
sub rsp, 0x20
movzx r8d, byte [rcx]
lea rdx, [rcx + 1]
mov r14, qword [0x180ae6e00]
mov r9d, 0xffffffff
mov ebx, r9d
test r8b, r8b
je 0x1801bd084
lea r10, [0x18041c380]
cmp r8b, 0x23
jne 0x1801bd067
cmp byte [rdx], r8b
jne 0x1801bd067
cmp byte [rdx + 1], r8b
cmove ebx, r9d
movzx ecx, bl
movzx eax, r8b
movzx r8d, byte [rdx]
xor rcx, rax
shr ebx, 8
inc rdx
xor ebx, dword [r10 + rcx*4]
test r8b, r8b
jne 0x1801bd054
mov eax, dword [r14 + 0x5c40]
xor edi, edi
mov qword [rsp + 0x30], rbp
not ebx
mov qword [rsp + 0x38], rsi
test eax, eax
jle 0x1801bd0de
mov esi, edi
mov ebp, edi
test rsi, rsi
js 0x1801bd0aa
cmp edi, eax
jl 0x1801bd0bd
lea rdx, str.i___0__i___Size
lea rcx, str._ImGui__Assertion_failed:__s_n
call fcn.1801c11a0
mov rax, qword [r14 + 0x5c48]
cmp dword [rax + rbp + 8], ebx
je 0x1801bd0fb
mov eax, dword [r14 + 0x5c40]
inc edi
inc rsi
add rbp, 0x48
cmp edi, eax
jl 0x1801bd0a1
xor eax, eax
mov rsi, qword [rsp + 0x38]
mov rbp, qword [rsp + 0x30]
mov rbx, qword [rsp + 0x40]
mov rdi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
test edi, edi
js 0x1801bd108
cmp edi, dword [r14 + 0x5c40]
jl 0x1801bd11b
lea rdx, str.i___0__i___Size
lea rcx, str._ImGui__Assertion_failed:__s_n
call fcn.1801c11a0
movsxd rax, edi
lea rcx, [rax + rax*8]
mov rax, qword [r14 + 0x5c48]
lea rax, [rax + rcx*8]
jmp 0x1801bd0e0
Function at 0x1801eaef0
Capabilities:
Enumerate threads
Suspend thread

Disassembly:
mov qword [rsp + 0x18], rbx
push rbp
push rsi
push rdi
push r14
push r15
sub rsp, 0x50
mov rax, qword [0x180acd980]
xor rax, rsp
mov qword [rsp + 0x40], rax
xor r15d, r15d
mov r14d, edx
mov qword [rcx], r15
mov rbx, rcx
mov qword [rcx + 8], r15
xor edx, edx
mov ecx, 4
mov ebp, r8d
mov edi, r15d
call qword [sym.imp.KERNEL32.dll_CreateToolhelp32Snapshot]
mov rsi, rax
cmp rax, 0xffffffffffffffff
je 0x1801eb0aa
lea rdx, [rsp + 0x20]
mov dword [rsp + 0x20], 0x1c
mov rcx, rax
call qword [sym.imp.KERNEL32.dll_Thread32First]
test eax, eax
je 0x1801eb038
mov edi, 1
cmp dword [rsp + 0x20], 0x10
jb 0x1801eaff2
call qword [sym.imp.KERNEL32.dll_GetCurrentProcessId]
cmp dword [rsp + 0x2c], eax
jne 0x1801eaff2
call qword [sym.imp.KERNEL32.dll_GetCurrentThreadId]
cmp dword [rsp + 0x28], eax
je 0x1801eaff2
mov rdx, qword [rbx]
test rdx, rdx
jne 0x1801eafb4
mov rcx, qword [0x180ae6e10]
mov r8d, 0x200
mov dword [rbx + 8], 0x80
call qword [sym.imp.KERNEL32.dll_HeapAlloc]
mov qword [rbx], rax
mov rdx, rax
test rax, rax
je 0x1801eb01b
jmp 0x1801eafe5
mov eax, dword [rbx + 8]
cmp dword [rbx + 0xc], eax
jb 0x1801eafe5
mov rcx, qword [0x180ae6e10]
add eax, eax
mov r9d, eax
mov r8, rdx
shl r9, 2
xor edx, edx
mov dword [rbx + 8], eax
call qword [sym.imp.KERNEL32.dll_HeapReAlloc]
mov rdx, rax
test rax, rax
je 0x1801eb01b
mov qword [rbx], rax
mov ecx, dword [rbx + 0xc]
mov eax, dword [rsp + 0x28]
mov dword [rdx + rcx*4], eax
inc dword [rbx + 0xc]
lea rdx, [rsp + 0x20]
mov dword [rsp + 0x20], 0x1c
mov rcx, rsi
call qword [sym.imp.KERNEL32.dll_Thread32Next]
test eax, eax
jne 0x1801eaf62
call qword [sym.imp.KERNEL32.dll_GetLastError]
cmp eax, 0x12
je 0x1801eb038
mov r8, qword [rbx]
mov edi, r15d
test r8, r8
je 0x1801eb038
mov rcx, qword [0x180ae6e10]
xor edx, edx
call qword [sym.imp.KERNEL32.dll_HeapFree]
mov qword [rbx], r15
mov rcx, rsi
call qword [sym.imp.KERNEL32.dll_CloseHandle]
test edi, edi
je 0x1801eb0aa
cmp qword [rbx], r15
je 0x1801eb0a5
mov edi, r15d
cmp dword [rbx + 0xc], r15d
jbe 0x1801eb0a5
nop dword [rax]
nop word [rax + rax]
mov r8, qword [rbx]
xor edx, edx
mov eax, edi
mov ecx, 0x5a
mov r8d, dword [r8 + rax*4]
call qword [sym.imp.KERNEL32.dll_OpenThread]
mov rsi, rax
test rax, rax
je 0x1801eb09e
mov rcx, rax
call qword [sym.imp.KERNEL32.dll_SuspendThread]
mov r8d, ebp
mov edx, r14d
mov rcx, rsi
call fcn.1801ead40
mov rcx, rsi
call qword [sym.imp.KERNEL32.dll_CloseHandle]
inc edi
cmp edi, dword [rbx + 0xc]
jb 0x1801eb060
mov eax, r15d
jmp 0x1801eb0af
mov eax, 9
mov rcx, qword [rsp + 0x40]
xor rcx, rsp
call fcn.180342780
mov rbx, qword [rsp + 0x90]
add rsp, 0x50
pop r15
pop r14
pop rdi
pop rsi
pop rbp
ret
Function at 0x1801eb0d0
Capabilities:
Resume thread

Disassembly:
push rdi
sub rsp, 0x20
cmp qword [rcx], 0
mov rdi, rcx
je 0x1801eb141
mov qword [rsp + 0x30], rbx
xor ebx, ebx
cmp dword [rcx + 0xc], ebx
jbe 0x1801eb12a
mov qword [rsp + 0x38], rsi
mov r8, qword [rdi]
xor edx, edx
mov ecx, 0x5a
mov r8d, dword [r8 + rbx*4]
call qword [sym.imp.KERNEL32.dll_OpenThread]
mov rsi, rax
test rax, rax
je 0x1801eb11e
mov rcx, rax
call qword [sym.imp.KERNEL32.dll_ResumeThread]
mov rcx, rsi
call qword [sym.imp.KERNEL32.dll_CloseHandle]
inc ebx
cmp ebx, dword [rdi + 0xc]
jb 0x1801eb0f0
mov rsi, qword [rsp + 0x38]
mov r8, qword [rdi]
xor edx, edx
mov rcx, qword [0x180ae6e10]
call qword [sym.imp.KERNEL32.dll_HeapFree]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x1801eb150
Capabilities:
Allocate or change rwx memory

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rbp
mov qword [rsp + 0x20], rsi
push rdi
sub rsp, 0x20
mov eax, ecx
lea r9, [rsp + 0x30]
imul rbx, rax, 0x38
mov esi, edx
add rbx, qword [0x180ae6bd8]
mov r8, qword [rbx]
movzx eax, byte [rbx + 0x20]
and al, 1
movzx ecx, al
lea rdi, [r8 - 5]
cmove rdi, r8
mov r8d, 0x40
lea rbp, [rcx*2 + 5]
mov rcx, rdi
mov rdx, rbp
call qword [sym.imp.KERNEL32.dll_VirtualProtect]
test eax, eax
jne 0x1801eb1b4
mov eax, 0xa
jmp 0x1801eb247
test esi, esi
je 0x1801eb1d6
mov byte [rdi], 0xe9
mov eax, dword [rbx + 8]
sub eax, edi
sub eax, 5
mov dword [rdi + 1], eax
test byte [rbx + 0x20], 1
je 0x1801eb1f9
mov rax, qword [rbx]
mov word [rax], 0xf9eb
jmp 0x1801eb1f9
mov eax, dword [rbx + 0x18]
test byte [rbx + 0x20], 1
mov dword [rdi], eax
je 0x1801eb1f2
movzx eax, word [rbx + 0x1c]
mov word [rdi + 4], ax
movzx eax, byte [rbx + 0x1e]
mov byte [rdi + 6], al
jmp 0x1801eb1f9
movzx eax, byte [rbx + 0x1c]
mov byte [rdi + 4], al
mov r8d, dword [rsp + 0x30]
lea r9, [rsp + 0x30]
mov rdx, rbp
mov rcx, rdi
call qword [sym.imp.KERNEL32.dll_VirtualProtect]
call qword [sym.imp.KERNEL32.dll_GetCurrentProcess]
mov r8, rbp
mov rdx, rdi
mov rcx, rax
call qword [sym.imp.KERNEL32.dll_FlushInstructionCache]
movzx ecx, sil
shl sil, 2
add cl, cl
xor cl, byte [rbx + 0x20]
and cl, 2
xor cl, byte [rbx + 0x20]
xor sil, cl
and sil, 4
xor sil, cl
mov byte [rbx + 0x20], sil
xor eax, eax
mov rbx, qword [rsp + 0x38]
mov rbp, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop rdi
ret
Function at 0x1801eb260
Capabilities:
Resume thread

Disassembly:
mov qword [rsp + 0x18], rbx
push rsi
sub rsp, 0x30
mov r8d, dword [0x180ae6be4]
mov esi, ecx
xor ecx, ecx
mov ebx, ecx
test r8d, r8d
je 0x1801eb2a7
mov rax, qword [0x180ae6bd8]
add rax, 0x20
nop word [rax + rax]
movzx edx, byte [rax]
shr edx, 1
and edx, 1
cmp edx, esi
jne 0x1801eb2b4
inc ebx
add rax, 0x38
cmp ebx, r8d
jb 0x1801eb290
mov eax, ecx
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rsi
ret
cmp ebx, 0xffffffff
je 0x1801eb2a7
test esi, esi
mov qword [rsp + 0x48], rdi
mov edx, 0xffffffff
setne cl
mov r8d, ecx
lea rcx, [rsp + 0x20]
call fcn.1801eaef0
mov edi, eax
test eax, eax
jne 0x1801eb39f
mov r9d, dword [0x180ae6be4]
cmp ebx, r9d
jae 0x1801eb32c
nop dword [rax + rax]
mov ecx, ebx
imul rdx, rcx, 0x38
mov rcx, qword [0x180ae6bd8]
movzx r8d, byte [rdx + rcx + 0x20]
shr r8d, 1
and r8d, 1
cmp r8d, esi
je 0x1801eb325
mov edx, esi
mov ecx, ebx
call fcn.1801eb150
mov edi, eax
test eax, eax
jne 0x1801eb32c
mov r9d, dword [0x180ae6be4]
inc ebx
cmp ebx, r9d
jb 0x1801eb2f0
cmp qword [rsp + 0x20], 0
je 0x1801eb39d
mov eax, dword [rsp + 0x2c]
test eax, eax
je 0x1801eb389
mov rbx, qword [rsp + 0x20]
mov qword [rsp + 0x40], rbp
mov ebp, eax
nop dword [rax + rax]
mov r8d, dword [rbx]
xor edx, edx
mov ecx, 0x5a
call qword [sym.imp.KERNEL32.dll_OpenThread]
mov rsi, rax
test rax, rax
je 0x1801eb37a
mov rcx, rax
call qword [sym.imp.KERNEL32.dll_ResumeThread]
mov rcx, rsi
call qword [sym.imp.KERNEL32.dll_CloseHandle]
add rbx, 4
sub rbp, 1
jne 0x1801eb350
mov rbp, qword [rsp + 0x40]
mov r8, qword [rsp + 0x20]
xor edx, edx
mov rcx, qword [0x180ae6e10]
call qword [sym.imp.KERNEL32.dll_HeapFree]
mov eax, edi
mov rdi, qword [rsp + 0x48]
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rsi
ret
Function at 0x1801ef790
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbp
push r13
push r15
sub rsp, 0x30
mov qword [rsp + 0x50], rbx
mov r15, rdx
mov qword [rsp + 0x58], rsi
mov r13, rcx
mov qword [rsp + 0x60], rdi
mov r9, r8
mov qword [rsp + 0x28], r12
mov rdi, r8
mov r12, qword [r8 + 0x18]
cmp r12, 0xf
jbe 0x1801ef7c7
mov r9, qword [r8]
mov rsi, qword [rdi + 0x10]
xor ebp, ebp
movabs r8, 0xcbf29ce484222325
mov ecx, ebp
test rsi, rsi
je 0x1801ef804
movabs rdx, 0x100000001b3
nop dword [rax + rax]
movzx eax, byte [r9 + rcx]
inc rcx
xor r8, rax
imul r8, rdx
cmp rcx, rsi
jb 0x1801ef7f0
mov rcx, qword [r13 + 0x30]
mov rax, qword [r13 + 0x18]
and rcx, r8
add rcx, rcx
mov rbx, qword [rax + rcx*8 + 8]
cmp rbx, qword [r13 + 8]
je 0x1801ef870
mov qword [rsp + 0x20], r14
mov r14, qword [rax + rcx*8]
nop word [rax + rax]
cmp qword [rbx + 0x28], 0xf
lea rdx, [rbx + 0x10]
jbe 0x1801ef83f
mov rdx, qword [rbx + 0x10]
mov rcx, rdi
cmp r12, 0xf
jbe 0x1801ef84b
mov rcx, qword [rdi]
cmp rsi, qword [rbx + 0x20]
jne 0x1801ef85d
mov r8, rsi
call fcn.180381530
test eax, eax
je 0x1801ef868
cmp rbx, r14
je 0x1801ef86b
mov rbx, qword [rbx + 8]
jmp 0x1801ef830
mov rbp, rbx
mov r14, qword [rsp + 0x20]
mov r12, qword [rsp + 0x28]
mov rdi, qword [rsp + 0x60]
mov rsi, qword [rsp + 0x58]
mov rbx, qword [rsp + 0x50]
test rbp, rbp
je 0x1801ef899
mov qword [r15], rbp
mov rax, r15
add rsp, 0x30
pop r15
pop r13
pop rbp
ret
mov rax, qword [r13 + 8]
mov qword [r15], rax
mov rax, r15
add rsp, 0x30
pop r15
pop r13
pop rbp
ret
Function at 0x1801f4bc0
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 0x20], rsi
push rdi
sub rsp, 0x20
movabs rax, 0xfffffffffffffff
mov rsi, rcx
bsr rcx, rax
mov edi, 1
mov eax, edi
shl rax, cl
cmp rdx, rax
ja 0x1801f4d4f
lea rax, [rdx - 1]
mov qword [rsp + 0x30], rbx
mov rbx, qword [rsi + 8]
or rax, rdi
bsr rcx, rax
mov r8, rbx
mov qword [rsp + 0x40], r14
inc ecx
shl rdi, cl
lea rcx, [rsi + 0x18]
lea rdx, [rdi + rdi]
call fcn.180019230
lea rax, [rdi - 1]
mov qword [rsi + 0x38], rdi
mov qword [rsi + 0x30], rax
mov rax, qword [rsi + 8]
mov rax, qword [rax]
mov rcx, rax
cmp rax, rbx
je 0x1801f4d14
mov qword [rsp + 0x38], rbp
movabs rdi, 0xcbf29ce484222325
movabs rbp, 0x100000001b3
nop dword [rax]
nop dword [rax + rax]
movzx r9d, byte [rax + 0x10]
mov r11, qword [rsi + 0x30]
mov edx, r9d
mov rcx, qword [rcx]
xor rdx, rdi
imul rdx, rbp
and r11, rdx
shl r11, 4
add r11, qword [rsi + 0x18]
mov r8, qword [r11]
cmp r8, rbx
jne 0x1801f4c92
mov qword [r11], rax
mov qword [r11 + 8], rax
jmp 0x1801f4d03
mov rdx, qword [r11 + 8]
cmp r9b, byte [rdx + 0x10]
jne 0x1801f4ccb
mov r10, qword [rdx]
cmp r10, rax
je 0x1801f4cc5
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 0x1801f4d03
cmp r8, rdx
je 0x1801f4cdf
mov rdx, qword [rdx + 8]
cmp r9b, byte [rdx + 0x10]
je 0x1801f4d29
cmp r8, rdx
jne 0x1801f4cd0
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
jne 0x1801f4c60
mov rbp, qword [rsp + 0x38]
mov rbx, qword [rsp + 0x30]
mov r14, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x48]
add rsp, 0x20
pop rdi
ret
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 0x1801f4d03
lea rcx, str.invalid_hash_bucket_count
call fcn.18031c22c
int3