joyce8/EMBER2024-capa huggingface dataset:
Function at 0x44d89c
Capabilities:
Get number of processors

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x472754
mov eax, dword fs:[0]
push eax
push ecx
push esi
push edi
mov eax, dword [0x4a2008]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov esi, ecx
mov dword [ebp - 0x10], esi
xorps xmm0, xmm0
push 1
movups xmmword [esi], xmm0
push 0x48f868
mov dword [esi + 0x10], 0
mov dword [esi + 0x14], 0
call fcn.00480d8c
mov dword [ebp - 4], 0
mov dword [esi + 0x18], 0
mov dword [esi + 0x1c], 0
mov dword [esi + 0x20], 0
mov byte [ebp - 4], 1
mov dword [esi + 0x24], 0
mov dword [esi + 0x28], 0
mov dword [esi + 0x2c], 0
mov byte [ebp - 4], 2
mov dword [esi + 0x30], 0
mov dword [esi + 0x34], 0
mov dword [esi + 0x38], 0
mov byte [ebp - 4], 3
mov dword [esi + 0x3c], 0
mov dword [esi + 0x40], 0
mov dword [esi + 0x44], 0
mov byte [ebp - 4], 4
mov dword [esi + 0x48], 0
mov dword [esi + 0x4c], 0
mov dword [esi + 0x50], 0
mov byte [ebp - 4], 5
mov ecx, dword [0x4a2a48]
mov eax, dword [0x4a2a4c]
add ecx, 1
mov dword [esi + 0x58], 0
mov dword [esi + 0x5c], 0
adc eax, 0
mov dword [esi + 0x60], 0
mov dword [esi + 0x64], 0
mov dword [0x4a2a4c], eax
mov dword [esi + 0x6c], eax
mov dword [esi + 0x68], ecx
mov eax, dword [esi + 0x20]
sub eax, dword [esi + 0x18]
sar eax, 3
mov dword [0x4a2a48], ecx
cmp eax, 0x64
jae 0x44d9bf
push ecx
lea ecx, [esi + 0x18]
call fcn.0046d0bc
mov eax, dword [esi + 0x2c]
sub eax, dword [esi + 0x24]
sar eax, 3
cmp eax, 0x14
jae 0x44d9d6
push ecx
lea ecx, [esi + 0x24]
call fcn.0046cfcc
mov dword [ebp - 4], 0xffffffff
mov eax, esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
mov esp, ebp
pop ebp
ret

Function at 0x453320
Capabilities:
Encode data using xor

Disassembly:
xchg byte [edi - 0x57], bh
ret
test eax, 0x9ba38cc3
mov edi, 0xe45b017e
inc ebp
in al, 0x45
stc
salc
dec ebx
in eax, dx
pushal
mov dl, 0xa9
das
clc
adc ebp, dword [edi - 0x3e]
xchg ebx, eax
jb 0x4532a5
ret 0x58ff
xchg byte [eax], dl
scasb al, byte es:[edi]
jno 0x4532b0
je 0x4532a7
sub al, 0x19
add al, 0x21
sal byte [ebx + 0x3ea71dce], 1
popal
test byte [ebx], cl
js 0x4532ec
test edx, edi
clc
or ah, byte [edx - 0x20]
adc ecx, esi
outsd dx, dword [esi]
xchg edx, eax
push ebp
in al, dx
lds esi, [ecx]
invalid
xchg dword [eax - 0x74], esp
mov word [esi + ebx*2 - 0x6d3401c4], ds
mov ah, 0xd2
add dword [ebp - 0x78f138a9], ebx
mov dword [edx], edx
scasd eax, dword es:[edi]
xor ecx, dword [edx + 0x63]
or al, 0x53
arpl word [ebx + edx*2], cx
enter 0xffffffffffffd136, 0x44
pop edi
xor ch, byte [ebp - 0x227aa0d5]
pop ss
jb 0x453337
mov al, byte [eax + 0x6c4fd479]
push ds
test eax, 0x512fc934
pop ecx
xor al, 0x98
jno 0x4532f7
jnp 0x45330a
popfd
push es
retf 0xbb1f
Function at 0x45bfbc
Capabilities:
Encode data using xor

Disassembly:
out 0x2a, al
sbb bh, byte [edx]
mov ch, 0xd4
jge 0x45c008
retf
dec dword [edx - 0x7a]
sub esp, dword [edi + 0x3ed31912]
mov ebp, 0xf6abc6a3
aas
mov al, byte [ebx - 0x7e]
xor esi, dword [eax + ebx*4 + 0x66]
cmp bh, ah
xchg esi, eax
mov esp, 0x6d96638a
scasd eax, dword es:[edi]
push edx
rcr byte [ecx], 0xdf
sbb byte [ebx + edx*4 + 0x564f231b], bh
push es
or dh, byte [ecx - 0x5a97118e]
xor al, byte [ebx + ebp*8]
out dx, al
push 0xeb0432a5
daa
popal
in al, dx
cmp ah, cl
loop 0x45bfda
xchg edi, eax
aad 0xff
fsubr dword [0x190b69a]
movsb byte es:[edi], byte [esi]
pushal
insd dword es:[edi], dx
salc
mov eax, dword [0x782659a9]
dec ebp
outsb dx, byte [esi]
imul ebp, dword [ebx - 0x34], 0x3e
sbb al, 0x14
cmpsd dword [esi], dword es:[edi]
retf
Function at 0x49682c
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x47262f
mov eax, dword fs:[0]
push eax
sub esp, 0x138
mov eax, dword [0x4a2008]
xor eax, ebp
mov dword [ebp - 0x10], eax
push esi
push edi
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov dword [ebp - 0x13c], edx
mov eax, ecx
mov dword [ebp - 0x12c], eax
mov dword [ebp - 0x134], eax
mov esi, dword [ebp + 8]
mov edi, esi
mov dword [ebp - 0x144], eax
mov dword [ebp - 0x140], 0
cmp dword [esi + 0x14], 0x10
mov ecx, dword [esi + 0x10]
mov dword [ebp - 0x138], ecx
jb 0x496893
mov edi, dword [esi]
cmp dword [edx + 0x14], 0x10
mov ecx, dword [edx + 0x10]
mov dword [ebp - 0x134], ecx
mov dword [ebp - 0x130], edx
jb 0x4968b0
mov ecx, dword [edx]
mov dword [ebp - 0x130], ecx
cmp dword [edx + 0x10], 0
jbe 0x496919
push 0x100
lea eax, [ebp - 0x128]
push 0
push eax
call fcn.004df7fc
mov ecx, dword [ebp - 0x138]
add esp, 0xc
add ecx, edi
cmp edi, ecx
je 0x4968ec
nop dword [eax]
movzx eax, byte [edi]
inc edi
mov byte [ebp + eax - 0x128], 1
cmp edi, ecx
jne 0x4968dc
mov edx, dword [ebp - 0x130]
mov edi, edx
mov ecx, dword [ebp - 0x134]
add ecx, edx
cmp edx, ecx
jae 0x496913
movzx eax, byte [edi]
mov al, byte [ebp + eax - 0x128]
test al, al
je 0x49696d
inc edi
cmp edi, ecx
jb 0x496900
mov eax, dword [ebp - 0x12c]
xorps xmm0, xmm0
mov ecx, eax
push 0
movups xmmword [eax], xmm0
push 0x491667
mov dword [eax + 0x10], 0
mov dword [eax + 0x14], 0
call fcn.004ca19c
mov dword [ebp - 4], 0
mov dword [ebp - 0x140], 1
mov eax, dword [ebp - 0x12c]
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
mov ecx, dword [ebp - 0x10]
xor ecx, ebp
call fcn.004de078
mov esp, ebp
pop ebp
ret
sub edi, edx
cmp edi, 0xffffffff
je 0x496913
cmp dword [esi + 0x14], 0x10
jb 0x49697c
mov esi, dword [esi]
mov ecx, dword [ebp - 0x13c]
mov dword [ebp - 0x130], ecx
cmp dword [ecx + 0x14], 0x10
jb 0x496996
mov eax, dword [ecx]
mov dword [ebp - 0x130], eax
push 0x100
lea eax, [ebp - 0x128]
push 0
push eax
call fcn.004df7fc
mov ecx, dword [ebp - 0x138]
add esp, 0xc
add ecx, esi
cmp esi, ecx
je 0x4969cc
nop dword [eax]
movzx eax, byte [esi]
inc esi
mov byte [ebp + eax - 0x128], 1
cmp esi, ecx
jne 0x4969bc
mov eax, dword [ebp - 0x134]
or ecx, 0xffffffff
mov edx, dword [ebp - 0x130]
dec eax
cmp eax, ecx
cmovb ecx, eax
movzx eax, byte [ecx + edx]
add ecx, edx
mov al, byte [ebp + eax - 0x128]
test al, al
je 0x496a0a
cmp ecx, edx
je 0x496a81
movzx eax, byte [ecx - 1]
dec ecx
mov al, byte [ebp + eax - 0x128]
test al, al
jne 0x4969f2
sub ecx, edx
sub ecx, edi
lea eax, [ebp - 0x28]
inc ecx
push ecx
mov ecx, dword [ebp - 0x13c]
push edi
push eax
call fcn.004b576c
mov dword [ebp - 4], 1
xorps xmm0, xmm0
mov esi, dword [ebp - 0x12c]
mov dword [ebp - 0x140], 1
movups xmmword [esi], xmm0
mov dword [esi + 0x10], 0
movups xmm0, xmmword [ebp - 0x28]
mov dword [esi + 0x14], 0
mov byte [ebp - 0x28], 0
movups xmmword [esi], xmm0
movq xmm0, qword [ebp - 0x18]
movq qword [esi + 0x10], xmm0
mov dword [ebp - 0x18], 0
mov dword [ebp - 0x14], 0xf
mov byte [ebp - 4], 0
lea ecx, [ebp - 0x28]
call fcn.004ca2cc
mov eax, esi
jmp 0x496952
or ecx, 0xffffffff
jmp 0x496a0c
Function at 0x496cac
Capabilities:
Get number of processors

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x472754
mov eax, dword fs:[0]
push eax
push ecx
push esi
push edi
mov eax, dword [0x4a2008]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov esi, ecx
mov dword [ebp - 0x10], esi
xorps xmm0, xmm0
push 1
movups xmmword [esi], xmm0
push 0x48f868
mov dword [esi + 0x10], 0
mov dword [esi + 0x14], 0
call fcn.004ca19c
mov dword [ebp - 4], 0
mov dword [esi + 0x18], 0
mov dword [esi + 0x1c], 0
mov dword [esi + 0x20], 0
mov byte [ebp - 4], 1
mov dword [esi + 0x24], 0
mov dword [esi + 0x28], 0
mov dword [esi + 0x2c], 0
mov byte [ebp - 4], 2
mov dword [esi + 0x30], 0
mov dword [esi + 0x34], 0
mov dword [esi + 0x38], 0
mov byte [ebp - 4], 3
mov dword [esi + 0x3c], 0
mov dword [esi + 0x40], 0
mov dword [esi + 0x44], 0
mov byte [ebp - 4], 4
mov dword [esi + 0x48], 0
mov dword [esi + 0x4c], 0
mov dword [esi + 0x50], 0
mov byte [ebp - 4], 5
mov ecx, dword [0x4a2a48]
mov eax, dword [0x4a2a4c]
add ecx, 1
mov dword [esi + 0x58], 0
mov dword [esi + 0x5c], 0
adc eax, 0
mov dword [esi + 0x60], 0
mov dword [esi + 0x64], 0
mov dword [0x4a2a4c], eax
mov dword [esi + 0x6c], eax
mov dword [esi + 0x68], ecx
mov eax, dword [esi + 0x20]
sub eax, dword [esi + 0x18]
sar eax, 3
mov dword [0x4a2a48], ecx
cmp eax, 0x64
jae 0x496dcf
push ecx
lea ecx, [esi + 0x18]
call fcn.004b64cc
mov eax, dword [esi + 0x2c]
sub eax, dword [esi + 0x24]
sar eax, 3
cmp eax, 0x14
jae 0x496de6
push ecx
lea ecx, [esi + 0x24]
call fcn.004b63dc
mov dword [ebp - 4], 0xffffffff
mov eax, esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
mov esp, ebp
pop ebp
ret

Function at 0x4b5ecc
Capabilities:
Encode data using xor

Disassembly:
cmp eax, 0xe19a40a6
add dword [edi + 0x26], ebp
mov esi, ebp
xchg ebx, eax
fsub qword [eax + 0x37]
aad 0x20
xchg ecx, eax
popal
aad 0xf1
fld dword [0x435381a5]
add eax, 0x435381a5
loopne 0x4b5ef6
jno 0x4b5e97
int3
sub eax, 0x72c05dfc
aaa
inc edi
sbb edx, dword [ecx - 0xf574963]
xor al, 0x58
loope 0x4b5e82
and dword [edi], esp
sub eax, dword [eax + 0x3d]
loope 0x4b5f27
sbb eax, 0x64e4c1ae
push ds
push ecx
into
cli
xor eax, 0xf5d8be8a
cwde
xchg dword [ecx - 0x7d5f7532], eax
test ax, 0x260b
mov ch, 0x27
or esi, 0x6682a08a
test eax, 0x27b5260b
xor eax, 0x90117431
or byte [edx], dl
cmp al, 0x28
xor ah, byte [ebx - 0x13]
fld xword [ebp - 0x52]
rol dword [ecx], 1
cmpsb byte [esi], byte es:[edi]
sub dword [ebp - 0x49925edd], edx
inc edi
imul dword [ecx - 0x1f]
add byte [esi + 0x1380315c], cl
cmpsd dword [si], dword es:[di]
xchg ebp, eax
and esp, dword [ecx - 0x8b84993]
imul esp, ecx, 0x315c8e00
adc byte [ebx], 0x67
cmpsd dword [esi], dword es:[edi]
in al, dx
inc edi
xchg dword [ecx], esp
movsd dword es:[edi], dword [esi]
je 0x4b5f14
push eax
mov eax, 0xeba71776
pop edx
invalid
Function at 0x4b64cc
Capabilities:
Encode data using xor

Disassembly:
sub edi, edx
js 0x4b6511
mov ebx, 0x9c085710
xchg ecx, eax
xchg ecx, eax
invalid
jno 0x4b6514
das
jle 0x4b6587
add ecx, dword [bx + di - 0x7b9d]
insb byte es:[edi], dx
sub dh, byte [ecx - 0x69]
fnsave dword [ecx + 0x7907f46e]
mov eax, dword [0x10840734]
dec ebp
in al, 0xf1
fist word [eax + 0x77a6772f]
xchg ecx, eax
inc ecx
hlt
sahf
mov ah, 0xb2
mov ch, 0x8a
movsb byte es:[edi], byte [esi]
imul ecx, edi, 0xffffff91
dec esi
rcr dword [ecx], 1
mov ecx, 0xf1811213
push ecx
xchg byte [ebp + 0x31], bl
jo 0x4b6606
jle 0x4b6571
call 0xe0e66b0f
sbb dword [ebp + 0x1f], 0x746e0c4
les eax, [esp]
cmp eax, ecx
and ecx, esp
mov dh, byte [eax]
add ecx, ecx
push ecx
arpl sp, ax
adc al, 0x30
adc al, 0xca
cmp ebx, esp
invalid
add byte [0x5d81e09b], 0x1f
invalid
add al, 0x68
test byte [edi], cl
int1
mov ch, 0x99
xor ecx, esp
popfd
sar esi, 1
leave
leave
test al, 0x7c
jo 0x4b6624
invalid
mov dl, 0x9a
dec edi
mov eax, dword [0x63cef93f]
dec edx
adc dword [edi - 0x4d], esp
rol byte [edx], 0x55
cdq
xchg ecx, esp
jno 0x4b665c
inc ecx
je 0x4b65d2
stc
nop
dec ecx
xor dl, byte [esi - 0x1badcd53]
inc ecx
push edx
in al, 0x41
shl byte [ebx - 0x183cc53b], 0x50
bound esi, qword [eax - 0x70]
xchg dword [ecx - 0x1a92fe81], eax
arpl dx, ax
adc byte [eax - 0x6fe4d6ee], dl
pop ecx
leave
adc al, byte [edi]
mov al, 0x58
adc dword [ecx], 0xffffffed
jb 0x4b661a
push esp
inc edi
shr dword [ecx - 0x5c269b7], 0x74
xor byte [ecx - 0xc1e2fc1], ah
in al, dx
push ebx
ret 0xcb34

Function at 0x4ca2cc
Capabilities:
Encode data using xor

Disassembly:
lodsb al, byte [esi]
mov byte [esi], ch
adc dword [ecx], edx
xchg esi, eax
dec edx
and ecx, dword [esi]
dec ebx
dec ecx
mov ecx, 0x2519249a
add al, 0x46
add eax, 0x4a21324f
mov cl, 0x53
out dx, al
cmp dl, byte [ebp + edx*2 + 0x67632785]
loopne 0x4ca302
loopne 0x4ca302
xor byte [edi + 0x3fb2a224], al
or dl, byte [edi]
or eax, 0x227c60e2
dec esp
aam 0x46
pushal
lodsb al, byte [esi]
sbb byte [ecx], dh
add al, 0xb
mov cl, 0xd6
test dword [ecx], ebp
xor byte [ecx], ah
mov al, byte [0x8a549155]
cdq
jno 0x4ca2aa
push ecx
rcr dword [ebx], 0x9c
leave
nop
xlatb
cmc
and ebx, ecx
inc ebp
xchg ecx, eax
dec esi
xor byte [ecx + 0x2b], 0xad
jno 0x4ca32f
lodsd eax, dword [esi]
adc al, dl
xor eax, 0xa165fb21
push edx
test al, 0x32
retf 0x2221
cmp ch, 0x71
stosb byte es:[edi], al
je 0x4ca2d5
push ecx
lcall 0x25c, 0xe5313415
cdq
popal
add byte [eax + esi*2 + 0x71], dh
cmpsb byte [esi], byte es:[edi]
inc ecx
ret
Function at 0x52983c
Capabilities:
Get number of processors

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x472754
mov eax, dword fs:[0]
push eax
push ecx
push esi
push edi
mov eax, dword [0x4a2008]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov esi, ecx
mov dword [ebp - 0x10], esi
xorps xmm0, xmm0
push 1
movups xmmword [esi], xmm0
push 0x48f868
mov dword [esi + 0x10], 0
mov dword [esi + 0x14], 0
call fcn.0055cd2c
mov dword [ebp - 4], 0
mov dword [esi + 0x18], 0
mov dword [esi + 0x1c], 0
mov dword [esi + 0x20], 0
mov byte [ebp - 4], 1
mov dword [esi + 0x24], 0
mov dword [esi + 0x28], 0
mov dword [esi + 0x2c], 0
mov byte [ebp - 4], 2
mov dword [esi + 0x30], 0
mov dword [esi + 0x34], 0
mov dword [esi + 0x38], 0
mov byte [ebp - 4], 3
mov dword [esi + 0x3c], 0
mov dword [esi + 0x40], 0
mov dword [esi + 0x44], 0
mov byte [ebp - 4], 4
mov dword [esi + 0x48], 0
mov dword [esi + 0x4c], 0
mov dword [esi + 0x50], 0
mov byte [ebp - 4], 5
mov ecx, dword [0x4a2a48]
mov eax, dword [0x4a2a4c]
add ecx, 1
mov dword [esi + 0x58], 0
mov dword [esi + 0x5c], 0
adc eax, 0
mov dword [esi + 0x60], 0
mov dword [esi + 0x64], 0
mov dword [0x4a2a4c], eax
mov dword [esi + 0x6c], eax
mov dword [esi + 0x68], ecx
mov eax, dword [esi + 0x20]
sub eax, dword [esi + 0x18]
sar eax, 3
mov dword [0x4a2a48], ecx
cmp eax, 0x64
jae 0x52995f
push ecx
lea ecx, [esi + 0x18]
call fcn.0054905c
mov eax, dword [esi + 0x2c]
sub eax, dword [esi + 0x24]
sar eax, 3
cmp eax, 0x14
jae 0x529976
push ecx
lea ecx, [esi + 0x24]
call fcn.00548f6c
mov dword [ebp - 4], 0xffffffff
mov eax, esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
mov esp, ebp
pop ebp
ret

Function at 0x54fc2c
Capabilities:
Encode data using xor

Disassembly:
fld qword [eax - 0x389f8536]
fimul dword [ebx]
lodsb al, byte [esi]
push edi
in ax, dx
lodsb al, byte [esi]
lcall 0x2182, 0xc30eb95
adc al, 0x8a
sub eax, 0xf994be42
inc eax
xchg byte [edi], ah
or eax, 0x268e2008
test byte [eax - 0x2d5760e], dh
fdiv qword [0x40b30bc5]
test dh, dh
mov edx, 0x770b76b4
sbb eax, 0xeb1b1a56
inc ebp
mov edx, 0xb2592d9
invalid

Function at 0x55396c
Capabilities:
Encode data using xor

Disassembly:
add eax, 0x747497fa
in al, 0x95
cmc
leave
push ss
mov eax, 0x39aadad5
add eax, 0xbc1b94e9
cvtps2pd xmm3, qword [eax]
cli
das
inc edi
mov eax, 0x7aaea3fd
sub dword [ebx + 0x39], ebp
sub byte [ecx - 0x3ce40335], ch
dec ebx
invalid

Function at 0x55c46c
Capabilities:
Encode data using xor

Disassembly:
cmpsd dword [esi], dword es:[edi]
add eax, 0x4908007c
xor ebp, edx
sub dl, byte [edx + 0x5b]
mov bh, 0x4b
dec ebx
dec ebx
sbb al, 0x64
pop ebx
jo 0x55c45f
or edi, dword [edx - 0xf]
cmp eax, 0x44fbbfe5
mov ebp, 0x8a8f4f67
jne 0x55c4ec
into
shr dword [edi - 0x4906ae59], cl
inc edx
and al, 0x5d
mov bh, 0x62
sub edi, dword [edx + 0x30]
lodsd eax, dword [esi]
into
cli
test eax, 0xd97705c4
invalid
push 0x4a
std
je 0x55c53d
and esp, edx
xor dword [edi - 0x14], 0xb835d4b4
invalid
mov eax, 0xbc2eb48f
mov byte [0xecedaf07], al
pop esp
ret 0x7a4c
push ss
push eax
dec ebp
sub eax, 0x4f37de6e
dec ecx
jp 0x55c4f9
dec edx
int3
Function at 0x5a5bbc
Capabilities:
Encode data using xor

Disassembly:
das
invalid
xor esi, ecx
movsb byte es:[edi], byte [esi]
pop edi
cmc
adc al, 0x41
sahf
add eax, 0x8d99b320
inc esp
jecxz 0x5a5b2d
xchg byte [esi - 0x41ee5cce], bl
push esi
adc bh, byte [edx + 0x6e]
insb byte es:[edi], dx
in eax, dx
inc ebx
imul dword [esi + 0x60d12b2d]
invalid
shr dword [ebp - 0x3c], 1
xor al, 0x83
lahf
jge 0x5a5b30
add ch, ch
inc esi
mov ebp, esp
and al, 2
int1
sti
sub eax, 0x69e053a5
loopne 0x5a5bb9
test byte [edi + 0x3b271c11], ah
mov esp, 0xf7ecdf4f
cli
sar dl, 0xdd
sub eax, 0x4b00f91b
aaa
pop esi
pop ss
sub byte [ebx + 0x14d649a3], dl
jg 0x5a5af5
mov dl, 0xd
into
das
adc al, 0xa
push eax
aaa
mov al, 0xde
or eax, 0xfc639b3f
add al, 0x3e
pop ss
rol dword [edi - 0x36db764d], 1
cli
pop esi
adc ecx, edx
jnp 0x5a5b08
imul esi, dword [edi], 0x2a
adc cl, byte [ebx - 0x11]
das
push ebx
in al, 0xb7
lodsb al, byte cs:[esi]
lodsb al, byte [esi]
and dl, byte [ebx + 0x3af83fdd]
fdiv st(5), st(0)
invalid
lahf
inc esp
insd dword es:[edi], dx
inc ebp
jl 0x5a5bfb
dec eax
adc al, 0xf7
repne stosd dword es:[edi], eax
push edi
sbb eax, 0xe4ef8747
jp 0x5a5b75
mov edi, 0xc109db8f
xlatb
xchg byte [esi + edi*2 - 0xa], al
arpl word [0x61b930f7], dx
dec edx
xchg ebp, eax
out dx, eax
mul byte [ebx + 0x15]
div dword [eax]
mov ecx, 0xef954a61
jecxz 0x5a5bd5
shl byte [ebx + 0x1183e967], 0x57
cmc
pop eax
scasb al, byte es:[edi]
lahf
sbb dword [ebx - 0xa], eax
sbb al, 0xfc
jge 0x5a5b8d
push ss
rcl dword [eax + 0x70904ea6], cl
iretd
push ebp
into
and dword [edx + 0x18a038b9], esp
mov al, 0x59
jb 0x5a5c0c
lea ebx, [edi - 0x20c6cc5e]
loope 0x5a5c4c
invalid
rcr ah, cl
sub eax, 0xa1d70998
mov ebp, 0x8d586d19
fistp qword [edi]
pop esi
lahf
jno 0x5a5c5f
xlatb
mov eax, dword [0x586d19bd]
invalid
xor dword [edi - 0x2e], eax
pop edi
pop esi
push ss
jno 0x5a5bfb
mov edx, 0x7f23f07e
push edi
aaa
xchg esi, eax
and dword [ecx], esi
and byte [ebx + 0x4c583a0b], bl
inc esp
imul esi, dword [ecx], 0xffffff9f
sub dword [edi], 0x2ff77b70
jmp 0x91c028be
dec ebx
rol dword [ecx - 0x3a], 0xff
dec ecx
xchg ecx, eax
idiv byte [ebx - 0xd]
mov al, 0x87
fld xword [edi - 0x55]
xchg ebp, eax
popfd
pop eax
pop ds
pop esp
bound esi, qword [esp + edx*8 + 0x26]
jbe 0x5a5c14
out dx, eax
retf
Function at 0x5c1f72
Capabilities:
Encode data using xor

Disassembly:
push 0x131080c7
or byte [eax], bh
push 0xc46b0568
jmp 0x113b9d7d
das
xchg byte [0x5a7ac2ea], ah
je 0x5c1ef4
fxch st(3)
in al, 0x40
sar dword [eax], cl
push esi
pop ebp
adc al, 0x38
mov byte [0xded06011], al
test eax, 0x6ea767e9
insd dword es:[edi], dx
inc ecx
ficomp word [ebx]
dec edi
popfd
invalid
enter 0xffffffffffff85d8, 0xffffffffffffffbb
out dx, eax
jae 0x5c1f06
enter 0xfffffffffffffa07, 0x47
cli
je 0x5c1fc2
outsb dx, byte [esi]
jl 0x5c1f46
shl dword [esi + 0x22], 0x3d
js 0x5c1f4b
inc ebp
dec ebx
cmp edx, edi
movsb byte es:[edi], byte [esi]
aam 0xf3
add byte [ecx - 0xf], dh
shl dword es:[ebp + 0x51], cl
lcall 0xdb76, 0x58e96ee4
jecxz 0x5c1fdc
sti
cdq
ja 0x5c1f46
cmp bl, byte [ebx + 0x3d]
jbe 0x5c1fe1
push 0x2e
sub bh, byte [esi]
test al, 0x2f
pop eax
pop ecx
imul ebx, esi, 6
test eax, ecx
stosb byte es:[edi], al
jge 0x5c1fa9
cmp byte [esi], 0xfe
push esi
into
push es
dec esp
stosb byte es:[edi], al
test al, 0x9a
sbb byte [eax], bh
pop esp
sbb bl, byte [edi + ecx*8 + 0x7a]
xor dword [ecx - 0x37], ecx
mov byte [0xe16fba44], al
or byte [eax], bh
mov bh, 0xaa
stosb byte es:[edi], al
push eax
sub al, 0x9a
leave
mov ch, 0x9e
mov gs, word [ecx + 0x582a7025]
and al, byte [eax + 0x5a]
or byte [edx + 0x68], dh
xchg ebx, eax
pushal
xor ah, byte [edi - 0x2f]
or byte [esi - 0x9afead7], bh
mov esi, 0xf6501529
aam 0xb7
leave
xchg esp, eax
cwde
mov dh, 0x32
push esp
jecxz 0x5c1fde
sub byte [0x3ee0ee06], al
fld dword [ebp + 0x60]
xchg ebx, eax
or dh, 0x33
into
xor edx, edi
xlatb
or esi, dword [edx - 0x21446f35]
invalid
retf

Function at 0x5dd41c
Capabilities:
Encode data using xor

Disassembly:
xor ebp, dword [ebx - 0x517ca3ba]
fsubrp st(3)
iretd
inc ebx
dec edx
xchg ebx, eax
jbe 0x5dd3bf
dec edx
shr dword [edx - 0x12], cl
push esp
rol ebp, 1
inc edx
clc
sbb edi, ebx
mov edx, 0x89a88d31
outsd dx, dword [esi]
inc ebx
mov dh, 0x49
push ebx
cmpsd dword [esi], dword es:[edi]
inc edi
aaa
push edx
add eax, 0xf658c91e
sbb al, 0xc5
stc
mov al, byte [0xf4ba45e4]
pop ebp
salc
xchg edx, eax
idiv dword [ebp - 0x6a]
mov eax, dword [0x808727d]
add al, 0x36
sub ecx, dword [ecx]
ja 0x5dd471
pop esi
or ecx, dword [edx]
cwde
push ss
push esp
mov al, 0x44
invalid
xchg esi, eax
invalid
push ebx
mul byte [edi + ebx*4 + 0x3419c41e]
leave
xor eax, 0xa5389d38
je 0x5dd46b
stosd dword es:[edi], eax
test al, 0x62
hlt
Function at 0x60668c
Capabilities:
Get number of processors

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x472754
mov eax, dword fs:[0]
push eax
push ecx
push esi
push edi
mov eax, dword [0x4a2008]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov esi, ecx
mov dword [ebp - 0x10], esi
xorps xmm0, xmm0
push 1
movups xmmword [esi], xmm0
push 0x48f868
mov dword [esi + 0x10], 0
mov dword [esi + 0x14], 0
call fcn.00639b7c
mov dword [ebp - 4], 0
mov dword [esi + 0x18], 0
mov dword [esi + 0x1c], 0
mov dword [esi + 0x20], 0
mov byte [ebp - 4], 1
mov dword [esi + 0x24], 0
mov dword [esi + 0x28], 0
mov dword [esi + 0x2c], 0
mov byte [ebp - 4], 2
mov dword [esi + 0x30], 0
mov dword [esi + 0x34], 0
mov dword [esi + 0x38], 0
mov byte [ebp - 4], 3
mov dword [esi + 0x3c], 0
mov dword [esi + 0x40], 0
mov dword [esi + 0x44], 0
mov byte [ebp - 4], 4
mov dword [esi + 0x48], 0
mov dword [esi + 0x4c], 0
mov dword [esi + 0x50], 0
mov byte [ebp - 4], 5
mov ecx, dword [0x4a2a48]
mov eax, dword [0x4a2a4c]
add ecx, 1
mov dword [esi + 0x58], 0
mov dword [esi + 0x5c], 0
adc eax, 0
mov dword [esi + 0x60], 0
mov dword [esi + 0x64], 0
mov dword [0x4a2a4c], eax
mov dword [esi + 0x6c], eax
mov dword [esi + 0x68], ecx
mov eax, dword [esi + 0x20]
sub eax, dword [esi + 0x18]
sar eax, 3
mov dword [0x4a2a48], ecx
cmp eax, 0x64
jae 0x6067af
push ecx
lea ecx, [esi + 0x18]
call int.00625eac
mov eax, dword [esi + 0x2c]
sub eax, dword [esi + 0x24]
sar eax, 3
cmp eax, 0x14
jae 0x6067c6
push ecx
lea ecx, [esi + 0x24]
call fcn.00625dbc
mov dword [ebp - 4], 0xffffffff
mov eax, esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
mov esp, ebp
pop ebp
ret

Function at 0x60bda0
Capabilities:
Encode data using xor

Disassembly:
rol byte [ebx], 0x48
pushal
push edx
sbb bl, ah
mov ecx, 0x8ea1708b
mov ebx, 0x364928d0
sub esp, dword [ecx + 0x68]
jo 0x7791e076
rcl eax, 1
add byte [edx - 0x2e], bh
mov byte [0xd4aaf6a1], al
xor al, 0x92
jecxz 0x60bdbc
outsd dx, dword [esi]
invalid
Function at 0x6229cc
Capabilities:
Encode data using xor

Disassembly:
push es
or byte [edx + 0x4b], dl
mov dh, 0xbb
jmp 0x7f59e2a
cmp byte [esp + edi*2 - 0x24], dl
jnp 0x6229f7
jl 0x622a46
push eax
or ecx, dword [ebp - 0x6d]
jb 0x622a19
loopne 0x62297c
xor bh, byte [ebp + 0x2a]
adc eax, 0xd2e9e69d
ja 0x6229ed
adc byte [ebx + 0x73f52bba], dh
mov cl, 0xe6
cmpsd dword [esi], dword es:[edi]
jae 0x622a07
add cl, bh
push edx
push eax
push es
mov al, byte [0x77222379]
push ecx
fistp word [ebp - 0x43e60d0d]
xchg edx, eax
jo 0x622a31
mov esp, 0x962a7092
xchg esi, eax
inc esp
hlt
and ebx, esp
imul edi, dword [ebx + edx*2 - 0x4eb1b94e], 0xffffff83
push ebx
mov dl, 0x46
dec esi
mov cl, 0x83
push ds
pop edi
pop ss
add ebx, eax
mov dword [0x8d8853e0], eax
xor ch, byte [ebx + 0x73605710]
iretd
pushal
jae 0x622a03
dec ebp
xchg dword [edi + 0x537e7d45], edi
add dword [ecx + 0x52], edx
push ds
xor dword [edx], esp
mov word [ebx], es
clc
rcr dword [eax + 0x51598150], 0xb3
in eax, 0x1d
mov byte [ebx - 0x7d7f8c51], al
sar dh, 1
push eax
sbb dword [ecx + 0x51], 0x881de5b3
sub dword [edi - 0x2f7d7f8d], 0xfffffffe
mov cs, word [ecx]
cmp dl, byte [esi]
jbe 0x622a1d
scasb al, byte es:[edi]
out dx, eax
xchg ecx, eax
push esi
inc edx
add ah, cl
mov dl, 0xa5
xchg ebx, eax
adc cl, 0xe1
mov bh, 0xf3
add dh, byte [esi]
test byte [ecx - 0x73], bl
shl dword [eax + 5], cl
sbb al, 0xe2
or al, 0x9b
adc dl, byte [esi + 0x18]
bound ebx, qword [ebx]
popal
cwde
xor dword [ebx + 0x32], 0x73
mov dl, 0x57
xor dword [ebx - 0x55e87146], ecx
xor dword [ebp + 0x62669536], esi
add byte [esi - 0xffeaefb], dh
and eax, 0xd3c6fd78
retf 0xe0d