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

Disassembly:
movsxd rcx, dword [rcx]
jl 0x18000e542
mov rbx, rbx
jge 0x18000e542
je 0x180016c29
je 0x180014581
push r15
jg 0x18000f42b
xchg rbx, rbx
jle 0x18000f42b
mov rcx, qword [rsp + 8]
jl 0x1800090c5
xchg rdx, rdx
jge 0x1800090c5
xor edx, dword [rbp - 0x35]
test r15, 0
jb 0x18000f3f9
xor edx, 0x97b6e293
call fcn.180016f64
test dl, 0
jne 0x18000f7b6
test eax, eax
jne 0x1800170c9
lea edx, [rbp + rax*2 + 0x130]
call fcn.1800123b1
call fcn.18000b63e
loopne 0x18000f3b4
invalid
mov r15, qword [rsp + 8]
jo 0x180016507
xchg bp, bp
jno 0x180016507
lea rdx, [0x18000d732]
mov r9, r14
mov rax, qword [rax + 0x10]
call fcn.18000b63e
invalid
add ecx, dword [rax - 9]
ret 0
movsxd r15, dword [r15]
jmp fcn.180013b2f
call fcn.180012df2
xchg ebp, eax
cld
fiadd word [0x1774b6c35]
invalid

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

Disassembly:
push rbx
jb 0x18000abad
mov r10, r10
jae 0x18000abad
mov r8d, 0xd6237658
call fcn.180008b0d
call fcn.18000f97c
loop 0x180009937
add rdi, r15
inc dword [rbp - 0x73]
and al, 0
call fcn.180009934
invalid
nop
add byte [rax], al
mov rbx, qword [rsp + 8]
js 0x180011397
mov r10, r10
jns 0x180011397
lea rdx, [rbp + 0x20]
test bh, 0
call fcn.18000d63a
push rsp
int3
Function at 0x1800099da
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push r8
js 0x18000aa3c
mov r15, r15
jns 0x18000aa3c
mov rdi, qword [r11 + 0x20]
mov rsp, r11
pop rbp
call fcn.180014a59
int 0x42
call 0x1094999ff
js 0x180009a22
push r12
test r8, 0
call fcn.180013059
mov cl, 0xca
js 0x1800099e5
invalid
mov r8, qword [rsp + 8]
je 0x1800106fb
mov r11, r11
jne 0x1800106fb
movsxd r8, dword [r8]
jmp 0x180010fe9
pushfq
jb 0x18000e8c7
xchg r12, r12
jae 0x18000e8c7

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

Disassembly:
push r8
jmp 0x18000c255
mov r8, qword [rsp + 8]
js 0x180010604
xchg rbx, rbx
jns 0x180010604
sub rsp, 0x650
mov r12, rdx
lea rdx, [rsp + 0x20]
mov r8d, 0x104
mov rbx, rcx
call qword [0x18001d7a1]
call fcn.1800127c9
ja 0x18000c2f7
jg 0x18000c2b7
invalid
mov bp, bp
jbe 0x18000e78c
pushfq
jo 0x180016644
mov r14, r14
jno 0x180016644
jo 0x180012bcb
call fcn.18000a8af
add bl, byte [rbx]
invalid
movsxd r8, dword [r8]
jl 0x1800161aa
xchg dh, dh
jge 0x1800161aa
xor rbx, 0x3551cb6a
ja 0x180011f70
nop
jbe 0x180011f70

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

Disassembly:
push r15
ja 0x18000ecc1
xchg rcx, rcx
jbe 0x18000ecc1
mov r15, qword [rsp + 8]

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

Disassembly:
invalid
sub qword [rsp + 0x10], r10
js 0x180017af4
xchg r14, r14
jns 0x180017af4
jb 0x180008ebb
xor r9d, r9d
call fcn.1800127c9
add dl, byte [rbx - 0xd881]
lea edx, [rbp + rbp]
call fcn.18000db23
mov edx, 0xff28a15c
dec dword [rax - 0x7f]
jmp 0x18026e2e2
push r10
jo 0x1800169c2
mov cl, cl
jno 0x1800169c2
call qword [0x18001d80f]
test cl, 0
call fcn.1800119dc
invalid
add r10, 0x3e9ffa96
jg 0x18000a193
xchg al, al
jle 0x18000a193
pushfq
jb 0x18000b344
nop
jae 0x18000b344
lea ecx, [rsp + 0x20]
call fcn.180013d0d
call fcn.18000e90d
jp 0x18000ed5f
mov ah, 0
invalid
invalid
pop r10
jl 0x180010ba5
xchg rsp, rsp
jge 0x180010ba5
movsxd r10, dword [r10]
jb 0x18000c6c6
mov r13, r13
jae 0x18000c6c6
ret
test dword [rdx + 0xf000051], esi
test dword [rdi], esi
or eax, 0x8b490000
int3
mov r10, qword [rsp + 8]
jmp 0x180010615
popfq
jo 0x18000f30d
xchg rsp, rsp
jno 0x18000f30d
ja 0x180010cd6
test rdi, 0
jb 0x18000ed1d
and r8b, 0xdf
Function at 0x18000a66b
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
pop r11
jmp 0x180009358
ret
push r11
ja 0x180015a66
nop
jbe 0x180015a66
test byte [rdi + rax + 0x19b6e86d], 0
add byte [rdx - 0xdd715d], al
dec dword [rax - 0x77]
pop rbp
mov al, pe_nt_image_headers64
mov bl, 0x98
add byte [rax], al
or ah, ah
call 0x17749b1ad
mov dword [rax], 0xf000000
xor byte [rbp - 0x17ffffa6], 0xa
xchg byte [rax], al
add byte [rdx - 0x57a15], bl
dec dword [rcx - 9]
ret
pushfq
jp 0x180010cef
xchg cl, cl
jnp 0x180010cef
popfq
ja 0x1800088ba
xchg dl, dl
jbe 0x1800088ba
movsxd rcx, dword [rcx]
jb 0x180010687
mov r12, r12
jae 0x180010687
push rcx
call fcn.180017c94
xor dl, 0x18
invalid
sub r11, 0x63f7577
jb 0x18001681c
mov bl, bl
jae 0x18001681c
jmp fcn.18000f1f9
mov r11, qword [rsp + 8]
jb 0x18001737d
mov di, di
jae 0x18001737d
add eax, 0xb1000000
mov r8d, edi
mov rcx, rbx
call fcn.180015dfb
clc
invalid
add qword [rsp + 0x10], r11
jb 0x1800109d5
xchg r15, r15
jae 0x1800109d5
test r8, 0
jo 0x18000b18e
and rdi, rax
movsxd r11, dword [r11]
je 0x18000e8fe
xchg rbp, rbp
jne 0x18000e8fe
test ebx, 0
call fcn.180016929
sal eax, cl
test dword [rdi], ecx
invalid

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

Disassembly:
push rdx
jb 0x180016631
xchg si, si
jae 0x180016631
mov rsi, qword [r11 + 0x38]
call fcn.18000e92d
lahf
or esi, ebp
and eax, 0x8948ffff
pop rsp
and al, 8
push rdi
mov ecx, dword [rdi + 0x10]
movsxd rdx, dword [rdx]
jl 0x18000f6ef
xchg rsp, rsp
jge 0x18000f6ef
jo 0x18000bf3d
xor eax, eax
jmp 0x18001223e
mov rdx, qword [rsp + 8]
jl 0x180010bd2
xchg ah, ah
jge 0x180010bd2

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

Disassembly:
push r13
jg 0x180016360
mov r10, r10
jle 0x180016360

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

Disassembly:
push r13
jp 0x180013701
mov ah, ah
jnp 0x180013701
mov r13, qword [rsp + 8]
jb 0x18001724d
xchg ch, ch
jae 0x18001724d
movsxd r13, dword [r13]
je 0x18000dab9
xchg rsp, rsp
jne 0x18000dab9
mov r11d, dword [rsi]
lea eax, [r11 - 4]
mov dword [rsi + 8], eax
test bh, 0
call fcn.18000acc7
pop rsi
invalid
Function at 0x18000ad8c
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
add r10, 0x1ded397
jp 0x1800162d0
mov si, si
jnp 0x1800162d0
jne 0x18000b139
add ax, 0x61
jmp 0x18000af14
push r10
jb 0x18000baa6
mov bp, bp
jae 0x18000baa6
mov word [r9 + r8*2], ax
test ah, 0
call fcn.180017632
sti
scasd eax, dword [rdi]
cmp ebx, dword [rax]
invalid
mov r10, qword [rsp + 8]
jb 0x18000dcc8
xchg r9, r9
jae 0x18000dcc8
call qword [0x18001dd4c]
lea rdx, [rbp + 0x28]
lea rcx, [rbp - 0x30]
mov r8d, r13d
mov dword [rbp + 0x28], eax
call fcn.18000a69e
lea rcx, [rbp - 0x30]
call fcn.180009f82
call fcn.180014e13
sub al, 0x51
lodsd eax, dword [rsi]
sbb edi, edi
dec dword [rax + 0x63]
fdiv st(6)
mov dword [rax], 0xcb5850f
add byte [rax], al
add rbx, rbx
call fcn.18000ad8c
sbb byte [rbx - 0x1e0], ch
jb 0x18000c0ce
call fcn.18000d13b
wait
sbb eax, 0xffff27b7
test eax, eax
movsxd r10, dword [r10]
jb 0x180013ac1
xchg bl, bl
jae 0x180013ac1
lea r9, [rsp + 0x30]
mov r8d, edi
mov edx, edi
call fcn.18000c933
pop rax
or al, 0x17
and bh, bh
dec dword [rdi]
test esp, esi
sar bh, 0xff
jne 0x180011a14
call fcn.1800137c8
in eax, 0x89
jp 0x18000dd08
invalid
sbb bh, bh
enter 0x2ae8, 0xfffffffffffffff9
invalid
add esp, 0x20
pushfq
jo 0x180009014
nop
jno 0x180009014
call fcn.18000a69e
lea rcx, [rbp - 0x30]
call fcn.1800139ea
lea r11, [rsp + 0x70]
call fcn.1800094d8
push 0x1f
invalid

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

Disassembly:
push rbp
jb 0x1800166a0
nop
jae 0x1800166a0
call fcn.18000bfbd
call fcn.18000b5f2
movabs al, byte [0x21a1b9ffffdf689c]
scasd eax, dword [rdi]
sub ecx, dword [rcx - 0x75]
call 0x180022388
add byte [rax - 0x75], cl
call fcn.180017632
mov ecx, 0x850f0000
popfq
add byte cs:[rax], al
call fcn.1800151fb
imul eax, edi, 0xfffffffa
in eax, 0xff
push qword [rbx]
dec dword [rax - 0x73]
and al, 0x40
call fcn.1800119dc
xchg esp, eax
invalid
xor rbp, 0x2268da07
jo 0x18001167c
mov rsi, rsi
jno 0x18001167c
jne 0x18000dbfc
test eax, eax
call fcn.18000b742
je 0x18000b124
invalid
add qword [rsp + 0x10], rbp
jp 0x18001333f
mov rsp, rsp
jnp 0x18001333f
test r9d, r9d
call fcn.180012df2
cmpsd dword [rsi], dword [rdi]
invalid
pushfq
jp 0x18000b15e
mov si, si
jnp 0x18000b15e
xor edx, edx
mov al, byte [rcx]
call fcn.1800107fb
adc byte [rcx], 1
cmp eax, 0x8948ffff
mov word [rax + rcx*4], fs
add dword [rax], eax
add al, ch
adc al, byte [rax]
add dh, bh
sti
mov ch, 0x17
invalid
popfq
jo 0x180016b44
mov rsp, rsp
jno 0x180016b44
movsxd rbp, dword [rbp]
jo 0x180012ec3
mov r11, r11
jno 0x180012ec3
mov rbp, qword [rsp + 8]
jp 0x180014912
xchg dl, dl
jnp 0x180014912

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

Disassembly:
push rax
jl 0x180009000
mov al, al
jge 0x180009000
test r13, 0
jne 0x18000bc3b
call fcn.18000a66b
or ecx, dword [rcx]
invalid
Function at 0x18000b5f2
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push r14
jmp 0x180017066
mov ecx, ebx
mul r11d
call fcn.18000cd9e
ror edx, 0x10
invalid
movsxd r14, dword [r14]
jo 0x180016d00
xchg dh, dh
jno 0x180016d00
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
push r12
push r13
test di, 0
js 0x18000fbd5
sub rsp, 0x20
mov rsi, rcx
mov rcx, rdx
call fcn.180009cdd
invalid
mov r14, qword [rsp + 8]
je 0x180013845
mov dl, dl
jne 0x180013845

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

Disassembly:
xor eax, 0x8c00003d
mov ah, 0x16
out dx, al
invalid
mov rbx, qword [rsp + 8]
js 0x180012fe3
xchg r13, r13
jns 0x180012fe3
push rbx
jmp 0x18000a657
xchg dword [rcx + rbx*4], eax
add byte [rax], al
ror byte [rax - 0x75], cl
enter 0x69e8, 0x19
add byte [rax], al
push rdi
add byte [rax], al
lea rdx, [rbp + 0x130]
mov ecx, 0x104
call fcn.180011cd8
xchg rsi, rax
retf 0xff14
add rbx, 0x1298283c
ja 0x180009f44
mov bh, bh
jbe 0x180009f44
jb 0x180013974
sub rsp, 0x20
movsxd rax, dword [rcx + 0x18]
test ax, 0
js 0x180010e73
xor r14d, r14d
mov rsi, rcx
mov rcx, qword [rcx + 0x10]
lea r15d, [r14 + 0x5c]
test ebx, 0
jnp 0x180009149
or rbx, 0xffffffffffffffff
mov rbp, rdx
test rsi, 0
jb 0x18000d274
call fcn.18000bfb7
rcl dword [rsi], cl
or dh, bh
invalid
movsxd rbx, dword [rbx]
jb 0x180017138
mov sp, sp
jae 0x180017138
mov edx, dword [r14 + rax*4]
test edx, 0
jne 0x18000bcf7
call fcn.1800094d8
in al, dx
sub ecx, dword [rsi + 0x1f]
invalid
lea ecx, [rsp + 0x20]
pushfq
jmp 0x180012d6b

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

Disassembly:
push rbx
jb 0x180011ea4
xchg rcx, rcx
jae 0x180011ea4
mov rbx, qword [rsp + 8]
js 0x1800138e1

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

Disassembly:
or al, 0x28
test edx, 0
jnp 0x1800143c2
cmp ecx, dword [rsi + 4]
jbe 0x180011191
jbe 0x18000c348
mov eax, dword [rsi]
lea edx, [rax + rax]
call fcn.18000953e
invalid
push r13
jg 0x18000bcda
mov rdx, rdx
jle 0x18000bcda
mov rcx, qword [rsp + 0x118]
call qword [0x18001db0c]
mov r13, qword [rsp + 8]
jg 0x180010635
mov al, al
jle 0x180010635
jb 0x18000a5cd
cmp rsi, rbx
ja 0x180015600
ja 0x180014089
mov rcx, r12
call fcn.180013714
invalid
test dword [rax], ebx
test eax, 0xf7480000
ret
mov edi, dword [rsi + 8]
test bh, 0
js 0x180015f5d
call fcn.180015dfb
add ebx, edi
cdq
sub edi, edi
call [rdi + rcx - 0x7ef574]
call qword [rax - 0x7efc72f1]
invalid
test ebx, 0x9ee80000
pop rdi
invalid
call fcn.18000bfb7
invalid
mov ss, word [rdx + rdx*2 - 0x3a090001]
add al, ch
or al, 0x9e
invalid
Function at 0x18000c140
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
add rdx, 0x1e7c312
je 0x18000998a
xchg bp, bp
jne 0x18000998a
test bh, 0
jb 0x18000ca0a
test eax, eax
call fcn.180014e0d
mov edx, 0xff148a9e
invalid
popfq
ja 0x180014ae3
mov cx, cx
jbe 0x180014ae3
inc rdi
call fcn.1800088aa
invalid
sub qword [rsp + 0x10], rdx
jmp 0x18000d4a3
ret
push rbx
jmp 0x18000e01a
xor rbx, 0x1c5c29bb
js 0x1800129d8
xchg rdi, rdi
jns 0x1800129d8
invalid
movsxd rdx, dword [rdx]
jmp 0x1800157f8
popfq
jp 0x180014934
xchg bh, bh
jnp 0x180014934
mov rcx, rsi
call fcn.180014bee
call fcn.18000e699
mov eax, 0xff13591b
call [rdi + rcx + 0x52b88a]
add byte [rsi - 0x79], ah
fisttp dword [rdi]
mov ebp, dword [rdi + 0x44000052]
mov eax, dword [rbp - 0x48]
mov rdx, qword [rsp + 8]
ja 0x18000d044
xchg si, si
jbe 0x18000d044
mov rbx, qword [rsp + 8]
jp 0x1800105b0
mov cx, cx
jnp 0x1800105b0
mov rax, qword [rsp + 0x18]
call fcn.180009cdd
str word [rax - 0x170000f0]
jl 0x18000e090
add byte [rax], al
stc
sbb al, 0x19
add al, 0xff
invalid
call qword [rdx + 0xf]
mov byte [0x1c900e090], cl
xchg edx, edx
jns 0x18000d7a5
call rax
mov rcx, qword [rsi]
test dx, 0
call fcn.18000e91d
lodsb al, byte [rsi]
mov dl, 0x71
invalid
call fcn.18000a4da
invalid
movsxd rbx, dword [rbx]
jmp 0x1800151ad
sub qword [rsp + 0x10], rbx
jmp 0x1800094f7
pop rbx
jo 0x18000af08
xchg al, al
jno 0x18000af08
pushfq
jl 0x18000c9cf
mov al, al
jge 0x18000c9cf
je 0x18000f070
call fcn.1800107fb
jrcxz 0x1800151d9
add dword [0x10b4a51ce], edi
invalid
invalid
pushfq
jmp 0x180008d9c

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

Disassembly:
mov r11, qword [rsp + 8]
jb 0x18000b02c
xchg bl, bl
jae 0x18000b02c
push r11
je 0x18000b379
xchg ch, ch
jne 0x18000b379
Function at 0x18000c66e
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
add qword [rsp + 0x10], rsi
je 0x18000e3c8
xchg rbx, rbx
jne 0x18000e3c8
sub r8b, r13b
retf
mov dword [rdi + 0x10], eax
push rsi
ja 0x1800117e6
mov al, al
jbe 0x1800117e6
test si, 0
jb 0x18000dde4
call fcn.18000ece9
pop rsp
and dword [0x14400c5b7], edi
mov qword [rsp + 8], rbx
push rdi
test ah, 0
jb 0x18000bf39
sub rsp, 0x250
call fcn.180017621
fcom qword [rsi]
mov edx, ecx
invalid
iretd
popfq
jb 0x1800122fe
mov rdx, rdx
jae 0x1800122fe
mov dword [rax + 0x18], edi
xor rsi, 0x243600d3
jl 0x18000b14a
xchg dx, dx
jge 0x18000b14a
mov rcx, qword [rdi]
test dh, 0
jb 0x18001072c
or edx, 0xffffffff
call qword [0x18001da41]
mov rsi, qword [rsp + 8]
jb 0x180012b68
mov rax, rax
jae 0x180012b68
mov eax, dword [rsp + 0x30]
call fcn.18000a8af
push 0x71
add eax, 0x4cffffc4
add dword [rsp + 0x10], esi
add al, ch
add eax, dword [rax]
add ah, dl
outsd dx, dword [rsi]
sub eax, 0x4851ffff
lea ecx, [0x18001d2e5]
jmp fcn.18000f1f9
push rax
mov ah, 0xfc
invalid
pop rsi
je 0x180014f7b
xchg dh, dh
jne 0x180014f7b
test r9, 0
jne 0x18001532a
sub r9, r10
mov r8, r10
call fcn.18000a369
js 0x1800122b8
xor al, 0xff
dec dword [rax - 0x57]
add byte [rax], al
add byte [rax], al
jnp 0x18001540d
xor r9d, r9d
test bx, 0
jnp 0x18000ce65
xor r8d, r8d
call fcn.1800099da
jrcxz 0x1800122d6
or al, cl
invalid
pushfq
jb 0x180011466
mov rbx, rbx
jae 0x180011466
mov qword [rax + 8], rbx
mov qword [rax + 0x10], rbp
mov qword [rax + 0x18], rsi
mov qword [rax + 0x20], rdi
push r12
test rdx, 0
jb 0x18000bacc
call fcn.18000c933
invalid
movsxd rsi, dword [rsi]
jb 0x180012b03
xchg rcx, rcx
jae 0x180012b03
ret
mov esi, dword [rbx + 0x18]
mov rdi, qword [r11 + 0x20]
call fcn.18000ad8c
sub al, 0x68
and esi, edi
invalid
xchg ebp, eax
fcomp qword [rbx]

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

Disassembly:
push r9
jb 0x180008abf
mov dh, dh
jae 0x180008abf

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

Disassembly:
push r9
jl 0x180016eb3
mov dx, dx
jge 0x180016eb3
test si, 0
call fcn.180016690
lodsb al, byte [rsi]
rol byte [rdx], 0xc3
invalid
mov r9, qword [rsp + 8]

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

Disassembly:
mov rdx, qword [rsp + 8]
push rdx
je 0x18000943d
xchg dl, dl
jne 0x18000943d
xor r9d, r9d
mov r8, rcx
call int.18000b044
xchg edi, eax
adc edx, dword [rdi - 0x3c0000c6]
Function at 0x18000cb4d
Capabilities:
Check os version
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov byte [rax], ch
mov byte [rax], 0
call fcn.180014a59
in al, 0x6c
call 0x1ebe98d7b
lodsb al, byte [rsi]
add byte [rax], al
test rsi, 0
call fcn.180014e13
div byte [rbp*4 - 0x170000e7]
mov bh, 0x3d
add byte [rax], al
push 0xffffffffff228e5d
dec dword [rax - 0x7f]
ret 0xc312
movsxd rax, dword [rax]
jp 0x1800134bd
xchg dl, dl
jnp 0x1800134bd
sbb al, 0x7e
add byte [rax], al
call fcn.18001752a
invalid
movsxd rax, edi
mov rdi, qword [rsp + 0x18]
call fcn.180009c75
rol qword [rdx - 8], 0xff
dec dword [rax + 1]
and al, 0x10
add qword [rsp + 0x10], rax
jo 0x180016e8c
nop
jno 0x180016e8c
neg eax
test r9, 0
jne 0x18000c1cf
call fcn.180010c97
mov gs, word [rsi - 0xab]
add r8, 0x351aa126
ja 0x180011f1f
xchg al, al
jbe 0x180011f1f
js 0x18000a172
call fcn.180016872
mov edx, 0xfffff07b
pushfq
jg 0x18000d300
xchg rsp, rsp
jle 0x18000d300
mov dword [rax + 8], ebx
mov qword [rax + 0x10], rsi
mov qword [rax + 0x18], rdi
call fcn.18000b5f2
invalid
ret
mov ecx, dword [rdi + rbx*8]
push rax
je 0x1800169eb
mov rsp, rsp
jne 0x1800169eb
test edx, 0
jb 0x180012a70
xor al, 0x3f
test cl, 0
jne 0x180008ed1
test dword [rbp - 0x3d], ebx
invalid
call fcn.18000c8a5
scasd eax, dword [rdi]
test dword [rbp + 0x33ffff25], esp
shr al, 0xc2
clc
invalid
add r11, 0x3357bf70
ja 0x180010a3e
xchg cx, cx
jbe 0x180010a3e
sub qword [rsp + 0x10], r8
jo 0x180015f46
mov r10, r10
jno 0x180015f46
mov dword [rbp + 0x38], 0xedd
mov qword [rsp + 0x20], rax
call fcn.18000f045
xor byte [rdx - 0x59], 0x13
invalid
sbb dh, bh
invalid
sub rax, 0x228e09a4
jg 0x18000ac53
xchg bp, bp
jle 0x18000ac53
mov r11, qword [rsp + 8]
jg 0x180017bdb
xchg bx, bx
jle 0x180017bdb
js 0x18000a591
call fcn.1800127c9
js 0x180011fa0
and byte [rdi], 0xff
dec dword [rdi]
invalid
test bx, 0
jne 0x180008d6a
call fcn.1800096f3
jrcxz 0x1800125b5
movsd dword [rdi], dword [rsi]
invalid
push qword [rbp - 0x6b]
nop
xor al, 0xff
invalid
test eax, 0
pushfq
je 0x180011fb8
xchg rsi, rsi
jne 0x180011fb8
mov rdx, qword [rsp + 0x50]
call fcn.18000b706
mov dh, pe_nt_image_headers64
push rdi
adc edi, edi
dec dword [rax - 0x77]
and al, 0x48
call fcn.18000e699
push rdi
cmp eax, 0xffffeca6
je 0x180014a26
call fcn.18000bfb7
and byte [rdi + 0xa], ah
idiv edi
dec dword [rax - 9]
mov byte [rax], 0
add byte [rax], al
call fcn.180016872
xchg esi, eax
invalid
mov ebp, dword [rsp + 0x58]
call fcn.180015dfb
mov ah, 0x91
cdq
sub edi, edi
call [rcx + 0xf]
invalid
popfq
jp 0x18000fc07
mov rdx, rdx
jnp 0x18000fc07
jle 0x18000ac40
jle 0x18000b1f6
test ch, 0
call fcn.18000fd76
mov eax, 0xff247b8c
dec dword [rax - 0x7f]
rol edi, 0xb8
std
cmp al, 0xf
test byte [rbx + 0x4d000014], ch
mov ecx, ecx
mov rax, qword [rsp + 8]
jg 0x180009923
mov rsp, rsp
jle 0x180009923
popfq
jo 0x180010a85
mov ax, ax
jno 0x180010a85
movsxd r11, dword [r11]
jb 0x18000af7f
mov r9, r9
jae 0x18000af7f
pop r12
call fcn.180015f28
sub eax, 0xffcc7eb4
call [rcx + 0xf]
mov bl, bl
cmp edi, edi
dec dword [rax - 0x75]
leave
jnp 0x18000b7dc
jge 0x180012593
jge 0x18000cb6f
mov eax, dword [rsp + 0x10]
call fcn.1800137c8
fnstcw word [rcx - 0x57b]
Function at 0x18000d63a
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push r12
jg 0x18000cc51
mov bh, bh
jle 0x18000cc51
test bx, 0
call fcn.1800162b0
or al, 5
cmp edx, dword [0x18149d65b]
push rsp
and al, 0x10
jg 0x1800110ab
xchg dl, dl
jle 0x1800110ab
popfq
jo 0x18001713e
mov rdx, rdx

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

Disassembly:
push r15
jb 0x18000ea68
mov r8, r8
jae 0x18000ea68
jne 0x180012120
call fcn.180008951
adc ebp, dword [rax]
imul esi, ebx, 0x8b48ffff
pop rsp
and al, 0x30
call fcn.180010ecd
sbb byte [rbp - 0x36dc], bl
mov eax, dword [rsp + 0x48]

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

Disassembly:
pushfq
je 0x18000e3bc
mov r13, r13
jne 0x18000e3bc
pop rcx
jo 0x18000a467
mov sp, sp
jno 0x18000a467
movsxd rcx, dword [rcx]
js 0x180008e71
xchg r14, r14
jns 0x180008e71
movsxd r13, dword [rbx + 0x3c]
test rbx, 0
call fcn.18000f15c
invalid
ret
test edx, 0
push rcx
js 0x180016785
xchg sp, sp
jns 0x180016785
mov dword [rdi], ebx
test r14, 0
jb 0x180017847
call fcn.18000b742
push rbp
invalid
test rsi, 0
call fcn.18000fe42
invalid
mov ecx, dword [rsp]
movsxd rcx, dword [rcx]
jo 0x180017c4f
mov cl, cl
jno 0x180017c4f
mov ecx, edx
lea r11d, [rcx + rbx]
mov eax, r10d
test al, 0
jb 0x180016be1
xor esi, esi
call fcn.18000f4af
test dword [rdi + 0x51], ecx
invalid
mov rcx, qword [rsp + 8]
jo 0x180009ee1
xchg r10, r10
jno 0x180009ee1
test cl, 0
js 0x180013bc9
add rsp, 0x20
pop rdi
call fcn.18000b68d
cmpsb byte [rsi], byte [rdi]
shl byte [rdi - 0x13], 0xff
dec dword [rax - 0x75]
and al, 8
ja 0x1800134ab
xchg al, al
jbe 0x1800134ab
test edx, 0
call fcn.1800096b0
stc
invalid
test edi, 0
mov esp, dword [0x177ed784c]
adc dword [rdi + rdi*8], edx
dec dword [rax - 0x7b]
leave
je 0x18001030e
je 0x18000d87b
call fcn.1800178aa
test dx, 0
js 0x18001199f
call fcn.18000b68d
pop rdx
in eax, dx
invalid
pushfq
je 0x1800109bf
mov si, si
jne 0x1800109bf

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

Disassembly:
movsxd r8, dword [r8]
jmp 0x18000b55f
pushfq
jb 0x18000fac2
xchg rdi, rdi
jae 0x18000fac2
jo fcn.180011a19
sub rsp, 0x20
mov ebx, edx
mov rdi, rcx
test rsi, 0
jo 0x1800122a3
mov esi, dword [rbx + 0x18]
push r8
jp 0x180011fa4
xchg dl, dl
jnp 0x180011fa4
mov ecx, 0x68
call fcn.1800178af
test r14, 0
call fcn.180015a55
or eax, 0xff05716a
jmp qword [rsi - 9]
xor r8, 0x11842511
js 0x18000f505
xchg ah, ah
jns 0x18000f505
ret
mov r8, qword [rsp + 8]
ja 0x18000ad73
xchg rbx, rbx
jbe 0x18000ad73
test edx, 0
jo 0x18000da53
and qword [rbp - 0x50], 0

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

Disassembly:
push r9
jb 0x18001352f
mov rbp, rbp
jae 0x18001352f
mov r9, qword [rsp + 8]
jp 0x1800178d4
xchg dl, dl
jnp 0x1800178d4

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

Disassembly:
push rdi
jg 0x1800101f7
mov r12, r12
jle 0x1800101f7
mov rdi, qword [rsp + 8]