joyce8/EMBER2024-capa huggingface dataset:
Function at 0x19f9a0
Capabilities:
Encrypt data using curve25519

Disassembly:
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x198
mov qword [rsp + 0x28], rcx
xor eax, eax
nop word [rax + rax]
movzx ecx, byte [r8 + rax]
mov byte [rsp + rax + 0x30], cl
add rax, 1
cmp rax, 0x20
jne 0x19f9c0
and byte [rsp + 0x30], 0xf8
mov al, byte [rsp + 0x4f]
and al, 0x3f
or al, 0x40
mov byte [rsp + 0x4f], al
lea rbp, [rsp + 0x140]
mov rcx, rbp
call fcn.00199700
lea rbx, [rsp + 0x170]
mov rcx, rbx
call fcn.00199390
lea rsi, [rsp + 0xb0]
mov rcx, rsi
mov rdx, rbp
mov r8, rbx
call fcn.001993b0
mov rcx, rbx
mov rdx, rbx
mov r8, rbp
call fcn.0019b630
mov rcx, rbx
mov rdx, rbx
call fcn.00199990
mov rcx, rbp
mov rdx, rsi
mov r8, rbx
call fcn.0019a130
lea rcx, [rsp + 0x80]
call fcn.00199390
lea rdi, [rsp + 0x110]
mov rcx, rdi
call fcn.00199370
lea rcx, [rsp + 0x50]
mov rdx, rbp
call fcn.001996e0
lea r14, [rsp + 0xe0]
mov rcx, r14
call fcn.00199390
mov r13d, 0xfe
xor r15d, r15d
nop word cs:[rax + rax]
nop
mov ebp, r15d
mov eax, r13d
shr rax, 3
movzx r15d, byte [rsp + rax + 0x30]
mov ecx, r13d
and cl, 7
shr r15d, cl
and r15d, 1
xor ebp, r15d
lea rsi, [rsp + 0x80]
mov rcx, rsi
lea r12, [rsp + 0x50]
mov rdx, r12
mov r8d, ebp
call fcn.00199540
mov rcx, rdi
mov rdx, r14
mov r8d, ebp
call fcn.00199540
lea rbp, [rsp + 0xb0]
mov rcx, rbp
mov rdx, r12
mov r8, r14
call fcn.0019b630
mov rcx, rbx
mov rdx, rsi
mov r8, rdi
call fcn.0019b630
mov rcx, rsi
mov rdx, rsi
mov r8, rdi
call fcn.001993b0
mov rcx, rdi
mov rdx, r12
mov r8, r14
call fcn.001993b0
mov rcx, r14
mov rdx, rbp
mov r8, rsi
call fcn.0019a130
mov rcx, rdi
mov rdx, rdi
mov r8, rbx
call fcn.0019a130
mov rcx, rbp
mov rdx, rbx
call fcn.00199c20
mov rcx, rbx
mov rdx, rsi
call fcn.00199c20
mov rcx, r12
mov rdx, r14
mov r8, rdi
call fcn.001993b0
mov rcx, rdi
mov rdx, r14
mov r8, rdi
call fcn.0019b630
mov rcx, rsi
mov rdx, rbx
mov r8, rbp
call fcn.0019a130
mov rcx, rbx
mov rdx, rbx
mov r8, rbp
call fcn.0019b630
mov rcx, rdi
mov rdx, rdi
call fcn.00199c20
mov rcx, r14
mov rdx, rbx
call fcn.0019ac70
mov rcx, r12
mov rdx, r12
call fcn.00199c20
mov rcx, rbp
mov rdx, rbp
mov r8, r14
call fcn.001993b0
mov rcx, r14
lea rdx, [rsp + 0x140]
mov r8, rdi
call fcn.0019a130
mov rcx, rdi
mov rdx, rbx
mov r8, rbp
call fcn.0019a130
add r13d, 0xffffffff
cmp r13d, 0xffffffff
jne 0x19fa90
lea rsi, [rsp + 0x80]
lea rdx, [rsp + 0x50]
mov rcx, rsi
mov r8d, r15d
call fcn.00199540
lea rdi, [rsp + 0x110]
lea rdx, [rsp + 0xe0]
mov rcx, rdi
mov r8d, r15d
call fcn.00199540
mov rcx, rdi
mov rdx, rdi
call fcn.00199990
mov rcx, rsi
mov rdx, rsi
mov r8, rdi
call fcn.0019a130
mov rcx, qword [rsp + 0x28]
mov rdx, rsi
call fcn.0019a9a0
add rsp, 0x198
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
ret
Function at 0x18000646c
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov r10, qword [0x18010e9c0]
movabs rcx, 0xcbf29ce484222325
mov dword [rsp + 0x10], edx
xor r8d, r8d
mov r9, qword [r10 + 0x178]
movzx eax, byte [rsp + r8 + 0x10]
movabs r11, 0x100000001b3
xor rcx, rax
inc r8
imul rcx, r11
cmp r8, 4
jb 0x18000648b
mov r8, qword [r10 + 0x1a0]
and r8, rcx
mov rcx, qword [r10 + 0x188]
add r8, r8
mov rax, qword [rcx + r8*8 + 8]
cmp rax, r9
je 0x1800064df
mov rcx, qword [rcx + r8*8]
jmp 0x1800064d8
cmp rax, rcx
je 0x1800064df
mov rax, qword [rax + 8]
cmp edx, dword [rax + 0x10]
jne 0x1800064cf
jmp 0x1800064e1
xor eax, eax
test rax, rax
cmove rax, r9
cmp rax, r9
setne al
ret

Function at 0x1800064f0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
push rbp
push rdi
push r14
lea rbp, [rsp - 0x47]
sub rsp, 0xb0
mov dword [rbp + 0x7f], WSACleanup
xor eax, eax
mov byte [rbp + 0x83], 0x36
mov r9, rdx
mov byte [rbp + 0x84], 0x3e
mov rsi, rcx
mov byte [rbp + 0x85], 0x31
xor r8d, r8d
mov byte [rbp + 0x86], al
mov al, byte [rbp + 0x83]
mov al, byte [rbp + r8 + 0x83]
mov ecx, dword [rbp + 0x7f]
xor cl, al
mov byte [rbp + r8 + 0x83], cl
inc r8
cmp r8, 3
jb 0x18000653d
lea rdx, [rbp + 0x83]
mov byte [rbp + 0x86], 0
mov rcx, r9
call fcn.1800667d8
mov rdi, rax
test rax, rax
je 0x1800065f3
xor edx, edx
mov rcx, rax
call fcn.1800666bc
mov r14d, 1
jmp 0x1800065eb
mov r9d, 0x80
lea r8, [rbp - 0x39]
mov rdx, rbx
mov rcx, rdi
call fcn.180003068
mov rcx, rbx
call qword [sym.imp.msvcrt.dll_atoi]
lea r8, [rbp + 0x77]
mov dword [rbp + 0x77], eax
lea rdx, [rbp - 0x49]
lea rcx, [rsi + 0x170]
call fcn.18000a0d0
lea rcx, [rbp - 0x39]
mov rbx, qword [rax]
call qword [sym.imp.msvcrt.dll_strlen]
mov r8, rax
lea rdx, [rbp - 0x39]
lea rcx, [rbx + 0x18]
call fcn.1800091f0
mov edx, r14d
mov rcx, rdi
call fcn.1800666bc
inc r14d
mov rbx, rax
test rax, rax
jne 0x18000658b
lea r11, [rsp + 0xb0]
mov rbx, qword [r11 + 0x20]
mov rsi, qword [r11 + 0x28]
mov rsp, r11
pop r14
pop rdi
pop rbp
ret
Function at 0x18000660c
Capabilities:
Encode data using xor

Disassembly:
mov rax, rsp
mov qword [rax + 8], rbx
mov qword [rax + 0x10], rsi
mov qword [rax + 0x18], rdi
push rbp
lea rbp, [rax - 0x38]
sub rsp, 0x130
mov rdi, rdx
mov rbx, rcx
mov rdx, r9
mov rcx, r8
call fcn.1800667d8
lea rdx, [rbx + 0x10]
mov rcx, rax
mov ebx, 0x100
lea r8, [rsp + 0x30]
mov r9d, ebx
mov rsi, rax
call fcn.180003068
cmp byte [rsp + 0x30], 0
jne 0x1800066c3
mov dword [rsp + 0x20], 0x11
xor eax, eax
mov byte [rsp + 0x24], reloc.WS2_32.dll_WSACleanup
xor edx, edx
mov byte [rsp + 0x25], 0x7f
mov byte [rsp + 0x26], 0x76
mov byte [rsp + 0x27], 0x7d
mov byte [rsp + 0x28], 0x78
mov byte [rsp + 0x29], 0x62
mov byte [rsp + 0x2a], 0x79
mov byte [rsp + 0x2b], al
mov al, byte [rsp + 0x24]
mov al, byte [rsp + rdx + 0x24]
mov ecx, dword [rsp + 0x20]
xor cl, al
mov byte [rsp + rdx + 0x24], cl
inc rdx
cmp rdx, 7
jb 0x180006692
mov r9, rbx
mov byte [rsp + 0x2b], 0
lea r8, [rsp + 0x30]
mov rcx, rsi
lea rdx, [rsp + 0x24]
call fcn.180003068
xorps xmm0, xmm0
lea rcx, [rsp + 0x30]
movups xmmword [rdi], xmm0
and qword [rdi + 0x10], 0
and qword [rdi + 0x18], 0
call qword [sym.imp.msvcrt.dll_strlen]
lea rdx, [rsp + 0x30]
mov rcx, rdi
mov r8, rax
call fcn.18000a40c
lea r11, [rsp + 0x130]
mov rax, rdi
mov rbx, qword [r11 + 0x10]
mov rsi, qword [r11 + 0x18]
mov rdi, qword [r11 + 0x20]
mov rsp, r11
pop rbp
ret
Function at 0x180007e30
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 8
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180007e3d
mov byte [rcx + 0xc], r10b
ret

Function at 0x180007e58
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 7
jb 0x180007e5f
mov byte [rcx + 0xb], 0
ret

Function at 0x180007e80
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0x14
jb 0x180007e87
mov byte [rcx + 0x18], 0
ret

Function at 0x180007ec4
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0x17
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180007ed1
mov byte [rcx + 0x1b], r10b
ret

Function at 0x180007eec
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0xf
jb 0x180007ef3
mov byte [rcx + 0x13], 0
ret

Function at 0x180007f14
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0xc
jb 0x180007f1b
mov byte [rcx + 0x10], 0
ret

Function at 0x180007f3c
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0xa
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180007f49
mov byte [rcx + 0xe], r10b
ret

Function at 0x180007f64
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0xe
jb 0x180007f6b
mov byte [rcx + 0x12], 0
ret

Function at 0x180007f8c
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0x15
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180007f99
mov byte [rcx + 0x19], r10b
ret

Function at 0x180007fd0
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0xa
jb 0x180007fd7
mov byte [rcx + 0xe], 0
ret

Function at 0x180007ff8
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0xe
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180008005
mov byte [rcx + 0x12], r10b
ret

Function at 0x180008020
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 9
jb 0x180008027
mov byte [rcx + 0xd], 0
ret
Function at 0x180008048
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0x10
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180008055
mov byte [rcx + 0x14], r10b
ret

Function at 0x180008070
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0x12
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x18000807d
mov byte [rcx + 0x16], r10b
ret

Function at 0x1800080ec
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0x17
jb 0x1800080f3
mov byte [rcx + 0x1b], 0
ret

Function at 0x18000814c
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 9
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180008159
mov byte [rcx + 0xd], r10b
ret

Function at 0x180008190
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0xf
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x18000819d
mov byte [rcx + 0x13], r10b
ret

Function at 0x1800081b8
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0xb
jb 0x1800081bf
mov byte [rcx + 0xf], 0
ret

Function at 0x1800081fc
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0xc
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180008209
mov byte [rcx + 0x10], r10b
ret

Function at 0x180008224
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 7
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180008231
mov byte [rcx + 0xb], r10b
ret

Function at 0x180008268
Capabilities:
Encode data using xor

Disassembly:
lea rax, [rcx + 4]
mov r10d, 0xd
mov r9, rax
mov dl, byte [r9]
mov r8d, dword [rcx]
xor r8b, dl
mov byte [r9], r8b
inc r9
sub r10, 1
jne 0x180008275
mov byte [rcx + 0x11], r10b
ret

Function at 0x1800082c8
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 0x12
jb 0x1800082cf
mov byte [rcx + 0x16], 0
ret

Function at 0x18000830c
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 2
jb 0x180008313
mov byte [rcx + 6], 0
ret

Function at 0x180008334
Capabilities:
Encode data using xor

Disassembly:
xor r9d, r9d
lea rax, [rcx + 4]
mov dl, byte [rax + r9]
mov r8d, dword [rcx]
add r8b, r9b
xor r8b, dl
mov byte [rax + r9], r8b
inc r9
cmp r9, 4
jb 0x18000833b
mov byte [rcx + 8], 0
ret
Function at 0x180008378
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
xor ebx, ebx
lea rax, [rcx + 4]
mov r10d, ebx
mov r11, rax
movzx r9d, word [r11]
mov edx, dword [rcx]
add dl, r10b
inc r10
movsx r8d, dl
xor r8w, r9w
mov word [r11], r8w
lea r11, [r11 + 2]
cmp r10, 0x15
jb 0x180008389
mov word [rcx + 0x2e], bx
mov rbx, qword [rsp + 8]
ret
Function at 0x18000a0d0
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 r12
push r13
push r14
push r15
sub rsp, 0x30
mov r12, r8
mov r14, rdx
mov r15, rcx
movabs rdi, 0xcbf29ce484222325
xor ecx, ecx
movzx eax, byte [rcx + r8]
xor rdi, rax
movabs rdx, 0x100000001b3
imul rdi, rdx
inc rcx
cmp rcx, 4
jb 0x18000a101
mov rax, qword [r15 + 0x30]
and rax, rdi
add rax, rax
mov rcx, qword [r15 + 0x18]
mov rbx, qword [rcx + rax*8 + 8]
lea r13, [r15 + 8]
mov rbp, qword [r13]
cmp rbx, rbp
jne 0x18000a1a9
mov rbx, rbp
movabs rax, 0x492492492492492
cmp qword [r15 + 0x10], rax
je 0x18000a2f4
mov qword [rsp + 0x20], r13
and qword [rsp + 0x28], 0
mov ecx, 0x38
call fcn.180090580
mov rsi, rax
mov qword [rsp + 0x28], rax
mov ecx, dword [r12]
mov dword [rax + 0x10], ecx
xorps xmm0, xmm0
movups xmmword [rax + 0x18], xmm0
xor r12d, r12d
mov qword [rax + 0x28], r12
mov qword [rax + 0x30], 0xf
mov byte [rax + 0x18], r12b
mov rcx, qword [r15 + 0x10]
add rcx, 1
xorps xmm0, xmm0
js 0x18000a1e6
cvtsi2ss xmm0, rcx
jmp 0x18000a1fb
mov rdx, qword [rcx + rax*8]
mov eax, dword [r8]
jmp 0x18000a1bb
cmp rbx, rdx
je 0x18000a1df
mov rbx, qword [rbx + 8]
cmp eax, dword [rbx + 0x10]
jne 0x18000a1b2
mov rbp, qword [rbx]
mov rax, rbx
mov rbx, rbp
test rax, rax
je 0x18000a143
mov qword [r14], rax
mov byte [r14 + 8], 0
jmp 0x18000a2d4
mov rbp, rbx
xor eax, eax
jmp 0x18000a1c9
mov rax, rcx
shr rax, 1
and ecx, 1
or rax, rcx
cvtsi2ss xmm0, rax
addss xmm0, xmm0
mov rcx, qword [r15 + 0x38]
xorps xmm1, xmm1
test rcx, rcx
js 0x18000a20e
cvtsi2ss xmm1, rcx
jmp 0x18000a223
mov rax, rcx
shr rax, 1
and ecx, 1
or rax, rcx
cvtsi2ss xmm1, rax
addss xmm1, xmm1
divss xmm0, xmm1
comiss xmm0, dword [r15]
seta al
test al, al
je 0x18000a27d
mov rcx, r15
call fcn.18000acb4
mov rcx, rdi
and rcx, qword [r15 + 0x30]
add rcx, rcx
mov rdx, qword [r15 + 0x18]
mov rax, qword [rdx + rcx*8 + 8]
mov rbx, qword [r13]
cmp rax, rbx
je 0x18000a273
mov r8, qword [rdx + rcx*8]
mov ecx, dword [rsi + 0x10]
jmp 0x18000a26b
mov rbx, rax
cmp rax, r8
je 0x18000a2ae
mov rax, qword [rax + 8]
cmp ecx, dword [rax + 0x10]
jne 0x18000a25f
mov rbx, qword [rax]
mov qword [rsp + 0x20], rbx
mov rbp, qword [rsp + 0x20]
mov rcx, qword [rbx + 8]
inc qword [r15 + 0x10]
mov qword [rsi], rbp
mov qword [rsi + 8], rcx
mov qword [rcx], rsi
mov qword [rbx + 8], rsi
mov rax, qword [r15 + 0x18]
and rdi, qword [r15 + 0x30]
add rdi, rdi
mov rdx, qword [rax + rdi*8]
cmp rdx, qword [r13]
jne 0x18000a2b5
mov qword [rax + rdi*8], rsi
jmp 0x18000a2c7
mov qword [rsp + 0x20], rax
jmp 0x18000a278
cmp rdx, rbp
jne 0x18000a2c0
mov qword [rax + rdi*8], rsi
jmp 0x18000a2cc
cmp qword [rax + rdi*8 + 8], rcx
jne 0x18000a2cc
mov qword [rax + rdi*8 + 8], rsi
mov qword [r14], rsi
mov byte [r14 + 8], 1
mov rax, r14
mov rbx, qword [rsp + 0x60]
mov rbp, qword [rsp + 0x68]
mov rsi, qword [rsp + 0x70]
add rsp, 0x30
pop r15
pop r14
pop r13
pop r12
pop rdi
ret
lea rcx, str.unordered_map_set_too_long
call fcn.18008e678
int3
Function at 0x18000a9ec
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
push r14
sub rsp, 0x20
mov rdx, qword [rcx + 0x10]
mov rsi, rcx
add rdx, 1
mov rbx, qword [rcx + 0x38]
xorps xmm0, xmm0
js 0x18000aa1c
cvtsi2ss xmm0, rdx
jmp 0x18000aa31
mov rax, rdx
and edx, 1
shr rax, 1
or rax, rdx
cvtsi2ss xmm0, rax
addss xmm0, xmm0
divss xmm0, dword [rcx]
call qword [sym.imp.msvcrt.dll_ceilf]
movss xmm1, dword [0x1800ce9e0]
xor ecx, ecx
comiss xmm0, xmm1
jb 0x18000aa60
subss xmm0, xmm1
comiss xmm0, xmm1
jae 0x18000aa60
movabs rax, 0x8000000000000000
mov rcx, rax
cvttss2si rax, xmm0
add rax, rcx
mov ecx, 8
cmp rax, rcx
cmova rcx, rax
cmp rbx, rcx
jae 0x18000aa8e
cmp rbx, 0x200
jae 0x18000aa8b
shl rbx, 3
cmp rbx, rcx
jae 0x18000aa8e
mov rbx, rcx
movabs rax, 0xfffffffffffffff
bsr rcx, rax
mov eax, 1
shl rax, cl
cmp rbx, rax
ja 0x18000abf8
lea rax, [rbx - 1]
mov edi, 1
mov rbx, qword [rsi + 8]
or rax, 1
bsr rcx, rax
mov r8, rbx
inc ecx
shl rdi, cl
lea rcx, [rsi + 0x18]
lea rdx, [rdi + rdi]
call fcn.1800090cc
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 0x18000abbc
mov rcx, qword [rcx]
movabs r11, 0xcbf29ce484222325
xor r8d, r8d
movzx edx, byte [r8 + rax + 0x10]
movabs r9, 0x100000001b3
xor r11, rdx
inc r8
imul r11, r9
cmp r8, 4
jb 0x18000ab06
and r11, qword [rsi + 0x30]
mov rdi, qword [rsi + 0x18]
add r11, r11
cmp qword [rdi + r11*8], rbx
jne 0x18000ab42
mov qword [rdi + r11*8], rax
mov qword [rdi + r11*8 + 8], rax
jmp 0x18000abb0
mov r10, qword [rdi + r11*8 + 8]
mov edx, dword [rax + 0x10]
cmp edx, dword [r10 + 0x10]
jne 0x18000ab85
mov r10, qword [r10]
cmp r10, rax
je 0x18000ab3b
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 0x18000ab3b
mov r10, qword [r10 + 8]
cmp edx, dword [r10 + 0x10]
je 0x18000abd2
cmp qword [rdi + r11*8], r10
jne 0x18000ab7b
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 [rdi + r11*8], rax
mov rax, rcx
cmp rcx, rbx
jne 0x18000aaf6
mov rbx, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
mov rdi, qword [rsp + 0x40]
add rsp, 0x20
pop r14
ret
mov r10, qword [r10]
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 0x18000abb0
lea rcx, str.invalid_hash_bucket_count
call fcn.18008e678
int3
Function at 0x18000acb4
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
push r14
sub rsp, 0x20
mov rdx, qword [rcx + 0x10]
mov rsi, rcx
add rdx, 1
mov rbx, qword [rcx + 0x38]
xorps xmm0, xmm0
js 0x18000ace4
cvtsi2ss xmm0, rdx
jmp 0x18000acf9
mov rax, rdx
and edx, 1
shr rax, 1
or rax, rdx
cvtsi2ss xmm0, rax
addss xmm0, xmm0
divss xmm0, dword [rcx]
call qword [sym.imp.msvcrt.dll_ceilf]
movss xmm1, dword [0x1800ce9e0]
xor ecx, ecx
comiss xmm0, xmm1
jb 0x18000ad28
subss xmm0, xmm1
comiss xmm0, xmm1
jae 0x18000ad28
movabs rax, 0x8000000000000000
mov rcx, rax
cvttss2si rax, xmm0
add rax, rcx
mov ecx, 8
cmp rax, rcx
cmova rcx, rax
cmp rbx, rcx
jae 0x18000ad56
cmp rbx, 0x200
jae 0x18000ad53
shl rbx, 3
cmp rbx, rcx
jae 0x18000ad56
mov rbx, rcx
movabs rax, 0xfffffffffffffff
bsr rcx, rax
mov eax, 1
shl rax, cl
cmp rbx, rax
ja 0x18000aec3
lea rax, [rbx - 1]
mov edi, 1
mov rbx, qword [rsi + 8]
or rax, 1
bsr rcx, rax
mov r8, rbx
inc ecx
shl rdi, cl
lea rcx, [rsi + 0x18]
lea rdx, [rdi + rdi]
call fcn.1800090cc
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 0x18000ae87
mov rcx, qword [rcx]
movabs r8, 0xcbf29ce484222325
xor r9d, r9d
movzx edx, byte [r9 + rax + 0x10]
movabs r10, 0x100000001b3
xor r8, rdx
inc r9
imul r8, r10
cmp r9, 4
jb 0x18000adce
mov r11, qword [rsi + 0x30]
mov rdi, qword [rsi + 0x18]
and r11, r8
add r11, r11
cmp qword [rdi + r11*8], rbx
jne 0x18000ae0d
mov qword [rdi + r11*8], rax
mov qword [rdi + r11*8 + 8], rax
jmp 0x18000ae7b
mov r10, qword [rdi + r11*8 + 8]
mov edx, dword [rax + 0x10]
cmp edx, dword [r10 + 0x10]
jne 0x18000ae50
mov r10, qword [r10]
cmp r10, rax
je 0x18000ae06
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 0x18000ae06
mov r10, qword [r10 + 8]
cmp edx, dword [r10 + 0x10]
je 0x18000ae9d
cmp qword [rdi + r11*8], r10
jne 0x18000ae46
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 [rdi + r11*8], rax
mov rax, rcx
cmp rcx, rbx
jne 0x18000adbe
mov rbx, qword [rsp + 0x30]
mov rsi, qword [rsp + 0x38]
mov rdi, qword [rsp + 0x40]
add rsp, 0x20
pop r14
ret
mov r10, qword [r10]
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 0x18000ae7b
lea rcx, str.invalid_hash_bucket_count
call fcn.18008e678
int3
Function at 0x1800127e4
Capabilities:
Contain obfuscated stackstrings
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
push rbp
mov rbp, rsp
sub rsp, 0x50
xor ebx, ebx
cmp qword [0x18010e9e0], rbx
jne 0x18001294c
mov dword [rbp - 0x24], 0x62
mov dl, 0x64
mov eax, dword [rbp - 0x24]
mov cl, 0x6c
xor al, dl
mov byte [rbp - 0x20], al
mov eax, dword [rbp - 0x24]
inc al
xor al, 0x33
mov byte [rbp - 0x1f], al
mov eax, dword [rbp - 0x24]
add al, 2
xor al, dl
mov byte [rbp - 0x1e], al
mov eax, dword [rbp - 0x24]
add al, 3
xor al, 0x63
mov byte [rbp - 0x1d], al
mov eax, dword [rbp - 0x24]
add al, 4
xor al, 0x6f
mov byte [rbp - 0x1c], al
mov eax, dword [rbp - 0x24]
add al, 5
xor al, 0x6d
mov byte [rbp - 0x1b], al
mov eax, dword [rbp - 0x24]
add al, 6
xor al, 0x70
mov byte [rbp - 0x1a], al
mov eax, dword [rbp - 0x24]
add al, 7
xor al, 0x69
mov byte [rbp - 0x19], al
mov eax, dword [rbp - 0x24]
add al, 8
xor al, cl
mov byte [rbp - 0x18], al
mov eax, dword [rbp - 0x24]
add al, 9
xor al, 0x65
mov byte [rbp - 0x17], al
mov eax, dword [rbp - 0x24]
add al, 0xa
xor al, 0x72
mov byte [rbp - 0x16], al
mov eax, dword [rbp - 0x24]
add al, 0xb
xor al, 0x5f
mov byte [rbp - 0x15], al
mov eax, dword [rbp - 0x24]
add al, 0xc
xor al, 0x34
mov byte [rbp - 0x14], al
mov eax, dword [rbp - 0x24]
add al, 0xd
xor al, 0x37
mov byte [rbp - 0x13], al
mov eax, dword [rbp - 0x24]
add al, 0xe
xor al, 0x2e
mov byte [rbp - 0x12], al
mov eax, dword [rbp - 0x24]
add al, 0xf
xor al, dl
mov edx, ebx
mov byte [rbp - 0x11], al
mov eax, dword [rbp - 0x24]
add al, 0x10
xor al, cl
mov byte [rbp - 0x10], al
mov eax, dword [rbp - 0x24]
add al, 0x11
xor al, cl
mov byte [rbp - 0xf], al
xor eax, eax
mov byte [rbp - 0xe], al
mov al, byte [rbp - 0x20]
mov al, byte [rbp + rdx - 0x20]
mov ecx, dword [rbp - 0x24]
add cl, dl
xor cl, al
mov byte [rbp + rdx - 0x20], cl
inc rdx
cmp rdx, 0x12
jb 0x1800128c7
lea rcx, [rbp - 0x20]
mov byte [rbp - 0xe], bl
call qword [sym.imp.KERNEL32.dll_LoadLibraryA]
mov qword [0x18010e9e8], rax
mov byte [rbp - 0x30], 0x4a
mov byte [rbp - 0x2f], 0x39
mov byte [rbp - 0x2e], 0x4a
mov byte [rbp - 0x2d], 0x49
mov byte [rbp - 0x2c], 0x75
mov byte [rbp - 0x2b], reloc.WS2_32.dll_WSAStartup
mov byte [rbp - 0x2a], 0x76
mov byte [rbp - 0x29], WSASetLastError
mov byte [rbp - 0x28], WSACleanup
mov byte [rbp - 0x27], 0x6b
mov byte [rbp - 0x26], bl
mov al, byte [rbp - 0x30]
mov al, byte [rbp + rbx - 0x30]
sub al, 6
mov byte [rbp + rbx - 0x30], al
inc rbx
cmp rbx, 0xa
jb 0x180012921
mov rcx, qword [0x18010e9e8]
lea rdx, [rbp - 0x30]
call qword [sym.imp.KERNEL32.dll_GetProcAddress]
mov qword [0x18010e9e0], rax
mov rbx, qword [rsp + 0x60]
add rsp, 0x50
pop rbp
ret