joyce8/EMBER2024-capa huggingface dataset:
Function at 0x783f0d
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea esp, [esp + 8]
jmp fcn.00c3cedb
mov dword [edx], eax
jmp 0x75dd98

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

Disassembly:
add esi, 2
mov word [esi], dx
push 0x7cb84b3a
lea esp, [esp + 0x10]
jmp fcn.00c3cedb

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

Disassembly:
mov dword fs:[ecx], edx
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

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

Disassembly:
push 0xf5be2c80
and ecx, eax
not ecx
jmp 0x791ee8
mov dword [esi], ecx
jmp 0x87f071
lea esp, [esp + 0x10]
jmp fcn.00c3cedb
Function at 0x78aaa3
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp + ecx*2 - 0x6d751152], ebx
movzx edx, cl
lea ebx, [ecx + ecx*8 + 0x70093109]
xchg edx, ecx
cpuid
push 0x5266436
xor byte [esp + 3], 0x97
sbb esi, 0xc
not word [esp + 1]
mov dword [esi + 0xc], eax
mov dword [esi + 8], ebx
mov dword [esi + 4], ecx
mov dword [esi], edx
mov ebx, dword [esp + 4]
lea esp, [esp + 8]
jmp fcn.00c54562

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

Disassembly:
xor ebx, dword [esp + ebx - 0x2c02306f]
mov dword [esp + ebx*2 - 0x58040000], ebp
movsx eax, cx
push ebx
mov dword [esp + ecx - 0x306f], edi
lea esi, [ecx*8 - 0x56da0559]
adc ecx, eax
push edx
sal ebx, 0x65
rol ecx, cl
mov eax, 0
mov dword [esp], eax
mov edi, 0xd85c62e
mov esi, dword [esp + edi - 0xd85c606]
not esi
call fcn.00795d83
jmp 0xbeb751
push esi
mov esi, 0xf43830ac
push edx
push ebx
mov ebx, esi
lea ebx, [esi*8 - 0x354fbe3]
push ecx
lea ebx, [esi*4 + 0x5b216dbf]
push eax
movzx ecx, bx
pushfd
push ecx
jmp 0x785ca0

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

Disassembly:
bswap ecx
mov cl, byte [esi + ecx - 0x1833857c]
adc esi, 2
sal dl, cl
mov word [esi], dx
lea esp, [esp + 4]
jmp fcn.00c3cedb

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

Disassembly:
shr ebp, cl
mov dword [esi], ebp
push 0xdcbdd1a3
lea esp, [esp + 0x10]
jmp fcn.00c3cedb

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

Disassembly:
neg dl
inc dl
xor dl, 4
add dl, 0x97
xor bl, dl
sar dword [esp + 8], 0x3a
lea edx, [esp + edx + 0x10]
mov byte [edx], al
lea esp, [esp + 0x10]
js fcn.00c3cedb
add ebp, 2
call fcn.007a25f6
mov dh, byte [edi - 0x68495149]
lahf
scasb al, byte es:[edi]
cmpsb byte [esi], byte es:[edi]
mov dword [0x9392aaa3], eax
wait
mov ah, byte [edi - 0x40796159]
mov bh, byte [0xf3159156]
mov word [edi], ss
cmpsb byte [esi], byte es:[edi]
sal dword [esi - 0x28], 1
imul ecx, dword [ebx], 0x2a646ef5
or ch, byte [edi]
jo 0x78febe
enter 0xffffffffffffa8ae, 0xfffffffffffffff9
pop es
in eax, dx
xlatb
enter 0x2489, 0xc
cmp dh, 0xbf
aam 0x8f
bound ebx, qword [ebx]
and byte [edi - 4], ch
leave
stosb byte es:[edi], al
aad 0x57
jmp 0xf058065
and bh, byte [eax + 0x42]
inc edi
adc dword [ebx], 0xd0fa4173
mov dl, 0x9a
pop ecx
fxch st(1)
fcom st(0)
stc
sbb dword [edx + ecx*2 - 0x262203e9], 0x8f052d35
cmp dword [ebp - 0x62e5df5], esi
pop ss
retf

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

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

Disassembly:
adc ebp, 2
ror byte [esp + 0xe], 1
sal dl, cl
push 0x391d869b
mov word [ebp], dx
jmp 0x796033
call fcn.0078d78d
inc ecx
mov ebp, 0x80b9f61b
inc ecx
bswap ebp
dec edi
mov esi, dword [ebp + eax - 0x1bf6b980]
inc ecx
sar ebp, 0x91
inc edi
mov ebp, dword [ebp + eax - 0xdf3]
ja 0x880301
mov al, 0x45
test al, 0xf2
push ds
test eax, 0xc5aab4a
aam 0x61
cld
fdivr st(2), st(0)
invalid
jae 0x8be520
xor al, 0x27
out 0xa6, al
rol dl, 1
mov ecx, 0x6ee7843c
ficomp word [edi]
syscall
inc ecx
push ebx
dec ecx
mov ebx, 0x339c06b8
sub eax, 0x4c7abac5
mov ebx, dword [esp]
dec eax
mov dword [esp], 0x59fb4e65
call fcn.00c485ec
jnp 0xc0436b
push esi
sub cl, byte [ebx]
xor eax, esp
mov byte [0x6c08604c], al
and eax, 0xa27866b3
xchg dh, dh
fidiv word [ebx + 0x21]
test al, 0xc6
dec esp
sub al, 0x80
mov byte [ebp + 0xf], al
dec esi
jo 0x8be58f
push ss
and dl, bl
popfd
loopne 0x8be4f2
inc edx
add dword [ebx + edx*4 + 0x286356fb], esi
iretd
scasb al, byte es:[edi]
movd mm4, dword [edi]
je 0x8be610
insb byte es:[edi], dx
or bh, bh
invalid
mov eax, dword [0xd70bf19e]
mov bl, 0x49
neg byte [edx + 1]
imul esi, eax, 0xffffffe6
aam 0xb3
dec ecx
mov bl, 0x49
neg byte [0xe210d43]
jae 0x8be602
fnsave dword [esi - 0x166c7d5b]
xchg ecx, eax
and bl, byte [esi]
fnstcw word [esi - 0x9b64c2c]
clc
retf
dec ecx
adc eax, 0xc
push 0xfe81358c
call fcn.00c48ae1
Function at 0x7961c9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
jp 0xb927b4
dec ecx
add eax, 2
inc cx
shl esp, cl
inc bp
mov dword [eax], esp
dec eax
lea esp, [esp + 8]
jmp fcn.008d19a2
ret
inc bp
mov esp, dword [eax]
mov ecx, 0xf19ba039
dec eax
neg ecx
inc ecx
mov cl, byte [eax + 2]
jb 0x7720dc
pop esi
adc bx, bx
btc ebx, esi
sal ebx, cl
pop ebx
jmp 0x8547ba
jbe 0x78afe7
or eax, 0xffffffff
jmp 0xbde679
cmp cl, al
jmp 0x8016b3
ja 0xb92762
add cl, 0x20
test ebp, 0x6c242788
test al, al
je 0xbd1964
cmp al, cl
jmp 0xbd195e
or ebp, dword [eax + 0x40]
xor dh, bh
inc eax
not dh
inc eax
add dh, 0x92
test dword [eax - 0xa], 0xc68040d6
xchg edx, eax
dec eax
inc dword [esp]
inc eax
xor dh, 0xa3
inc eax
not dh
inc eax
xor bh, dh
dec eax
lea esi, [esp + esi + 0x10]
call fcn.007cbacd
lcall 0xb5ae, 0xf90b050c
xchg ecx, eax
jge 0xb927ca
add dword [edi], esp
int 0x98
test dword [ebp + 0x1f056445], esi
loope 0xb92764
and ecx, 0x4d930661
sbb dword [edx], eax
int1
clc
inc ecx
mov ebx, 0xc7fec32d
aaa
jns 0xb9281b
xchg dword [eax], edi
or byte [ebx - 0x22], al
cmp al, 0xd9
lahf
loop 0xb9279a
fnsave dword [edi - 0x3e]
mov al, 0xf5
imul esp, esi, 8
in eax, 0x77
mov ecx, es
dec edi
loop 0xb9286d
jge 0xb92880
inc edx
mov al, byte [0x2cacccc7]
push ecx
push esp
jle 0xb9279e
invalid
add byte [esi - 0x31e7858f], 0xeb
sbb esi, ecx
push 0xf777c015
int 0xa1
mov dh, 0xf6
push es
mov edi, 0xa7da9c31
cmp eax, 0xd1a33ea8
xchg esp, eax
xor cl, byte [edi - 0x483d7793]
sub dword [edx + ecx*2 + 0x10c86a7], esp
aas
fnsave dword [esi + 0x55afb9]
sbb eax, 0x4b3396d3
leave
retf 0x9c0a
retf
sbb al, 0xe8
xchg ebp, eax
pop edx
push ebx
salc
fnstcw word [0xa2060a0b]
xor edx, esi
and dl, byte [ebp + 0x7cfc5c9c]
xchg dword [ecx - 0x32], ebp
fistp qword [edi]
inc ebx
pop es
inc ebp
xchg esp, eax
xchg cl, dl
in al, 0x7a
cmp byte [eax], bh
mov ebp, 0x43c358b2
mov dword [0xed217e52], eax
xchg esp, eax
mov dword [edi + 0x4f5a17e3], edx
mov byte [edi + 0xda04eb5], 0xee
mov ch, byte [ecx]
add eax, dword [esi]
movsb byte es:[edi], byte [esi]
mov bh, 0x7c
rol byte [edi + 0x38e953ba], 1
push eax
cmp byte [edi], dh
invalid
je 0xbdbcb8
pop edi
jmp 0x79b6a8
mov cl, byte [edi]
xchg al, bl
mov al, byte [esi]
not bl
mov bx, cx
mov byte [ebp - 1], cl
mov bl, 0x32
mov cl, dl
inc esi
inc edi
btr ebx, ebp
movzx ebx, cx
mov ebx, 0x9c2696a4
rol ebx, cl
add bl, dl
xor al, bl
mov cl, al
cmc
sub cl, 0x41
jmp 0xbf9ab4
mov esp, ebp
xchg bp, bp
pop ebp
jmp 0x77adfd
ja 0xbead61
add al, 0x20
mov cl, byte [ebp - 1]
setbe bl
mov bl, cl
sub bl, 0x41
cmp bl, 0x19
jmp 0xb92753
inc edx
cmp cl, 0x19
jmp 0xbead59

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

Disassembly:
mov edx, dword [edx + esi - 0xe21cab0]
mov dword [esp], 0xebbd0194
mov ecx, 0x10b2a436
mov eax, dword [esi + ecx*4 - 0x42ca90d4]
inc dword [esp + ecx - 0x10b2a436]
ror word [esp + ecx - 0x10b2a434], 0x44
mov ecx, dword [ecx + esi - 0x10b2a42e]
add esi, 4
shr dword [esp], 0x7d
div ecx
mov dword [esi], edx
mov dword [esi + 4], eax
lea esp, [esp + 4]
jmp fcn.00c3cedb
Function at 0x797ca6
Capabilities:
Encode data using base64
Encrypt data using speck

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

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

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

Disassembly:
lea esp, [esp + 4]
jne 0x8affce

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

Disassembly:
call fcn.007855ae
call fcn.0080cead
mov ebp, 0x7281ac0f
ror bp, 0x8d
mov ebp, dword [edi + ebp - 0x7281607d]
jae 0x792de8
jmp 0x7bda57
add edi, 1
push 0x3a0fb285
push 0x1592891c
xor al, bl
xor al, 0x8b
neg al
inc al
push 0xd523d18d
xor al, 4
not byte [esp + 6]
not byte [esp + 5]
add al, 0x97
xor bl, al
lea eax, [esp + eax + 0xc]
not byte [esp + 0xa]
mov byte [eax], dl
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

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

Disassembly:
ret
push 0x34067e8b
ror byte [esp + 1], 0x23
dec ebx
call fcn.0079e05b
sbb eax, eax
clc
jmp 0x83be64
lea esp, [esp + 8]
jne 0x7cdc66
jmp 0xba1d29
mov eax, dword [ebp + ebx*4]
push eax
jmp 0x78afd7
jmp fcn.00c3cedb
neg eax
jmp 0xba71a9
mov eax, 0x30286019
mov eax, dword [eax + ebp - 0x30286019]
push 0xea199612
lea esp, [esp + 4]
call eax
mov ebp, dword [ebp - 4]
mov dword [ebp], eax
mov esi, ebp
pop ebx
mov edi, 0x101dca24
not di
pop edi
jmp 0x8269a3
mov esp, ebp
mov ebp, edi
pop ebp
jmp 0x76d165

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

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

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

Disassembly:
jmp 0xc5ed30
lea esp, [esp + 0xc]
je 0xc59452

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

Disassembly:
mov byte [ecx], al
lea esp, [esp + 0x18]
jmp fcn.00c3cedb

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

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

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

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

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

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

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

Disassembly:
sar dl, 0xa6
mov dx, word [esi + edx - 0x6d6950fd]
lea ecx, [ecx + ecx*2 - 0x37d1fdcc]
mov dword [esp], 0xfa15842e
sbb cl, ch
mov cl, byte [esi + 4]
adc esi, 4
shrd ax, dx, cl
mov word [esi], ax
push 0xf2ba4a30
lea esp, [esp + 8]
jmp fcn.00c3cedb

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

Disassembly:
add esi, 6
mov byte es:[edx], al
lea esp, [esp + 4]
jmp fcn.00c3cedb

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

Disassembly:
mov byte ss:[ecx], al
lea esp, [esp + 4]
jmp fcn.00c3cedb
adc esi, 6
jmp 0xc5f7ab
jmp 0x788c19

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

Disassembly:
add edi, 4
call fcn.00799b0a
mov eax, 0x24922798
movzx ax, byte [esi + eax*2 - 0x49244f30]
jmp 0xc3ff30
Function at 0x7b0d5b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
cmp ecx, dword [ebp - 0x40]
jmp 0x7b27c1
mov dword [esp], 0x2a02bd33
xor bl, dl
sar word [esp + 1], 0x41
lea edx, [esp + edx + 0xc]
jb 0x7b27b4
mov cl, 0xdb
insd dword es:[edi], dx
sbb ecx, ebx
jmp 0x1a0a478a
mov word [edx], cx
lea esp, [esp + 0xc]
jne fcn.008c7f98
je 0x7a307f
movzx edx, byte [ecx]
jmp 0x89a92a
cmp edi, 5
jmp 0x817ca3
jl 0x7a1f34
mov dword [ebp - 8], ecx
lea esp, [esp]
movsx edx, di
shl esi, 8
jmp 0xbaf60d
inc edi
cmp bh, 0x27
jmp 0xc3690c
or esi, edx
inc ecx
cmp ebx, 0xad84e3a9
cmp bp, bx
jmp 0x80ee43

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

Disassembly:
or edx, edi
not edx
call fcn.00b8eb29

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

Disassembly:
or dword [esp + 7], 0xe60e4616
sbb esi, 4
mov dword [esi], eax
lea esp, [esp + 0xc]
jmp fcn.00c54562

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

Disassembly:
mov byte [eax], dl
push 0x82ccfae
lea esp, [esp + 0x10]
jmp fcn.00c3cedb
xor al, 0x8b
neg al
mov dword [esp], 0x93ac923a
jmp 0xbf7701
push 0x93965790
inc al
xor al, 4
ror byte [esp + 6], 0x86
xor word [esp + 1], 0xff9b
adc al, 0x97
xor bl, al
lea eax, [esp + eax + 0xc]
jmp 0x753ef8

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

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

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

Disassembly:
push 0x523ad79e
mov word [esi], dx
push 0x4a31f8a1
jmp 0xbcb48a
lea esp, [esp + 0x14]
jmp fcn.00c54562

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

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

Disassembly:
shl dl, cl
mov word [esi], dx
push 0xba2b19a2
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

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

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

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

Disassembly:
lea esp, [esp + 4]
jne 0x7c4dea
mov eax, 0x7f982491
not al
mov eax, dword [eax + ebp - 0x7f98246e]
push 0xdf20f91e
lea esp, [esp + 4]
call eax
call fcn.00818d31
dec ebx
jmp 0x75dd70
lea esp, [esp + 8]
je 0x75dd7a
mov eax, 0x931005a3
ror ax, 0xc7
mov eax, dword [ebp + ebx*4]
push 0x272fc3a8
mov dword [esp], eax
push 0x9f96db35
jae 0x7651cb

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

Disassembly:
movsx edi, si
movzx ecx, di
pop eax
not cl
pop edi
pop esi
dec cl
jg 0x858bc8
mov edx, 0xa212f096
mov edx, dword [esi]
movzx bp, byte [edx]
push 0x1f13693c
jmp 0x8e307d
mov ebp, dword [ebp - 4]
pop esi
call fcn.0078154b
mov esp, esi
mov esi, 0xe094c088
pop edx
movzx ebp, si
pop ebp
jmp 0x7b37fb
shl cl, 0x47
popfd
pop ebx
call fcn.00c5f768
syscall
inc ecx
push edi
pushfd
dec ecx
mov edi, 0xce1c072c
xor cl, dl
cmp dword [edx], ecx
dec esp
mov edi, dword [esp + 8]
dec eax
mov dword [esp + 8], 0x99f4f99e
push dword [esp]
popfd
dec eax
lea esp, [esp + 8]
call fcn.00c485ec
push 0x5394ecbb
mov dword [esi], eax
push 0x61fb02c
push 0x5595100b
lea esp, [esp + 0xc]
jmp fcn.00c3cedb
push 0xd1240201
mov word [esi], bp
not word [esp + 4]
jmp 0x8d658d
lea esp, [esp + 8]
jmp fcn.00c3cedb
add esi, 2
jmp 0x882654

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

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

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

Disassembly:
not byte [esp + 9]
lea esp, [esp + 0xc]
jmp fcn.00c3cedb
mov dword [esi], edx
jmp 0x85e8f8
jmp 0x784ab6

Function at 0x7ce0e3
Capabilities:
Encode data using xor

Disassembly:
lea esp, [esp + 0xc]
je 0x7f3ca2
jmp 0xbf89bc
push edi
mov edi, 0x6322b833
rol edi, 0x70
shl edi, 0xc4
movzx edi, byte [ecx]
push 0xbe859393
xor edi, ebp
push 0x8fb3ff3a
and edi, 0xff
mov edi, dword [edi*4 + 0x7bd1e8]
shr ebp, 8
xor ebp, edi
inc ecx
shr word [esp + 4], 0x41
xor ebp, 0x12364a0f
dec edx
lea esp, [esp + 8]
jne 0xbf89bd
mov edi, 0xf6bcdc31
jmp 0x7f3ca1

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

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

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

Disassembly:
mov dword [esp], 0x3ba3022c
movzx ax, byte [ebp]
mov ecx, 0xdd26f60e
sal dword [esp], cl
mov cl, byte [ebp + 2]
setbe byte [esp]
adc ebp, 2
call fcn.00c50012
mov eax, 0x95911337
mov eax, esi
jmp 0x7606e2

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

Disassembly:
pop ecx
mov ecx, 0x960bec9d
mov eax, dword [esi]
push ecx
mov edx, dword [esi + 4]
sal cx, 0x25
jb 0x7835fd
Function at 0x7d4d04
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [esp + edi*2 - 0x2926d33c], 0xdbf4ba8
mov ebx, dword [esp + edi*2 - 0x2926d338]
mov edi, dword [esp + edi*4 - 0x524da670]
lea esp, [esp + 0xc]
jmp fcn.00c3cedb

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

Disassembly:
sar dx, 0xc6
mov dx, word [esi + edx - 0x23a7fe9a]
add esi, 2
add ax, dx
mov word [esi], ax
lea esp, [esp + 8]
jmp fcn.00c3cedb

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

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

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

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

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

Disassembly:
add esi, 2
push 0x720fafa6
jmp 0x87ed26

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

Disassembly:
mov word [esi], dx
call fcn.0088df0b
mov word [esi], dx
lea esp, [esp + 4]
jmp fcn.00c3cedb

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

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

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

Disassembly:
mov word [esi], ax
jmp 0x841f1e
lea esp, [esp + 8]
jmp fcn.00c3cedb
add esi, 2
not ax
not dx
and ax, dx
push 0xcc0b0d2b
jmp 0x755dc1
jmp 0x78d343

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

Disassembly:
mov ebx, 0x171dd1ad
movzx ebx, byte [eax + ebx*2 - 0x2e3ba35a]
push 0x6e89101a
xor ebx, edx
and ebx, 0xff
jmp 0x796ec6
mov ebx, dword [ebx*4 + 0xc53644]
mov byte [esp], 0xba
shr edx, 8
dec dword [esp]
xor edx, ebx
call fcn.00839581
add cl, 0x33
call fcn.008334d8
jmp fcn.00c3cedb
lea esp, [esp + 0x10]
jne 0x765b29
jmp 0x8e81b4
pop ebx
not edx
mov dword [esi], edx
jmp 0xc4973a
jmp 0x801713

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

Disassembly:
sal ax, cl
not dword [esp]
jmp 0x7bf4f3
mov word [esi], ax
lea esp, [esp + 4]
jmp fcn.00c3cedb
mov ax, word [esi + 2]
add esi, 2
call fcn.0083e4f8
mov ax, word [esi]
mov ecx, 0x4abfea2f
lea ecx, [ecx*2 + 0x74a0b635]
mov cl, byte [esi + ecx - 0xa208a91]
push 0x2435fe20
add esi, 2
not dword [esp]
jmp 0x765b48

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

Disassembly:
neg dl
lea eax, [eax + eax*2 + 0x273b3517]
dec dl
rol dl, 1
xor bl, dl
mov dword [esp], edi
dec ax
push ebx
mov ebx, edx
mov edx, ebx
shl edx, 2
call fcn.0088e8fc
clc

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

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

Function at 0x80e1b2
Capabilities:
Encode data using base64

Disassembly:
add cl, 0x3d
call fcn.0079b976
mov si, word [ebp]
add ebp, 2
mov ecx, 0xa07938c
rol ecx, 0x1c
sbb edi, 1
movzx ecx, byte [edi]
xor cl, bl
ror cl, 1
jmp 0x7c76b5

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

Disassembly:
mov word [esi], dx
lea esp, [esp + 0xc]
jmp fcn.00c3cedb
Function at 0x81199c
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
dec al
ror al, 1
jmp 0x7f6847

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

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

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

Disassembly:
add ebp, dword [esi + ecx - 0x4f196500]
mov ecx, dword [esi + ecx - 0x4f1964fc]
add esi, 8
mov dword [ebp], ecx
jmp 0xc51239
lea esp, [esp + 4]
jmp fcn.00c3cedb

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

Disassembly:
xor bl, cl
mov dword [esp + edx - 0x7ffffffc], esi
mov dword [esp + edx - 0x80000000], ebx
rol al, 0x61
jb 0xb9499d

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

Disassembly:
dec ecx
sub eax, 8
inc ecx
mov dword [eax + 4], eax
call fcn.0087d7f1
add esi, 2
sal eax, cl
push 0x3d82aa9c
mov dword [esi], eax
lea esp, [esp + 8]
jmp fcn.00c3cedb

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

Disassembly:
shl dl, cl
mov word [esi], dx
lea esp, [esp + 8]
jmp fcn.00c3cedb

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

Disassembly:
lea esp, [esp + 0x10]
jmp fcn.00c54562
not al
mov dword [esp + 4], 0x290d5fb3
neg word [esp + 4]
dec al
xor bl, al
ror dword [esp + 0xc], 0xc8
sub esi, 2
mov dword [esp + 8], 0xb897e4bb
mov word [esi], ax
jmp 0x7b8086

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

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

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

Disassembly:
add esi, 1
xor al, bl
ror al, 1
jmp 0xbf41a5
xor al, 0x3b
mov dword [esp], 0x98cee85
xor word [esp], 0x5297
inc al
ror al, 1
sal word [esp + 2], 0xa3
neg al
neg word [esp]
sar word [esp], 0xec
xor bl, al
shr dword [esp], 1
call fcn.0086ed79

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

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

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

Disassembly:
mov word [esi], ax
lea esp, [esp + 4]
jmp fcn.00c3cedb
add esi, 2
imul cl
jmp 0x7523b5
mov cl, byte [esi]
movzx ax, byte [esi + 2]
jmp 0x753e5e

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

Disassembly:
xor dl, bl
xor dl, 0x8b
neg dl
push 0xbaa83ea4
ror dword [esp], 0xa9
inc dl
xor dl, 4
push 0x3aad8b35
add dl, 0x97
xor bl, dl
lea edx, [esp + edx + 0xc]
mov byte [edx], cl
lea esp, [esp + 0xc]
jmp fcn.00c3cedb