joyce8/EMBER2024-capa huggingface dataset:
Function at 0x18000eb39
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push r13
je 0x180013a2f
mov r11, r11
jne 0x180013a2f
pushfq
ja 0x180008b53
mov rdx, rdx
jbe 0x180008b53
ret
mov r13, qword [rsp + 8]
ja 0x18000aed4
xchg rsi, rsi
jbe 0x18000aed4

Function at 0x18000ec34
Capabilities:
Encode data using base64
Get number of processors
Resolve function by parsing pe exports

Disassembly:
lea edx, [rsp + 0x20]
mov rcx, qword [rsp + 8]
jb 0x180016198
mov si, si
jae 0x180016198
jne 0x180010e96
call fcn.18000a4da
or edx, edi
pop rdi
sar edi, 0xff
ret
push rcx
jl 0x18000cf82
mov di, di
jge 0x18000cf82
mov ecx, 0x40
call fcn.18000fe42
mov eax, 0xff070809
inc dword [rcx + 0x54]
test r10, 0
jo 0x18000c00a
sub rsp, 0xf0
test dl, 0
jb 0x180012d59
and qword [rsp + 0x40], 0
call fcn.18000c8a5
push rax
pop rdx
invalid
call fcn.180017621
or ebx, dword [rbp - 0x75]
sar edi, 1
invalid
lea rcx, [0x18001db85]
call fcn.180016690
add qword [r10], 0x48ffffc3
add ebx, 0x1298283c

Function at 0x18000ece9
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
test si, 0
sub qword [rsp + 0x10], r13
jo 0x18000b110
xchg rsi, rsi
jno 0x18000b110
jne 0x1800170c9
call fcn.18000ce82
vunpckhpd ymm5, ymm1, ymm6
invalid
push r13
jb 0x180015888
nop
jae 0x180015888
jne 0x1800097c6
call fcn.180015f28
cmp byte [rcx + 0x7f], bh
int3
add al, ch
movabs eax, dword [0xff15b1a0ecffffad]
invalid
and al, 0x20
adc bh, byte [rcx]
invalid
movsxd r13, dword [r13]
ja 0x1800153bf
xchg cx, cx
jbe 0x1800153bf
jo 0x1800111d4
test eax, eax
jne 0x1800170c9
jne 0x180009c87
mov rcx, r13
call fcn.18000ba58
test al, 0
jnp 0x180011977
test eax, eax
call fcn.18000aa06
insd dword [rdi], dx
invalid
pushfq
jmp 0x180016b04
mov r13, qword [rsp + 8]
jb 0x180013c5c
mov sp, sp
jae 0x180013c5c
mov r9d, 0x3a21
call fcn.18000eb39
invalid
sub r13, 0x233d6c31
jb 0x18000e5b2
xchg r15, r15
jae 0x18000e5b2
lea r9, [rdx + 4]
lea rcx, [rsp + 0x10]
mov r11, r10
mov dword [rsp + 0x10], eax
call fcn.180010ecd
push rax
movabs byte [0xb4800f9dffffc924], al
add dword [rax], eax
add byte [rax - 0x70], cl
Function at 0x18000f045
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
pushfq
push r8
jp 0x180014364
xchg rbp, rbp
jnp 0x180014364
movsxd r8, dword [r8]
jb 0x18000cf19
xchg di, di
jae 0x18000cf19
call fcn.1800098c2
pushfq
invalid
mov r8, qword [rsp + 8]
jb 0x18001323e
xchg rdi, rdi
jae 0x18001323e

Function at 0x18000f15c
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push r12
ja 0x1800133e7
xchg dh, dh
jbe 0x1800133e7
mov r12, qword [rsp + 8]

Function at 0x18000f4af
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov r12, qword [rsp + 8]
jb 0x180017d15
mov rsi, rsi
jae 0x180017d15
jbe 0x18001449a
call fcn.1800088aa
mov byte [rbp - 0x37], cl
cmp edi, edi
inc dword [rbx + 0x4800cf65]
lea edx, [rbp - 0x31]
mov r8d, edi
mov rcx, rbx
call fcn.18000a69e
call fcn.18000c140
sbb bh, byte [0x17fffeade]
pushfq
jl 0x18000e888
mov di, di
jge 0x18000e888
cmp rax, 0xffffffffffffffff
call fcn.18000b5f2
nop
mov dl, 0x68
invalid
sub r12, 0xe510f75
js 0x180016808
xchg r14, r14
jns 0x180016808
push r12
jp 0x18000ce3f
xchg rsi, rsi
jnp 0x18000ce3f
je 0x18001135d
call fcn.180012fbf
test eax, 0xff041911
dec dword [rdi]
test byte [rcx - 0xa], al
invalid
pop rbx
lodsd eax, dword [rsi]
invalid
movsxd r12, dword [r12]
jmp 0x18000e2cc

Function at 0x18000f677
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push rax
jb 0x18000b44a
xchg bp, bp
jae 0x18000b44a
jne 0x1800143be
and eax, edi
call fcn.18000aa06
sub esi, dword [rax - 0x1c40]
test dl, 0
call fcn.18001752a
push rsp
invalid
dec dword [rax + 8]
test bx, 0
call fcn.18000a369
lodsb al, byte [rsi]
sub dword [rdi - 0x35], ebp
invalid
Function at 0x18000fd76
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push rdx
jp 0x18001204a
xchg bp, bp
jnp 0x18001204a
mov ecx, esi
call fcn.1800178af
call fcn.18000c8a5
hlt

Function at 0x18000fe42
Capabilities:
Resolve function by parsing pe exports

Disassembly:
pushfq
js 0x1800166d1
mov r8, r8
jns 0x1800166d1
mov byte [r11 + r10], r8b
test rcx, 0
jne 0x1800161e0
cmp r9d, 2
jl 0x1800171a0
call fcn.180008e91
add byte [rdx], ch
and al, 0xe3
invalid
xor eax, 0x48ffffe1
mov edi, dword [rbx + 0x10]
movsxd rbx, dword [rbx]
jl 0x1800095e0
xchg dx, dx
jge 0x1800095e0
push rbx
jp 0x18001637e
nop
jnp 0x18001637e
je 0x18001351f
call fcn.1800178aa
test di, 0
jo 0x18000aa8d
call fcn.180009dd6
sahf
jno 0x18000fe80
adc al, 0xff
call [rdi + rcx - 0x321278]
inc dword [rsi - 0x1a76f025]
int 0xff
inc edi
and al, 0x20
add eax, dword [rax]
add byte [rax], al
mov byte [rbp + 0x7d], al
invalid
lea ecx, [rsp + 0x20]
rol dword [rax], 0xf
mov esp, edx
invalid
mov rbx, qword [rsp + 8]
jg 0x18000c8fc
xchg dx, dx
jle 0x18000c8fc
jnp 0x18001425b
xor r8d, r8d
mov dword [rsp + 0x28], esi
call fcn.180013059
clc
mov esi, 0xffffd179
add r12w, ax
mov eax, 0x2000
lea rbp, [rsp + 0x90]
call fcn.18000f97c
scasd eax, dword [rdi]
push rax
add r15, r15
xchg ebp, eax
invalid
dec dword [rax - 0x73]
push rbp
nop
test rbx, 0
call fcn.180014e0d
loop 0x1800163bd
jne 0x1800163c5
invalid
xor rbx, 0x7086c4b
jb 0x18000b8e6
xchg r11, r11
jae 0x18000b8e6
call fcn.18000e699
mov byte [rax - 0x5a], bh
in al, dx
invalid
Function at 0x1800109ae
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov dword [rax], 0x2a6de8
add byte [rsp + rcx*8 + 0x57], dl
ret
pop rcx
js 0x1800164d7
xchg rsi, rsi
jns 0x1800164d7
add eax, edx
shr eax, 2
call fcn.180008e91
movabs eax, dword ss:[0x9a5d870fffffe323]
add byte [rax], al
mov r10, qword [rdi + 8]
test eax, 0
call fcn.18000ec34
add eax, 0xffc487c0
dec dword [rcx - 0x7f]
ret 0xfa96
ret
sub qword [rsp + 0x10], rcx
jo 0x180017acb
mov r11, r11
jno 0x180017acb
call fcn.180015ec0
je 0x18000c29e
outsb dx, byte [rsi]
xor eax, 0x8b48ffff
fld1
std
invalid
add dword [rax], eax
add bh, bh
invalid
ret
movsxd r8, dword [r8]
jb 0x180010ef4
xchg r8, r8
jae 0x180010ef4
popfq
ja 0x180010117
xchg bp, bp
jbe 0x180010117
pop r8
js 0x18000bf9f
mov bl, bl
jns 0x18000bf9f
call fcn.180016f46
lea rdx, [rsp + 0x40]
mov rcx, rbx
call fcn.180014bee
mov rdx, qword [rbx + 0x10]
mov rcx, rsi
call fcn.1800123b1
test al, 0
jnp 0x1800116e0
xor edi, 0x8235bee1
call fcn.180009dd6
invalid
pop r8
jmp 0x18000f22a
push r8
jb 0x18001759a
mov r8, r8
jae 0x18001759a
xor rcx, 0x208d6fec
ja 0x18000c228
mov sp, sp
jbe 0x18000c228
pushfq
test edx, edx
ret
mov r8, qword [rsp + 8]
ja 0x18000fbe5
mov r9, r9
jbe 0x18000fbe5
popfq
jp 0x18000b30a
xchg di, di
jnp 0x18000b30a
call fcn.18000ba58
test dh, 0
jne 0x18000abc6
call fcn.180009cdd
int 0x43
mov byte [rax], dl
invalid

Function at 0x180010c97
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
test ch, 0
jo 0x180012ac8
call fcn.18000ae75
movsxd r11, dword [r11]
jp 0x18000b5f9
mov r10, r10
jnp 0x18000b5f9
mov r11, qword [rsp + 8]
jg 0x1800114c6
mov bh, bh
jle 0x1800114c6
pushfq
jg 0x180011aef
xchg si, si
jle 0x180011aef
je 0x180017da2
mov rcx, rax
call fcn.18000f15c
loop 0x18000b648
test al, 0xc6
invalid
mov byte [rbp + 0x2d], al
add byte [rax], al
mov si, si
jns 0x18000e392
pop r9
js 0x18000f0f6
xchg di, di
jns 0x18000f0f6
ret
push r11
jp 0x1800173a0
mov di, di
jnp 0x1800173a0
call fcn.18000b802
add rsp, 0x28
pop r9
pop r8
pop rdx
pop rcx
call fcn.18000bfb7
pop rdi
or cl, byte [rdx]
idiv edi
dec dword [rax - 0x75]
invalid
mov ebx, eax
movsxd r11, dword [r11]
js 0x1800179ff
xchg dl, dl
jns 0x1800179ff
mov rbx, qword [rsp + 8]
jl 0x180017ea7
xchg bh, bh
jge 0x180017ea7
ret
add al, 1
add byte [rax], al
mov r11, qword [rsp + 8]
jp 0x180009b5d
xchg r8, r8
jnp 0x180009b5d
test ch, 0
jne 0x1800113a9
cmp edx, eax
jbe 0x180008c4f
call fcn.18000ec34
test dword [rax], esp
mov esp, eax
invalid
adc eax, 0x5f45

Function at 0x180010ecd
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push r9
jo 0x18000a75e
mov rdi, rdi
jno 0x18000a75e
mov rcx, qword [rsp + 0x30]
call qword [0x18001dcb4]

Function at 0x180010fe2
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov r11, qword [rsp + 8]
js 0x180010d59
xchg bl, bl
jns 0x180010d59
mov r9, rbp
mov r8d, 0x20
call fcn.180014ee9
movabs eax, dword [0xf5b41ffffc673e4]
xchg dword [rbp + 0x4800003e], ebp
mov esp, esp
movsxd r11, dword [r11]
je 0x1800167eb
mov r9, r9
jne 0x1800167eb
push r11
jmp 0x1800108d0
pushfq
Function at 0x18001131d
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
pushfq
je 0x18000cc3b
nop
jne 0x18000cc3b
mov rcx, qword [rdi]
test r12, 0
jnp 0x180016b1b
test rcx, rcx
je 0x180012c23
call fcn.18001752a
rol byte [rax], 0xea
ud0
sub ecx, eax
mov r8d, esi
inc ecx
movsxd rbx, ecx
xor rbp, 0x1db61901
je 0x1800142db
mov rsi, rsi
jne 0x1800142db
mov r12, qword [rsp + 8]
ja 0x180015e6c
xchg rsp, rsp
jbe 0x180015e6c
movsxd rbp, dword [rbp]
jb 0x18000964b
xchg rcx, rcx
jae 0x18000964b
pushfq
ja 0x18000e23d
nop
jbe 0x18000e23d
mov rbx, qword [rsp + 0x50]
mov rbp, qword [rsp + 0x58]
mov rsi, qword [rsp + 0x60]
mov rdi, qword [rsp + 0x68]
test dh, 0
jne 0x180011a14
add rsp, 0x40
pop r12
call fcn.1800094d8
adc eax, 0xff1f4f3b
dec dword [rdi]
test dword [rsp + rdx*4], ebx
add byte [rax], al
add edx, 0x1000
mov rcx, r12
call fcn.18000953e
pushfq
popfq
invalid
add r12, 0x3ca7f133
je 0x18001560b
xchg dl, dl
jne 0x18001560b
mov rax, rdi
jmp fcn.18000f9e9
popfq
jmp fcn.180013f82
sub esp, 0x70
call fcn.180008941
mov dh, 0xba
adc bl, bh
invalid
push rbp
jb 0x1800132b5
mov r11, r11
jae 0x1800132b5
jne 0x180011bea
call fcn.18000e699
invalid
test ah, bl
invalid
test cl, cl
sar bh, 0xff
mov rcx, rax
call fcn.1800096b0
push rbx
jo 0x180011be5
and edi, edi
dec dword [rcx + rbp + 0x5c]
and al, 0x10
mov rbp, qword [rsp + 8]
ja 0x18000ce2c
xchg r8, r8
jbe 0x18000ce2c
jnp 0x180009dc1
call fcn.18000ad8c
popfq
and byte [rcx], 0xfe
invalid
add qword [rsp + 0x10], rbp
sub qword [rsp + 0x10], r12
jo 0x18000ec1f
xchg di, di
jno 0x18000ec1f
sub rsp, 0x28
call fcn.1800096b0
jns 0x180015691
jmp 0x18001564d
add byte [rax], al
add byte [rax], al
jb 0x180010665
call fcn.18000f045
shr dword [0x180006a09], cl
call fcn.1800142b1
mov ah, 0xf
clc
invalid
invalid
movsxd r12, dword [r12]
jo 0x18000df8c
mov cl, cl
jno 0x18000df8c
lea ecx, [rdx + 4]
Function at 0x18001210f
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov rsi, qword [rsp + 8]
je 0x18000e864
xchg di, di
jne 0x18000e864
and r10, rdi
movsxd rsi, dword [rsi]
je 0x180010dd4
xchg dx, dx
jne 0x180010dd4
test rbx, 0
call fcn.18000af3c
pop rax
add byte [rdx], dl
sbb al, 0xff
dec dword [rcx - 0x7f]
in al, dx
jne 0x18000e89c
push rcx
invalid
add byte [rax], al
mov rbx, qword [rbp + 0x6f]
mov qword [rsp + 0x40], rax
mov rax, qword [r13 + 0x10]
call fcn.18000c933
push rbp
add dl, byte [rdi]
and bh, bh
inc ebx
pushfq
jp 0x180016f94
push rsi
je 0x180009e69
xchg rdx, rdx
jne 0x180009e69
mov rax, qword [rsp + 0x48]
call fcn.180008951
test eax, 0xfff36956
dec dword [rdi]
test dword [rcx + 0x3d000030], ebx
add byte [rax], al
add byte [rax], dl
call fcn.18001131d
adc al, 0x56
mov dh, 0x1d
invalid

Function at 0x180012df2
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
pushfq
jo 0x180012c0a
mov ax, ax
jno 0x180012c0a
mov ebx, dword [rsp + 0x170]
movsxd rcx, dword [rcx]
jp 0x180008b1c
mov rcx, rcx
jnp 0x180008b1c
pushfq
jb 0x1800112f7
xchg r10, r10
jae 0x1800112f7
xor rdi, 0x11ec1730
push rcx
je 0x180014b62
mov r11, r11
jne 0x180014b62
jne 0x180010411
call fcn.18000aa06
mov dl, 0xe
shl ebx, 0xff
dec dword [rdi]
mov esp, dword [rcx + rdx*8 - 1]
jmp qword [rbx]
mov rcx, qword [rsp + 8]
je 0x18000a468
xchg ah, ah
jne 0x18000a468
test rdx, 0
js 0x18000984e
cmp dword [rcx], eax
call fcn.18000a9a4
imul esp, dword [rdi], 0xffff0d47
mov r15, qword [rsp + 8]
jb 0x180015db8
xchg r14, r14
jae 0x180015db8
call fcn.1800178aa
call fcn.18000953e
movsb byte [rdi], byte [rsi]
cmpsb byte [rsi], byte [rdi]
sahf
invalid

Function at 0x180012fbf
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov qword [0x1a0], rbp
call fcn.180014399
call fcn.18000fd76
invalid
movsxd r10, dword [r10]
push r10
ja 0x1800141cb
xchg dl, dl
jbe 0x1800141cb
jb 0x18000c0dc
test rax, rax
call fcn.18000f045
retf 0xa7f2
mov r10, qword [rsp + 8]
jb 0x180010822
xchg dx, dx
jae 0x180010822

Function at 0x180013059
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov r13, qword [rsp + 8]
ja 0x180013e19
xchg r14, r14
jbe 0x180013e19
test dword [rcx + rdx*8], esi
invalid
push r13
jo 0x18000c19b
nop
jno 0x18000c19b
movsxd r13, dword [r13]
jl 0x180008df4
mov cl, cl
jge 0x180008df4
jne 0x180011069
test bx, 0
call fcn.18000e92d
sub ebp, r13d
and eax, 0x8b0fffff
adc byte [0x155e93e49], al
invalid
Function at 0x180013714
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
ror dword [rax + 0x63], 0xd9
call fcn.18000aa06
push rsp
rol ecx, 1
jrcxz 0x180009dd4
invalid
call qword [rdi + 0xf]
test byte [rcx], bl
jmp 0x180009ddb
invalid
movsxd rsi, dword [rsi]
jo 0x180013f21
mov sp, sp
jno 0x180013f21
mov rsi, qword [rsp + 8]
jb 0x180009f22
mov bh, bh
jae 0x180009f22
push rsi
jb 0x180011258
xchg r8, r8
jae 0x180011258
test ebx, 0
jb 0x180009dc7
xor eax, eax
call fcn.18000dc71
mov ss, word [0x1800048c1]
pushfq
jg 0x1800091fb
xchg dh, dh
jle 0x1800091fb
mov qword [rdx], r9
mov qword [rdx + 8], r9
ret

Function at 0x1800137c8
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push rdx
jp 0x18000a737
xchg dl, dl
jnp 0x18000a737

Function at 0x180014155
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov rdi, qword [rsp + 8]
jb 0x1800118ff
xchg rdx, rdx
jae 0x1800118ff
push rdi
jg 0x18000aa28
mov ch, ch
jle 0x18000aa28
mov rcx, qword [rbx + 0x10]
lea rax, [rsp + 0x48]
call fcn.18000b645
invalid
Function at 0x1800142b1
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
pop r9
jb 0x180017bc2
xchg sp, sp
jae 0x180017bc2
sub qword [rsp + 0x10], r15
js 0x180014895
mov bh, bh
jns 0x180014895
popfq
jmp 0x1800088c1
sal bh, cl
mov byte [rax], 0
add byte [rax], al
call fcn.180012df2
pop rcx
leave
fiadd word [0x10510b298]
stosb byte [rdi], al
jnp 0x18000b29c
add byte [rdi], cl
test dword [0x17f00b360], esp
adc eax, 0x12845
call fcn.180012df2
mov r15d, 0xffff05de
test edi, 0
js 0x18000bc74
and r9d, 3
je 0x180011797
call fcn.18000c140
add cl, dh
movabs dword [0x8b49c78b4cffffe3], eax
invalid
mov edx, ebx
call qword [0x18001dd44]
test esi, 0
call fcn.1800095d0
movabs dword [0xe8c35fffff0c4fcb], eax
invalid
test dword [rdx + 0x22], ebx
add byte [rax], al
test r8b, r8b
call fcn.18001210f
add ebp, dword [rdi - 0x5b]
jrcxz 0x18000bc85
invalid
inc dword [rcx + 0x57]
je 0x180016d51
xchg al, al
jne 0x180016d51
js 0x18000b7aa
xor edx, edx
call fcn.18000f045
invalid
pushfq
je 0x180017d3b
mov si, si
jne 0x180017d3b
add qword [rsp + 0x10], r9
jl 0x180008990
mov al, al
jge 0x180008990
add qword [rsp + 0x10], r8
jp 0x18000fbf7
xchg rbx, rbx
jnp 0x18000fbf7
and qword [rsp + 0xa8], 0
lea rax, [rsp + 0xa8]
call fcn.18000b706
xor edx, esi
push rdi
adc edi, edi
dec dword [rax - 0x73]
sbb byte [r13 + r9*4 + 0x42], r8b
sbb bh, bh
adc ecx, ebx
invalid
call fcn.18000d13b
loop 0x180011812
mov bh, 0x27
invalid
add byte [rax], al
movsxd r15, dword [r15]
jo 0x18000ca4c
xchg rsp, rsp
jno 0x18000ca4c
xor eax, eax
call fcn.18001016d
movabs al, byte [0x9c49e8ffff2fccaa]
invalid
mov rax, qword [rsp + 8]
jb 0x1800146ae
mov ch, ch
jae 0x1800146ae
push rax
jl 0x180012368
mov cx, cx
jge 0x180012368
jne 0x18000b285
test rbx, rbx
movsxd rax, dword [rax]
jo 0x18000f4e2
xchg r8, r8
jno 0x18000f4e2
or edx, 0xffffffff
call fcn.18000acc7
movsb byte [rdi], byte [rsi]
add dword [rdi + 0x34], esp
invalid
popfq
je 0x180016e07
nop
jne 0x180016e07
jo 0x1800112d1
call fcn.1800137c8
or ah, byte [rbx - 0x57b]
add qword [rsp + 0x10], rax
je 0x1800141ee
xchg r9, r9
jne 0x1800141ee
and qword [rsp + 0x38], 0
call fcn.18000e92d
invalid
mov r15, qword [rsp + 8]
jb 0x180011deb
mov r11, r11
jae 0x180011deb
test si, 0
pop r15
jb 0x180015bab
mov rcx, rcx
jae 0x180015bab
je 0x180009314
mov r8d, dword [rbp - 0x48]
mov rdx, qword [rbp - 0x50]
lea rcx, [rbp - 0x30]
call fcn.18000a69e
call fcn.180014bb3
invalid
ret
xor rax, 0x25078194
jp 0x18001553d
xchg rcx, rcx
jnp 0x18001553d
mov edx, 0x40471961
mov ecx, 0x2baf21a1
call fcn.18000b015
mov qword [rbx + 0xe18], rax
call fcn.18001347b
invalid
Function at 0x180014555
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
call fcn.1800164c6
xor eax, 0xffd9d126
dec dword [rbx + rcx*4 - 0x10]
call fcn.18000bf7b
std
test byte [rcx + 0x48ffff15], dh
pop rsi
add byte [rax], al
lea rcx, [rbp - 0x50]
popfq
jl 0x180012799
mov dl, dl
jge 0x180012799
jnp 0x18001440f
test eax, eax
je 0x18000c52c
je 0x18000a34c
mov eax, 0x54f
jmp fcn.18000fa63
mov rcx, qword [rdi]
mov ebx, dword [rdi + 0x60]
call fcn.180010590
jge 0x18000c4c8
add eax, 0xfffff18
test esp, ebp
loopne 0x18000c541
invalid
invalid
xor r14, 0x2c03466b
jg 0x180012659
mov bh, bh
jle 0x180012659
test cl, 0
jb 0x180015f57
call fcn.18000f15c
enter 0xffffffffffffa878, 0xffffffffffffffc6
add qword [rsp + 0x10], r14
jb 0x18000c503
xchg sp, sp
jae 0x18000c503
jle 0x18000b84a
call fcn.180009c75
mov edi, 0xff07bd13
dec dword [rcx - 0x75]
invalid
insd dword [rdi], dx
outsd dx, dword [rsi]
invalid
mov r14, qword [rsp + 8]
jb 0x180013ce7
xchg r14, r14
jae 0x180013ce7
movsxd r14, dword [r14]
jp 0x18001746e
xchg al, al
jnp 0x18001746e
jne 0x1800128dc
lea r8d, [rsi + 1]
call fcn.180011cd8
sahf
invalid
mov eax, ecx
push r14
je 0x1800133b3
mov ax, ax
jne 0x1800133b3
invalid
mov rbx, qword [rsp + 0x30]
call fcn.180016872
mov bl, 0x5f
jp 0x180014564
invalid
mov fs, esp
invalid
pushfq
jb 0x18000ed38
mov dh, dh
jae 0x18000ed38
mov rcx, qword [rdi + 0x10]
call fcn.18000b63e
lea esp, [rax + rbx*2 + 0x49ffff25]
xor ebx, 0x18b99c5

Function at 0x180014a59
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov rcx, qword [rsp + 8]
jmp fcn.18000cfcd
mov eax, 0xc1
ret
push rcx
jl 0x180008a89
xchg sp, sp
jge 0x180008a89
jnp 0x180016268
cmp eax, 0x7b86b2ad
jne 0x1800141ba
call fcn.18000a4da
cmp bh, bl
pop rdi
sar edi, 0xff
xor r11d, r11d
call fcn.1800127c9
invalid
sal byte [rdx], cl
invalid

Function at 0x180014e0d
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push rcx
jmp 0x180015fe3
mov rcx, qword [rsp + 8]
jp 0x18000f16c
mov r10, r10
jnp 0x18000f16c

Function at 0x180014ee9
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov r9, qword [rsp + 8]
jb 0x1800160d1
xchg r15, r15
jae 0x1800160d1
push r9
jb 0x18000ca28
xchg r12, r12
jae 0x18000ca28

Function at 0x180015768
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
add cl, byte [rbx + rcx*4 - 0x2f]
lea rdx, [rsp + 0x60]
mov rcx, rdi
call qword [0x18001dd2c]
call fcn.1800095d0
lodsb al, byte [rsi]
or al, 0xff
invalid
push r11
je 0x1800120ae
mov r14, r14
jne 0x1800120ae
jg 0x18000d926
jmp 0x18000f057

Function at 0x180015dfb
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov rax, qword [rsp + 8]
jmp fcn.1800133f2
push rax
jb 0x1800126b0
xchg r8, r8
jae 0x1800126b0
mov eax, r9d
mov ecx, r9d
call fcn.18000bf7b
mov edx, 0xff15b1ba
inc dword [rcx - 0x48]
hlt

Function at 0x180015ec0
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push r14
js 0x18000f28a
mov si, si
jns 0x18000f28a
Function at 0x180015f28
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push rbx
jb 0x1800114d7
xchg r9, r9
jae 0x1800114d7
test rcx, rcx

Function at 0x1800162b0
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov rbp, qword [rsp + 8]
jmp 0x18001701c
push rbp
js 0x18000f102
mov dx, dx
jns 0x18000f102

Function at 0x1800162c1
Capabilities:
Resolve function by parsing pe exports

Disassembly:
push rcx
jb 0x18001512e
mov al, al
jae 0x18001512e
sub qword [rsp + 0x10], r10

Function at 0x180016690
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov rcx, qword [rsp + 8]
jb 0x18000ee67
mov rbp, rbp
jae 0x18000ee67
pop rbx
ret
push rcx
je 0x180014134
mov di, di
jne 0x180014134

Function at 0x180016929
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
movsxd rcx, dword [rcx]
ja 0x1800115ef
xchg rdi, rdi
mov rcx, qword [rsp + 8]
jp 0x18000e629
nop
jnp 0x18000e629
mov dword [rsp + 0x40], edx
lea edx, [r8 - 4]
call fcn.1800096b0
mov bh, 0xb0
jmp fcn.18000f26f
push rcx
js 0x18000f22b
mov rsp, rsp
jns 0x18000f22b
and qword [rsp + 0x30], 0
call fcn.180009cdd
pop rdx
scasd eax, dword [rdi]
xchg dword [rax], edx
invalid

Function at 0x180016faa
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov rcx, qword [rcx + 0x10]
lea rax, [rsp + 0x40]
lea r9, [rsp + 0x48]
call fcn.180014925
push rsi
mov edx, 0xfffffec
test dl, ah
add byte [r8], al
call fcn.18000c1af
cmp qword [rbx + 0x66ffff01], rcx
pushfq
jp 0x180012501
xchg rbp, rbp
jnp 0x180012501
call fcn.1800178aa
test rdi, 0
call fcn.18000daf1
add ebp, dword [rdi]
rcr bh, cl
invalid
jnp 0x180015919
cmp r8d, 4
jae 0x180009d39
xor dword [rax + 0xfffffcb], 0xffffff83
scasd eax, dword [rdi]
and eax, dword [rax]
add al, ch
xor edx, 0xffffffff
push qword [rdi]
jrcxz 0x18000d179
jae 0x18000f53e
call fcn.18000c417
invalid
jmp 0x1a949d19b
test di, 0
js 0x180017e19
xor edx, edx
call fcn.180016faa
sbb eax, 0xffeb7215
inc dword [rbp - 0x597af040]
add byte [rax], al
call fcn.1800162b0
push rsi
stosd dword [rdi], eax
ror byte [rax - 0x75], 1
pop rsp
and al, 0x30
call fcn.180017632
out dx, eax
cmp ebx, dword [rax]
invalid
movsxd rax, dword [rax]
jb 0x18000a2f6
nop
jae 0x18000a2f6
call fcn.18000ba58
dec rsi
jne 0x18000dc9d
call fcn.180017985
invalid
mov rax, qword [rsp + 8]
jp 0x18000f858
mov r8, r8
jnp 0x18000f858
adc eax, 0x7a46
mov rcx, rdi
call fcn.1800178aa
push rax
jo 0x180014df9
xchg r11, r11
jno 0x180014df9
jne 0x18000d184
sub rsp, 0x40
movsxd rsi, dword [rcx + 0x18]
mov rbx, rcx
mov r12d, edx
call fcn.18000b645
insd dword [rdi], dx
add rdi, r15
call [rdi + rcx - 0x889776]
dec dword [rbp - 0x79]
ror byte [rdi], cl
mov ebx, dword [rdi + 0x77]
invalid
idiv dword [rax + 0x258effff]
pop rbp
out dx, al
invalid