joyce8/EMBER2024-capa huggingface dataset:
Function at 0x10014ca0
Capabilities:
Hash data with md5

Disassembly:
mov byte [ecx + 0x68], 0
mov eax, ecx
mov dword [ecx + 0x10], 0
mov dword [ecx + 0x14], 0
mov dword [ecx], 0x67452301
mov dword [ecx + 4], 0xefcdab89
mov dword [ecx + 8], 0x98badcfe
mov dword [ecx + 0xc], 0x10325476
ret

Function at 0x10015b10
Capabilities:
Access peb ldr_data

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x10069806
mov eax, dword fs:[0]
push eax
sub esp, 0x14
push esi
mov eax, dword [0x100854b4]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov esi, ecx
mov dword [ebp - 0x10], esi
mov eax, dword [ebp + 8]
mov dword [esi], eax
mov dword [esi + 4], 0
mov dword [esi + 8], 0
mov dword [ebp - 4], 0
mov dword [esi + 0xc], 0
mov dword [esi + 0x10], 0
mov dword [esi + 0x14], 0
mov ecx, dword [esi]
lea edx, [ebp - 0x18]
mov eax, dword [ebp + 0xc]
mov dword [esi + 0x1c], eax
push edx
mov eax, dword [ecx + 0x74]
mov byte [ebp - 4], 1
mov eax, dword [eax + 0x28]
mov dword [esi + 0x20], eax
mov ecx, dword [ecx + 0x10]
mov eax, dword [ecx]
call dword [eax + 8]
mov ecx, dword [eax + 4]
mov eax, dword [esi + 0x20]
sub eax, ecx
mov dword [esi + 0x24], ecx
mov dword [esi + 0x28], eax
mov dword [esi + 0x2c], 0
mov dword [esi + 0x30], 0
mov dword [esi + 0x3c], 0
mov dword [esi + 0x40], 0
mov dword [esi + 0x44], 0
mov dword [esi + 0x6c], 0
mov eax, dword [esi]
lea edx, [ebp - 0x20]
mov dword [esi + 0x70], 0
push edx
mov byte [ebp - 4], 2
mov ecx, dword [eax + 0x10]
mov eax, dword [ecx]
call dword [eax + 4]
mov ecx, dword [esi]
mov eax, dword [eax + 0xc]
mov dword [esi + 0x18], eax
mov eax, dword [ecx + 0x4c]
mov dword [esi + 0x30], eax
mov eax, dword [ecx + 0x50]
add eax, dword [ecx + 0x4c]
mov dword [esi + 0x44], eax
mov eax, esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop esi
mov esp, ebp
pop ebp
ret 8
Function at 0x100282f0
Capabilities:
Read file on windows

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x10069ce0
mov eax, dword fs:[0]
push eax
push ecx
push ebx
push esi
push edi
mov eax, dword [0x100854b4]
xor eax, ebp
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov esi, ecx
mov dword [ebp - 0x10], esi
mov ebx, dword [ebp + 8]
push 2
push 0
mov dword [esi], fcn.100284b0
mov dword [esi + 4], 0
push ebx
mov dword [esi + 8], 0
call fcn.1004960a
add esp, 0xc
test eax, eax
jne 0x100283c8
push ebx
call fcn.10049c1d
mov edi, eax
add esp, 4
test edi, edi
js 0x100283c8
push 0
push 0
push ebx
call fcn.1004960a
add esp, 0xc
test eax, eax
jne 0x100283c8
push edi
call fcn.100481ec
add esp, 4
mov ecx, dword [esi + 4]
mov dword [ebp - 4], 0
mov dword [esi + 4], eax
test ecx, ecx
je 0x10028397
mov eax, dword [esi]
push ecx
cmp eax, fcn.100284b0
jne 0x10028392
call fcn.10045e53
jmp 0x10028394
call eax
add esp, 4
mov eax, dword [esi + 4]
test eax, eax
je 0x100283c8
push ebx
push edi
push 1
push eax
call fcn.10048c54
add esp, 0x10
cmp eax, edi
mov eax, esi
jne 0x100283ca
mov dword [esi + 8], edi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 4
mov eax, esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 4

Function at 0x10058e27
Capabilities:
Read file on windows

Disassembly:
mov edi, edi
push ebp
mov ebp, esp
pop ebp
jmp fcn.10058c9d

Function at 0x1005ce4b
Capabilities:
Set environment variable

Disassembly:
mov edi, edi
push ebp
mov ebp, esp
pop ebp
jmp fcn.1005cac8
Function at 0x10066d60
Capabilities:
Compute adler32 checksum

Disassembly:
push ebp
mov ebp, esp
pop ebp
jmp fcn.10066d70

Function at 0x10067160
Capabilities:
Encode data using xor
Hash data with crc32

Disassembly:
push ebp
mov ebp, esp
pop ebp
jmp fcn.10067170

Function at 0x10d88058
Capabilities:
Decompress data using aplib

Disassembly:
call 0x10d881a8
push ebx
mov ebx, esp
push ebx
mov esi, dword [ebx + 8]
mov edi, dword [ebx + 0x10]
cld
mov dl, 0x80
mov al, byte [esi]
inc esi
mov byte [edi], al
inc edi
mov ebx, 2
add dl, dl
jne 0x10d8807e
mov dl, byte [esi]
inc esi
adc dl, dl
jae 0x10d8806a
add dl, dl
jne 0x10d88089
mov dl, byte [esi]
inc esi
adc dl, dl
jae 0x10d880dc
xor eax, eax
add dl, dl
jne 0x10d88096
mov dl, byte [esi]
inc esi
adc dl, dl
jae 0x10d8817d
add dl, dl
jne 0x10d880a5
mov dl, byte [esi]
inc esi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x10d880b0
mov dl, byte [esi]
inc esi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x10d880bb
mov dl, byte [esi]
inc esi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x10d880c6
mov dl, byte [esi]
inc esi
adc dl, dl
adc eax, eax
je 0x10d880d2
push edi
mov eax, eax
sub edi, eax
mov al, byte [edi]
pop edi
mov byte [edi], al
inc edi
mov ebx, 2
jmp 0x10d88075
mov eax, 1
add dl, dl
jne 0x10d880ea
mov dl, byte [esi]
inc esi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x10d880f5
mov dl, byte [esi]
inc esi
adc dl, dl
jb 0x10d880e1
sub eax, ebx
mov ebx, 1
jne 0x10d88128
mov ecx, 1
add dl, dl
jne 0x10d8810e
mov dl, byte [esi]
inc esi
adc dl, dl
adc ecx, ecx
add dl, dl
jne 0x10d88119
mov dl, byte [esi]
inc esi
adc dl, dl
jb 0x10d88105
push esi
mov esi, edi
sub esi, ebp
rep movsb byte es:[edi], byte [esi]
pop esi
jmp 0x10d88075
dec eax
shl eax, 8
mov al, byte [esi]
inc esi
mov ebp, eax
mov ecx, 1
add dl, dl
jne 0x10d8813f
mov dl, byte [esi]
inc esi
adc dl, dl
adc ecx, ecx
add dl, dl
jne 0x10d8814a
mov dl, byte [esi]
inc esi
adc dl, dl
jb 0x10d88136
cmp eax, 0x7d00
jae 0x10d8816d
cmp eax, 0x500
jb 0x10d88168
inc ecx
push esi
mov esi, edi
sub esi, eax
rep movsb byte es:[edi], byte [esi]
pop esi
jmp 0x10d88075
cmp eax, 0x7f
ja 0x10d88170
add ecx, 2
push esi
mov esi, edi
sub esi, eax
rep movsb byte es:[edi], byte [esi]
pop esi
jmp 0x10d88075
mov al, byte [esi]
inc esi
xor ecx, ecx
shr al, 1
je 0x10d8819e
adc ecx, 2
mov ebp, eax
push esi
mov esi, edi
sub esi, eax
rep movsb byte es:[edi], byte [esi]
pop esi
mov ebx, 1
jmp 0x10d88075
pop ebx
sub edi, dword [ebx + 0x10]
mov eax, edi
pop ebx
ret 0x10
Function at 0x412f50
Capabilities:
Parse pe header

Disassembly:
push ebp
mov ebp, esp
mov eax, dword [ebp + 8]
mov ecx, 0x5a4d
cmp word [eax], cx
jne 0x412f7d
mov ecx, dword [eax + 0x3c]
add ecx, eax
cmp dword [ecx], 0x4550
jne 0x412f7d
mov edx, 0x10b
xor eax, eax
cmp word [ecx + 0x18], dx
sete al
pop ebp
ret
xor eax, eax
pop ebp
ret

Function at 0xc3625d
Capabilities:
Encode data using xor

Disassembly:
xor al, al
mov al, byte [edi]
xor al, bl
mov byte [edi], al
inc edi
cmp edi, ecx
jne fcn.00c3625d
ret
Function at 0x102dd3ad
Capabilities:
Encode data using xor

Disassembly:
mov byte [esp + 8], 0x42
mov word [esp], sp
lea esp, [esp + 0x10]
jne 0x103a313b
xadd ecx, esi
jp 0x102e0ac0
mov ecx, edi
rol esi, cl
clc
neg esi
rcl si, 5
sub ecx, ebx
shld si, cx, 7
movzx si, al
shl si, cl
mov si, di
mov esi, esp
pushal
push dword [esp + 4]
dec byte [ecx + 0x74ff60e6]
and al, 4
call fcn.1039f7e7
std
add al, 0xa7
mov edx, 0x6aa4dbc3
scasb al, byte es:[edi]
xchg ebx, eax
out 0xc3, al
sbb bh, byte [edi]
mov ebx, 0x88d6df3d
dec edi
mov esp, ecx
xchg edx, eax
mov eax, dword [0xe88edab7]
xor ebx, dword [eax]
mov eax, 0x945533fd
wait
dec eax
fisub dword [ebp + ebx + 0x5cb13a31]
xchg dword [ecx], edx
loopne 0x102dd3e4
invalid
neg cx
mov ecx, edi
bswap si
shr esi, 0x1f
push 0x2120270
or si, si
sub ecx, ebx
bt di, dx
not si
cmc
stc
lea esi, [esp + 4]
pushal
test bh, dh
sub edi, 4
call fcn.102d47ca
add byte [eax], al
add byte [eax], al
add byte [ecx], ch
adc byte [eax + eax], dl
sub dword [eax], edx
sbb byte [eax], al
sub dword [eax], edx
or byte [ebx], cl
adc byte cs:[eax], al
add byte [eax], al
add byte [eax], al
add byte [eax], al
add byte [ebx + esi*2], al
adc byte cs:[eax], al
add byte [eax], al
add byte [ecx - 0x38bef62], dh
invalid

Function at 0x1039fb42
Capabilities:
Encode data using xor

Disassembly:
call fcn.102dec04
lea esp, [esp + 0xc]
jae 0x10292011
cmp ch, dl
pushal
cmc
xor eax, eax
pushfd
push eax
lea esp, [esp + 0x28]
call fcn.103a074c
pushfd
lea esp, [esp + 4]
jae 0x103a0a39
push esp
setge al
mov bl, 2
push dword [esp]
push eax
setl al
inc ecx
jmp 0x1029306e
jmp 0x10296a18

Function at 0x103a074c
Capabilities:
Authenticate hmac

Disassembly:
cmc
add dl, dl
push esp
mov byte [esp], ah
call fcn.102ddbce
pop ebx
lds ebp, [ecx]
clc
out 0xa4, eax
fidivr dword [eax - 0x558fcafd]
std
mov ebx, 0x83cfac62
in eax, dx
or eax, dword [esi - 0x233a00d0]
jle 0x103a07d9
invalid
adc al, 0x8b
adc ch, byte [esi + 0x6baea795]
aas
jp 0x103a084d
imul ebx, dword [edi], 0xf370310e
pop ds
push cs
xor dword [eax - 0xd], esi
mov dword [0xaf2fb833], eax
loop 0x103a0811
in al, dx
jp 0x103a0840
mov edx, edx
loope 0x103a0873
in al, dx
daa
inc esi
invalid
movsb byte es:[edi], byte [esi]
jg 0x103a085a
cmp eax, 0x4f90d6ef
lea ebx, [eax]
mov edx, 0xfc2677d9
rep movsd dword es:[edi], dword [esi]
insb byte es:[edi], dx
retf
jbe 0x103a07e3
mov al, 0x6f
dec edx
test dword [edx + 0x79a437f9], 0x33e5dff4
dec esi
jo 0x103a0899
aaa
movsb byte es:[edi], byte [esi]
jns 0x103a0838
invalid
or eax, 0x2e51feb4
std
push ecx
std
leave
dec ecx
xlatb
invalid
jecxz 0x103a0838
sahf
hlt
or al, 0x97
test dword [ecx - 0x3ad3c629], 0x895f4684
invalid
and eax, 0x1d3a2bfc
arpl word [edx - 0x68], bx
xchg ebx, eax
int1
fsubr qword [edx - 2]
dec ebx
fisub word [esi - 0x2685b4b]
movsd dword es:[edi], dword [esi]
or bl, cl
pop ds
push ss
xchg esp, eax
fild word [eax + ebp*2]
bound edi, qword [esi - 0x4c]
inc ecx
invalid
cmpsb byte [esi], byte es:[edi]
in eax, 0x68
invalid
pop esi
Function at 0x103a2a9a
Capabilities:
Encode data using xor

Disassembly:
add byte [eax], al
add byte [eax], al
push ecx
call fcn.1039fb47
mov byte [esp], 0x3d
pushal
lea esp, [esp + 0x24]
jae 0x103a3144
cmc
cmc
mov ebx, eax
sub edi, edi
mov edi, eax
btr cx, 4
mov ecx, 0x104
clc
sub al, al
call fcn.1037050c
inc ebp
test al, 0xef
inc esp
sbb ebp, eax
movsb byte es:[edi], byte [esi]
jp 0x103a2b13
sbb byte [eax + 0x2383acda], bh
lodsd eax, dword [esi]
dec ebx
xor cl, dl
in al, 0x98
sal byte [esi - 0x18], cl
add cl, byte [ebp - 0x11d64561]
push ecx
dec esi
jo 0x103a2a96
xchg esi, eax
add al, 0xbf
cmp ecx, esi
daa
invalid
int 0x38
push eax
lea eax, [ebx - 0x2d60e7de]
xor byte [0xc2e5cca4], ah
outsd dx, dword [esi]
push 0xde063984
cld
sti
push eax
enter 0x3716, 0xffffffffffffff95
add eax, 0x153f7273
or al, 0x49
mov ecx, 0x28a58617
in eax, dx
jnp 0x103a2b9b
and ecx, esp
int 0x20
add dword [ebp + ecx*4 + 0x87e841c], ebp
in eax, 0x1f
inc ecx
xor eax, 0x16c38485
leave
movsb byte es:[edi], byte [esi]
mov ebp, 0x91b6cf5d
invalid
test dword [edi], eax
into
invalid
Function at 0x6d8c30c0
Capabilities:
Encrypt data using salsa20 or chacha
Resolve function by parsing pe exports

Disassembly:
mov ecx, dword [0x6da2bd58]
mov ecx, dword fs:[ecx]
mov ecx, dword [ecx]
cmp esp, dword [ecx + 8]
jbe 0x6d8c3290
mov eax, dword [esp + 8]
mov dword [eax], 0x61707865
mov dword [eax + 4], 0x61707865
mov dword [eax + 8], 0x61707865
mov dword [eax + 0xc], 0x61707865
mov dword [eax + 0x10], 0x3320646e
mov dword [eax + 0x14], 0x3320646e
mov dword [eax + 0x18], 0x3320646e
mov dword [eax + 0x1c], 0x3320646e
mov dword [eax + 0x20], 0x79622d32
mov dword [eax + 0x24], 0x79622d32
mov dword [eax + 0x28], 0x79622d32
mov dword [eax + 0x2c], 0x79622d32
mov dword [eax + 0x30], 0x6b206574
mov dword [eax + 0x34], 0x6b206574
mov dword [eax + 0x38], 0x6b206574
mov dword [eax + 0x3c], 0x6b206574
mov ecx, dword [esp + 4]
mov edx, dword [ecx]
mov dword [eax + 0x40], edx
mov dword [eax + 0x44], edx
mov dword [eax + 0x48], edx
mov dword [eax + 0x4c], edx
mov edx, dword [ecx + 4]
mov dword [eax + 0x50], edx
mov dword [eax + 0x54], edx
mov dword [eax + 0x58], edx
mov dword [eax + 0x5c], edx
mov edx, dword [ecx + 8]
mov dword [eax + 0x60], edx
mov dword [eax + 0x64], edx
mov dword [eax + 0x68], edx
mov dword [eax + 0x6c], edx
mov edx, dword [ecx + 0xc]
mov dword [eax + 0x70], edx
mov dword [eax + 0x74], edx
mov dword [eax + 0x78], edx
mov dword [eax + 0x7c], edx
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x80], edx
mov dword [eax + 0x84], edx
mov dword [eax + 0x88], edx
mov dword [eax + 0x8c], edx
mov edx, dword [ecx + 0x14]
mov dword [eax + 0x90], edx
mov dword [eax + 0x94], edx
mov dword [eax + 0x98], edx
mov dword [eax + 0x9c], edx
mov edx, dword [ecx + 0x18]
mov dword [eax + 0xa0], edx
mov dword [eax + 0xa4], edx
mov dword [eax + 0xa8], edx
mov dword [eax + 0xac], edx
mov ecx, dword [ecx + 0x1c]
mov dword [eax + 0xb0], ecx
mov dword [eax + 0xb4], ecx
mov dword [eax + 0xb8], ecx
mov dword [eax + 0xbc], ecx
mov ecx, dword [esp + 0xc]
mov dword [eax + 0xc0], ecx
lea edx, [ecx + 1]
mov dword [eax + 0xc4], edx
lea edx, [ecx + 2]
mov dword [eax + 0xc8], edx
add ecx, 3
mov dword [eax + 0xcc], ecx
mov dword [eax + 0xd0], 0
mov dword [eax + 0xd4], 0
mov dword [eax + 0xd8], 0
mov dword [eax + 0xdc], 0
mov dword [eax + 0xe0], 0
mov dword [eax + 0xe4], 0
mov dword [eax + 0xe8], 0
mov dword [eax + 0xec], 0
mov dword [eax + 0xf0], 0
mov dword [eax + 0xf4], 0
mov dword [eax + 0xf8], 0
mov dword [eax + 0xfc], 0
ret
call fcn.6d92af70
jmp fcn.6d8c30c0
Function at 0x6d8c48b0
Capabilities:
Access peb ldr_data

Disassembly:
sub esp, 0x38
mov eax, dword [0x6da2bd58]
mov eax, dword fs:[eax]
mov eax, dword [eax]
mov dword [esp + 0x30], eax
mov ecx, dword [eax + 0x18]
cmp dword [ecx + 0x50], eax
je 0x6d8c48fa
call fcn.6d8f6bb0
lea eax, [0x6d9820e2]
mov dword [esp], eax
mov dword [esp + 4], 0x1e
call fcn.6d8f7410
call fcn.6d8f6c10
mov dword [esp], 2
call fcn.6d8f2090
mov eax, dword [esp + 0x30]
mov ecx, dword [eax + 0x18]
mov edx, dword [ecx]
mov edx, dword [edx + 0x1c]
mov dword [esp], ecx
mov dword [esp + 4], edx
mov byte [esp + 8], 0
call fcn.6d8c4670
mov eax, dword [0x6da2bd58]
mov eax, dword fs:[eax]
mov eax, dword [eax]
mov eax, dword [eax + 0x18]
nop
inc dword [eax + 0x140]
mov eax, dword [0x6da2bd58]
mov eax, dword fs:[eax]
mov eax, dword [eax]
mov ecx, dword [eax + 0x18]
mov edx, eax
nop
mov dword [ecx + 0xb8], eax
mov eax, dword [edx + 0x18]
mov dword [edx + 0x88], eax
mov eax, dword [esp + 0x30]
mov ecx, dword [eax + 0x18]
mov dword [esp + 0x34], ecx
test byte [ecx], al
lea esi, [ecx + 0x1d0]
lea edi, [esp + 0xc]
call fcn.6d92ca74
mov ecx, dword [eax + 0x38]
mov edx, dword [eax + 0x40]
mov dword [esp + 0x28], ecx
mov ebx, dword [eax + 0x3c]
mov dword [esp + 0x24], ebx
mov dword [esp + 0x2c], edx
call fcn.6d927050
mov eax, dword [esp + 0x30]
mov ecx, dword [eax + 0x18]
mov byte [ecx + 0x8c], 0
mov ecx, dword [eax + 0x18]
movzx edx, byte [ecx + 0x8d]
test dl, dl
je 0x6d8c49a1
mov byte [ecx + 0x8e], 0
mov ecx, dword [eax + 0x18]
test byte [ecx], al
add ecx, 0x318
mov dword [esp], ecx
mov dword [esp + 4], 0
call fcn.6d930aa0
mov eax, dword [esp + 0x30]
movzx ecx, byte [eax + 0x75]
test cl, cl
jne 0x6d8c4a75
mov eax, dword [esp + 0x3c]
mov dword [esp], eax
mov eax, dword [esp + 0x40]
mov dword [esp + 4], eax
mov eax, dword [esp + 0x44]
mov dword [esp + 8], eax
call fcn.6d8c4a90
mov eax, dword [esp + 0x30]
mov ecx, dword [eax + 0x18]
mov byte [ecx + 0x8c], 1
call fcn.6d901de0
mov eax, dword [esp + 0x30]
mov ecx, dword [eax + 0x18]
movzx edx, byte [ecx + 0x8d]
test dl, dl
je 0x6d8c4a14
mov byte [ecx + 0x8e], 1
mov ecx, dword [eax + 0x18]
mov edx, dword [esp + 0x34]
cmp ecx, edx
jne 0x6d8c4a5f
mov dword [esp], ecx
call fcn.6d8f3ae0
mov eax, dword [esp + 0x28]
mov ecx, dword [esp + 0x2c]
mov edx, dword [esp + 0x24]
mov dword [esp], edx
mov dword [esp + 4], eax
mov dword [esp + 8], ecx
call fcn.6d8ffec0
mov eax, dword [esp + 0x30]
mov eax, dword [eax + 0x18]
test byte [eax], al
lea edi, [eax + 0x1d0]
lea esi, [esp + 0xc]
call fcn.6d92ca74
add esp, 0x38
ret
lea eax, [0x6d983933]
mov dword [esp], eax
mov dword [esp + 4], 0x26
call fcn.6d926bb0
lea eax, [0x6d96dfc0]
mov dword [esp], eax
lea eax, [0x6d99e9c0]
mov dword [esp + 4], eax
call fcn.6d926820
nop
int3
Function at 0x6d8cbe90
Capabilities:
Decompress data using quicklz

Disassembly:
mov ecx, dword [0x6da2bd58]
mov ecx, dword fs:[ecx]
mov ecx, dword [ecx]
cmp esp, dword [ecx + 8]
jbe 0x6d8cc05b
sub esp, 0x38
mov eax, dword [esp + 0x3c]
cmp eax, 0x7000000
jle 0x6d8cbeb9
mov eax, 0x7000000
jmp 0x6d8cbec1
test eax, eax
je 0x6d8cc036
mov dword [esp + 0x34], eax
mov ecx, dword [0x6da2bd58]
mov ecx, dword fs:[ecx]
mov ecx, dword [ecx]
mov ecx, dword [ecx + 0x18]
mov edx, dword [ecx + 0x448]
mov ebx, dword [ecx + 0x44c]
mov ebp, edx
shl edx, 0x11
xor edx, ebp
mov ebp, ebx
xor ebx, edx
shr edx, 7
xor edx, ebx
mov ebx, ebp
shr ebp, 0x10
xor ebp, edx
lea edx, [ebp + ebx]
shr edx, 6
inc edx
mov dword [ecx + 0x448], ebx
mov dword [ecx + 0x44c], ebp
mov dword [esp], edx
call fcn.6d92c330
movsd xmm0, qword [esp + 4]
movsd qword [esp + 0x24], xmm0
mov eax, dword [esp + 0x28]
mov ecx, eax
shr ecx, 0x14
and ecx, 0x7ff
mov edx, eax
shr edx, 0xf
and edx, 0x1f
shl eax, 5
mov ebx, dword [esp + 0x24]
shr ebx, 0x1b
or ebx, eax
lea eax, [0x6d95dba0]
movsd xmm0, qword [eax + edx*8]
mov ebp, ecx
add ecx, 0xfffffc01
add edx, 1
mov esi, 0
adc esi, 0
test esi, esi
jne 0x6d8cc04e
cmp edx, 0x21
jae 0x6d8cc042
movsd qword [esp + 0x14], xmm0
add ebp, 0xfffffc01
mov ebp, 0xffffffff
adc ebp, 0
and ebx, 0xfffff
mov dword [esp + 0x10], ebx
movsd xmm0, qword [eax + edx*8]
movsd qword [esp + 0x1c], xmm0
mov dword [esp], ecx
mov dword [esp + 4], ebp
call fcn.6d91f930
movsd xmm0, qword [esp + 8]
movsd qword [esp + 0x2c], xmm0
mov eax, dword [esp + 0x10]
mov dword [esp], eax
mov dword [esp + 4], 0
call fcn.6d91fa00
movsd xmm0, qword [esp + 0x2c]
movsd xmm1, qword [esp + 0x14]
addsd xmm0, xmm1
movsd xmm2, qword [esp + 0x1c]
subsd xmm2, xmm1
movsd xmm1, qword [esp + 8]
mulsd xmm1, xmm2
movsd xmm2, qword [0x6d99e8f8]
mulsd xmm2, xmm1
addsd xmm0, xmm2
movsd xmm1, qword [0x6d99e968]
subsd xmm0, xmm1
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jbe 0x6d8cc011
xorps xmm0, xmm0
mov eax, dword [esp + 0x34]
cvtsi2sd xmm1, eax
movsd xmm2, qword [0x6d99e9b0]
mulsd xmm1, xmm2
mulsd xmm0, xmm1
cvttsd2si eax, xmm0
inc eax
mov dword [esp + 0x40], eax
add esp, 0x38
ret
mov dword [esp + 0x40], 0
add esp, 0x38
ret
mov eax, edx
mov ecx, 0x21
call fcn.6d92c410
mov eax, edx
mov ecx, 0x21
call fcn.6d92c4a0
nop
call fcn.6d92af70
jmp fcn.6d8cbe90
Function at 0x6d8d3740
Capabilities:
Check for software breakpoints

Disassembly:
mov ecx, dword [0x6da2bd58]
mov ecx, dword fs:[ecx]
mov ecx, dword [ecx]
cmp esp, dword [ecx + 8]
jbe 0x6d8d393e
sub esp, 0x18
mov eax, dword [0x6da2bc94]
test eax, eax
jne 0x6d8d3927
nop
nop
lea eax, [0x6da2bc84]
mov dword [esp], eax
call fcn.6d8ca4e0
mov eax, dword [0x6da2bc88]
test eax, eax
je 0x6d8d3788
cmp dword [eax + 8], 0xcc
jne 0x6d8d37fe
mov edx, dword [0x6da2bc8c]
test edx, edx
jne 0x6d8d37e0
mov dword [esp], 0x1000
mov dword [esp + 4], 0
lea eax, [0x6da2e350]
mov dword [esp + 8], eax
call fcn.6d8cc070
mov eax, dword [esp + 0xc]
mov dword [0x6da2bc8c], eax
mov ecx, dword [0x6da2bc90]
mov dword [eax], ecx
mov eax, dword [0x6da2bc8c]
mov dword [0x6da2bc90], eax
movzx eax, byte [0x6da2c0e0]
test al, al
jne 0x6d8d37e0
xor eax, eax
jmp 0x6d8d38f8
mov edx, dword [0x6da2bc8c]
mov ebx, dword [edx + 4]
mov dword [0x6da2bc8c], ebx
mov ebx, dword [0x6da2bc88]
mov dword [edx + 4], ebx
mov dword [0x6da2bc88], edx
mov edx, dword [0x6da2bc88]
mov eax, dword [edx + 8]
cmp eax, 0xcc
jae 0x6d8d38d7
mov dword [esp + 0x14], edx
mov dword [esp + 0x10], eax
lea eax, [edx + 8]
mov dword [esp], eax
mov dword [esp + 4], 1
call fcn.6d9309d0
mov eax, dword [0x6da2be38]
mov ecx, dword [esp + 0x10]
lea ecx, [ecx + ecx*4]
test eax, eax
jne 0x6d8d3850
mov eax, dword [esp + 0x20]
mov edx, dword [esp + 0x14]
mov ebx, dword [esp + 0x28]
mov ebp, dword [esp + 0x2c]
jmp 0x6d8d3890
call fcn.6d92c3f0
mov eax, dword [esp + 0x20]
mov dword [edi], eax
mov edx, dword [esp + 0x14]
mov ebx, dword [edx + ecx*4 + 0x10]
mov dword [edi + 4], ebx
mov ebx, dword [esp + 0x28]
mov dword [edi + 8], ebx
mov ebp, dword [edx + ecx*4 + 0x1c]
mov dword [edi + 0xc], ebp
mov ebp, dword [esp + 0x2c]
mov dword [edi + 0x10], ebp
mov esi, dword [edx + ecx*4 + 0x20]
mov dword [edi + 0x14], esi
mov esi, dword [esp + 0x1c]
mov dword [edi + 0x18], esi
mov esi, dword [edx + ecx*4 + 0x14]
mov dword [edi + 0x1c], esi
mov dword [edx + ecx*4 + 0x10], eax
mov eax, dword [esp + 0x24]
mov dword [edx + ecx*4 + 0x18], eax
mov dword [edx + ecx*4 + 0x1c], ebx
mov dword [edx + ecx*4 + 0x20], ebp
mov eax, dword [esp + 0x1c]
mov dword [edx + ecx*4 + 0x14], eax
nop
nop
lea eax, [0x6da2bc84]
mov dword [esp], eax
call fcn.6d8ca700
nop
lea eax, [0x6da2bc80]
mov dword [esp], eax
mov dword [esp + 4], 8
call fcn.6d930b50
add esp, 0x18
ret
mov ecx, 0xcc
call fcn.6d92c410
lea edx, [0x6d95d284]
movzx ebx, byte [edx + eax]
lea ebp, [0x6da2c0e0]
mov byte [ebp + ecx], bl
lea eax, [ecx + 1]
cmp eax, 0x80
jge 0x6d8d37e0
mov ecx, eax
mov eax, 0xcccccccd
imul ecx
add edx, ecx
sar edx, 2
lea edx, [edx + edx*4]
mov eax, ecx
sub eax, edx
cmp eax, 5
jb 0x6d8d38e1
mov ecx, 5
call fcn.6d92c400
lea eax, [0x6d980830]
mov dword [esp], eax
mov dword [esp + 4], 0x18
call fcn.6d926bb0
nop
call fcn.6d92af70
jmp fcn.6d8d3740
Function at 0x6d8d86c0
Capabilities:
Enumerate pe sections

Disassembly:
mov ecx, dword [0x6da2bd58]
mov ecx, dword fs:[ecx]
mov ecx, dword [ecx]
cmp esp, dword [ecx + 8]
jbe 0x6d8d8749
sub esp, 0x10
mov eax, dword [esp + 0x14]
test byte [eax], al
mov dword [esp], eax
mov dword [esp + 4], 0
mov dword [esp + 8], 1
call fcn.6d930880
movzx eax, byte [esp + 0xc]
test al, al
je 0x6d8d872e
mov eax, dword [esp + 0x14]
movzx ecx, byte [eax + 6]
test cl, cl
jne 0x6d8d8732
mov dword [esp], eax
mov ecx, dword [esp + 0x18]
mov dword [esp + 4], ecx
mov ecx, dword [esp + 0x1c]
mov dword [esp + 8], ecx
call fcn.6d8d8760
mov eax, dword [esp + 0x14]
mov dword [esp], eax
call fcn.6d8d8d10
add esp, 0x10
ret
add esp, 0x10
ret
lea eax, [0x6d980848]
mov dword [esp], eax
mov dword [esp + 4], 0x18
call fcn.6d926bb0
nop
call fcn.6d92af70
jmp fcn.6d8d86c0
Function at 0x6d8e7c50
Capabilities:
Enumerate pe sections

Disassembly:
mov ecx, dword [0x6da2bd58]
mov ecx, dword fs:[ecx]
mov ecx, dword [ecx]
cmp esp, dword [ecx + 8]
jbe 0x6d8e7d94
sub esp, 0x1c
mov eax, dword [esp + 0x20]
mov dword [esp], eax
call fcn.6d8e58e0
mov eax, dword [esp + 4]
test eax, eax
je 0x6d8e7d7d
mov dword [esp + 0xc], eax
lea ecx, [eax + 0x4c]
mov dword [esp + 0x18], ecx
mov edx, dword [0x6da2bd58]
mov edx, dword fs:[edx]
mov edx, dword [edx]
mov ebx, dword [edx + 0x18]
nop
inc dword [ebx + 0x7c]
mov edx, dword [edx + 0x18]
mov dword [esp + 0x14], edx
mov dword [esp], eax
call fcn.6d8e32c0
mov eax, dword [esp + 0x20]
mov ecx, dword [esp + 0xc]
sub eax, dword [ecx + 0xc]
mov dword [esp + 0x10], eax
mov edx, dword [esp + 0x24]
movzx ebx, byte [edx + 6]
mov byte [esp + 0xa], bl
nop
mov ebp, dword [esp + 0x18]
mov dword [esp], ebp
call fcn.6d8ca4e0
mov eax, dword [esp + 0xc]
lea ecx, [eax + 0x50]
mov edx, dword [esp + 0x10]
movzx ebx, byte [esp + 0xa]
jmp 0x6d8e7ce7
mov ecx, ebp
mov ebp, dword [ecx]
test ebp, ebp
je 0x6d8e7d12
movzx esi, word [ebp + 4]
cmp esi, edx
jne 0x6d8e7cfc
cmp byte [ebp + 6], bl
je 0x6d8e7d07
cmp esi, edx
ja 0x6d8e7d0e
jne 0x6d8e7ce5
cmp byte [ebp + 6], bl
jbe 0x6d8e7ce5
jmp 0x6d8e7d0e
mov ebx, 1
jmp 0x6d8e7d14
xor ebx, ebx
jmp 0x6d8e7d14
xor ebx, ebx
mov byte [esp + 0xb], bl
test bl, bl
jne 0x6d8e7d32
mov ebx, dword [esp + 0x24]
mov word [ebx + 4], dx
mov edx, dword [ecx]
mov dword [ebx], edx
mov dword [ecx], ebx
mov dword [esp], eax
call fcn.6d8e7b50
nop
nop
mov eax, dword [esp + 0x18]
mov dword [esp], eax
call fcn.6d8ca700
mov eax, dword [esp + 0x14]
mov ecx, dword [eax + 0x7c]
lea edx, [ecx - 1]
nop
mov ebx, dword [0x6da2bd58]
mov ebx, dword fs:[ebx]
mov ebx, dword [ebx]
mov dword [eax + 0x7c], edx
cmp ecx, 1
jne 0x6d8e7d6d
movzx eax, byte [ebx + 0x69]
test al, al
je 0x6d8e7d6d
mov dword [ebx + 8], 0xfffffade
movzx eax, byte [esp + 0xb]
xor eax, 1
mov byte [esp + 0x28], al
add esp, 0x1c
ret
lea eax, [0x6d981d1f]
mov dword [esp], eax
mov dword [esp + 4], 0x1d
call fcn.6d926bb0
nop
call fcn.6d92af70
jmp fcn.6d8e7c50