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

Disassembly:
inc ebx
movzx ebp, word [edi + ebx]
dec edx
mov dword [esp + edi*4], 0x118c15bd
xor bp, di
dec esi
lea edx, [esi*2 + 0x683fbb89]
inc edx
shr byte [esp + edi + 1], 0x61
xor bp, 0xe9f
xor bp, cx
dec esp
add esp, eax
neg bp
inc dx
rol dword [esp + edi + 4], 0xe1
ror bp, 1
inc ecx
push edi
jmp 0x132be5f
dec esi
lea esi, [ecx + edx*8 + 0x2081f16]
xor di, bp
dec eax
lea ebp, [esp + ebp + 0x18]
ror al, 0x83
dec ecx
sal edi, cl
inc ecx
push esp
dec ebp
mov esi, dword [edi + ebp]
dec edx
lea ebx, [ebx + edi - 8]
inc dx
shl dword [esp + edi + 0x1a], 0xb
inc cx
adc esp, 0xcd021f1b
dec ebp
mov dword [edi + ebx], esi
dec ecx
sal esp, 0x45
pop eax
inc ecx
pop esi
pop ebp
inc ecx
pop esp
jne fcn.01228351

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

Disassembly:
dec ebx
lea esp, [esp + 4]
jne 0x138e144

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

Disassembly:
dec edx
lea ebx, [ebx + ecx*2 - 0x6e]
inc edx
and dword [esp + ecx + 0x29], 0xe32f919c
dec eax
lea ebp, [ecx + eax*8 - 0x39dc9b77]
inc ecx
pop ecx
inc ecx
pop edx
pop ebp
inc ecx
pop esp
inc ecx
pop eax
inc ecx
pop eax
inc ecx
pop esp
inc ecx
pop edi
inc ecx
pop edi
inc ecx
pop esi
pop edx
inc ecx
pop esp
jbe fcn.01228351
inc ecx
mov esp, 0xfda66c31
inc ecx
not esp
inc ebp
mov edx, esp
inc si
movzx eax, byte [ebx - 0x25993ce]
inc ecx
mov dl, byte [esp + ebx - 0x25993cc]
inc ecx
rol dl, 2
inc ecx
not al
dec ebx
lea esi, [esp - 0x72fb60e0]
mov ecx, 0x690c582f
jb 0x1387c45
add ebp, esp
dec esp
mov dword [esp + 0x18], edi
push eax
inc ebp
mov edx, dword [ebx - 8]
inc ebp
mov esp, edi
dec esp
lea ecx, [ebp*8 - 0x75e86dfc]
dec ecx
add ebx, 0xfffffff8
dec eax
xchg dword [esp + 0x18], esi
dec eax
add esi, 0x26212
jmp esi
call fcn.01248074
loope 0x1309b24
jecxz 0x1309b27
scasb al, byte es:[edi]
les edi, [eax]
adc byte [ecx + 0x15], al
add ah, 0x38
adc byte [ecx], dl
mov ecx, 0x1038c4ee
or dword [ebp - 0x2e], eax
les edi, [eax]
adc byte [0x386e861d], cl
adc byte [edi], dl
pop ebx
invalid
inc ecx
neg edx
inc dx
shl dword [esp - 0x4b3279c], 0xc7
inc ecx
pop ecx
inc ebp
movzx edi, sp
push edi
inc esi
xor dword [esp - 0x12cc9e70], edx
inc ecx
movsx edi, ah
pop edi
dec ebp
arpl dx, dx
dec esp
xchg esi, ecx
jmp 0x1309b4d
not dl
xor cx, 0xb0a1
dec esp
lea ecx, [esi - 0x2cff71e8]
inc esp
and al, dl
dec eax
lea esi, [esi - 0xe5459e6]
inc eax
shr dh, 0x67
dec esi
lea edx, [ecx + 0x58aa5004]
inc si
mov dword [ebx - 0x25993cc], eax
inc ebp
mov edx, dword [ebx + ecx - 0x690ce892]
push esi
inc esp
xor edx, edi
inc ecx
xor edx, 0x6c20cd05
inc ebp
lea edx, [edx + esi*2 + 0x3ac91efe]
inc dx
sub dword [esp - 0x25993ce], ecx
inc ecx
rol edx, 1
jmp 0x1323a2b
Function at 0x130812f
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
pop esi
inc ecx
bswap edx
inc dx
neg dword [esp + esi*2 - 0x176b9b51]
inc esp
movzx eax, cx
dec edx
mov dword [esp + esi*4 - 0x2ed736a4], edi
call fcn.012eed2f
or eax, dword [esi + eax*2]
ror byte [esp + 0xc], 0xe7
mov edx, dword [esi + 4]
mov cl, byte [esi + 8]
push 0x6089c90f
mov dword [esp + 4], 0x381dd1e
adc esi, 6
shld eax, edx, cl
mov dword [esi], eax
call fcn.01345f9d

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

Disassembly:
lea edi, [eax + edi - 0x61038a4c]
xor edx, ebx
call fcn.013165e5

Function at 0x131212c
Capabilities:
Encode data using xor

Disassembly:
inc esp
movzx edi, byte [esp + ecx*4 - 0x2d4]
sub byte [esp + ecx*2 - 0x15c], 3
dec eax
mov dword [esp + ebp - 0xaf5], edi
dec eax
mov dword [esp + ecx - 0xb8], ecx
dec ecx
add edi, 0x3e0aeeaf
inc esp
xor dword [esp + ecx*2 - 0x160], esi
inc ecx
add cl, 0x2c
dec ecx
lea esi, [edi + ebp*8 - 0x10e904f7]
inc eax
dec eax
mov edi, dword [esp + ebp*4 - 0x2c04]
dec eax
sal dword [esp + ecx - 0xb0], 0xff
dec dx
dec ebp
arpl si, si
inc ecx
pop eax
jle 0x131e05c

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

Disassembly:
dec eax
lea ecx, [ebp*8 - 0x4f0e3f2]
dec ecx
mov eax, dword [ecx + ebx - 0xb5]
inc cx
dec eax
dec esi
mov esi, dword [ebx + ecx*4 - 0x2cc]
inc ecx
sar edi, 0xe1
ja 0x134ac24
inc edx
movsx esi, word [esp + ecx - 0xb1]
dec edx
lea ebx, [ebx + ecx*4 - 0x2cc]
inc eax
xadd dh, ch
dec ebp
xchg ecx, edi
dec ecx
add eax, esi
inc ecx
sal al, cl
dec esi
sbb dword [esp + ecx - 0xa7f], eax
inc esi
adc cl, byte [esp + ecx - 0xa7c]
dec edx
mov dword [ebx + ecx*2 - 0x1520], eax
dec edx
cmovs edx, dword [esp + ecx - 0xa90]
dec esi
mov dword [esp + ecx*2 - 0x1520], ebp
ret
dec edx
mov dword [esp + ecx*4 - 0x2d4], ecx
inc ecx
movzx edx, cl
dec ebp
add ebp, esp
jmp 0x1304d44
inc eax
xadd dh, dl
inc esp
xor dword [esp + esi - 0x1013ac9a], edx
pop edi
dec ecx
ror ecx, cl
mov ebp, ecx
inc bp
dec ebp
arpl dx, dx
jne 0x1305a0a
dec edi
lea edi, [edi - 0x386ca37b]
inc cx
xor edi, eax
dec ecx
rol esp, 0x98
mov eax, 0xd2ad6428
sub dl, dl
dec esp
adc eax, esp
dec ecx
lea ebp, [edi + edx*8 - 0xf763c6e]
inc bp
mov dword [eax], edx
inc cx
sal esp, 0x69
mov esi, edx
dec ecx
sbb ebx, 4
dec esp
lea edx, [edx + ebp - 0x26e844c8]
inc ecx
mov ebp, dword [ebx]
dec eax
xor edx, 0x56a0f9a5
push esi
neg word [esp + 4]
xor ebp, edi
inc ebp
movzx eax, bh
bswap ebp
inc dx
shl dword [esp + eax*2 - 0x1cd], 0x61
neg ebp
dec ebp
inc cx
rol eax, 0x63
inc ecx
dec ah
inc ecx
sar al, 0x24
rol ebp, 1
dec ebp
lea ecx, [edi + esi*8 - 0x506d95c5]
call fcn.01345414

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

Disassembly:
mov dword [esp], eax
dec edx
not ecx
rol edx, 1
xadd cx, ax
inc edx
call fcn.01236c32
Function at 0x13165e5
Capabilities:
Encode data using xor

Disassembly:
xor edx, 0xe399dc20
mov dword [esp + eax - 0x61038a4c], eax
add ax, 0xad8b
mov dword [esp + eax - 0x610337db], eax
not edx
inc edx
not edx
inc edx
jmp 0x1324281
xchg word [esp + eax - 0x610337d7], ax
and dword [esp + eax - 0x61038a4e], eax
neg edx
movsx ecx, byte [esp + eax - 0x61038a4c]
sub ecx, dword [esp + ecx*2 - 2]
dec edx
xor edx, 0xe0929796
inc ecx
dec edx
xor ebx, edx
add ebp, edx
push eax
neg byte [esp + eax - 0x61038a4e]
call fcn.013ed282

Function at 0x1316ed4
Capabilities:
Encode data using base64
Encode data using xor
Encrypt data using speck

Disassembly:
dec ebp
arpl sp, sp
inc ecx
rol dh, 0xa6
inc sp
xchg dword [esp + edx - 2], edi
dec eax
dec ecx
dec ebp
adc ebp, esp
call fcn.0139e6c7
dec eax
mov dword [esp + edx - 5], 0x78a5db13
neg eax
dec eax
mov edi, dword [esp + edx*2 - 2]
dec esp
lea eax, [eax + ecx*4 + 0x7e912bbb]
jne 0x124c1ef

Function at 0x131fc8f
Capabilities:
Get number of processors

Disassembly:
dec ecx
lea ebp, [edx - 0x565d446b]
dec esi
mov dword [esp + esi - 0xa952e61], eax
inc ecx
rol cl, 1
inc ecx
sub cl, 0xa7
dec dx
inc ecx
push esp
inc ecx
xor cl, 0x22
inc ecx
dec cl
inc ecx
xor bh, cl
inc ecx
ror bh, 0x26
inc ecx
sar ah, 0x42
dec esi
lea ecx, [esp + ecx + 0x10]
inc edi
add edx, dword [esi + ecx - 0xa952e61]
inc ecx
sub eax, 0x49833b3c
jge 0x132aeca
push edx
dec ecx
lea ebx, [esi + ebx - 0xa952e65]
inc eax
xadd dh, ch
inc ebp
mov dword [esi + ebx - 0xa952e61], edx
dec eax
add ecx, 0x36ba17a2
dec esi
lea ecx, [eax*4 - 0x1a7ca261]
dec eax
bswap esi
pop eax
inc ecx
pop edi
inc ecx
pop esi
jge fcn.01228351

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

Disassembly:
dec eax
sub edx, esi
dec esp
adc ebp, ecx
dec esp
mov dword [esp + eax*2 - 0x777c009a], ecx
call fcn.01396043

Function at 0x13223dd
Capabilities:
Encode data using xor

Disassembly:
call fcn.012fd019
call fcn.01255430

Function at 0x132c706
Capabilities:
Encode data using xor

Disassembly:
inc eax
setb ch
dec esi
lea edi, [esp + edi + 8]
inc bx
movzx ebp, byte [edi + eax - 0xe3c8]
dec esi
mov dword [esp + eax*8 - 0x71e40], esp
mov word [ebx + eax*2 - 0x590dfe14], bp
dec ecx
dec eax
dec esi
xadd dword [esp + eax*2 - 0x1c78e], eax
dec edx
lea ebx, [ebx + edx - 0x48e2cc99]
inc word [esp + eax*2 - 0x590dfe0e]
sbb eax, 0x84ff66b7
inc esp
add edx, esi
cmpsb byte [esi], byte es:[edi]
pop edx
jno fcn.01228351
lea edi, [edi + ecx - 0xe]
neg al
inc eax
xor edx, ebx
ror eax, 0x6a
ror edx, 1
lea edx, [ecx + edx - 0x511fa03c]
call fcn.01258043
aad 0x8c
loope 0x132c73b
lcall 0xb2e5, 0x4d103a98
cwde
cmp dl, byte [eax]
xor eax, 0x3a98fe69
adc byte [0x3a98b6e1], cl
adc byte [ebp + 0x15], cl
invalid
Function at 0x1332ed7
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
dec edx
mov dword [esp + eax + 0x3fc9], esi
neg ecx
dec edx
mov dword [esp + eax + 0x3fc9], edi
inc ecx
sar ecx, 0x28
jp 0x13d47c0
add ebp, ecx
shr dl, 0x46
mov ecx, 0xd91e8b2b
sal ecx, cl
jmp ebp
dec edx
mov dword [esp + eax + 0x3fc1], 0x2ba03e28
xor ecx, 0x810b4a5
inc ecx
shl esp, 0x32
dec ebp
or esi, edi
inc ecx
push esi
rol ecx, 1
dec ecx
shr esp, 0x21
inc edx
lea ecx, [ecx + eax*4 - 0x5400e694]
inc edx
mov esi, dword [esp + 7]
jns 0x124072b
inc edx
xor dword [esp + eax + 0x3fc2], ebp
inc edx
xor dword [esp + eax + 0x3fc9], ecx
inc edx
ror dword [esp + eax*4 + 0xff08], 0xfe
inc eax
sub ch, 0x82
inc ecx
neg bh
dec edx
mov edi, dword [esp + 8]
dec eax
arpl cx, cx
push ebp
dec esp
add ebp, ecx
pop ecx
pop eax
inc ecx
pop edi
jmp fcn.01228351

Function at 0x1334e16
Capabilities:
Encode data using xor

Disassembly:
dec eax
neg ecx
call fcn.01371323
lodsd eax, dword [esi]
add eax, 0x11e2d1e0
cmp edx, dword [eax]
cmp eax, 0x3b11b225
adc byte [ecx + 5], ah
rcl byte [ecx], cl
cmp edx, dword [eax]
xor dword [ecx], eax
salc
adc dword [ebx], edi
adc byte [ecx], dl
pop ebp
invalid

Function at 0x1335497
Capabilities:
Encode data using xor

Disassembly:
cld
adc eax, 0xc8c0b4a
add dword [edx + ebp*8], eax
mov ch, 0x89
xchg esp, eax
xor ecx, eax
add ecx, dword [eax - 0x6f]
rol ecx, 0x77
mov dword [ecx + esi - 0x1fb75bfa], eax
call fcn.013dbf13
pop edi
call fcn.012436b0
call fcn.01249e56
das
pop ds
loopne 0x1335471
pushal
or edi, dword [ebx]
adc byte [edi + 0x3b0b6cfb], ch
adc byte [ebx + 0x3b0b386f], al
adc byte [edi], al
mov dword [0x103b0b74], eax
mov dword [0x3ba130ab], eax
adc ch, bl
shl dword [esi + esi + 0x4a], 0x10
push 0xffffffffffffffae
out dx, eax
sbb ah, byte [edx]
cmc
enter 0x59ad, 0x63
jmp 0x9b14509f

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

Disassembly:
lea esi, [edx + esi - 0x29841d]
lea edx, [edx + edx + 0x68304cb3]
mov word ss:[ecx + edx - 0x688354f9], ax
mov eax, edx
shr word [esp + eax - 0x688354f6], 0xc6
mov dword [esp + edx - 0x688354f9], ebp
ret 4
xor edx, ebx
dec cx
pop ecx
xchg dword [esp + eax*2 - 0x6110], eax
inc edx
shl byte [esp + eax - 0x529c224b], 0xc2
shl eax, 0x84
push eax
rol edx, 3
sal byte [esp + eax*2 - 0x5384499e], 0x41
pop ecx
inc edx
sub eax, 0xf2bf933c
xchg ecx, eax
bswap edx
xchg dword [esp + eax*2 - 0x530849a0], ecx
jl 0x13120ef
jg 0x13fdeba
mov ecx, 0x1e3cbc9b
mov eax, 0x6891cda2
mov ecx, dword [esi + ecx*4 - 0x78f2f26c]
lea edx, [eax + eax*2 - 0x4edb94d7]
movzx ax, byte [ecx + eax - 0x6891cda2]
lea ecx, [edx*2 - 0x2bd711e9]
add cl, dl
not ecx
lea esi, [ecx + esi - 0x562369b9]
jg 0x13d89d1
dec edx
shl dword [esp + eax - 0x298424d0], cl
inc eax
shr eax, cl
xor ebx, edx
shl ecx, 0xf3
add ebp, edx
dec ax
mov ecx, dword [esi + eax*2 - 0x530846]
mov edx, eax
mov ax, word [esi + eax*8 - 0x14c2114]
push edx
jle 0x1256e66
Function at 0x133756b
Capabilities:
Parse pe header
Resolve function by parsing pe exports

Disassembly:
inc ecx
and edx, 0xff
inc edi
mov edx, dword [esi + edx*4]
sal dword [esp + 0xc], 0xb7
inc ecx
shr eax, 8
inc ebp
xor eax, edx
dec eax
mov dword [esp], 0xb3b070a8
dec eax
inc ecx
not dword [esp]
inc ecx
xor eax, 0x3a95648c
call fcn.012fedfe

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

Disassembly:
inc esp
mov ecx, ecx
not esi
call fcn.013ed57b

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

Disassembly:
mov dword [ebp - 0x28], edi
mov dword [ebp - 0x24], edi
mov dword [ebp - 0x2c], edi
jmp 0x17c38fa
mov byte [ebp - 1], bl
sub esi, edi
mov dword [ebp - 0x48], esi
btr esi, 0x81
cmp ecx, 0x3fb33515
movsx esi, cx
mov esi, dword [eax]
test edx, ebp
test sp, 0xa3a0
mov dword [ecx], ebx
stc
movsx cx, dh
mov ecx, dword [ebp + 0x14]
jmp 0x13f455e
call fcn.0138a9f4
cmp edi, 0x822fd695
push ebx
cmc
clc
push esi
bsf si, ax
push edi
shl esi, 0xbd
mov edi, 1
adc esi, 0xd9889835
mov esi, edi
test cl, 0x38
stc
shl esi, cl
mov ecx, dword [eax + 4]
cmp di, dx
xor ebx, ebx
mov dword [ebp - 0x20], edx
test di, 0xec15
sub esi, edi
cmc
stc
test esp, ebx
mov dword [ebp - 0x44], esi
adc esi, ebp
mov esi, edi
test bp, di
clc
shl esi, cl
neg cx
btc cx, dx
or ch, dl
mov ecx, dword [ebp + 0xc]
mov dword [ebp - 0x18], ebx
jmp 0x1333406
mov dword [ecx], ebx
or cx, si
mov ecx, dword [eax + 4]
add ecx, esi
mov eax, 0x300
shl eax, cl
mov dword [ebp - 0x3c], esi
jmp 0x17baec3
mov dword [ebp - 0x14], ebx
mov dword [ebp - 0x10], edi
cmp dx, 0x1123
add eax, 0x736
jmp 0x12f25ea
je 0x13ee168
mov ecx, eax
mov eax, 0x400
bswap edi
mov edi, edx
btr edx, 0xab
ror edx, 0x9b
bt edx, eax
movzx edx, ax
mov eax, edx
cmp edx, esp
cmc
cmp ebx, 0x2214371f
shl edx, 0x10
cmc
stc
or eax, edx
shr ecx, 1
jmp 0x1339976

Function at 0x133c1fe
Capabilities:
Encode data using xor

Disassembly:
inc ecx
pop ecx
dec eax
mov edi, dword [esp + edi*2 - 0x4abe88ba]
inc ecx
pop ecx
call fcn.01395200
mov byte [0x5ff13307], al
lodsd eax, dword [esi]
pop es
test al, 0x14
dec esp
salc
pop ds
test al, 0x14
dec esp
out dx, al
imul bh
test al, 0x14
dec esp
jne 0x133c276
aaa
test al, 0x14
dec esp
mov esp, 0x14a8bf06
dec esp
ja 0x133c271
test al, 0x14
dec esp
push ds
mov bh, 0xa8
adc al, 0x4c
lds ecx, [ebp - 9]
test al, 0x14
dec esp
aaa
lea edx, [edi]
test al, 0x14
dec esp
push ss
jge 0x133c274
fistp dword [ebx + 0x3c]
iretd
pop ds
xor al, byte [ecx]
adc edi, dword [ebx]
sbb byte [edi], bl
xor al, byte [ecx]
invalid

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

Disassembly:
inc bp
sub esi, esi
xor ecx, edi
rol ecx, 1
dec esi
mov dword [esp - 0x413c], esi
inc ecx
rol dh, 0x47
xor ecx, 0x808a8816
call fcn.0132b018
sysenter
call fcn.013bf2df

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

Disassembly:
inc sp
mov eax, dword [ebx]
inc esp
mov edi, ebp
call fcn.01254e84
movzx ecx, bp
pop edi
call fcn.0122b8d3
Function at 0x1341469
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
inc eax
dec edx
lea ebp, [ecx*4 - 0x296f1d4f]
push esi
xor eax, 0x969cb48f
inc ecx
push esi
ror byte [esp + esi - 0x3a], 0x26
dec eax
mov dword [esp + esi - 0xb], edi
inc ecx
setae ah
inc bp
xor edx, esi
inc edx
xor dword [esp + edx + 0x17], eax
inc ecx
sar dh, 0x41
dec eax
mov edi, dword [esp + esi*2 - 0x46]
jle 0x135cbc5
dec bp
inc ecx
push edx
dec eax
arpl ax, ax
movsx ecx, word [esp + esi - 8]
inc esp
sbb bh, ch
dec esp
adc ebp, eax
dec esp
mov eax, dword [esp + 0x18]
dec ecx
add eax, 0xb7598
inc ecx
jmp eax

Function at 0x1343936
Capabilities:
Parse pe header
Resolve function by parsing pe exports

Disassembly:
inc eax
and dh, ch
dec edi
lea ebx, [ebx + ecx*2 + 0x4f4400ac]
dec edx
mov dword [esp + ecx + 0x27a20058], 0x66013716
inc esi
mov esp, dword [esp + ecx + 0x27a20058]
inc ebx
mov eax, dword [ebx + ecx*2 + 0x4f4400b0]
inc esi
movsx esi, byte [esp + ecx + 0x27a2005c]
xor eax, edi
inc cx
not ecx
not eax
dec ecx
and ecx, 0x87fb29
dec eax
dec esi
xadd dword [esp + ecx - 0x50001], esp
rol eax, 2
dec edx
ror dword [esp + ecx - 0x50001], 0x84
inc ecx
sal esp, 0x67
dec esi
lea esp, [ecx*8 - 0x29e0f06b]
inc edx
lea eax, [eax + ecx*4 + 0xe8ce01a]
dec esi
xor ecx, dword [esp + ecx - 0x50001]
inc ecx
push esi
dec edx
ror dword [esp + ecx*4 - 0x33149b85], 0x95
dec edx
mov dword [esp + ecx*4 - 0x33149b84], edi
dec edx
rol dword [esp + ecx*8 - 0x66293718], 0xaa
dec esp
lea esi, [esi*2 + 0x25240723]
dec eax
bswap ebp
inc edx
xor dword [esp + 0x29b8f06b], eax
inc ecx
push ecx
dec ecx
not esp
dec ecx
sal esi, 0x85
dec edx
mov edi, dword [esp + ecx*4 - 0x33149b7c]
jb 0x134a10b
dec ecx
dec esi
inc ecx
mov eax, 0x61885731
dec eax
arpl ax, ax
inc ebp
movsx edi, sp
call fcn.01361365
dec ecx
mov dword [eax + ebx - 0x22], ecx
jmp 0x13ef1e5
mov esi, edx
inc ebp
add esp, esp
dec edi
lea ebx, [eax + ebx - 0x26]
inc ebx
mov eax, dword [ebx + eax*4 - 0x88]
xor eax, edi
inc ebp
mov ecx, esp
mov ebp, 0x541e8f84
dec eax
inc esp
xor eax, esi
inc esp
movsx esi, dl
not eax
call fcn.013a1f6c

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

Disassembly:
xor bl, dl
lea edx, [esp + edx + 0xc]
sal ecx, 0xa6
mov dword [edx + ecx*8], eax
mov edx, 0x4fb1aa81
ja 0x17b4b3b
pop ecx
adc ecx, 0xfff21c06
jmp ecx
mov edx, 0xa90cd80e
movsx eax, dx
jmp 0x1315abb

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

Disassembly:
dec edx
mov dword [esp + esi*2 - 0x486bfff8], edi
inc esi
xor dword [esp + esi - 0x2435fff8], ecx
dec edx
mov dword [esp + esi*2 - 0x486c0000], 0xea18f226
call fcn.013398c2
Function at 0x134f018
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
add cl, dh
ror eax, 2
sub eax, 0x8e9f8396
neg eax
add dl, 0x19
not eax
xor ecx, ecx
xor ebx, eax
sar ecx, 0xc1
adc ebp, eax
push edx
movzx eax, cx
call fcn.0138a314
movzx dx, byte [esi]
mov eax, 0xd1b418ac
mov cl, byte [esi + 2]
sar ax, 0x86
add esi, 2
pop eax
add dl, cl
mov ecx, 0xfc2a590a
movsx eax, cl
mov word [esi + eax - 0xa], dx
mov eax, dword [eax + edi - 0xa]
sub cl, cl
movsx edx, cx
lea edi, [edx + edi - 0x58fc]
dec ecx
xor eax, ebx
sub edx, edx
jp 0x130dd37

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

Disassembly:
inc cx
xor edi, 0x46668608
or dword [esp + esi*2 - 0x180], esp
dec edx
mov dword [esp + esi*4 - 0x31c], edx
inc cx
neg edi
mov ebp, 0x2392498f
inc si
xchg dword [esp + esi*8 - 0x62e], esp
inc cx
sub edi, 0x4166793f
ror edi, 1
inc eax
and dh, byte [esp + ebp - 0x23924981]
inc edx
sbb edx, dword [esp + esi - 0xc1]
sal ebp, 0x58
inc cx
xor edi, edi
call fcn.01220578

Function at 0x13574ae
Capabilities:
Encode data using xor

Disassembly:
dec ebx
lea esi, [esi + esi*2 - 0x73568c60]
dec esp
mov dword [eax + ebx - 0x21], edx
inc ebp
sub cl, cl
inc cx
xor eax, 0x894ca201
je 0x135750c
mov esi, 0x35c8d4d
invalid
out 0xd1, al
imul byte [edx]
cmp eax, 0xca1d7d10
sub bh, byte [0xb6e14510]
sub bh, byte [0xba2d6d10]
sub bh, byte [0xaa5d4110]
inc dword [edi + 0x10]
dec ecx
cmp eax, 0x96f078ec
salc
mov al, byte [0x4c29754d]
dec ecx
lcall 0xf178, 0xe7d54c19
invalid

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

Disassembly:
ror dword [esp + edx*2 - 0x454eb216], 0x11
not ecx
setb al
not al
or dword [esp + edx - 0x22a7590b], 0xc98da4a8
neg ecx
xor ebx, ecx
add dword [esp + edx*2 - 0x454eb216], edx
shl edx, 0xf3
adc ebp, ecx
pop edx
jmp ebp
dec ebp
lea ebx, [ebx + edx - 0x78000004]
inc edx
add ebp, dword [ecx + ebx]
xor ebp, edi
inc ecx
bswap edx
inc ecx
shr eax, 0x12
dec ecx
inc edi
lea ebp, [ebp + ecx - 0x490e9d3f]
inc ecx
not bh
inc ecx
shr edi, 0x55
not ebp
inc ecx
pop esp
inc ecx
mov eax, esi
ror ebp, 3
or al, dh
inc ecx
movsx esi, si
inc bp
cmovns edi, esi
neg ebp
jmp 0x13771db
inc esp
movzx esp, dl
inc ebp
xor ebp, 0x969cb48f
rol dl, 1
push edi
dec ecx
ror esp, 0x8c
xor dword [esp + ecx*2], ebp
push esi
dec eax
or dword [esp + ecx*4], 0xbb3354a2
dec edx
mov edi, dword [esp + eax*2 - 0x174e]
inc esp
or dword [esp + edx - 0x77ffffff], ecx
jae 0x139050f
dec eax
arpl bp, bp
js 0x1395f35
sbb ecx, 0xb004ff13
pop eax
jmp 0x135a81a
inc bp
sbb esp, eax
dec esp
cmovle edx, eax
dec esp
add ebp, ebp
dec eax
inc ecx
dec esp
mov dword [esp + edx - 0x78000000], ebp
ret 8
Function at 0x135eaf6
Capabilities:
Encode data using xor

Disassembly:
inc ebp
mov ecx, eax
dec ebx
lea eax, [ecx + eax - 0x17cc0a63]
dec eax
bswap eax
inc esp
xor esi, edi
inc cx
xadd eax, eax
inc ecx
rol esi, 2
jmp fcn.01352768
inc ecx
pop esi
dec eax
mov dword [esp + ebp - 0xfffffe8], edi
jae 0x1388619
mov eax, 0x4488b8a9
movzx edx, ax
shr eax, 0xa8
mov edx, dword [eax + esi - 0x4488b8]
jns 0x138424d
mov ecx, dword [eax + edi]
movsx edx, ax
bswap edx
jb 0x131704e
xor ecx, ebx
xchg al, dl
sar ax, 0x83
xor ecx, 0xe399dc20
and dl, al
inc ax
not ecx
adc ecx, eax
not eax
not ax
ror edx, 0xee
not ecx
call fcn.01393a21
mov eax, 0xae300b96
dec eax
mov edx, dword [ebx]
inc ecx
mov ecx, 0x2e8a7490
inc cx
shl ecx, 0x62
loope 0x135ebc7
dec ebp
mov esi, dword [ecx + ebx - 0x2e8ad238]
inc esp
movzx edx, al
call fcn.012330be
lds esp, [eax - 0x4b752e1a]
cmp eax, 0xd2455d10
mov ah, 0x3d
adc byte [ecx], ch
popal
div byte [ebp + edi - 0x39ae32f0]
mov ah, 0x3d
adc byte [0x3d1ece55], al
adc byte [ebx], ah
jae 0x135eb63
or al, 0xcf
adc esi, dword [edx - 0x1f]
retf 0x5bc2
sti
jge 0x135eb60
inc esp
hlt
inc esp
xor dword [esp + ebp - 0xfffffe8], eax
dec eax
mov edi, dword [esp + ebp - 0xfffffe8]
sub byte [esp + ebp*2 - 0x1fffffed], 0xaa
mov word [esp + ebp*2 - 0x1ffffff1], 0xf33
dec ebp
arpl ax, ax
je 0x130e8d5
dec ebp
add ebp, eax
dec esp
lea edi, [ebp*2 - 0x407b8a45]
dec eax
lea eax, [ebp*4 - 0x6b77b26a]
dec esp
mov esp, dword [ebp + ebx - 0x10000000]
dec esp
mov edx, dword [ebx + ebp - 0xffffff8]
mov cl, byte [ebx + ebp*2 - 0x1ffffff0]
rol word [esp + ebp - 0xfffffed], 0xcc
sub dword [esp + ebp - 0xffffff6], eax
dec eax
lea ebx, [ebx + ebp - 0xffffff6]
dec ebp
shld esp, edx, cl
dec ecx
lea esi, [ecx + ebp*2 - 0xbc06ddf]
dec esp
mov dword [ebp + ebx - 0x10000000], esp
inc ebp
movzx edx, cl
dec esp
mov dword [esp + ebp - 0x10000000], ebp
ret 0x18

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

Disassembly:
dec eax
or dword [esp + eax*4 - 0x2daa4], edx
pop ebp
inc ecx
pop ecx
pop ecx
pop ecx
jge fcn.01228351
not esi
inc eax
shr ch, 0x41
inc ebp
mov esi, esp
dec esp
mov dword [esp + eax - 0xb6a9], esp
inc esi
dec esi
lea esi, [edx*2 - 0x136d12cb]
jmp 0x1399366
bswap esi
dec eax
ror dword [esp + eax*8 - 0x5b543], cl
inc ecx
neg edx
rol esi, 2
dec eax
mov dword [esp + eax*8 - 0x5b540], edi
xor dword [esp + ecx - 0xafc1], esi
inc ecx
push edx
dec eax
mov edi, dword [esp + eax - 0xb699]
ror cx, 0x46
dec eax
xor ecx, dword [esp + eax*8 - 0x5b540]
inc ecx
push edx
dec eax
arpl si, si
inc ecx
movzx edx, dl
dec esp
adc ebp, esi
jmp 0x1316ef2