joyce8/EMBER2024-capa huggingface dataset:
Function at 0x829edb
Capabilities:
Encode data using xor

Disassembly:
adc eax, 0xbacf4811
xor byte [edx], ch
adc ebp, ebx
or edx, edx
mov eax, dword [ebp]
jae 0xc30ee2
lea esp, [esp + 8]
call fcn.0087aee6
adc al, 0x6b
pop ebx
jb 0x829ec6
dec eax
popal
out 0xd2, al
xor eax, 0xf9cd908
aaa
insb byte es:[edi], dx
aad 0x12
dec ebp
pushfd
ror byte [ecx - 0x16740d0], cl
cmp byte [ebx], dl
dec edx
outsb dx, byte [esi]
sbb dword [ebp + 0x4a], edi
inc esi
jmp 0xbfec171f
mov dl, byte [ebp + 4]
push 0x272289a9
adc ebp, 6
push 0x15a7cebd
mov byte [eax], dl
not byte [esp + 1]
not dword [esp]
lea esp, [esp + 8]
jmp fcn.00c55337

Function at 0x82bf05
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov esi, 0x7f1dc2b5
push ebx
dec eax
mov ebp, dword [esp + esi - 0x7f1dc2a5]
call fcn.008c7eb7

Function at 0x82cf16
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [esi], cx
mov dword [esp + 4], 0xbf126485
jmp 0xb9f57f
jmp 0xc541a1
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

Function at 0x82d183
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
dec cl
ror cl, 1
shr byte [esp], 0xa4
not cl
xor bl, cl
jmp 0x879179
mov eax, dword [ebp]
mov dword [esp], 0x821698
movzx di, byte [eax]
call fcn.008a8c1d
mov ecx, 0x90050cb0
sub ebp, 1
inc cx
movzx ecx, byte [ebp]
push 0x3cbb8319
xor cl, bl
inc cl
xor cl, 0x37
not cl
ror word [esp + 2], 0x45
jb 0x7fa901
call fcn.00ba87ec

Function at 0x82d1b0
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
xor ebx, eax
sub esi, 4
mov dword [esi], eax
lea esp, [esp + 8]
jmp fcn.00c54562

Function at 0x832f47
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov edi, eax
pop ebp
pop ecx
jns fcn.00c3cec2

Function at 0x83ae9e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov cl, byte [esi + ecx - 0x450b8d95]
push 0xf2078cba
add esi, 6
push 0x7b088a15
shrd ebp, edx, cl
push 0x8daab302
push 0x94011cbf
mov dword [esi], ebp
push 0x8203838c
lea esp, [esp + 0x18]
jmp fcn.00c3cedb

Function at 0x83f119
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
and eax, edx
pop eax
pop edx
pop eax
jp fcn.00c3cec2
mov eax, 0x9636609e
not al
mov esi, 0x898679b0
mov eax, dword [ebp]
call fcn.008add6b

Function at 0x83f177
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
dec eax
mov dword [esp], 0xf9fad20c
call fcn.00c485ec
mov ecx, 0xec9ce096
mov ecx, esi
sub esi, 4
mov dword [esi], ecx
push 0x478acd03
lea esp, [esp + 4]
jmp fcn.00c54562

Function at 0x843504
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
adc esi, 8
mov dword ss:[eax], ecx
lea esp, [esp + 4]
jmp fcn.00c3cedb

Function at 0x84ed7e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
sub edi, 1
movzx ecx, byte [edi]
call fcn.00859243

Function at 0x854300
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
sub esi, 4
mov dword [esi], ebp
lea esp, [esp + 4]
jmp fcn.00c54562
Function at 0x857282
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
dec ecx
add eax, 4
inc esp
or edi, edx
jmp 0xbdfe67
jmp 0xbe3d4c
call fcn.008b5e3f
add ebp, 4
mov dword [esp], 0x672f3d39
not ecx
not esi
call fcn.00c545cf
cmp al, 0xdf
test byte [ebx + 7], cl
pop esi
loope 0x857302
inc ecx
mov dh, 0x92
shl dword [ecx - 8], cl
jns 0x8572f0
sbb al, 0xa5
je 0x8572de
scasb al, byte es:[edi]
xchg edx, eax
fild qword [edx + ecx*2 + 0x3a]
jnp 0x857304
pushal
cmp dh, bl
nop
int1
mov ebp, 0x97368cc6
sbb esi, eax
mov al, byte [0x21854245]
scasb al, byte es:[edi]
ja 0x8572ea
push cs
stosd dword es:[edi], eax
push 0xfffffffffffffff5
xchg edi, eax
push esp
mov edi, 0x3497368c
out 0xd, al
int3
sbb esi, dword [edi + ecx]
in eax, dx
dec edi
aas
test eax, 0x1e045add
outsb dx, byte [esi]
dec eax
adc ch, byte [edi]
and al, 4
push eax
add al, 0xe9
mov dl, 0xa0
cld
invalid
jmp 0x8213bb

Function at 0x8572ef
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 4]
jmp fcn.00c54562

Function at 0x8619c7
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x53a5b130
mov dword [esi], ecx
push 0x2c90d09f
lea esp, [esp + 8]
jmp fcn.00c3cedb
sub esi, 4
mov byte [esp + 0xa], 0x98
mov dword [esi], eax
call fcn.008a8c31
jmp 0xb902c6
push 0x6197c8b7
pop edx
mov edx, dword [esi + edx - 0x6197c8b7]
mov ecx, 0xfc9af987
mov ecx, dword ss:[edx]
jmp 0x84a7d1

Function at 0x863b7a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esi], ecx
lea esp, [esp + 4]
jmp fcn.00c3cedb

Function at 0x8665c8
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
shr al, cl
mov word [esi], ax
mov dword [esp], 0x2029f928
push 0x4c31a735
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x866ca9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add eax, edx
mov dword [ebp - 4], eax
test ebx, ebx
call fcn.0081d069
jmp 0x866c96
mov ebx, ecx
sal dx, 0x22
xchg dx, ax
mov edx, ebx
neg ax
je 0xb9576b
mov dword [esp], eax
jmp 0xc5944b
call 0xbffb86
sub ebp, edx
xor ebp, edi
jmp 0x84ac93
shl edx, 2
mov eax, ebp
jmp 0x7f5eae
mov eax, 0x5b8cc330
mov eax, dword [ebp + eax - 0x5b8cc330]
call fcn.0075b784
dec ebx
jne 0xc5ed3a
jmp 0xbe61e8
mov eax, dword [ebp + ebx*4]
call 0x866ca9

Function at 0x86a5b5
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add esi, 2
push 0x4126e23b
shr dx, cl
mov word [esi], dx
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

Function at 0x86b45e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp], 0xfb8d295a
call fcn.00c49118
mov ecx, 0x3029f7a6
mov ecx, dword [esi + ecx*2 - 0x6053ef4c]
mov ebp, dword [esi + 4]
add esi, 8
mov dword [ecx], ebp
push 0xaa0cd736
push 0x8db9d536
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x88df0b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x14]
jmp fcn.00c54562

Function at 0x88e4a3
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 8]
je 0x79e065
jmp 0x7cdc5c
Function at 0x88e8e4
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add esi, 6
push 0x71b46120
mov word ss:[edx], bp
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x88e8fc
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
jmp fcn.00c5e7e0
dec ebx
push 0x163d4326
lea esp, [esp + 8]
jne 0x88e920
push 0xa9b8f4ac
mov eax, dword [ebp]
lea esp, [esp + 4]
call eax
mov ebp, dword [ebp - 4]
mov edi, 0x4093d801
bswap edi
mov dword [ebp + edi*8 - 0xec49a00], eax
pop ebx
bswap edi
pop edi
jmp 0x7677a6
jmp fcn.00c3cedb
jmp 0x8c91ac
mov dword [esp], eax
shr dword [esp], 0xf7
mov eax, ebp
inc byte [esp + 1]
add eax, edx
mov dword [ebp - 4], eax
test ebx, ebx
push 0x8f913699
lea esp, [esp + 8]
je 0x7a357c
mov eax, 0xd4939f12
inc al
mov eax, dword [ebp + ebx*4]
push eax
push 0x17a36f99
jg 0x7a356c
mov ecx, 0x2ba62d2e
movsx eax, cx
movzx eax, byte [ecx + esi - 0x2ba62d2e]
ror cl, 0x21
jb 0x82bbc0
lea esi, [esi + ecx*2 - 0x574c5a2d]
dec ecx
shr ecx, cl
xor al, bl
sar ecx, 0x6d
ror cl, 0x46
or ecx, 0x673cf880
inc al
xor al, 0xbc
push ecx
sar cl, 0x86
call fcn.00844416
cld
mov fs, edi
sal ebx, 1
cmpsd dword [esi], dword es:[edi]
xchg dword [edi - 0x4456d7de], edi
sub ecx, esp
mov ecx, 0x898fce84
mov ebx, 0xd24bdfe7
mov esp, 0xb1ad93a1
dec ecx
and dword [esi - 0x79], ecx
std
jnp 0x88e99e
int1
mov cl, 0x6c
insb byte es:[edi], dx
cmp dword [ebx - 0x80], 9
pop esp
jp 0x88e9b9
pop ss
aam 0x25
dec dword [ecx + ecx - 0x27ec85a4]
shr dword [eax + 0x44], 0x6b
push ss
in al, dx
test al, 0xe6
ljmp 0xffff
salc
xor esi, ebp
jmp 0x815068

Function at 0x892dc1
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
shr edx, 0x3d
dec dx
rol cl, 1
sub cl, 0x1e
xor edx, 0x79a906b8
ror word [esp + edx - 0x79a906bd], 0xc1
xor bl, cl
lea ecx, [esp + ecx + 4]
lea edx, [edx*8 + 0x34a51f0c]
push edx
movzx dx, byte [edx + ecx - 0x1ed54fc]
sub esi, 2
mov word [esi], dx
lea esp, [esp + 8]
jmp fcn.00c54562
xor cl, 0x1a
mov dword [esp], edx
add cl, 0x18
jmp 0x776695

Function at 0x8938c1
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov cx, word [esi + 4]
mov dword [esp], 0x67058784
add esi, 2
rol dword [esp], 0xfe
shr cx, 1
rcr eax, cl
mov dword [esi], eax
mov dword [esp], 0xde04e612
lea esp, [esp + 4]
jmp fcn.00c3cedb

Function at 0x8942b9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
shr dl, cl
jmp 0x78c8f8
mov word [esi], dx
lea esp, [esp + 8]
jmp fcn.00c3cedb
movzx dx, byte [esi]
mov cl, byte [esi + 2]
push 0x86bf0724
add esi, 2
not dword [esp]
jmp 0x77f7e2
Function at 0x89a8a2
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov ecx, 0
movsx edi, bl
mov dword [esp + ebx - 0x3145a2], ecx
sar bl, 0x44
jne 0x7ef195
movzx ebp, bx
push eax
and cl, 5
xadd bl, ch
push edi
adc ebp, ebx
lea ecx, [ebx*2 + 0x3ab92e2d]
push edx
adc bl, bl
push esi
jg 0x76068a
mov edx, 0x959fb29a
sar dx, 2
dec eax
lea ebp, [edx - 0x5d7a6869]
dec edx
mov ebp, dword [ebp + eax - 0x3825843d]
sal dl, 0x66
sbb dl, dl
ror dx, 0xc
movzx dx, byte [ebp]
call fcn.007d3e3f
mov esi, dword [esp + ebx*2 - 0x628bcc]
call fcn.00ba2262
push ebx
push 0x6e24be3f
mov ebx, dword [esp]
mov dword [esp + ebx - 0x6e24be3f], ebp
push ebx
pushfd
pop ebx
mov dword [esp], ebx
mov ebx, 0x3120bf
push eax
xor bx, 0x65ad
push ecx
movsx ecx, bx
jp 0x76d8bf

Function at 0x8a41e5
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x69a5c63f
mov word [esi], ax
lea esp, [esp + 0x10]
jmp fcn.00c3cedb

Function at 0x8a9f93
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
ror cl, 1
shl eax, 0x16
inc cl
call fcn.0075fe0d

Function at 0x8af293
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
sbb esi, 4
jmp 0x8cdc46
mov dword [esi], ebp
lea esp, [esp + 0xc]
jmp fcn.00c54562

Function at 0x8aff71
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
neg dl
rol dl, 1
sal al, 0x63
xor bl, dl
mov dword [esp + eax*4 - 0x2320], eax
mov dword [esp + ebp*8 - 0x69508], edi
push ebx
sal eax, 0x12
mov ebp, esi
lea ebx, [eax*8 + 0x5c9ad922]
add ax, bx
mov ebx, edx
mov edx, ebx
push eax
or dword [esp + eax*2 - 0x4641b244], eax
shl edx, 2

Function at 0x8bdc43
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [esi], ax
lea esp, [esp + 4]
jmp fcn.00c4dcac
mov al, byte [edx + eax - 0x20280001]
jno 0x7cdc18
dec ebp
mov esi, dword [eax]
inc ecx
mov cl, byte [eax + 8]
push 0x75bd4437
dec ecx
add eax, 2
dec ecx
shr esi, cl
jmp 0xbcf0d4
add esi, 4
xor edx, edx
test edi, edi
jmp 0xc409d1
sbb esi, 2
jmp 0x77c80c
push 0xa02181a7
lea esp, [esp + 0xc]
jmp fcn.0087f052
mov dword [esp], ebx
mov ebx, 0x16891b8f
push ebx
movzx ebx, byte [eax + ebx*2 - 0x2d12371e]
push 0xe3b36d82
xor ebx, edx
and ebx, 0xff
mov ebx, dword [ebx*4 + 0x784ee8]
call fcn.00b8db04
movzx cx, byte [ebp]
mov edx, 0xf8be8e2e
and dl, dh
mov dl, byte [ebp + 2]
push 0x8d8976af
adc ebp, 2
push 0x6a081426
not cl
sal word [esp + 6], 0xc
call fcn.007f67df
mov ecx, 0xd52628af
sal ecx, 0x62
call fcn.008e30d2
jae 0x797342
mov si, word [esi]
push 0xca833fb5
lea esp, [esp + 4]
jmp fcn.00c54562
jmp 0xb90357
not edx
push 0x990a049f
mov dword [esi], edx
push 0xf09f042c
jmp 0x88dbf4
dec ebp
mov dword [eax], esi
call fcn.00771c49
push 0x718cae21
lea esp, [esp + 8]
je 0xb8db26
push 0xa0053a2c
jmp 0x8bdbd9
jmp 0xc37d6e

Function at 0x8be070
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
not eax
mov dword [esi], eax
lea esp, [esp + 0x10]
jmp fcn.00c3cedb
Function at 0x8c2c22
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov cl, byte [esi + 4]
adc esi, 2
shr eax, cl
mov dword [esi], eax
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x8c32d7
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [edx], eax
push 0x738c38b4
lea esp, [esp + 0x20]
jmp fcn.00c3cedb

Function at 0x8c7919
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add esi, 2
shr dx, cl
mov word [esi], dx
jmp 0xc31139
jmp 0x8af278
lea esp, [esp + 4]
jmp fcn.00c3cedb

Function at 0x8c9067
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
call fcn.008cb7f4
add byte [eax], al
inc esi
jb 0x8c90d6
dec esp
imul esp, dword [edx + 0x72], 0x797261
dec ebp
invalid
xor ebx, dword [ebx]
pushal
invalid

Function at 0x8d0543
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x1c]
jae fcn.00c3cedb

Function at 0x8d13f0
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add esi, 4
shrd bp, ax, cl
push 0x7d118e8a
mov word [esi], bp
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x8d18db
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
and esi, edx
call fcn.00beb6aa
mov word [esi], ax
lea esp, [esp + 4]
jmp fcn.00c3cedb
not esi
inc dword [esp + 4]
not edx
jno 0x7894bc
mov edx, 0xea2a9bf
movzx dx, byte [ebp + edx*2 - 0x1d45537e]
mov ecx, 0x7511e33a
shl cx, 0x69
neg cx
add cl, byte [ecx + ebp - 0x75118bfe]
add ebp, 2
sal dl, cl
call fcn.007a360f
mov edx, 0x79fc016
movsx eax, dx
mov edx, dword [esi + edx*8 - 0x3cfe00b0]
mov ax, word ss:[edx]
push 0x489574aa
add esi, 2
jmp 0x7b3bd7

Function at 0x8d6596
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add esi, 2
sal ax, cl
mov word [esi], ax
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x8d7f9b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

Function at 0x8d908d
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esi], ebp
lea esp, [esp + 0xc]
jmp fcn.00c54562

Function at 0x8d9652
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esi], ecx
jmp 0xc3fc18
jmp 0x81b911
lea esp, [esp + 0x10]
jmp fcn.00c3cedb

Function at 0x8de1b3
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add edi, 1
xor al, bl
jmp 0x8ebc89
neg al
dec al
jmp 0xbeb72d
ror al, 1
xor al, 0xae
xor bl, al
lea eax, [esp + eax + 4]
mov word [eax], dx
push 0x11c4e2a
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x8e436a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

Function at 0x8e54a5
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0x8e974d
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x14]
jmp fcn.00c3cedb
Function at 0x8ed5ca
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x5a81b1ae
lea esp, [esp + 0x10]
jmp fcn.00c3cedb

Function at 0xb8edc9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
test edx, edx
mov dword [esp], 0x5416e790
lea esp, [esp + 4]
je 0xb8edbf
jmp 0xbb0983
push 0xe68eb1b7
lea esp, [esp + 8]
jne 0xbb0984
mov ebx, 0x9aedb05
push ebx
mov ebx, dword [esp + ebx - 0x9aedb01]
lea esp, [esp + 8]
push 0xff144c90
call fcn.00791cd9
mov ebx, 0x49a67b0e
call fcn.00ba942d
cmp ch, dl
push ebx
movzx ebx, byte [ecx]
push 0x3c31c4ac
xor ebx, eax
inc dword [esp]
xor word [esp], 0xf58c
and ebx, 0xff
mov ebx, dword [ebx*4 + 0x7fb5ec]
shr eax, 8
or dword [esp], 0xbb855b85
neg dword [esp]
xor eax, ebx
inc dword [esp]
inc ecx
xor eax, 0x4491f40e
shl byte [esp + 2], 0x41
dec edx
jmp 0xb8ed9f

Function at 0xb92771
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esi], edx
push 0xf8171082
lea esp, [esp + 0x10]
jmp fcn.00c3cedb

Function at 0xba2211
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add esi, 2
mov word [esi], bp
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0xba2ad0
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x5ebc8898
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0xba4625
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
jno 0xc51758
mov ecx, 0xe21d0647
mov eax, 0x6b31c6dd
cmp ah, byte [ecx]
invalid
adc ebp, 2
shr cx, 1
push 0x1581be96
call fcn.0081ccaf

Function at 0xbab4db
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
inc word [esp + 8]
lea eax, [esp + eax + 0xc]
mov dword [eax], ebp
lea esp, [esp + 0xc]
jge fcn.00c3cedb
rol al, 1
xor al, 0x14
neg byte [esp + 7]
neg al
shl dword [esp + 7], 0xb2
adc al, 0xa0
xor bl, al
jmp 0xc3fc98
jmp 0x8d9657

Function at 0xbad07e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 4]
jmp fcn.00c3cedb
not ecx
mov dword [esi], ecx
jmp 0x843321

Function at 0xbafda2
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 4]
jmp fcn.00c3cedb
adc esi, 6
mov byte es:[ebp], al
jmp 0x7961df

Function at 0xbc9772
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x10]
jmp fcn.00c3cedb

Function at 0xbcb455
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
not byte [esp + 8]
xor bx, ax
not byte [esp + 0xa]
sub esi, 2
mov word [esi], ax
call fcn.007c0d1d
mov ecx, 0xe017e236
mov eax, dword [esi]
push ecx
pop edi
add esi, 4
mov ebp, eax
ror edi, 0x3b
mov edi, esi
jae 0x844a31

Function at 0xbcb46e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
not byte [esp + 8]
xor bx, ax
not byte [esp + 0xa]
sub esi, 2
mov word [esi], ax
call fcn.007c0d1d
mov ecx, 0xe017e236
mov eax, dword [esi]
push ecx
pop edi
add esi, 4
mov ebp, eax
ror edi, 0x3b
mov edi, esi
jae 0x844a31
Function at 0xbcbd34
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0xe0b8b32b
mov word [esi], bp
jmp 0x860324
lea esp, [esp + 0x14]
jmp fcn.00c3cedb
mov dword [esp + 8], 0x549371bc
or bp, ax
push 0x5ea849a4
jmp 0x7fffa2

Function at 0xbcc7f3
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
movzx edx, byte [eax + ebp - 0x3f1f731a]
call fcn.0086d102
retf 0x27ce
mov word [ebp], si
call fcn.00bfe035
push ebx
pushfd
mov ebx, 0x339309b8
add bl, bh
not bl
or ebx, 0xcfbe0f08
jns 0xbcc784
mov ebx, dword [esp + 4]
mov dword [esp + 4], 0x7062cbad
push dword [esp]
popfd
lea esp, [esp + 4]
call fcn.0089a8a2
mov eax, 0x93a26d17
mov eax, dword [edi]
mov ebp, 0x6ab8fd1f
mov ebp, dword [edi + ebp - 0x6ab8fd1b]
add edi, 4
add eax, ebp
mov dword [edi], eax
call fcn.00838afb
mov edx, 0x5519d324
mov ecx, 0x62bb3ab3
mov ecx, dword [edx + edi - 0x5519d324]
mov dx, word [edi + edx - 0x5519d320]
call fcn.00779029
mov eax, 0x3f1f731b
lea ebp, [ebp + eax - 0x3f1f731c]
mov edx, eax
dec ax
jno 0x8043ad

Function at 0xbcd2d3
Capabilities:
Encode data using xor

Disassembly:
lea esp, [esp + 4]
and al, 4
call eax
mov edi, 0x1493699e
mov ebp, dword [ebp + edi*4 - 0x524da67c]
lea esi, [edi + edi - 0x68f0a7e8]
mov dword [edi + ebp - 0x1493699e], eax
mov esi, ebp
movsx ebx, di
call fcn.007d4d04
and esp, dword ss:[ebx]
dec edx
xor cl, byte [edi]
lar eax, word [edx]
sbb eax, dword [ebx]
push ds
push ds
daa
aas
push cs
or ecx, dword [ebx]
add esp, dword cs:[edx]
cmp dword [esi + 0x26], 0x1f247dbb
sub cl, byte [esi - 0x18]
cmp esi, esp
jno 0x88d6a6
add eax, 0x37163678
jge 0x88d761
cmp al, 0x81
jmp 0x30469a52
push 0xffffffffffffff85
movsd dword es:[edi], dword [esi]
pop ecx
add al, 0xf5
push 0xffffffffffffff8a
fistp dword [ecx + 0xe]
test esp, edx
cmp eax, 0x246b6163
and byte [ebx], al
push eax
das
xchg esi, eax
add ch, byte [edi]
xchg ecx, eax
and al, 0x24
and byte [eax], al
lds esp, [esi + 0x38e3521a]
mov esi, 0xb2b7fcae
inc ebp
push edi
xchg ebp, eax
jp 0x88d7e9
pushal
dec eax
mov ecx, 0x69ebfc26
jp 0x88d7c4
ret 0x5153
push eax
stc
xor dword [esi], eax
mov word [esi + 0xa], gs
adc byte [esp + edi*2], dl
mov esi, 0x9a612f25
xor byte [esi - 0x33], bh
div dword [eax + 0x6be2812d]
inc ebx
imul ebx, dword [ebx + 0x10], 0xc71e1df5
call dword [ecx]
mov edx, 0x869a2035
mov dx, word [edi]
mov ebp, 0xfc08fe8c
lcall 0x8cbd, 0x178b6686
dec byte [eax]
cld
lea ecx, [ebp + 0xd3eb002]
not ebp
mov bp, word [edi + ebp*4 - 0xfdc05ca]
push ecx
sub ecx, 0xb507578c
xor ecx, ecx
xor cl, byte [edi + ecx + 4]
add edi, 4
call fcn.007812eb
jmp 0x88d6a4

Function at 0xbd0118
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0x10]
jmp fcn.00c3cedb
Function at 0xbd0618
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
or al, ah
mov ax, word [ecx]
jae 0xbd0605
jmp 0x79b9b7
sub ebx, ecx
mov ebx, ebp
mov ecx, 0x860a733c
mov ecx, 0
jmp 0x778c64
mov ecx, dword [esi]
add esi, 4
mov ebp, ecx
mov ecx, 0xc90ea685
dec ecx
mov edi, esi
movsx esi, cx
shl ecx, 0x72
movzx edx, si
jae 0x7a4970
push 0x6519ad34
adc edi, 2
mov word [edi], ax
call fcn.00877ee1
mov ebp, 0xe98bef9e
jmp 0xb90309
mov cx, word [esi]
pop edi
mov di, word [esi + 2]
push 0x3213d299
add esi, 2
not cx
not di
sub word [esp], 0x2d98
and cx, di
call fcn.007ab28d
mov ecx, dword [edi]
mov eax, 0xa4276997
jmp 0x75e225

Function at 0xbd3053
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea eax, [ebp - 0x80]
not di
and eax, 0xfffffffc
sub eax, ecx
lea edi, [edi + edi*2 - 0x1e531848]
jmp fcn.00ba3d44
cmp ebp, edx
lea esp, [esp + 4]
ja fcn.007959a6
mov edx, 0xafa44f2c
mov edx, esp
mov ecx, 0x44
mov edi, 0x67bec4ac
add edi, 0x77a31d87
ja 0x80d074
mov word [esi], dx
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

Function at 0xbda2c3
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [esi], ax
lea esp, [esp + 4]
jmp fcn.00c3cedb

Function at 0xbda6e0
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [esi], ax
lea esp, [esp + 8]
jmp fcn.00c3cedb
add esi, 2
not al
not cl
mov dword [esp], 0x979d7f09
sal dword [esp], 0xe1
and al, cl
jmp 0x78ab52

Function at 0xbda752
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [eax], edx
lea esp, [esp + 8]
jae fcn.008aeb84

Function at 0xbda75e
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

Function at 0xbde644
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [esi], dx
mov dword [esp], 0x896b42b
jmp 0xbf27f0
lea esp, [esp + 8]
jmp fcn.00c3cedb

Function at 0xbe29a6
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0xa4b85f19
mov byte es:[edx], al
jmp 0x876bd1
lea esp, [esp + 0xc]
jmp fcn.00c3cedb
add esi, 6
push 0xc824c23e
jmp 0x7d4680

Function at 0xbe6a46
Capabilities:
Encrypt data using rc4 prga

Disassembly:
and eax, 0x9036e800
adc al, 0
shr eax, 8
call fcn.00b8faab
lahf
lcall 0xca3a, 0xa016694
popfd
xchg dh, ah
and ax, 0xa32
loop 0x79a8a7
mov edi, 0x7ceafdfd
and eax, 0x191d2627
pop esi
and byte [ebp + 0x119bcde5], al
dec esp
inc esp
cmpsb byte [esi], byte es:[edi]
adc cl, byte [ecx - 0x7a]
imul ebp, dword [eax - 0x30], 0xd33331b4
aad 0x75
lahf
push ebp
sbb ecx, dword [esi - 0x20]
invalid
xor edi, eax
and edi, 0xff
mov edi, dword [edi*4 + 0x830bf0]
jmp 0x79a8cc