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

Disassembly:
je 0x40a954
push edi
xor edi, 0xa97e
add byte [edi + 0x57], bl
push eax
add esp, 4
sub edi, 0x735a
pop edi
push edx
push edx
add esp, 4
and edx, 0xd10e
xor edx, 0xfe41
pop edx
push esi
push edi
add esp, 4
sub esi, 0xbe1d
pop esi
mov eax, dword [ebp - 0x3f4]
mov dword [ebp - 0x19d8], eax
push ecx
push esi
add esp, 4
jmp 0x40a8cf
call 0x40a8df
add byte [ebx + 0x3e], al
cmp dword [edi + 0x46], ecx
aas
inc edi
dec eax
dec esp
cmp al, 0x83
les eax, [ecx + ebx*2]
push ecx
call 0x40a8f2
add byte [esi + 0x39], cl
inc ebp
inc eax
inc ebx
cmp al, 0x38
cmp byte [edx], dh
add esp, 4
pop ecx
mov ecx, dword [ebp - 0x19d8]
invalid
lea esp, [esi]

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

Disassembly:
je 0x40a954
push edi
xor edi, 0xa97e
add byte [edi + 0x57], bl
push eax
add esp, 4
sub edi, 0x735a
pop edi
push edx
push edx
add esp, 4
and edx, 0xd10e
xor edx, 0xfe41
pop edx
push esi
push edi
add esp, 4
sub esi, 0xbe1d
pop esi
mov eax, dword [ebp - 0x3f4]
mov dword [ebp - 0x19d8], eax
push ecx
push esi
add esp, 4
jmp 0x40a8cf
call 0x40a8df
add byte [ebx + 0x3e], al
cmp dword [edi + 0x46], ecx
aas
inc edi
dec eax
dec esp
cmp al, 0x83
les eax, [ecx + ebx*2]
push ecx
call 0x40a8f2
add byte [esi + 0x39], cl
inc ebp
inc eax
inc ebx
cmp al, 0x38
cmp byte [edx], dh
add esp, 4
pop ecx
mov ecx, dword [ebp - 0x19d8]
invalid
lea esp, [esi]

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

Disassembly:
je 0x40a954
push edi
xor edi, 0xa97e
add byte [edi + 0x57], bl
push eax
add esp, 4
sub edi, 0x735a
pop edi
push edx
push edx
add esp, 4
and edx, 0xd10e
xor edx, 0xfe41
pop edx
push esi
push edi
add esp, 4
sub esi, 0xbe1d
pop esi
mov eax, dword [ebp - 0x3f4]
mov dword [ebp - 0x19d8], eax
push ecx
push esi
add esp, 4
jmp 0x40a8cf
call 0x40a8df
add byte [ebx + 0x3e], al
cmp dword [edi + 0x46], ecx
aas
inc edi
dec eax
dec esp
cmp al, 0x83
les eax, [ecx + ebx*2]
push ecx
call 0x40a8f2
add byte [esi + 0x39], cl
inc ebp
inc eax
inc ebx
cmp al, 0x38
cmp byte [edx], dh
add esp, 4
pop ecx
mov ecx, dword [ebp - 0x19d8]
invalid
lea esp, [esi]

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

Disassembly:
je 0x40a954
push edi
xor edi, 0xa97e
add byte [edi + 0x57], bl
push eax
add esp, 4
sub edi, 0x735a
pop edi
push edx
push edx
add esp, 4
and edx, 0xd10e
xor edx, 0xfe41
pop edx
push esi
push edi
add esp, 4
sub esi, 0xbe1d
pop esi
mov eax, dword [ebp - 0x3f4]
mov dword [ebp - 0x19d8], eax
push ecx
push esi
add esp, 4
jmp 0x40a8cf
call 0x40a8df
add byte [ebx + 0x3e], al
cmp dword [edi + 0x46], ecx
aas
inc edi
dec eax
dec esp
cmp al, 0x83
les eax, [ecx + ebx*2]
push ecx
call 0x40a8f2
add byte [esi + 0x39], cl
inc ebp
inc eax
inc ebx
cmp al, 0x38
cmp byte [edx], dh
add esp, 4
pop ecx
mov ecx, dword [ebp - 0x19d8]
invalid
lea esp, [esi]
Function at 0x40a8f2
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
je 0x40a954
push edi
xor edi, 0xa97e
add byte [edi + 0x57], bl
push eax
add esp, 4
sub edi, 0x735a
pop edi
push edx
push edx
add esp, 4
and edx, 0xd10e
xor edx, 0xfe41
pop edx
push esi
push edi
add esp, 4
sub esi, 0xbe1d
pop esi
mov eax, dword [ebp - 0x3f4]
mov dword [ebp - 0x19d8], eax
push ecx
push esi
add esp, 4
jmp 0x40a8cf
call 0x40a8df
add byte [ebx + 0x3e], al
cmp dword [edi + 0x46], ecx
aas
inc edi
dec eax
dec esp
cmp al, 0x83
les eax, [ecx + ebx*2]
push ecx
call 0x40a8f2
add byte [esi + 0x39], cl
inc ebp
inc eax
inc ebx
cmp al, 0x38
cmp byte [edx], dh
add esp, 4
pop ecx
mov ecx, dword [ebp - 0x19d8]
invalid
lea esp, [esi]

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

Disassembly:
sal byte [ebp + 0x41], 0x52
xor edx, 0x271e
sub edx, 0x5fe2
and edx, 0x6d68
add edx, 0x6124
pop edx
push eax
jmp 0x40a933
xor eax, 0x5044
jmp 0x40a93e
and eax, 0x820b

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

Disassembly:
pop eax
mov dword [ebp - 0x79c], 0
jmp 0x40b03e

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

Disassembly:
cmp byte [edx], dh
add esp, 4
pop ecx
mov ecx, dword [ebp - 0x19d8]
mov dword [ebp - 0x19dc], ecx
dec dword [ebp - 0x173b6b]
call dword [edx - 1]
xchg ebp, eax
and al, 0xe6
invalid
invalid
test eax, eax
invalid
jne 0x40a954
push edx
push edx
push eax
add esp, 4
call 0x40a968
add byte [edx], dh
aas
inc ebp
inc esp
inc edi
xor al, 0x3f
xor cl, byte [ebx - 0x7d]
les eax, [edx + ebx*2]
push ebx
xor ebx, 0xff04
and ebx, 0x642a
pop ebx
push edx
push ebx
add esp, 4
xor edx, 0x387e
add byte [edx + 0x64], bl
mov eax, dword [0x18]
mov dword [ebp - 0x19e0], eax
mov ecx, dword [ebp - 0x19e0]
Function at 0x40a9b8
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
les eax, [ecx + eax*4]
out 0x4f, al
out 0, eax
add byte [ecx + 0xfabcee], al
add byte [ecx + 0xb0acc6], al
add byte [ecx + 0xbb3fc6], al
add byte [eax], al
pop esi
push ecx
Function at 0x40ac70
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov dword [ebp - 0x50c], eax
mov ecx, dword [ebp - 0x50c]
cmp ecx, dword [ebp - 0xcb4]
je 0x40ac94

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

Disassembly:
mov edx, dword [ebp - 0x50c]
cmp dword [edx + 0x30], 0
jne 0x40aa5f
mov dword [ebp - 0x31c], 0

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

Disassembly:
add ecx, 0xb795
pop ecx
push ebx
sub ebx, 0xe6f3
call 0x40ad01
out 0, al
add al, ch
or al, byte [eax]
add byte [eax], al
add byte [esi + 0x33], cl
inc eax
inc ecx
inc edx
inc edx
aas
cmp al, byte [ebx - 0x7d]
les eax, [ecx + eax*4]
jmp 0x40acef

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

Disassembly:
add ecx, 0xb795
pop ecx
push ebx
sub ebx, 0xe6f3
call 0x40ad01
out 0, al
add al, ch
or al, byte [eax]
add byte [eax], al
add byte [esi + 0x33], cl
inc eax
inc ecx
inc edx
inc edx
aas
cmp al, byte [ebx - 0x7d]
les eax, [ecx + eax*4]
jmp 0x40acef

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

Disassembly:
mov eax, dword [ebp - 0x770]
mov dword [ebp - 0x510], eax
jmp 0x40b032

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

Disassembly:
add al, byte [ebp - 0x647bf040]
add byte [eax], al
add byte [ebx - 0x19b73], cl
dec dword [edi]
mov esi, 0xf7880d94
invalid

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

Disassembly:
mov ecx, dword [ebp - 0x19c]
add ecx, 1
mov dword [ebp - 0x19c], ecx
inc esp
inc esp
aaa
cmp eax, 0x4c48333
sub ebx, 0x1371f
or ebx, 0xeb26
pop ebx
mov eax, dword [ebp - 0x76c]
invalid
test dword [esi + edi*8 - 1], esp

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

Disassembly:
mov ecx, dword [ebp - 0x19c]
add ecx, 1
mov dword [ebp - 0x19c], ecx
inc esp
inc esp
aaa
cmp eax, 0x4c48333
sub ebx, 0x1371f
or ebx, 0xeb26
pop ebx
mov eax, dword [ebp - 0x76c]
invalid
test dword [esi + edi*8 - 1], esp

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

Disassembly:
je 0x40af2e
mov ecx, dword [ebp - 0x76c]
add ecx, dword [ebp - 0x19c]
movsx edx, byte [ecx]
xor edx, 0x20
mov eax, dword [ebp - 0x19c]
movsx ecx, byte [ebp + eax - 0x878]
cmp edx, ecx
jne 0x40af35
jmp 0x40ae7b
jmp 0x40af3c
push eax
push ecx
add esp, 4
xor eax, 0x11140
pop eax
push edx
push edx
add esp, 4
call fcn.0040af5b
add byte [esi + 0x43], al
cmp al, 0x4a
aas
inc edi
dec edx
dec edx

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

Disassembly:
add esp, 4
or edx, 0x14eb8
jmp 0x40af6d
pop edx
mov edx, dword [ebp - 0x76c]
add edx, dword [ebp - 0x19c]
invalid
invalid
Function at 0x40afc4
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov edx, dword [ebp - 0x768]
add edx, 1
mov dword [ebp - 0x768], edx
invalid
dec dword [ebx - 0x7637b]
dec dword [ebx - 0x76773]
invalid
cmp ecx, dword [eax + 0x18]
jae 0x40b026
mov edx, dword [ebp - 0x768]
mov eax, dword [ebp - 0x19e8]
mov ecx, dword [ebp - 0x324]
inc dword [ebx]
or al, 0x90
mov dword [ebp - 0x76c], ecx
mov edx, dword [ebp - 0x768]
mov eax, dword [ebp - 0x19ec]
movzx ecx, word [eax + edx*2]
or al, 0x50
mov edx, dword [ebp - 0x1d74]
mov eax, dword [ebp - 0x324]
add eax, dword [edx + ecx*4]
mov cl, byte [ecx - 0x19ef7b]
inc edi
test dword [esi + edi*8 - 1], esp
inc dword [eax]
add byte [eax], al
add bl, ch
invalid
mov edx, dword [ebp - 0x76c]
add edx, dword [ebp - 0x19c]
movsx eax, byte [edx]
add al, byte [ebp - 0x647bf040]
add byte [eax], al
invalid
mov ecx, dword [ebp - 0x19c]
movsx edx, byte [ebp + ecx - 0x878]
test edx, edx
je 0x40af3c
push eax
push ebx
add esp, 4
sub eax, 0x7e0a
pop eax
push ebx
jmp 0x40aecc
call 0x40aed9
add byte [esi + 0x3c], cl
pop ebx
push eax
sub eax, 0x12fe8
pop eax
mov eax, dword [ebp - 0x76c]
add eax, dword [ebp - 0x19c]
movsx ecx, byte [eax]
or ecx, 0x20
mov edx, dword [ebp - 0x19c]
movsx eax, byte [ebp + edx - 0x878]
or eax, 0x20
cmp ecx, eax
jge 0x40b000
mov dword [ebp - 0xcb8], 0xffffffff
jmp 0x40b00a
mov dword [ebp - 0xcb8], 1
cmp dword [ebp - 0xcb8], 0
jne 0x40b021
mov ecx, dword [ebp - 0x19f0]
mov dword [ebp - 0x510], ecx
jmp 0x40b032
jmp 0x40ae0b
mov edx, dword [ebp - 0x770]
mov dword [ebp - 0x510], edx
mov eax, dword [ebp - 0x510]
mov dword [ebp - 0x79c], eax

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

Disassembly:
test dword [ebx], esi
idiv bh
call dword [eax - 0x3a]
test dword [esi + esi*8], esi
invalid

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

Disassembly:
push ecx
push esi
add esp, 4
call 0x40b289
add byte [edi + 0x4f], cl
dec edx
dec edx
cmp dh, byte [esi]
add esp, 4

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

Disassembly:
push ecx
push esi
add esp, 4
call 0x40b289
add byte [edi + 0x4f], cl
dec edx
dec edx
cmp dh, byte [esi]
add esp, 4

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

Disassembly:
jmp 0x40b295
pop ecx
cmp dword [ebp - 0x1618], 0
add byte [ebp + 0xf], dh
mov dword [ebp - 0x2fc], 0
jmp 0x40b555
add byte [eax], al
mov ecx, dword [ebp - 0x1618]
mov edx, dword [ecx + 0xc]
mov eax, dword [edx + 0xc]
mov dword [ebp - 0xcc4], eax
push edx
sub edx, 0x131e4
pop edx
push edi
push edi
add esp, 4
add edi, 0x14a07
add edi, 0x1106
add edi, 0x215d
invalid
pop ebp
and dword [eax], eax
add byte [ecx + 0x1726ae7], al
add byte [edi + 0x53], bl
push edx
add esp, 4
or ebx, 0x1285b
pop ebx
cmp dword [ebp - 0xcc4], 0
jne 0x40b30a
mov dword [ebp - 0x2fc], 0
jmp 0x40b555
mov ecx, dword [ebp - 0xcc4]
mov dword [ebp - 0x514], ecx
push esi
invalid
Function at 0x40b2dc
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
and dword [eax], eax
add byte [ecx + 0x1726ae7], al
add byte [edi + 0x53], bl

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

Disassembly:
mov eax, dword [ebp - 0x514]
mov ecx, dword [eax + 0x30]
mov dword [ebp - 0xcbc], ecx
xor edx, edx
mov word [ebp - 0x21c], dx
in al, 0xfd
invalid
push dword [ebx]
shl byte [esi - 0x77], 0x45
invalid

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

Disassembly:
push edx
sub edx, 0x1867e
add byte [edx + 0x53], bl
push edx
add esp, 4
xor ebx, 0x1311c
call 0x40b391
add byte [edx + 0x3a], cl
cmp ecx, dword [ebp + 0x37]
aas
add esp, 4
call 0x40b3a0
add byte [eax], bh
cmp ecx, dword [edx + ecx*2 + 0x32]
push eax
add esp, 4
pop ebx
mov ecx, dword [ebp - 0xcbc]
mov dx, word [ecx]
mov word [ebp - 0x103e], dx
mov eax, dword [ebp - 0xcbc]
add eax, 2
mov dword [ebp - 0xcbc], eax
mov cx, word [ebp - 0x103e]
mov word [ebp - 0x21c], cx
mov edx, dword [ebp - 0xcc0]
mov ax, word [edx]
mov word [ebp - 0x1040], ax
mov ecx, dword [ebp - 0xcc0]
invalid
invalid
inc dword [ebx - 0x7276fd3f]
inc eax
invalid
invalid
invalid
mov dx, word [ebp - 0x1040]
mov word [ebp - 0x38], dx
push esi
and esi, 0x35ca
sub esi, 0x145e4
pop esi
push ebx
xor ebx, 0xf98a
pop ebx
push eax
xor eax, 0x113f9
and eax, 0x11dbc
pop eax
push ebx
and ebx, 0x983e
add ebx, 0xb643
pop ebx
movzx eax, word [ebp - 0x38]
test eax, eax
jne 0x40b44a
movzx ecx, word [ebp - 0x21c]
movzx edx, word [ebp - 0x38]
sub ecx, edx
mov dword [ebp - 0x1620], ecx
jmp 0x40b4a4
movzx eax, word [ebp - 0x21c]
movzx ecx, word [ebp - 0x38]
cmp eax, ecx
je 0x40b372
movzx edx, word [ebp - 0x21c]
xor edx, 0x20
movzx eax, word [ebp - 0x38]
cmp edx, eax
invalid
test bh, bh
Function at 0x40b391
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push edx
sub edx, 0x1867e
add byte [edx + 0x53], bl
push edx
add esp, 4
xor ebx, 0x1311c
call 0x40b391
add byte [edx + 0x3a], cl
cmp ecx, dword [ebp + 0x37]
aas
add esp, 4
call 0x40b3a0
add byte [eax], bh
cmp ecx, dword [edx + ecx*2 + 0x32]
push eax
add esp, 4
pop ebx
mov ecx, dword [ebp - 0xcbc]
mov dx, word [ecx]
mov word [ebp - 0x103e], dx
mov eax, dword [ebp - 0xcbc]
add eax, 2
mov dword [ebp - 0xcbc], eax
mov cx, word [ebp - 0x103e]
mov word [ebp - 0x21c], cx
mov edx, dword [ebp - 0xcc0]
mov ax, word [edx]
mov word [ebp - 0x1040], ax
mov ecx, dword [ebp - 0xcc0]
invalid
invalid
inc dword [ebx - 0x7276fd3f]
inc eax
invalid
invalid
invalid
mov dx, word [ebp - 0x1040]
mov word [ebp - 0x38], dx
push esi
and esi, 0x35ca
sub esi, 0x145e4
pop esi
push ebx
xor ebx, 0xf98a
pop ebx
push eax
xor eax, 0x113f9
and eax, 0x11dbc
pop eax
push ebx
and ebx, 0x983e
add ebx, 0xb643
pop ebx
movzx eax, word [ebp - 0x38]
test eax, eax
jne 0x40b44a
movzx ecx, word [ebp - 0x21c]
movzx edx, word [ebp - 0x38]
sub ecx, edx
mov dword [ebp - 0x1620], ecx
jmp 0x40b4a4
movzx eax, word [ebp - 0x21c]
movzx ecx, word [ebp - 0x38]
cmp eax, ecx
je 0x40b372
movzx edx, word [ebp - 0x21c]
xor edx, 0x20
movzx eax, word [ebp - 0x38]
cmp edx, eax
invalid
test bh, bh

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

Disassembly:
push edx
sub edx, 0x1867e
add byte [edx + 0x53], bl
push edx
add esp, 4
xor ebx, 0x1311c
call 0x40b391
add byte [edx + 0x3a], cl
cmp ecx, dword [ebp + 0x37]
aas
add esp, 4
call 0x40b3a0
add byte [eax], bh
cmp ecx, dword [edx + ecx*2 + 0x32]
push eax
add esp, 4
pop ebx
mov ecx, dword [ebp - 0xcbc]
mov dx, word [ecx]
mov word [ebp - 0x103e], dx
mov eax, dword [ebp - 0xcbc]
add eax, 2
mov dword [ebp - 0xcbc], eax
mov cx, word [ebp - 0x103e]
mov word [ebp - 0x21c], cx
mov edx, dword [ebp - 0xcc0]
mov ax, word [edx]
mov word [ebp - 0x1040], ax
mov ecx, dword [ebp - 0xcc0]
invalid
invalid
inc dword [ebx - 0x7276fd3f]
inc eax
invalid
invalid
invalid
mov dx, word [ebp - 0x1040]
mov word [ebp - 0x38], dx
push esi
and esi, 0x35ca
sub esi, 0x145e4
pop esi
push ebx
xor ebx, 0xf98a
pop ebx
push eax
xor eax, 0x113f9
and eax, 0x11dbc
pop eax
push ebx
and ebx, 0x983e
add ebx, 0xb643
pop ebx
movzx eax, word [ebp - 0x38]
test eax, eax
jne 0x40b44a
movzx ecx, word [ebp - 0x21c]
movzx edx, word [ebp - 0x38]
sub ecx, edx
mov dword [ebp - 0x1620], ecx
jmp 0x40b4a4
movzx eax, word [ebp - 0x21c]
movzx ecx, word [ebp - 0x38]
cmp eax, ecx
je 0x40b372
movzx edx, word [ebp - 0x21c]
xor edx, 0x20
movzx eax, word [ebp - 0x38]
cmp edx, eax
invalid
test bh, bh
Function at 0x40b3f0
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push edx
sub edx, 0x1867e
add byte [edx + 0x53], bl
push edx
add esp, 4
xor ebx, 0x1311c
call 0x40b391
add byte [edx + 0x3a], cl
cmp ecx, dword [ebp + 0x37]
aas
add esp, 4
call 0x40b3a0
add byte [eax], bh
cmp ecx, dword [edx + ecx*2 + 0x32]
push eax
add esp, 4
pop ebx
mov ecx, dword [ebp - 0xcbc]
mov dx, word [ecx]
mov word [ebp - 0x103e], dx
mov eax, dword [ebp - 0xcbc]
add eax, 2
mov dword [ebp - 0xcbc], eax
mov cx, word [ebp - 0x103e]
mov word [ebp - 0x21c], cx
mov edx, dword [ebp - 0xcc0]
mov ax, word [edx]
mov word [ebp - 0x1040], ax
mov ecx, dword [ebp - 0xcc0]
invalid
invalid
inc dword [ebx - 0x7276fd3f]
inc eax
invalid
invalid
invalid
mov dx, word [ebp - 0x1040]
mov word [ebp - 0x38], dx
push esi
and esi, 0x35ca
sub esi, 0x145e4
pop esi
push ebx
xor ebx, 0xf98a
pop ebx
push eax
xor eax, 0x113f9
and eax, 0x11dbc
pop eax
push ebx
and ebx, 0x983e
add ebx, 0xb643
pop ebx
movzx eax, word [ebp - 0x38]
test eax, eax
jne 0x40b44a
movzx ecx, word [ebp - 0x21c]
movzx edx, word [ebp - 0x38]
sub ecx, edx
mov dword [ebp - 0x1620], ecx
jmp 0x40b4a4
movzx eax, word [ebp - 0x21c]
movzx ecx, word [ebp - 0x38]
cmp eax, ecx
je 0x40b372
movzx edx, word [ebp - 0x21c]
xor edx, 0x20
movzx eax, word [ebp - 0x38]
cmp edx, eax
invalid
test bh, bh

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

Disassembly:
push esi
add esp, 4
or esi, 0xeae3
jmp 0x40b4d8
or esi, 0x14294
pop esi
mov ecx, dword [ebp - 0x514]
mov dword [ebp - 0x2fc], ecx
jmp 0x40b555

Function at 0x40b550
Capabilities:
Contain obfuscated stackstrings
Get number of processors
Resolve function by parsing pe exports

Disassembly:
inc dword [eax]
add byte [eax], al
add byte [ecx - 0x7f], dl
jmp 0x41ceed
in al, dx
add byte [eax], al
mov cl, byte [esi + 0xff89]
test byte [esi + 0xff89], bh
add dword [ebp + 0xd], esi
enter 0xffffffffffffed86, 0xffffffffffffffff
add byte [eax], al
add dword [ecx], eax
add dword [ecx], eax
in al, dx
and al, cl
xchg ch, ch
inc dword [eax]
add byte [0xecc10103], al
adc al, 0x8c
push esi
invalid
Function at 0x40bb54
Capabilities:
Resolve function by parsing pe exports

Disassembly:
mov edx, dword [ebp - 0x778]
mov eax, dword [ebp - 0x3a4]
add eax, dword [edx + 0x24]
invalid
test esp, esi
in eax, 0xff

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

Disassembly:
dec dword [ebx - 0x77773]
dec dword [ebx - 0x3a36b]
inc dword [ebx]
push ecx
sbb al, 0x89
xchg ebp, eax
invalid
Function at 0x40bc4f
Capabilities:
Resolve function by parsing pe exports

Disassembly:
inc edi
test dword [eax + edi*8 + 0xffff], eax
add byte [eax], al
jmp 0x40bb99
mov eax, dword [ebp - 0x77c]
add eax, 1
mov dword [ebp - 0x77c], eax
mov ecx, dword [ebp - 0x778]
mov edx, dword [ebp - 0x77c]
cmp edx, dword [ecx + 0x18]
jae 0x40bda5
mov eax, dword [ebp - 0x77c]
mov ecx, dword [ebp - 0x1a08]
mov edx, dword [ebp - 0x3a4]
add edx, dword [ecx + eax*4]
mov dword [ebp - 0x780], edx
mov eax, dword [ebp - 0x77c]
mov ecx, dword [ebp - 0x1a0c]
movzx edx, word [ecx + eax*2]
mov eax, dword [ebp - 0x1a10]
mov ecx, dword [ebp - 0x3a4]
add ecx, dword [eax + edx*4]
mov dword [ebp - 0x1a14], ecx
mov dword [ebp - 0x1a0], 0
jmp 0x40bc09
mov edx, dword [ebp - 0x1a0]
add edx, 1
mov dword [ebp - 0x1a0], edx
mov eax, dword [ebp - 0x780]
add eax, dword [ebp - 0x1a0]
movsx ecx, byte [eax]
test ecx, ecx
je 0x40bcbb
mov edx, dword [ebp - 0x1a0]
movsx eax, byte [ebp + edx - 0x8a4]
test eax, eax
je 0x40bcbb
push esi
push ebx
add esp, 4
xor esi, 0xe7ef
pop esi
push esi
call 0x40bc4f
add byte [edi + 0x4f], cl
cmp eax, dword [ebp + 0x34]
xor al, byte [ebx + 0x7eb04c4]
inc eax
cmp byte [eax + 0x40], al
inc ebx
aas
or esi, 0x548f
sub esi, 0xa434
pop esi
mov ecx, dword [ebp - 0x780]
add ecx, dword [ebp - 0x1a0]
movsx edx, byte [ecx]
mov eax, dword [ebp - 0x1a0]
movsx ecx, byte [ebp + eax - 0x8a4]
cmp edx, ecx
je 0x40bcad
mov edx, dword [ebp - 0x780]
add edx, dword [ebp - 0x1a0]
movsx eax, byte [edx]
xor eax, 0x20
mov ecx, dword [ebp - 0x1a0]
movsx edx, byte [ebp + ecx - 0x8a4]
cmp eax, edx
jne 0x40bcb4
jmp 0x40bbfa
jmp 0x40bcbb
push esi
or esi, 0x8623
or esi, 0xb01d
xor esi, 0x5f42
add byte [eax], al
pop esi
push edx
push edi
add esp, 4
jmp 0x40bcda
jmp 0x40bce0
and edx, 0xb7cd
and edx, 0x23f6
pop edx
mov eax, dword [ebp - 0x780]
add eax, dword [ebp - 0x1a0]
movsx ecx, byte [eax]
mov edx, dword [ebp - 0x1a0]
movsx eax, byte [ebp + edx - 0x8a4]
cmp ecx, eax
jne 0x40bd1a
mov dword [ebp - 0xcd4], 0
jmp 0x40bd89
push esi
jmp 0x40bd23
pop esi
push esi
xor esi, 0x6296
jmp 0x40bd34
and esi, 0x8f4f
call 0x40bd48
add byte [ebx + 0x3d], cl
cmp byte [eax], bh
xor al, 0x4e
push eax
inc esp
add esp, 4
pop esi
mov ecx, dword [ebp - 0x780]
add ecx, dword [ebp - 0x1a0]
movsx edx, byte [ecx]
or edx, 0x20
mov eax, dword [ebp - 0x1a0]
movsx ecx, byte [ebp + eax - 0x8a4]
or ecx, 0x20
cmp edx, ecx
jge 0x40bd7f
mov dword [ebp - 0xcd4], 0xffffffff
jmp 0x40bd89
mov dword [ebp - 0xcd4], 1
cmp dword [ebp - 0xcd4], 0
jne 0x40bda0
mov edx, dword [ebp - 0x1a14]
mov dword [ebp - 0x3f8], edx
jmp 0x40bdb1
jmp 0x40bb8a
mov eax, dword [ebp - 0x784]
mov dword [ebp - 0x3f8], eax
cmp dword [ebp - 0x3f8], 0
je 0x40be8c
push ecx
push ecx
add esp, 4
and ecx, 0x38
or ecx, 0x4392
and ecx, 0xd734
pop ecx
push eax
xor eax, 0xb26e
xor eax, 0x17652
xor eax, 0x8951
and eax, 0xc152
pop eax
Function at 0x40bd48
Capabilities:
Resolve function by parsing pe exports

Disassembly:
inc edi
test dword [eax + edi*8 + 0xffff], eax
add byte [eax], al
jmp 0x40bb99
mov eax, dword [ebp - 0x77c]
add eax, 1
mov dword [ebp - 0x77c], eax
mov ecx, dword [ebp - 0x778]
mov edx, dword [ebp - 0x77c]
cmp edx, dword [ecx + 0x18]
jae 0x40bda5
mov eax, dword [ebp - 0x77c]
mov ecx, dword [ebp - 0x1a08]
mov edx, dword [ebp - 0x3a4]
add edx, dword [ecx + eax*4]
mov dword [ebp - 0x780], edx
mov eax, dword [ebp - 0x77c]
mov ecx, dword [ebp - 0x1a0c]
movzx edx, word [ecx + eax*2]
mov eax, dword [ebp - 0x1a10]
mov ecx, dword [ebp - 0x3a4]
add ecx, dword [eax + edx*4]
mov dword [ebp - 0x1a14], ecx
mov dword [ebp - 0x1a0], 0
jmp 0x40bc09
mov edx, dword [ebp - 0x1a0]
add edx, 1
mov dword [ebp - 0x1a0], edx
mov eax, dword [ebp - 0x780]
add eax, dword [ebp - 0x1a0]
movsx ecx, byte [eax]
test ecx, ecx
je 0x40bcbb
mov edx, dword [ebp - 0x1a0]
movsx eax, byte [ebp + edx - 0x8a4]
test eax, eax
je 0x40bcbb
push esi
push ebx
add esp, 4
xor esi, 0xe7ef
pop esi
push esi
call 0x40bc4f
add byte [edi + 0x4f], cl
cmp eax, dword [ebp + 0x34]
xor al, byte [ebx + 0x7eb04c4]
inc eax
cmp byte [eax + 0x40], al
inc ebx
aas
or esi, 0x548f
sub esi, 0xa434
pop esi
mov ecx, dword [ebp - 0x780]
add ecx, dword [ebp - 0x1a0]
movsx edx, byte [ecx]
mov eax, dword [ebp - 0x1a0]
movsx ecx, byte [ebp + eax - 0x8a4]
cmp edx, ecx
je 0x40bcad
mov edx, dword [ebp - 0x780]
add edx, dword [ebp - 0x1a0]
movsx eax, byte [edx]
xor eax, 0x20
mov ecx, dword [ebp - 0x1a0]
movsx edx, byte [ebp + ecx - 0x8a4]
cmp eax, edx
jne 0x40bcb4
jmp 0x40bbfa
jmp 0x40bcbb
push esi
or esi, 0x8623
or esi, 0xb01d
xor esi, 0x5f42
add byte [eax], al
pop esi
push edx
push edi
add esp, 4
jmp 0x40bcda
jmp 0x40bce0
and edx, 0xb7cd
and edx, 0x23f6
pop edx
mov eax, dword [ebp - 0x780]
add eax, dword [ebp - 0x1a0]
movsx ecx, byte [eax]
mov edx, dword [ebp - 0x1a0]
movsx eax, byte [ebp + edx - 0x8a4]
cmp ecx, eax
jne 0x40bd1a
mov dword [ebp - 0xcd4], 0
jmp 0x40bd89
push esi
jmp 0x40bd23
pop esi
push esi
xor esi, 0x6296
jmp 0x40bd34
and esi, 0x8f4f
call 0x40bd48
add byte [ebx + 0x3d], cl
cmp byte [eax], bh
xor al, 0x4e
push eax
inc esp
add esp, 4
pop esi
mov ecx, dword [ebp - 0x780]
add ecx, dword [ebp - 0x1a0]
movsx edx, byte [ecx]
or edx, 0x20
mov eax, dword [ebp - 0x1a0]
movsx ecx, byte [ebp + eax - 0x8a4]
or ecx, 0x20
cmp edx, ecx
jge 0x40bd7f
mov dword [ebp - 0xcd4], 0xffffffff
jmp 0x40bd89
mov dword [ebp - 0xcd4], 1
cmp dword [ebp - 0xcd4], 0
jne 0x40bda0
mov edx, dword [ebp - 0x1a14]
mov dword [ebp - 0x3f8], edx
jmp 0x40bdb1
jmp 0x40bb8a
mov eax, dword [ebp - 0x784]
mov dword [ebp - 0x3f8], eax
cmp dword [ebp - 0x3f8], 0
je 0x40be8c
push ecx
push ecx
add esp, 4
and ecx, 0x38
or ecx, 0x4392
and ecx, 0xd734
pop ecx
push eax
xor eax, 0xb26e
xor eax, 0x17652
xor eax, 0x8951
and eax, 0xc152
pop eax