joyce8/EMBER2024-capa huggingface dataset:
Function at 0x18000c0ae
Capabilities:
Check for software breakpoints
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
popfq
jg 0x18001288e
mov rsi, rsi
jle 0x18001288e
cld
invalid
mov dword [rsp + 8], ebx
push rdi
test bx, 0
jb 0x18000d01d
sub rsp, 0x250
mov rbx, rcx
lea rcx, [rsp + 0x40]
mov edx, 0x104
push rsi
jl 0x18000c81f
mov dl, dl
jge 0x18000c81f
test ecx, 0
call fcn.180007aca
mov esi, 0x41e8dc4c
pop rsp
ret
mov rsi, qword [rsp + 8]
js 0x1800112e6
xchg rdi, rdi
jns 0x1800112e6
add qword [rsp + 0x10], rbx
je 0x180007186
mov r8, r8
jne 0x180007186
test ax, 0
call fcn.18000fad7
movabs al, byte [0xda9f281e829085e]
cmp esp, ecx
call fcn.180012e04
test ecx, 0
jne 0x180008027
call fcn.180013ae2
sbb byte [rcx], ch
imul esp, ebx, 0xffffffe8
jb 0x18000afc6
add rsp, 0x30
call fcn.18000b1c7
add dword [rax + 0x32], ebx
invalid
lea edx, [rbp + 0x130]
mov ecx, 0x104
call qword [0x18001a542]
test r10, 0
call fcn.180014574
leave
invalid
test byte [rcx], dh
movabs dword [0x5def840fffff], eax
movsxd rsi, dword [rsi]
jmp 0x18001081d
pop rbx
jg 0x18000c6c5
xchg dl, dl
jle 0x18000c6c5
mov rcx, rax
call fcn.18000956c
test ah, 0
jo 0x1800089b6
test eax, eax
jne 0x180012c2f
jne 0x18000d163

Function at 0x18000c151
Capabilities:
Check for software breakpoints
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
movsxd rdi, dword [rdi]
jb 0x1800087b0
xchg ch, ch
push rdi
jp 0x180014a3b
mov rdi, rdi
jnp 0x180014a3b
mov rdi, qword [rsp + 8]
ja 0x1800076fe
xchg si, si
jbe 0x1800076fe

Function at 0x18000c1d6
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
mov r11, qword [rsp + 8]
jmp 0x18000c88a
push r11
ja 0x180008c77
mov r15, r15
jbe 0x180008c77
call qword [0x18001a8a3]
mov qword [rbx], rax
movsxd r11, dword [r11]
jo 0x18000ff1c
xchg dx, dx
jno 0x18000ff1c

Function at 0x18000c8e9
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get system information on windows
Packed with generic packer

Disassembly:
call fcn.1800149ad
add eax, 0xe8ce013b
test r8, 0

Function at 0x18000c9bb
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
mov rdi, qword [rsp + 8]
jb 0x180008113
xchg r12, r12
jae 0x180008113
pop rdi
movsxd rdi, dword [rdi]
jmp 0x18000b278
push rdi
jb 0x180007ed3
mov di, di
jae 0x180007ed3
Function at 0x18000caed
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
ret
pop rcx
jmp 0x180006203
add al, 1
add byte [rax], al
call qword [0x18001a7f2]
test rbx, 0
call fcn.180008a5d
adc bl, byte [rdi + rdx*4]
call 0x17fe616ed
dec dword [rax - 9]
ret 0
push rbx
jb 0x18000fb8b
xchg rbx, rbx
jae 0x18000fb8b
test dh, 0
jnp 0x18000afe6
call fcn.180009839
sbb byte [0x11de8f1f2], bl
jmp 0x180006522
movsxd rbx, dword [rbx]
js 0x180007a58
xchg r15, r15
jns 0x180007a58
mov rbx, qword [rsp + 8]
jg 0x18000d094
mov bp, bp
jle 0x18000d094
popfq
je 0x18000ff78

Function at 0x18000cfcf
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
sub esp, 0x2b0
call fcn.18000caed
invalid
push r8
js 0x180011a1c
xchg al, al
jns 0x180011a1c
mov r8, qword [rsp + 8]
je 0x180006cb6
mov r14, r14
jne 0x180006cb6
jne 0x18001458c
call fcn.180008bfe
test al, 0x72
adc esp, edx
call 0x106b63043
add byte [rax], al
test si, 0
jo 0x180008b95
call fcn.180012269
rcr dword [rdx - 0x7f], 0x2d
call 0x17f694947
invalid

Function at 0x18000d0a6
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push rdi
je 0x18000df53
xchg cl, cl
jne 0x18000df53
Function at 0x18000d14f
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
mov eax, 0x504
mov rbx, qword [rsp + 0x30]
test rdi, 0
jb 0x1800144f8
add rsp, 0x20
call fcn.18000a0f2
out dx, al
push rdi
cld
or eax, ebp
add qword [rsp + 0x10], r14
jo 0x18000cb33
mov rbp, rbp
jno 0x18000cb33
mov eax, gs
invalid
xchg ebp, eax
mov al, 0
add byte [rax - 0x75], cl
retf
popfq
jb 0x18000d12e
nop
jae 0x18000d12e
movsxd r13, dword [r13]
je 0x180013d0b
xchg dh, dh
jne 0x180013d0b
test bx, 0
jb 0x180008ab5
call fcn.18000d3d2
adc dh, byte [rsi + 0x4ce8348b]
sub dword [rsp + 0x10], ecx
add r13, 0x187be36f
jo 0x18000f207
xchg cl, cl
jno 0x18000f207
mov rdx, r12
mov rcx, rdi
popfq
pop r13
jp 0x1800139b6
xchg r12, r12
jnp 0x1800139b6
push r13
jb 0x180011f6b
xchg rdx, rdx
jae 0x180011f6b
cmp al, 0xf3
je 0x180007499
je 0x180012f5d
mov rcx, qword [rdi]
test eax, 0
jb 0x18000ebb3
or edx, 0xffffffff
call fcn.18000f2bb
sbb al, dh
cmp ah, bh
call 0x1a4555ed5
mov rcx, rsi
call fcn.180007949
lea r11, [rsp + 0x80]
test r11, 0
js 0x180008f9f
xor eax, eax
mov rbx, qword [r11 + 0x10]
call fcn.180009f09
invalid
xor ecx, ecx
call fcn.180012597
cmc
in al, 0x10
enter 0x48e8, 0xffffffffffffff85
ror byte [rdi], 0x85
js 0x18000ebe9
add byte [rax], al
call fcn.1800120d9
fstp st(4)
in al, 0xc1
call 0x12006d528
push rdx
invalid
invalid
invalid
invalid
add dword [rbx - 0x2e], 0xffffffff
dec dword [rax - 0x7f]
int1
cmc
cmp dword [0x18e82fb20], edi
lodsd eax, dword [rsi]
invalid
sub qword [rsp + 0x10], r13
jb 0x180009074
mov r8, r8
jae 0x180009074
mov r13, qword [rsp + 8]
jg 0x18000961c
mov al, al
jle 0x18000961c
mov eax, ecx
ret
pushfq
jb 0x18000aa67
xchg dx, dx
jae 0x18000aa67
mov rsi, qword [rsp + 0x40]
call fcn.180006716
ficomp word [rax]
add eax, 0x8948e8ee
lahf
cwde
add byte [rax], al
add byte [rax - 0x75], cl
invalid

Function at 0x18000d718
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
pushfq
jb 0x18000c6d8
mov r15, r15
jae 0x18000c6d8
movsxd r12, dword [r12]
jp 0x1800096c1
xchg rsi, rsi
jnp 0x1800096c1
mov rbp, rcx
mov al, byte [rdx]
test r12, 0
jb 0x18000e15e
add r12, 0x3cef478
jb 0x18000ada8
or dword [rbp + 0xf000079], 0xffffff83
mov al, 0x96
invalid
push r12
jo 0x18000e816
mov sp, sp
jno 0x18000e816
mov qword [rsp + 0x28], rax
mov rax, qword [rsp + 0x48]
lea rdx, [rbp - 0x70]
test cl, 0
jo 0x18000cd41
xor r9d, r9d
test r15, 0
call fcn.1800117dd
cmp bl, byte [rbx]
cmp al, al
call 0x19082e6f5
cmp al, 0
add byte [rbp - 0x75], cl
test byte [rdi], 0x83
invalid
mov r12, qword [rsp + 8]
jmp 0x18000b5d1
Function at 0x18000d793
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get system information on windows

Disassembly:
mov r9, qword [rsp + 8]
add byte [rax], al
lea edx, [rbp + 0x20]
call fcn.18000d3d2
std
je 0x180007b16
xor al, 0xe8
adc eax, 0xce58
push r9
je 0x180005fb4
mov sp, sp
jne 0x180005fb4
push rdi
test bx, 0
jne 0x180007b80
sub rsp, 0x20
mov ebx, edx
mov rdi, rcx
test edi, 0
js 0x18000d2fe
call fcn.18000b3ab
xchg esp, eax
pop rdx
adc ch, byte [rdx]
call 0x1a455631f
or byte [rdi], cl
invalid

Function at 0x18000d900
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
mov ecx, 0xa0
call fcn.180008293
call fcn.180006830
mov bh, 0xa6
outsb dx, byte [rsi]
int 0xe8
movsxd r14, dword [r14]
je 0x18000a8b3
xchg bh, bh
jne 0x18000a8b3
cmp byte [rax + 1], 0xe3
call fcn.180010af2
sbb eax, edi
pushfq
cmp eax, 0x70880fe8
mov ebx, 0x8548ffff
leave
jne 0x18000a5e9
jne 0x18000dfe1
mov eax, 0x54f
call fcn.180013325
cmp ah, byte [rbp + 0x66e81953]
mov dword [r9 + r8*2], eax
mov r14, qword [rsp + 8]
js 0x18000bc22
nop
jns 0x18000bc22
push r14
jl 0x18000c7f5
xchg si, si
jge 0x18000c7f5
lea ecx, [rbp - 0x50]

Function at 0x18000dc1a
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
movsxd rbp, dword [rbp]
push rbp
jb 0x1800132d8
xchg r14, r14
jae 0x1800132d8
mov rbp, qword [rsp + 8]
jp 0x180009fb2
mov r15, r15
jnp 0x180009fb2
popfq
jb 0x18000ad5a
mov bl, bl
jae 0x18000ad5a

Function at 0x18000dd46
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push r8
jg 0x180012571
mov dh, dh
jle 0x180012571
jb 0x18000edc8
and dword [rbx + 8], 0
mov rcx, qword [rbx + 0x10]
call fcn.18000dc1a
lodsb al, byte [rsi]
fsincos
int1
call 0x15da35d81
invalid
and dword [rbp - 0x40], 0
call fcn.18000693c
mov esi, 0xe8dde669

Function at 0x18000e40c
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push r13
jmp 0x180014379
mov r13, qword [rsp + 8]
js 0x18000b398
mov cl, cl
jns 0x18000b398
mov edi, 4
lea rdx, [rbp - 0x31]
test ebx, 0
call fcn.180009657
invalid
Function at 0x18000e67b
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get system information on windows
Packed with generic packer

Disassembly:
movsxd r12, dword [r12]
ja 0x180009fc4
mov bh, bh
jbe 0x180009fc4
jne 0x18000b304
jne 0x1800131c1
mov byte [rsp + rdx + 0x21], 0x44
call fcn.18001046b
mov eax, 0xe8f50719
mov rcx, qword [rsi + 0x10]
call fcn.1800135c2
loopne 0x180009d4e
sbb ebx, 0x9c8b48e8
and al, 0x70
add dword [rax], eax
add byte [rax - 9], cl
rol dword [rax], 0
add byte [rax], al
cdq
jge 0x180009d51
add byte [rax + 0xb], cl
ret 0x8b48
mov al, byte [rcx]
inc rdx
call fcn.18001163a
push rdi
xor esp, ebx
add al, ch
mov eax, 0x718
jmp 0x18000e9a7
push r12
jb 0x180012ee1
mov r13, r13
jae 0x180012ee1
test bx, 0
jnp 0x18000e7b7
call fcn.180012e98
pop rdi
invalid
mov rbx, qword [rsp + 8]
mov rdi, qword [rsp + 0x10]
ret
mov ebx, dword [rsp + 8]
mov r12, qword [rsp + 8]
jg 0x180009cc1
mov rbx, rbx
jle 0x180009cc1
test rax, 0
jne 0x18001040b
call fcn.18000a19f
int3
shr al, 0x9a
invalid

Function at 0x18000e7a1
Capabilities:
Check for software breakpoints
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
mov rbp, qword [rsp + 8]
jo 0x18000e668
mov rbx, rbx
jno 0x18000e668
call fcn.1800148da
add byte [rdi + rax - 0x18], cl
popfq
jo 0x18000d00b
xchg bl, bl
jno 0x18000d00b
mov rbp, qword [rsp + 0x68]
mov rsi, qword [rsp + 0x70]
call fcn.180007f38
in eax, 0x51
movabs eax, dword [0x245c8b48c033e828]
push rax
mov rbp, qword [rsp + 0x58]
mov rsi, qword [rsp + 0x60]
mov rdi, qword [rsp + 0x68]
test cx, 0
jnp 0x180008c1c
call fcn.180009b91
movsb byte [rdi], byte [rsi]
scasb al, byte [rdi]
invalid
pop rbp
push rbp
jp 0x180007e1d
nop
jnp 0x180007e1d
jo 0x18000bdf9
sub ecx, r8d
mov r8d, esi

Function at 0x18000e8db
Capabilities:
Check for software breakpoints
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
or eax, edx
push r11
ja 0x180006dc8
xchg rbp, rbp
jbe 0x180006dc8
dec eax
movsxd rbx, eax
test rbx, 0
jne 0x18000c795
add rbx, rbx
call fcn.1800080e1
mov ecx, 0xe8e37966
mov rsi, qword [r11 + 0x30]
mov rdi, qword [r11 + 0x38]
mov rsp, r11
call fcn.18001166c
invalid
Function at 0x18000ea2c
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
test eax, 0x850f0000
push 0x13
mov eax, dword [rcx + 5]
inc rcx
test edx, 0
sal edi, 0xc2
add byte [rax], al
add byte [rax], al
jb 0x180006797
call fcn.18000f21b
jp 0x180006d99
ret 0xe830
mov ss, edi
mov ebx, 0x53e80000
invalid
lea ecx, [0x18001a264]
push rdx
jo 0x180014786
xchg rdi, rdi
jno 0x180014786
call fcn.18001273e
lea rcx, [rsp + 0x70]
call fcn.180013325
xchg ebp, eax
lodsb al, byte [rsi]
out 0xe8, al
cmp dword [rcx], eax
jne 0x180006d94
jne 0x180010c1a
mov rax, rcx
ret
test esi, esi
xor eax, 0xd7e80000
add byte es:[rax], al
movsxd rdx, dword [rdx]
jb 0x180009a40
mov cl, cl
jae 0x180009a40
pushfq
jb 0x180012967
mov rsp, rsp
jae 0x180012967
ret
xor rbp, 0x349a9c12
jp 0x18000ccef
xchg ch, ch
jnp 0x18000ccef
pushfq
jl 0x18001356a
mov ax, ax
jge 0x18001356a
jne 0x18000848a
jne 0x18001494b
lea rdx, [rsp + 0x60]
mov rcx, rsi
call fcn.18000c571
mov dl, 0x4c
and al, 0x3f
call 0x19493b1bd
add byte [rax], al
test eax, eax
call fcn.18000a0f2
invalid
add rdx, 0x1c99daf9
jl 0x18000defe
mov r14, r14
jge 0x18000defe
mul r8
call fcn.18000b45b
cmp dword [rsi + rcx*4 - 0x7cb717c9], ebp
in al, dx
pop rax
mov rax, qword [0x18001a03e]
test rdx, 0
jb 0x1800095cd
test rax, rax
call fcn.18000f3b4
mov bh, 0x87
insb byte [rdi], dx
sub ebp, eax
movsxd rbx, dword [rbx]
jo 0x18000a14d
nop
jno 0x18000a14d
mov rdx, qword [rsp + 8]
js 0x180011e19
xchg cl, cl
jns 0x180011e19
test r14, 0
jo 0x180008728
add rbp, 2
call fcn.18000c9bb
sub al, byte [rcx + 0x29]
invalid
lea ecx, [0x18001a64a]
call fcn.180013325
pop rsi
or dword [rbx + 0x19], edx
call 0x142829222
cmpsd dword [rsi], dword [rdi]
pop rdx
adc dword [rdi], ecx
mov byte [rdi + 0x28], ch
invalid

Function at 0x18000ec40
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push r12
jo 0x180011162
mov bh, bh
jno 0x180011162
call qword [0x18001a934]
jmp 0x180009689
movsxd r12, dword [r12]
jp 0x1800120c9
xchg r15, r15
jnp 0x1800120c9
mov r12, qword [rsp + 8]
jmp 0x18000fc22

Function at 0x18000f0da
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get system information on windows
Packed with generic packer

Disassembly:
test esi, 0
jb 0x18000f5d6
call fcn.180006069
mov eax, 0xe8e36652
invalid
Function at 0x18000f391
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push r12
jo 0x180012718
mov r12, qword [rsp + 8]
jl 0x180008d20
xchg rdi, rdi
jge 0x180008d20
pop r11
ja 0x18000fb30
xchg dx, dx
jbe 0x18000fb30
ret

Function at 0x18000f58a
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get number of processors
Get system information on windows
Packed with generic packer

Disassembly:
add dword [rax - 1], ecx
ret 0x2ce8
ret 0
push r13
jo 0x180012dad
xchg dl, dl
jno 0x180012dad
test rax, rax
mov r13, qword [rsp + 8]
je 0x180006f24
xchg di, di
jne 0x180006f24
call qword [0x18001a994]
test rdx, 0
jo 0x18000f178
test eax, eax
jne 0x18000d825
jne 0x18000b305
call fcn.18000ec40
idiv dword [rbp - 0x63]
invalid

Function at 0x18000f7fa
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get system information on windows
Packed with generic packer

Disassembly:
mov rax, rsp
mov qword [rax + 8], rbx
mov qword [rax + 0x10], rsi
mov qword [rax + 0x18], rdi
call fcn.180010746
or esi, dword [rbp + 0x4ce82e50]
mov esi, dword [rsp + 8]

Function at 0x18000fad7
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push r15
jl 0x18000fb77
mov r11, r11
jge 0x18000fb77

Function at 0x18000fd3b
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
call fcn.180008f1e
invalid
movsxd r11, dword [r11]
jo 0x180010d50
mov ah, ah
jno 0x180010d50
test edi, 0
jnp 0x180008314
test rax, rax
call fcn.18000c161
scasb al, byte [rdi]
add dword [rax - 0x74b717da], edi
enter 0xfffffffffffff4e8, 0xfffffffffffffffd
invalid
mov r11, qword [rsp + 8]
jg 0x180009082
mov rdi, rdi
jle 0x180009082
push r11
jmp 0x18000bcf1

Function at 0x18000fd42
Capabilities:
Check for software breakpoints
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
movsxd rsi, dword [rsi]
jb 0x18000a91a
mov rsp, rsp
jae 0x18000a91a
mov rax, qword [rbx + 0x10]
mov qword [rsp + 0x28], rax
call fcn.1800148c9
ret 0x2d64
push rsi
jb 0x1800107e3
mov r8, r8
jae 0x1800107e3
mov rsi, qword [rsp + 8]
ja 0x18000f6cc
mov r8, r8
jbe 0x18000f6cc
Function at 0x18001013a
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
pop rbp
jb 0x180011a93
xchg di, di
jae 0x180011a93
mov edx, 0x5120924
mov ecx, 0x1e79e9b7
call fcn.18000ae80
call fcn.180010b69
je 0x18000697d
scasd eax, dword [rdi]
ret 0x48e8
test byte [rcx + 0xf0000dd], cl
test ah, ah
xor eax, dword [rax]
add byte [rbx - 0x78b417e1], cl
add byte [rax], al
popfq
jl 0x1800068ff
nop
jge 0x1800068ff
je 0x18001258b
mov al, byte [rdx - 5]
test r13, 0
jnp 0x180007fb5
test dword [rdi], edx
lodsd eax, dword [rsi]
add byte [rax], al
mov rbp, qword [rsp + 8]
jo 0x18000c450
xchg al, al
jno 0x18000c450
movsxd rbp, dword [rbp]
jg 0x180011795
xchg rdi, rdi
jle 0x180011795
sub qword [rsp + 0x10], rbp
je 0x180006a34
xchg rbp, rbp
jne 0x180006a34
mov qword [rsp + 0x20], rcx
lea rdx, [rdi + 0x10]
mov r8d, 0xa
call fcn.1800145dc
movabs byte [0x6349f633e828f4b2], al
ret
sub rbp, 0x21948256
ja 0x18000d1bb
xchg r10, r10
jbe 0x18000d1bb
and qword [rsp + 0x30], 0
test rsi, 0
jb 0x180009d53
and dword [rsp + 0x28], 0
call fcn.180012269
fsub dword [rcx + rax*4 + 0x2d]
call 0x1d0ed6004
invalid
push rbp
jb 0x180008ef5
mov rcx, rcx
jae 0x180008ef5
pushfq
je 0x18000de80
mov r11, r11
jne 0x18000de80
ret
mov ecx, esp

Function at 0x18001046b
Capabilities:
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
add byte [rbx - 0x1700000d], 0x21
pop rsi
add byte [rax], al
sbb al, 0x46
invalid
xor dword [rcx], esi
shr al, 0x48
mov ecx, ebx
mov dword [rbp - 0x31], eax
call fcn.180009e67
mov r8d, dword [rbp + 7]
mov rdx, qword [rbp + 0x17]
call fcn.1800117dd
jle 0x18000805c
cmp al, al
call 0x1a45481c9
adc byte [rdi], cl
invalid
mov rsi, qword [rsp + 8]
jo 0x180013548
push rsi
jp 0x180008cf9
xchg sp, sp
jnp 0x180008cf9
test bh, 0
jnp 0x180006b90
and eax, 0xc18b9329
mov r9d, eax
test r10, 0
js 0x180008061
xor r9d, ecx
dec rdx
call fcn.180007f38
outsb dx, byte [rsi]
invalid

Function at 0x180010541
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
movsxd r15, dword [r15]
jp 0x18001177a
xchg bx, bx
jnp 0x18001177a
mov rdx, qword [rbp + 0x77]
call fcn.180007f38
xchg byte [rax + riz*4 - 0x78f017d8], bh
invalid
push r15
jp 0x1800121df
xchg dl, dl
jnp 0x1800121df
pushfq
jo 0x180007b1d
mov rax, rax
jno 0x180007b1d
push rbx
call fcn.180008a5d
add cl, bh
push 0xf9ce8c9
test ah, ah
invalid
mov r15, qword [rsp + 8]
je 0x18000e4cb
xchg cx, cx
jne 0x18000e4cb
mov r8d, dword [rbp - 0x29]
mov rdx, qword [rbp - 0x19]
mov rcx, rbx
call fcn.180009e67
test r8, 0
Function at 0x1800105a5
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
sub rdx, 0x3d9d1c07
js 0x1800082ea
mov cl, cl
jns 0x1800082ea
ret
mov rdx, qword [rsp + 8]
js 0x18000fd29
mov rbp, rbp
jns 0x18000fd29
call qword [0x18001a5ed]
mov r12, rax
test cx, 0
jb 0x18000a4b0
test rax, rax
jne 0x18000ec5b
call fcn.18000f2bb
mov dword [rcx + 0x3a], ecx
out 0xe8, eax
pushfq
jl 0x180007bbf
mov cx, cx
jge 0x180007bbf
xor rax, 0x3de01f7
jl 0x180010a49
mov bl, bl
jge 0x180010a49
sub qword [rsp + 0x10], rdx
jb 0x18000b4b2
mov sp, sp
jae 0x18000b4b2
popfq
jp 0x18000c70c
xchg r14, r14
jnp 0x18000c70c
invalid
popfq
ja 0x180011ca8
nop
jbe 0x180011ca8
test edi, 0
jnp 0x18000829e
pop rax
jb 0x1800109e5
call fcn.18000e67b
cmp ah, byte [rdx + 0x33e83c6c]
test byte [rbp - 0x75], 0xc3
mov ecx, r11d
mul r11d
test al, 0
jo 0x18000ba88
call fcn.1800074f2
cmp al, cl
cmp al, ch
movsxd rdx, dword [rdx]
js 0x18001217b
mov r15, r15
jns 0x18001217b
push rdx
jl 0x18000822f
xchg bh, bh
jge 0x18000822f
je 0x1800105c2
je 0x1800131bb
call qword [0x18001a83b]
test esi, 0
jnp 0x180012248
add rsp, 0x28
call fcn.18001228f
invalid
add qword [rsp + 0x10], rax
jg 0x180010c76
mov r13, r13
jle 0x180010c76
jmp fcn.180005d4f

Function at 0x180010746
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
mov r12, qword [rsp + 8]
push r12
jl 0x18000d0fd
xchg ah, ah
jge 0x18000d0fd

Function at 0x1800109c6
Capabilities:
Authenticate hmac
Encode data using base64
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push r8
jb 0x18000839f
xchg dh, dh
jae 0x18000839f
lea rcx, [rsp + 0x30]

Function at 0x180010a38
Capabilities:
Authenticate hmac
Check for software breakpoints
Check os version
Encode data using base64
Encrypt data using speck
Execute anti-debugging instructions
Get number of processors
Get system information on windows

Disassembly:
push r11
jl 0x180014024
mov bp, bp
jge 0x180014024