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

Disassembly:
push edx
call 0x1000605a
add byte [ecx + 0x3f], cl
cmp edx, dword [eax + 0x43]
xor dh, byte [edx + edi]
dec esp
dec ebx
add esp, 4
call 0x1000606b
add byte [eax], bh
inc ebx
dec esi
dec ecx
inc esi
inc edx
cmp ecx, dword [edx - 0x7d]
les eax, [ecx + eax*4]
invalid
push edx
push ebx
add esp, 4
add edx, 0x17eb9
jmp 0x100060b9
pop edx
push eax
xor eax, 0x8081
add byte [ecx + 0x3e2cf0], al
add byte [ecx + 0x131cde8], al
add byte [eax + 0x51], bl
push ebx
add esp, 4
add ecx, 0x163d0
pop ecx
mov ecx, dword [ebp - 0xeb4]
push ebx
push ecx
add esp, 4
xor ebx, 0x4c4a
pop ebx
push edi
and edi, 0x8064
add edi, 0x163b8
sub edi, 0x16537
sub edi, 0x8df6
pop edi
movzx eax, word [ebp - 0x13c]
test eax, eax
jne 0x10006189
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
sub ecx, edx
mov dword [ebp - 0x1920], ecx
jmp 0x100061ec
movzx eax, word [ebp - 0x274]
movzx ecx, word [ebp - 0x13c]
cmp eax, ecx
je 0x100060a8
movzx edx, word [ebp - 0x274]
xor edx, 0x20
movzx eax, word [ebp - 0x13c]
cmp edx, eax
je 0x100060a8
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
cmp ecx, edx
jge 0x100061d6
mov dword [ebp - 0x191c], 0xffffffff
jmp 0x100061e0
mov dword [ebp - 0x191c], 1
mov eax, dword [ebp - 0x191c]
mov dword [ebp - 0x1920], eax
cmp dword [ebp - 0x1920], 0
jne 0x10006235
push ebx
push eax
add esp, 4
xor ebx, 0x53c6
xor ebx, 0xc58b
add ebx, 0x14c06
pop ebx
push esi
push esi
add esp, 4
xor esi, 0xc6af
jmp fcn.10006220
push ebx
and ebx, 0x6de9
or ebx, 0x3910
pop ebx
push esi
or esi, 0x233c
and esi, 0x8e08
jmp 0x10006256
call 0x10006263
add byte [ecx + 0x48], al
cmp ecx, dword ds:[edi + 0x4a]
inc esi
add esp, 4
pop esi
mov edx, dword [ebp - 0x5d4]
mov eax, dword [edx]
mov dword [ebp - 0x5d4], eax
mov ecx, dword [ebp - 0x5d4]
cmp ecx, dword [ebp - 0xebc]
je 0x10006293
mov edx, dword [ebp - 0x5d4]
cmp dword [edx + 0x30], 0
jne 0x10006049
mov dword [ebp - 0x888], 0
push edi
push esi
add esp, 4
jmp 0x100062a8
call 0x100062b7
add byte [eax + 0x44], al
cmp dword [ebp + 0x41], ecx
inc ebx
xor eax, 0xc483484f
add al, 0x81
invalid

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

Disassembly:
mov dx, word [ecx]
mov word [ebp - 0x12ca], dx
mov eax, dword [ebp - 0xeb4]
add eax, 2
mov dword [ebp - 0xeb4], eax
mov cx, word [ebp - 0x12ca]
mov word [ebp - 0x274], cx
mov edx, dword [ebp - 0xeb8]
mov ax, word [edx]
mov word [ebp - 0x12cc], ax
mov ecx, dword [ebp - 0xeb8]
add ecx, 2

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

Disassembly:
mov dword [ebp - 0xeb8], ecx
mov dx, word [ebp - 0x12cc]
mov word [ebp - 0x13c], dx
push ebx
push ecx
add esp, 4
jmp 0x1000613f
pop ebx
Function at 0x10006140
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push edx
call 0x1000605a
add byte [ecx + 0x3f], cl
cmp edx, dword [eax + 0x43]
xor dh, byte [edx + edi]
dec esp
dec ebx
add esp, 4
call 0x1000606b
add byte [eax], bh
inc ebx
dec esi
dec ecx
inc esi
inc edx
cmp ecx, dword [edx - 0x7d]
les eax, [ecx + eax*4]
invalid
push edx
push ebx
add esp, 4
add edx, 0x17eb9
jmp 0x100060b9
pop edx
push eax
xor eax, 0x8081
add byte [ecx + 0x3e2cf0], al
add byte [ecx + 0x131cde8], al
add byte [eax + 0x51], bl
push ebx
add esp, 4
add ecx, 0x163d0
pop ecx
mov ecx, dword [ebp - 0xeb4]
push ebx
push ecx
add esp, 4
xor ebx, 0x4c4a
pop ebx
push edi
and edi, 0x8064
add edi, 0x163b8
sub edi, 0x16537
sub edi, 0x8df6
pop edi
movzx eax, word [ebp - 0x13c]
test eax, eax
jne 0x10006189
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
sub ecx, edx
mov dword [ebp - 0x1920], ecx
jmp 0x100061ec
movzx eax, word [ebp - 0x274]
movzx ecx, word [ebp - 0x13c]
cmp eax, ecx
je 0x100060a8
movzx edx, word [ebp - 0x274]
xor edx, 0x20
movzx eax, word [ebp - 0x13c]
cmp edx, eax
je 0x100060a8
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
cmp ecx, edx
jge 0x100061d6
mov dword [ebp - 0x191c], 0xffffffff
jmp 0x100061e0
mov dword [ebp - 0x191c], 1
mov eax, dword [ebp - 0x191c]
mov dword [ebp - 0x1920], eax
cmp dword [ebp - 0x1920], 0
jne 0x10006235
push ebx
push eax
add esp, 4
xor ebx, 0x53c6
xor ebx, 0xc58b
add ebx, 0x14c06
pop ebx
push esi
push esi
add esp, 4
xor esi, 0xc6af
jmp fcn.10006220
push ebx
and ebx, 0x6de9
or ebx, 0x3910
pop ebx
push esi
or esi, 0x233c
and esi, 0x8e08
jmp 0x10006256
call 0x10006263
add byte [ecx + 0x48], al
cmp ecx, dword ds:[edi + 0x4a]
inc esi
add esp, 4
pop esi
mov edx, dword [ebp - 0x5d4]
mov eax, dword [edx]
mov dword [ebp - 0x5d4], eax
mov ecx, dword [ebp - 0x5d4]
cmp ecx, dword [ebp - 0xebc]
je 0x10006293
mov edx, dword [ebp - 0x5d4]
cmp dword [edx + 0x30], 0
jne 0x10006049
mov dword [ebp - 0x888], 0
push edi
push esi
add esp, 4
jmp 0x100062a8
call 0x100062b7
add byte [eax + 0x44], al
cmp dword [ebp + 0x41], ecx
inc ebx
xor eax, 0xc483484f
add al, 0x81
invalid

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

Disassembly:
xor esi, 0x163b1
pop esi
mov ecx, dword [ebp - 0x5d4]
mov dword [ebp - 0x888], ecx
jmp 0x1000629d
Function at 0x10006263
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push edx
call 0x1000605a
add byte [ecx + 0x3f], cl
cmp edx, dword [eax + 0x43]
xor dh, byte [edx + edi]
dec esp
dec ebx
add esp, 4
call 0x1000606b
add byte [eax], bh
inc ebx
dec esi
dec ecx
inc esi
inc edx
cmp ecx, dword [edx - 0x7d]
les eax, [ecx + eax*4]
invalid
push edx
push ebx
add esp, 4
add edx, 0x17eb9
jmp 0x100060b9
pop edx
push eax
xor eax, 0x8081
add byte [ecx + 0x3e2cf0], al
add byte [ecx + 0x131cde8], al
add byte [eax + 0x51], bl
push ebx
add esp, 4
add ecx, 0x163d0
pop ecx
mov ecx, dword [ebp - 0xeb4]
push ebx
push ecx
add esp, 4
xor ebx, 0x4c4a
pop ebx
push edi
and edi, 0x8064
add edi, 0x163b8
sub edi, 0x16537
sub edi, 0x8df6
pop edi
movzx eax, word [ebp - 0x13c]
test eax, eax
jne 0x10006189
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
sub ecx, edx
mov dword [ebp - 0x1920], ecx
jmp 0x100061ec
movzx eax, word [ebp - 0x274]
movzx ecx, word [ebp - 0x13c]
cmp eax, ecx
je 0x100060a8
movzx edx, word [ebp - 0x274]
xor edx, 0x20
movzx eax, word [ebp - 0x13c]
cmp edx, eax
je 0x100060a8
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
cmp ecx, edx
jge 0x100061d6
mov dword [ebp - 0x191c], 0xffffffff
jmp 0x100061e0
mov dword [ebp - 0x191c], 1
mov eax, dword [ebp - 0x191c]
mov dword [ebp - 0x1920], eax
cmp dword [ebp - 0x1920], 0
jne 0x10006235
push ebx
push eax
add esp, 4
xor ebx, 0x53c6
xor ebx, 0xc58b
add ebx, 0x14c06
pop ebx
push esi
push esi
add esp, 4
xor esi, 0xc6af
jmp fcn.10006220
push ebx
and ebx, 0x6de9
or ebx, 0x3910
pop ebx
push esi
or esi, 0x233c
and esi, 0x8e08
jmp 0x10006256
call 0x10006263
add byte [ecx + 0x48], al
cmp ecx, dword ds:[edi + 0x4a]
inc esi
add esp, 4
pop esi
mov edx, dword [ebp - 0x5d4]
mov eax, dword [edx]
mov dword [ebp - 0x5d4], eax
mov ecx, dword [ebp - 0x5d4]
cmp ecx, dword [ebp - 0xebc]
je 0x10006293
mov edx, dword [ebp - 0x5d4]
cmp dword [edx + 0x30], 0
jne 0x10006049
mov dword [ebp - 0x888], 0
push edi
push esi
add esp, 4
jmp 0x100062a8
call 0x100062b7
add byte [eax + 0x44], al
cmp dword [ebp + 0x41], ecx
inc ebx
xor eax, 0xc483484f
add al, 0x81
invalid
Function at 0x100062b7
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
push edx
call 0x1000605a
add byte [ecx + 0x3f], cl
cmp edx, dword [eax + 0x43]
xor dh, byte [edx + edi]
dec esp
dec ebx
add esp, 4
call 0x1000606b
add byte [eax], bh
inc ebx
dec esi
dec ecx
inc esi
inc edx
cmp ecx, dword [edx - 0x7d]
les eax, [ecx + eax*4]
invalid
push edx
push ebx
add esp, 4
add edx, 0x17eb9
jmp 0x100060b9
pop edx
push eax
xor eax, 0x8081
add byte [ecx + 0x3e2cf0], al
add byte [ecx + 0x131cde8], al
add byte [eax + 0x51], bl
push ebx
add esp, 4
add ecx, 0x163d0
pop ecx
mov ecx, dword [ebp - 0xeb4]
push ebx
push ecx
add esp, 4
xor ebx, 0x4c4a
pop ebx
push edi
and edi, 0x8064
add edi, 0x163b8
sub edi, 0x16537
sub edi, 0x8df6
pop edi
movzx eax, word [ebp - 0x13c]
test eax, eax
jne 0x10006189
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
sub ecx, edx
mov dword [ebp - 0x1920], ecx
jmp 0x100061ec
movzx eax, word [ebp - 0x274]
movzx ecx, word [ebp - 0x13c]
cmp eax, ecx
je 0x100060a8
movzx edx, word [ebp - 0x274]
xor edx, 0x20
movzx eax, word [ebp - 0x13c]
cmp edx, eax
je 0x100060a8
movzx ecx, word [ebp - 0x274]
movzx edx, word [ebp - 0x13c]
cmp ecx, edx
jge 0x100061d6
mov dword [ebp - 0x191c], 0xffffffff
jmp 0x100061e0
mov dword [ebp - 0x191c], 1
mov eax, dword [ebp - 0x191c]
mov dword [ebp - 0x1920], eax
cmp dword [ebp - 0x1920], 0
jne 0x10006235
push ebx
push eax
add esp, 4
xor ebx, 0x53c6
xor ebx, 0xc58b
add ebx, 0x14c06
pop ebx
push esi
push esi
add esp, 4
xor esi, 0xc6af
jmp fcn.10006220
push ebx
and ebx, 0x6de9
or ebx, 0x3910
pop ebx
push esi
or esi, 0x233c
and esi, 0x8e08
jmp 0x10006256
call 0x10006263
add byte [ecx + 0x48], al
cmp ecx, dword ds:[edi + 0x4a]
inc esi
add esp, 4
pop esi
mov edx, dword [ebp - 0x5d4]
mov eax, dword [edx]
mov dword [ebp - 0x5d4], eax
mov ecx, dword [ebp - 0x5d4]
cmp ecx, dword [ebp - 0xebc]
je 0x10006293
mov edx, dword [ebp - 0x5d4]
cmp dword [edx + 0x30], 0
jne 0x10006049
mov dword [ebp - 0x888], 0
push edi
push esi
add esp, 4
jmp 0x100062a8
call 0x100062b7
add byte [eax + 0x44], al
cmp dword [ebp + 0x41], ecx
inc ebx
xor eax, 0xc483484f
add al, 0x81
invalid

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

Disassembly:
mov ebp, 0xfffff778
add byte [ebp + 0x41], dh
push ecx
call fcn.100062e8
add byte [ebp + 0x3d], al
dec edi
cmp ecx, dword [esi + 0x3d]
xor al, 0x34
cmp dword [ebx + 0xae804c4], eax
add esp, 4
call 0x100062fa
add byte [ebx + 0x50], al
push eax
add eax, 0xf8bf
sub eax, 0x8887
pop eax
push edx
push esi
add esp, 4
and edx, 0x260
add edx, 0x343d
and edx, 0xe997
pop edx
push esi
push eax
add esp, 4
add esi, 0x1866f
pop esi
mov ecx, dword [ebp - 0x494]
add ecx, 0xe
mov dword [ebp - 0x1fc0], ecx
push edx
jmp 0x10006e9d
pop edx
push edi
push ecx

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

Disassembly:
add esp, 4
call 0x100062fa
add byte [ebx + 0x50], al
dec esp
push eax
dec edi
inc eax
cmp dword [ebx + eax*4], esi
les eax, [ecx + ebx*2]
push eax
push ebx
add esp, 4
xor eax, 0x6bcd
pop eax
mov dword [ebp - 0x8d4], 0
jmp 0x10006e55
Function at 0x100062fa
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
add esp, 4
call 0x100062fa
add byte [ebx + 0x50], al
dec esp
push eax
dec edi
inc eax
cmp dword [ebx + eax*4], esi
les eax, [ecx + ebx*2]
push eax
push ebx
add esp, 4
xor eax, 0x6bcd
pop eax
mov dword [ebp - 0x8d4], 0
jmp 0x10006e55

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

Disassembly:
add esp, 4
pop ecx
push eax
or eax, 0xcac1
xor eax, 0x16222
sub eax, 0x43a7
or eax, 0x13ed7
pop eax
mov eax, dword [ebp - 0x888]
mov ecx, dword [eax + 0x18]
mov dword [ebp - 0x3d8], ecx
mov dword [ebp - 0x898], 0
mov edx, dword [ebp - 0x3d8]
mov dword [ebp - 0x1924], edx
cmp dword [ebp - 0x1924], 0
jne 0x1000638a
mov eax, dword [ebp - 0x898]
invalid

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

Disassembly:
mov edx, dword [ebp - 0x890]
add edx, 1
mov dword [ebp - 0x890], edx
mov eax, dword [ebp - 0x88c]
mov ecx, dword [ebp - 0x890]
cmp ecx, dword [eax + 0x18]
jae 0x1000666f
mov edx, dword [ebp - 0x890]
mov eax, dword [ebp - 0x26b8]
mov ecx, dword [ebp - 0x3d8]
add ecx, dword [eax + edx*4]
mov dword [ebp - 0x894], ecx
mov edx, dword [ebp - 0x890]
mov eax, dword [ebp - 0x26bc]
movzx ecx, word [eax + edx*2]
mov edx, dword [ebp - 0x26c0]
mov eax, dword [ebp - 0x3d8]
add eax, dword [edx + ecx*4]
mov dword [ebp - 0x26c4], eax
mov dword [ebp - 0x1e0], 0
jmp 0x100064d3
mov ecx, dword [ebp - 0x1e0]
add ecx, 1
mov dword [ebp - 0x1e0], ecx
mov edx, dword [ebp - 0x894]
add edx, dword [ebp - 0x1e0]
movsx eax, byte [edx]
test eax, eax
je 0x10006585
mov ecx, dword [ebp - 0x1e0]
movsx edx, byte [ebp + ecx - 0xb24]
test edx, edx
je 0x10006585
push eax
push edx
add esp, 4
call 0x10006513
add byte [ebx], dh
xor al, byte [ebx + 0x3a]
dec eax
cmp dword [ebx], esi
cmp eax, dword [ebx - 0x3f7efb3c]
outsb dx, byte [esi]
test dword [eax], eax
add byte [eax + 0x50], bl
push ecx
add esp, 4
les eax, [ebx + ebp*8]
invalid
pop eax
push edx
add edx, 0x1774c
pop edx
mov eax, dword [ebp - 0x894]
add eax, dword [ebp - 0x1e0]
invalid
invalid
Function at 0x10006513
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
mov edx, dword [ebp - 0x890]
add edx, 1
mov dword [ebp - 0x890], edx
mov eax, dword [ebp - 0x88c]
mov ecx, dword [ebp - 0x890]
cmp ecx, dword [eax + 0x18]
jae 0x1000666f
mov edx, dword [ebp - 0x890]
mov eax, dword [ebp - 0x26b8]
mov ecx, dword [ebp - 0x3d8]
add ecx, dword [eax + edx*4]
mov dword [ebp - 0x894], ecx
mov edx, dword [ebp - 0x890]
mov eax, dword [ebp - 0x26bc]
movzx ecx, word [eax + edx*2]
mov edx, dword [ebp - 0x26c0]
mov eax, dword [ebp - 0x3d8]
add eax, dword [edx + ecx*4]
mov dword [ebp - 0x26c4], eax
mov dword [ebp - 0x1e0], 0
jmp 0x100064d3
mov ecx, dword [ebp - 0x1e0]
add ecx, 1
mov dword [ebp - 0x1e0], ecx
mov edx, dword [ebp - 0x894]
add edx, dword [ebp - 0x1e0]
movsx eax, byte [edx]
test eax, eax
je 0x10006585
mov ecx, dword [ebp - 0x1e0]
movsx edx, byte [ebp + ecx - 0xb24]
test edx, edx
je 0x10006585
push eax
push edx
add esp, 4
call 0x10006513
add byte [ebx], dh
xor al, byte [ebx + 0x3a]
dec eax
cmp dword [ebx], esi
cmp eax, dword [ebx - 0x3f7efb3c]
outsb dx, byte [esi]
test dword [eax], eax
add byte [eax + 0x50], bl
push ecx
add esp, 4
les eax, [ebx + ebp*8]
invalid
pop eax
push edx
add edx, 0x1774c
pop edx
mov eax, dword [ebp - 0x894]
add eax, dword [ebp - 0x1e0]
invalid
invalid

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

Disassembly:
or byte [ebx - 0x1df6b], cl
dec dword [edi]
mov esi, 0xf4dc1584
invalid
Function at 0x100065a7
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
les eax, [ebx + ebp*8]
add eax, 0x3f4f3c3b
inc esp
mov ecx, dword [ebp - 0x894]
add ecx, dword [ebp - 0x1e0]
movsx edx, byte [ecx]
xor edx, 0x20
mov eax, dword [ebp - 0x1e0]
movsx ecx, byte [ebp + eax - 0xb24]
cmp edx, ecx
jne 0x1000657e
jmp 0x100064c4
jmp 0x10006585
push edi
push ecx
add esp, 4
jmp 0x10006592
pop edi
push edi
sub edi, 0x13b20
call 0x100065a7
add byte [edx], dh
xor bh, byte [ebx]
dec esi
inc esp
push eax
aaa
add esp, 4
pop edi
push edi
push eax
add esp, 4
and edi, 0xd68c
pop edi
mov edx, dword [ebp - 0x894]
add edx, dword [ebp - 0x1e0]
movsx eax, byte [edx]
mov ecx, dword [ebp - 0x1e0]
movsx edx, byte [ebp + ecx - 0xb24]
cmp eax, edx
jne 0x100065e4
mov dword [ebp - 0xec0], 0
jmp 0x10006653
push ebx
push esi
add esp, 4
sub ebx, 0x168f5
pop ebx
push esi
push ecx
add esp, 4
add esi, 0x2178
pop esi
push ecx
push edx
add esp, 4
add ecx, 0x11827
pop ecx
push edx
xor edx, 0xfb66
and edx, 0x7863
loop 0x10006675
js 0x10006614
add byte [edx - 0x75], bl
test dword [edi + esi*8 - 1], ebp
inc dword [ebx]
test dword [eax], esp
invalid
invalid
dec dword [edi]
mov esi, 0x20c98308
mov edx, dword [ebp - 0x1e0]
movsx eax, byte [ebp + edx - 0xb24]
or eax, 0x20
cmp ecx, eax
jge 0x10006649
mov dword [ebp - 0xec0], 0xffffffff
jmp 0x10006653
mov dword [ebp - 0xec0], 1
cmp dword [ebp - 0xec0], 0
jne 0x1000666a
mov ecx, dword [ebp - 0x26c4]
mov dword [ebp - 0x48c], ecx
jmp 0x1000667b
jmp 0x10006454
cmp dword [ebp - 0x48c], 0
je 0x10006756
push ebx
push eax
add esp, 4
or ebx, 0x2e79
pop ebx
push edx
jmp 0x1000669a
add edx, 0xcb1f
call 0x100066b0
add byte [edx + 0x46], al
inc ecx
aaa
inc ebx
xor eax, dword [ecx + 0x4a]
inc eax
add esp, 4
jmp 0x100066b9
pop edx
mov eax, dword [ebp - 0x48c]
Function at 0x10006610
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
les eax, [ebx + ebp*8]
add eax, 0x3f4f3c3b
inc esp
mov ecx, dword [ebp - 0x894]
add ecx, dword [ebp - 0x1e0]
movsx edx, byte [ecx]
xor edx, 0x20
mov eax, dword [ebp - 0x1e0]
movsx ecx, byte [ebp + eax - 0xb24]
cmp edx, ecx
jne 0x1000657e
jmp 0x100064c4
jmp 0x10006585
push edi
push ecx
add esp, 4
jmp 0x10006592
pop edi
push edi
sub edi, 0x13b20
call 0x100065a7
add byte [edx], dh
xor bh, byte [ebx]
dec esi
inc esp
push eax
aaa
add esp, 4
pop edi
push edi
push eax
add esp, 4
and edi, 0xd68c
pop edi
mov edx, dword [ebp - 0x894]
add edx, dword [ebp - 0x1e0]
movsx eax, byte [edx]
mov ecx, dword [ebp - 0x1e0]
movsx edx, byte [ebp + ecx - 0xb24]
cmp eax, edx
jne 0x100065e4
mov dword [ebp - 0xec0], 0
jmp 0x10006653
push ebx
push esi
add esp, 4
sub ebx, 0x168f5
pop ebx
push esi
push ecx
add esp, 4
add esi, 0x2178
pop esi
push ecx
push edx
add esp, 4
add ecx, 0x11827
pop ecx
push edx
xor edx, 0xfb66
and edx, 0x7863
loop 0x10006675
js 0x10006614
add byte [edx - 0x75], bl
test dword [edi + esi*8 - 1], ebp
inc dword [ebx]
test dword [eax], esp
invalid
invalid
dec dword [edi]
mov esi, 0x20c98308
mov edx, dword [ebp - 0x1e0]
movsx eax, byte [ebp + edx - 0xb24]
or eax, 0x20
cmp ecx, eax
jge 0x10006649
mov dword [ebp - 0xec0], 0xffffffff
jmp 0x10006653
mov dword [ebp - 0xec0], 1
cmp dword [ebp - 0xec0], 0
jne 0x1000666a
mov ecx, dword [ebp - 0x26c4]
mov dword [ebp - 0x48c], ecx
jmp 0x1000667b
jmp 0x10006454
cmp dword [ebp - 0x48c], 0
je 0x10006756
push ebx
push eax
add esp, 4
or ebx, 0x2e79
pop ebx
push edx
jmp 0x1000669a
add edx, 0xcb1f
call 0x100066b0
add byte [edx + 0x46], al
inc ecx
aaa
inc ebx
xor eax, dword [ecx + 0x4a]
inc eax
add esp, 4
jmp 0x100066b9
pop edx
mov eax, dword [ebp - 0x48c]
Function at 0x100066b0
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
les eax, [ebx + ebp*8]
add eax, 0x3f4f3c3b
inc esp
mov ecx, dword [ebp - 0x894]
add ecx, dword [ebp - 0x1e0]
movsx edx, byte [ecx]
xor edx, 0x20
mov eax, dword [ebp - 0x1e0]
movsx ecx, byte [ebp + eax - 0xb24]
cmp edx, ecx
jne 0x1000657e
jmp 0x100064c4
jmp 0x10006585
push edi
push ecx
add esp, 4
jmp 0x10006592
pop edi
push edi
sub edi, 0x13b20
call 0x100065a7
add byte [edx], dh
xor bh, byte [ebx]
dec esi
inc esp
push eax
aaa
add esp, 4
pop edi
push edi
push eax
add esp, 4
and edi, 0xd68c
pop edi
mov edx, dword [ebp - 0x894]
add edx, dword [ebp - 0x1e0]
movsx eax, byte [edx]
mov ecx, dword [ebp - 0x1e0]
movsx edx, byte [ebp + ecx - 0xb24]
cmp eax, edx
jne 0x100065e4
mov dword [ebp - 0xec0], 0
jmp 0x10006653
push ebx
push esi
add esp, 4
sub ebx, 0x168f5
pop ebx
push esi
push ecx
add esp, 4
add esi, 0x2178
pop esi
push ecx
push edx
add esp, 4
add ecx, 0x11827
pop ecx
push edx
xor edx, 0xfb66
and edx, 0x7863
loop 0x10006675
js 0x10006614
add byte [edx - 0x75], bl
test dword [edi + esi*8 - 1], ebp
inc dword [ebx]
test dword [eax], esp
invalid
invalid
dec dword [edi]
mov esi, 0x20c98308
mov edx, dword [ebp - 0x1e0]
movsx eax, byte [ebp + edx - 0xb24]
or eax, 0x20
cmp ecx, eax
jge 0x10006649
mov dword [ebp - 0xec0], 0xffffffff
jmp 0x10006653
mov dword [ebp - 0xec0], 1
cmp dword [ebp - 0xec0], 0
jne 0x1000666a
mov ecx, dword [ebp - 0x26c4]
mov dword [ebp - 0x48c], ecx
jmp 0x1000667b
jmp 0x10006454
cmp dword [ebp - 0x48c], 0
je 0x10006756
push ebx
push eax
add esp, 4
or ebx, 0x2e79
pop ebx
push edx
jmp 0x1000669a
add edx, 0xcb1f
call 0x100066b0
add byte [edx + 0x46], al
inc ecx
aaa
inc ebx
xor eax, dword [ecx + 0x4a]
inc eax
add esp, 4
jmp 0x100066b9
pop edx
mov eax, dword [ebp - 0x48c]

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

Disassembly:
mov dword [ebp - 0x26c8], eax
push ecx
and ecx, 0x5d56
xor ecx, 0x11f6
add ecx, 0xd30e
pop ecx
push edx
push esi
add esp, 4
sub edx, 0x55c9
add edx, 0xd12b
or edx, 0x40a5
xor edx, 0xf69b
pop edx
mov ecx, dword [ebp - 0x26c8]
mov dword [ebp - 0x26cc], ecx
lea edx, [ebp - 0x1a88]
push edx
call dword [ebp - 0x26cc]
test eax, eax
jne 0x10006756
push edx
jmp 0x1000671e
and edx, 0xf1a5
pop edx
push eax
or eax, 0xdf7e
sub eax, 0x12b90
add eax, 0x35fd
pop eax
push edi
xor edi, 0x21ff
add edi, 0x596
pop edi
mov dword [ebp - 0x8d4], 0
jmp 0x10006e55
push ecx
push ecx
add esp, 4
or ecx, 0x3d7b
add byte [ecx + 0x5916e1], al
add byte [ecx + 0xe382c9], al
add bl, ch
invalid
pop ecx
push edx
or edx, 0xde31
sub edx, 0xe5e
or edx, 0x9460
pop edx
mov eax, dword fs:[0x18]
mov dword [ebp - 0x26d0], eax
mov ecx, dword [ebp - 0x26d0]
mov edx, dword [ecx + 0x30]
mov dword [ebp - 0x26d4], edx
mov eax, dword [ebp - 0x26d4]
mov dword [ebp - 0x1930], eax
push esi
push ebx
add esp, 4
sub esi, 0xc04a
sub esi, 0x1278
and esi, 0x3f86
pop esi
push edi
add edi, 0x932b
xor edi, 0x87fc
sub edi, 0x12576
and edi, 0x11456
Function at 0x100067e0
Capabilities:
Get number of processors
Resolve function by parsing pe exports

Disassembly:
pop edi
cmp dword [ebp - 0x1930], 0
jne 0x100067f9
mov dword [ebp - 0x37c], 0
jmp 0x10006ab5
mov ecx, dword [ebp - 0x1930]
mov edx, dword [ecx + 0xc]
mov eax, dword [edx + 0xc]
mov dword [ebp - 0xecc], eax
push edx
push edx
add esp, 4
or edx, 0x15901
xor edx, 0xbb08
xor edx, 0xc8c1
pop edx
push eax
push eax
add esp, 4
add eax, 0x12bd0
and eax, 0x5cf7
pop eax
push eax
and eax, 0x14f89
pop eax
cmp dword [ebp - 0xecc], 0
jne 0x10006855
mov dword [ebp - 0x37c], 0
mov ecx, dword [ebp - 0xecc]
mov dword [ebp - 0x5d8], ecx
push edx
push esi
add esp, 4
and edx, 0xa46f
pop edx
push edi
or edi, 0x2891
sub edi, 0xff86
xor edi, 0x8159
call 0x1000688f
add byte [ecx + 0x45], cl
dec ebp
dec ebx
cmp esi, dword [edx]
cmp dword [edx], edi
invalid

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

Disassembly:
add byte [ecx + 0xe941e6], al
add byte [esi + 0x51], bl

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

Disassembly:
add esp, 4
pop edx
mov ecx, dword [ebp - 0x5d8]
mov dword [ebp - 0x37c], ecx
jmp 0x10006ab5