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

Disassembly:
push es
add byte [eax], al
add byte [eax - 0x16ffdab4], cl
mov eax, dword [0x87000ad7]
xchg dword [esp + 0xc], eax
xchg dword [esp + 0xc], eax
call fcn.1016e249
mov ebp, 0x8c7b0b
mov ecx, 0xe32030ae
das
jecxz 0x10133a32
push es
ror dword [edi - 0x6ef71be1], 1
xchg ecx, eax
sbb dword [0x51bef03e], esi
xchg esp, eax
insd dword es:[edi], dx
cmp al, 0x6f
add ebx, dword [edx - 0x22f1d63a]
or dword [ebp + 0x3483cf2], edx
mov al, byte cs:[0x9e1012f9]
pop edi
shr dword [edi], 0xca
pushal
cmc
jnp 0x10133a09
imul ecx, dword [edx], 0x29
pop ebx
ja 0x10133a01
jne 0x101339e2
out dx, al
inc edi
fist dword [ebx - 0x593d0493]
jl 0x10133aa0
xchg esi, eax
dec esp
leave
mov ah, bh
sbb dword [edi - 0x2b], edi
jo 0x10133a97
dec ecx
inc edi
sub al, byte [ebx - 0x43730854]
adc eax, 0xc9446cd
xchg edx, eax
int 0x46
inc esi
xchg esp, eax
or al, 0x92
pop ss
add eax, 0x7ef8ef61
xor ebx, dword [esi]
rcr dword [ecx + ecx*8 + 0x58], 1
inc ebp
pushfd
je 0x10133a86
jno 0x10133ab5
aam 0xf5
sub al, 0xdb
fnstcw word [ebp - 0x55833c62]
mov byte [0x6c117ee4], al
jno 0x10133abe
push edx
retf
cmp dword [esi - 0x36], ecx
or byte [esi], 0xc3
js 0x10133a9a
aad 0xd4
sar dword [edx + ebp*4], 1
add dl, dh
retf 0x10c
add dword [eax + 0x43], esp
push ds
mov eax, dword [0xa1550768]
pop ds
xchg byte [edi], dl
xor al, 0x4c
ror dword [ecx + 0x6e], 1
mov ch, 0x19
jge 0x10133a55
inc esp
and al, 0x38
pop ebp
fcomp dword [eax + 0x5a]
int1
sbb al, 0xdc
inc edx
mov bl, 0x3e
inc ecx
ljmp 0xe7c4
dec ebp
test byte [ebp - 0x466a183c], ah
pop edi
xchg ebx, eax
jp 0x10133a56
xor al, 0xd4
fmul qword es:[ebx - 0x75018971]
outsb dx, byte [esi]
inc ebx
pushal
invalid

Function at 0x10153013
Capabilities:
Encode data using xor

Disassembly:
call fcn.1018184b
and edx, dword [ecx - 0x13a7c41f]
je 0x1015309e
loop 0x10153052
mov dword [0x7173], eax
jmp 0x3109690e
push dword [ebx - 0x6c5a128d]
frstor dword [ebp + edx - 0x75]
xor eax, dword [edi + 0x2056fcc8]
mov eax, dword [0x5b45f7c]
adc eax, 0xc887338b
cld
push esi
and byte [ecx + 0x5b45f7c], ah
mov edi, 0x12f4f576
push ebx
arpl word [edx + eax*4 - 0x79], di
insd dword es:[edi], dx
sbb dword [edi + edx*2 + 0x3fea482d], ecx
dec edx
push ecx
cmp eax, 0xcb843069
inc edx
add al, ah
inc edx
push es
push ss
sub al, 0x88
bound esi, qword [eax - 0x57]
je 0x101530bd
loop 0x10153059
outsd dx, dword [esi]
loope 0x10153026
add eax, 0xb0af6667
dec esi
movsd dword es:[edi], dword [esi]
push esi
jno 0x10153061
mov dh, byte [ecx + 0x5889a9e]
mov ebp, 0x1a1c8c78
mov dh, 0xd8
mov ebx, 0xf5ea854c
or edx, ebx
jns 0x1015305f
sahf
lcall 0x1c8c, 0x78bd0588
sbb dh, byte [esi - 0x7ab34428]
ljmp 0x99ad
cdq
cwde
popal
dec esp
out 0x7a, al
pop ebx
hlt
push es
arpl sp, cx
push 0xffffffffffffffe6
salc
dec ecx
invalid
Function at 0x1017c4af
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp + edx - 0x3fdfac90], edx
mov edx, dword [esp + edx - 0x3fdfac98]
mov edx, dword [edx]
neg word [esp + 0xc]
xor word [esp + 0xc], 0x9aac
or dword [esp + 0xc], 0xe226c003
add dword [esp], 0xeffcb834
and al, 0
xor al, 0xb8
cld
out dx, eax
lea edx, [edx + 0x2c1037a0]
neg dword [esp + 0xc]
mov dword [esp + 4], 0x6adc5ac
and byte [esp + 4], 0x8d
test byte [esp + 4], 0x31
call fcn.10075980
push edi
lea edi, [edi + 0x641b292a]
call fcn.1027145f
or ah, byte [ebx]
or esp, dword [edi + 0x5f]
or eax, 0x9c21b8bd
cmp eax, 0x5b125141
outsb dx, byte [esi]
out dx, eax
and ebx, dword [ebx]
inc esi
xchg ebp, edx
and eax, 0xcd64a920
xchg ecx, eax
rcl dword [ebx - 0x22f0d0a5]
in al, 0x72
sub eax, 0x8dac8be9
adc al, 0xc2
ja 0x1017c4d5
pop ebx
das
paddusw mm4, mm4
jb 0x1017c55a
jmp 0x24a571bd
sub byte [ebp + 0x1d], bl
mov dword [0xa4495bfd], eax
mov ch, 0x46
ja 0x1017c56e
mov dword [0xb7b7bc1d], eax
invalid
sub eax, 0x5c26ffde
xor eax, 0x3d6e837f
mov dword [0x50ccf1bd], eax
push eax
and dword [eax], ebx
cld
ror dword [ecx], 1
mov ebp, 0x8e77286f
stosb byte es:[edi], al
add ch, byte [esi]
mov ah, 0x89
cmpsd dword [esi], dword es:[edi]
inc edi
dec ebp
xor byte [eax - 0x6e], bl
pop eax
xchg edx, eax
inc ebp
loop 0x1017c54c
inc edi
jg 0x1017c526
cmp ch, al
mov byte [esi - 0x41cb6044], 0xba
leave
adc al, 0xf0
invalid

Function at 0x1018d48b
Capabilities:
Get number of processors

Disassembly:
sets byte [esp + 4]
add dword [esp + 4], ebx
add dword [esp], 0x24a140
add dword [esp + 0x18], 0x5c249e06
lea ebx, [ebx*8 + 0x773e7c1d]
jno 0x10102315
mov ebp, 0xf98b68c
mov ebp, dword [esp]
mov ebp, dword [ebp]
cmp bl, byte [esp + 7]
jle 0x1025e8f7
add ebp, 2
push 0x4984890e
or dword [esp], 0x7c9a783f
not cl
mov byte [esp + 2], 0xb8
add dword [esp], 0x6c1d3abb
jle 0x101e907c
not dl
dec dword [esp]
push 0xc33dbbb4
or cl, dl
not byte [esp + 1]
push 0xa202bc27
jmp 0x10192cbd
mov word [ebp], cx
call fcn.1012bb29
Function at 0x101a273e
Capabilities:
Encode data using xor

Disassembly:
imul dword [eax + ebp*2 + 0x2efb8354]
push cs
inc eax
into
mov dh, 0xe5
add dword [edi], eax
push edx
aaa
xchg edx, eax
cmp dword [edx], 0x8f8850fe
pop edx
mov bh, 0x89
pop es
pop edi
dec edi
movsb byte es:[edi], byte [esi]
inc eax
inc esi
sbb ebp, dword [0xb1777a91]
dec edx
mov esi, dword [edx + ebp + 0x27]
xchg ecx, eax
mov esp, 0x6e9e4345
push esi
add dword [ebp + 0x1f260220], 0xffffffb0
jb 0x101a273c
cmp al, 0x11
push edi
mov dl, 0xa8
invalid
mov eax, 0x911cd81d
xor ecx, dword [ecx - 0x18]
retf 0xe0ed
pop ss
sbb eax, 0x70468278
pop es
jo 0x101a26f2
arpl si, di
push 0xd0200782
call 0xea806253
jae 0x101a269c
add byte [edi], 0x20
shr al, 1
cmp eax, 0x73da663b
test dl, bh
cli
mov ebp, 0x810a8a69
sbb al, 0xbe
mov esp, 0x96a703e2
imul ecx, dword [edx - 0x41e37ef6], 0xa703e2bc
xchg esi, eax
xor dword [ebx], edx
insd dword es:[edi], dx
sub edi, dword [ebp - 0x38]
jns 0x101a270d
les edi, [edx + 0xeb48b9c]
jle 0x101a2701
cli
lcall 0x8dff, 0xf6bdc1e8
invalid
mov dh, 0x11
jle 0x101a276f
idiv bh
lea esi, [esi + 0x6e2c7e11]
outsb dx, byte [esi]
call fcn.1014b93b
jb 0x101a271b
mov eax, 0x1060d4a
stosd dword es:[edi], eax
invalid
adc al, 0xda
mov ecx, 0x1172f55e
jnp 0x101a2799
retf
sti
daa
inc eax
pop ss
fld qword [edx + 0x4ace2103]
cli
or byte [ebp - 0x2b], cl
or byte [ebx - 0x12], cl
into
push ebp
adc byte [edx], 0x1b
adc dword [edx], ebp
add ebx, dword [edx - 0x7ff31b32]
out 0x91, eax
mov bh, byte [ecx]
push ebx
scasb al, byte es:[edi]
invalid
Function at 0x101baca7
Capabilities:
Encode data using xor

Disassembly:
sub ebx, 0xada2f53c
call fcn.1008302a
in al, dx
push edx
xchg dword [esi], ebp
invalid
Function at 0x101efb91
Capabilities:
Encode data using xor

Disassembly:
inc sp
mov dword [ecx], edx
call fcn.1020c2b8
and dh, ch
arpl word [ebp - 0x4050966b], ax
scasb al, byte es:[edi]
mov al, bl
inc esp
stosb byte es:[edi], al
xchg byte [edi - 0x3f], dh
test eax, 0x8e12bcee
or eax, 0xaf011338
shr dword [ecx + 0x5c91d8fd], cl
mov eax, dword [esi]
int1
sub eax, 0x16b6a498
mov eax, dword [0xeded5136]
sub eax, 0x8de783fc
sub ah, byte [ebx + 0x77f2845c]
sahf
cmp bh, al
adc cl, byte [eax + 0x465b7940]
sbb eax, 0x44829b8f
or al, 0x4f
fbstp tbyte [eax - 0x25415f7c]
push esp
push edx
add eax, 0x9cf1e319
push ecx
mov cl, 0x9c
and al, 0x35
pop ss
or ah, byte [eax]
pop esp
sar byte [esi + 0x1d34caed], cl
pop ss
in al, 0x65
mov ah, 0x4d
pop ss
fcomp qword [ebx + 0x56684816]
mul byte [edi + 0x4e]
mov esp, 0xa5c1dc90
iretd
dec ecx
adc ecx, 0xa
jmp 0x102357e7
jae 0x10193433
mov ebp, 0xba80010c
inc ebp
lea eax, [ebp + ebp*8 + 0xa911938]
mov ax, word [edi]
mov bp, word [edi + 2]
push 0x13a76e14
add edi, 2
call fcn.101495c4
xor al, byte [edx]
or dl, dh
xchg dl, ch
add byte [eax], 5
cld
inc eax
pushal
or eax, 0x4a7ea6e4
or dl, dh
invalid
jmp 0x1014f628

Function at 0x101f3bbb
Capabilities:
Encode data using xor

Disassembly:
add ecx, dword [esi + 0x74]
xor edx, 0x7e
test dword [edi + edi*4 + 0x239ceaad], esi
xchg bl, al
jmp 0x8e103aac
not dl
push 0xb4bbd8b0
mov word [ebp], dx
push 0xc398d538
call fcn.10184b09
mov al, byte [0x9785ed3a]
or al, 0x3a
ja 0x101f3c34
jge 0x101f3b6e
aaa
fcom qword [eax + 9]
inc eax
inc ebp
pop esi
cdq
cmc
out dx, eax
out 0xe7, al
aas
ror dword [esi], 1
pop esi
cmc
ret
pop ds
and byte [edi + 0x19], al
sbb dword [ebx], 0xffffffb4
jp 0x101f3cb0
daa
int1
ret 0x3bab
invalid
push ebx
sub byte [ecx - 0x76], 0xde
xor al, 0x26
pushfd
push ebp
mov ebp, 0x2fc16e37
mov edx, dword [edx - 0x1d]
test al, 0x37
call 0xc2215b8c
pop eax
invalid
push cs
push ebp
lodsd eax, dword [esi]
daa
adc bh, byte [ebp + 0x1df85cb8]
adc dh, 0xcb
salc
mov al, 0xa3
xor ebx, dword [ebp + 0x79]
push esi
or byte [edi + edi], dh
push ecx
jne 0x101f3c96
mov edi, 0x731cb6ec
sub eax, 0xc67d3011
ja 0x101f3c76
sub ebp, edx
or eax, 0xc1e69a9d
invalid

Function at 0x1022d4f8
Capabilities:
Encode data using xor

Disassembly:
lea ebp, [ebp + edx + 0x45555258]
push ecx
add dword [esp + edx + 0x4555525b], 0xfffa40a1
not dx
Function at 0x10239f32
Capabilities:
Check for software breakpoints

Disassembly:
call fcn.1024d813
adc eax, 0xf8cf5a96
sub bl, byte [edx - 0x4b]
pop ecx
rol byte [edi + 0x1a164535], 1
cmp ecx, esp
dec edx
or byte [esi], 0xe2
nop
mov bx, 0x9465
imul edx, dword ds:[ebp + 0x32], 0x23
push ss
mov ebp, fs
insb byte es:[edi], dx
cwde
punpckhwd mm5, qword [edi + ecx*4]
mov edx, 0x402c0a22
mov esp, 0x3b290ec0
mov ebp, 0x856deacb
add ecx, dword [ebp + 0x5404a560]
dec esp
call 0xde5ff92e
scasd eax, dword es:[edi]
push cs
aad 0x71
xor esi, dword [ecx - 0x2d]
jno 0x10239ff8
lodsb al, byte [esi]
xchg byte ss:[edi - 0x44], bl
retf 0x2bfb
add ebx, dword [edi - 0x419c67c1]
mov eax, dword [ebp + 0x2c]
push ebx
aad 0x74
int3
and esp, edi
mov ebp, 0xcbba12f6
and al, 0xcb
cmpsb byte [esi], byte es:[edi]
mov edx, 0xa6cb24cb
cld
mov ebx, 0x201562e3
out dx, al
out 0x67, al
loope 0x1023a028
xchg ebx, eax
rcr byte [ecx - 0x454bd783], cl
mov byte [0x159905e9], al
xchg esi, eax
stc
insb byte es:[edi], dx
pop ecx
xchg edi, eax
inc byte [ecx - 0x54c581f9]
pop eax
mov esp, 0x2684a40c
xor dh, 0x5c
mov edi, 0x98adc587
push esi
jno 0x1023a085
in eax, 0xb6
add edx, dword [eax + 4]
inc esi
push ebx
xor eax, 0x501e8653
arpl word [esi], bp
clc
or dword [edi + 0x47], 0x739240c6
cmp al, 0x82
jae 0x10239fc4
cwde
add al, 0xac
pop edx
jecxz 0x10239fe4
fst qword [ebx]
jp 0x1023a04c
xor ch, byte [ebx + 0x6dfca9a4]
insd dword es:[edi], dx
sahf
add bh, byte [edx - 9]
bound edx, qword [ebx]
jo 0x10239fe9
test al, 0x9d
in al, dx
aad 0xda
push ds
movsb byte es:[edi], byte [esi]
hlt
cmp dword [esi], esi
jo 0x1023a028
adc dword [ebx - 0x6a2e7955], edi
call 0x6dcfe7b2
push ss
push esp
js 0x1023a047
cmc
xchg edi, eax
in eax, 0x51
sbb dword [edx], 0xffffffa4
test bl, 0xf0
dec ebp
inc edx
invalid

Function at 0x1023c3a1
Capabilities:
Encode data using xor

Disassembly:
mov dword [ebp + 4], edx
mov dword [ebp], esi
jmp 0x10083a75
jmp fcn.100a6054
sub dword [esp + edi + 0x3b767632], 0x3e13e01d
mov edi, dword [esp + edi*2 + 0x76ecec44]
not dword [esp + 0x14]
cmp word [esp + 0x14], 0x4404
jno 0x1024c5b2
mov esi, 0x91874ab4
bts esi, 0x96
lea edx, [esi + 0x3b9bc1a0]
mov edx, dword [ebp]
mov esi, dword [ebp + 4]
not edx
push 0xe51cea3c
not esi
or edx, esi
mov esi, dword [esp]
pop esi
pushfd
pop esi
jmp 0x101eeda5
jmp 0x1002b15f
mov ebx, edi
xchg dword [esp + ebx + 0x3b76763a], eax
mov ebx, dword [esp + edi*2 + 0x76ecec40]
or edi, edi
jae 0x100d2664
lodsb al, byte [esi]
invalid
or dword [esp + 0x14], 0xb121d89a
call fcn.1026962c

Function at 0x1026e265
Capabilities:
Encode data using xor

Disassembly:
and word [esp + 0x10], 0x8019
lea eax, [eax + 0xaa0f326]
and byte [esp + 0x10], 0xb
Function at 0x10283a5c
Capabilities:
Encode data using xor

Disassembly:
cmp bl, 0x83
push dword [esp + 0xc]
popfd
lea esp, [esp + 0x14]
call fcn.101b7093
pop ebp
push ebp
adc al, 0xe8
sub dword [esi], esi
call [ebp + 0x55]
mov ebp, 0x4c1e5703
xor al, 0x94
loop 0x10283a8f
rol dword [ecx + 0x11], cl
lea edi, [ebx + 0x43]
adc al, byte [edx + 0x4576cadc]
inc ebx
adc eax, 0x86e0fa09
jmp 0x7d1d5ad1
je 0x10283ab7
and al, 0x83
or bh, byte [esp + eax*8 + 0x34]
xor ah, byte [eax + ebx*8 - 0x67]
push ebx
jne 0x10283a94
movsb byte es:[edi], byte [esi]
loop 0x10283a64
push ss
rol al, 0xaa
push ecx
rcl byte [eax - 0x80]
loop 0x10283a3e
invalid
jbe 0x10283b2d
dec esi
dec ebx
adc edi, dword [ecx]
insb byte es:[edi], dx
sub al, 0x57
pop esi
in al, dx
aad 0xde
div eax
and ecx, ebp
jns 0x10283b34
lahf
imul esi, dword [ecx - 0x18], 0xffffffde
dec esi
push esp
dec edx
add dh, byte [ecx + 0x747a4890]
add byte [edx + 0x11], cl
xchg esp, eax
pop ss
sub byte [esp], bl
xor al, 0x46
cli
fsubp st(5)
hlt
movsb byte es:[edi], byte [esi]
push edx
shl byte [0x52bfbffb], 0xd5
aaa
cli
out 0x3b, eax
mov al, byte [0x72d5c791]
sti
adc ch, byte [ebx]
ror dword [eax + 0x2d2d1c36], 1
and byte [ebp - 0x4de02f4b], 0
push ecx
xlatb
bound ebx, qword [ecx - 0x4ef89d5f]
jmp 0xc1989d51
test al, 0x23
xor esp, dword [ecx]
xchg byte [edi], cl
add edx, dword [ebx + 0x6e]
push esp
jecxz 0x10283ba5
mov cl, 0xc
sal byte [edx], cl
xor al, byte [esi]
aam 0xfe
jo 0x10283aee
enter 0xfffffffffffff6a0, 0xffffffffffffff93
mov ecx, 0x19a58598
xchg ebp, eax
retf
mov byte [0x7624c9f6], al
push edi
cmp dword [ecx - 0x25], eax
int1
insd dword es:[edi], dx
loopne 0x10283c2f
mov bh, 0xe1
test byte [ecx + 0x5ae88bd4], bh
invalid
dec ecx
jnp 0x10283ca7
sub edx, ebx
rcr byte [edi - 0x3cdfabe9], 0xf1
inc ecx
cmp esp, dword [edi + 0x4a]
retf
test byte [edx - 0x7a], dh
pushfd
pop ecx
ret 0xa996
mov ds, eax
test al, 0x13
jge 0x10283d18
cmp eax, eax
notrack call 0x23356449
ja 0x10283cab
rol ah, cl
je 0x10283d1c
push edx
mov eax, dword [ecx]
loope 0x10283c55
fild dword [edi]
push es
cmp byte [eax], dl
enter 0x4aa6, 0xffffffffffffff8b
adc eax, 0x547ff115
retf
into
lea esp, [esp + 0x14]
jmp fcn.1029fe51
adc al, 0xe9
das
rol dword [ecx], 0
Function at 0x102a3d54
Capabilities:
Encode data using xor

Disassembly:
lea ecx, [ecx*8 - 0x1262174e]
mov ebx, 0x370acda5
jb fcn.100f16df
jle 0x101e469f
mov edx, 0x2bb5f325
movsx ecx, dl
mov cl, byte [edx + ebp - 0x2bb5f325]
rol edx, 0x7c
sar dx, 0xf
lea ebp, [edx + ebp - 0x52baffff]
xor cl, bl
lea edx, [edx + edx*8 - 0x1152c94c]
or dx, dx
jae 0x101d18c8
mov eax, 0x5bc3eaf8
cli
mov ds, word [esi + 1]
mov ecx, 0x10307e0
and dword [ecx], esi
xchg esp, eax
aad 0x71
mov dh, 0x31
xchg byte [eax - 0x7301113b], al
into
xor dword [ebp + edx*8 - 0x298cb941], esi
jnp 0x102a3c66
clc
ljmp 0x15e
cli
call [edx - 0x6b]
xor byte [eax], bh
aad 0x14
mov eax, 0xd8391847
cmp eax, ebx
out 0x61, al
mov bl, 0x7b
fdiv st(2), st(0)
call [edi + 0x46]
insb byte es:[edi], dx
xor dword [esi + ebx], edi
push ss
add al, 0x22
sbb al, 0x84
and eax, 0x6d4c9f79
mov word [ebx], gs
xor esi, dword [esi - 0x4c]
jnp 0x102a3c92
cli
jg 0x102a3c65
das
mov bl, 7
mov dword [0x50fffd6e], edi
pop edx
outsd dx, dword [esi]
push 0xa1c091bf
push esi
movsb byte es:[edi], byte [esi]
cmp eax, 0xffffff82
jg 0x102a3cc9
out dx, al
sub dword [ebp + 0x20d9ce9e], esi
mov ecx, 0xfb60eb04
xchg ebp, eax
stosd dword es:[edi], eax
mov esp, 0x29e0c524
int3
cmp byte [edx + 0x58bc59dc], ah
cmp al, 0xea
adc eax, 0xc5093190
push 0xffffff96
inc dword [edx]
mov bl, 0x45
js 0x102a3c95
pop es
jb 0x102a3d68
aas
cmp eax, 0xa2a24362
add byte [ebp - 0xb], dl
cmc
mov cl, 0xa9
sal byte [eax - 0x4f], 1
jecxz 0x102a3cec
pcmpeqd mm5, qword [esi + 0x921656f]
jo 0x102a3d8e
sub dword [ebx + 0x2f], 0xf96f68f
mov eax, es
pop ds
idiv edi
jl 0x10215d1a
cmc
lahf
inc edx
mov dh, 0xc7
sal dword [ecx + 0x39], cl
lcall 0x2f5, 0x8121337c
out 0xa7, al
add ah, dh
cmpsd dword [esi], dword es:[edi]
test eax, 0x699a3027
add ebp, dword [ecx + 0x137f82a5]
sub cl, byte [edi + edx*2 + 0x32]
adc dl, byte [ecx + 0x525b39cf]
sahf
sub byte [esi], 0xfa
das
jae 0x102a3d3d
arpl word [ecx], si
sbb esp, dword [esi]
mov edx, 0xc727fa9c
mov ah, byte [eax + edx*2 + 0x2203c72a]
sub byte [eax - 0x6900fc3c], ah
mov ah, 0x44
push ds
in al, 0x16
xchg byte [edx + 0x29c7e2ac], ah
xchg esp, eax
jmp 0x910f16a1
cli
daa
invalid

Function at 0x102b97d4
Capabilities:
Encode data using base64

Disassembly:
dec eax
lea esp, [esp + 0x20]
jmp fcn.1040d023

Function at 0x102b9daa
Capabilities:
Encode data using base64

Disassembly:
inc bp
mov dword [ecx], ebx
jmp 0x103e9f6c
dec eax
lea esp, [esp + 0x48]
jmp fcn.1040d023

Function at 0x102bfd07
Capabilities:
Encode data using base64

Disassembly:
mov ebp, dword [esi]
mov ecx, 0xc6be4cb5
mov ecx, dword [esi + 4]
add esi, 4
call fcn.103350d7
not ax
sub dword [esp + 8], 0x3bb8489a
and si, ax
pop eax
pushfd
pop eax
mov dword [esp + 4], eax
mov eax, 0xe51e3a86
call fcn.102c23d4
jmp 0x10413e24
jae 0x10335ca4
mov ebp, 0xa59637bd
jmp 0x10418b2a
mov dword [esi + 4], eax
mov dword [esi], edx
call fcn.10399f61
push 0x2aa7be39
not ax
call fcn.102b978b
jmp 0x102b3d40

Function at 0x102c8e93
Capabilities:
Encode data using base64

Disassembly:
mov byte [esp + 4], 0xa8
mov dword [esi], eax
call fcn.10457115

Function at 0x102d03e5
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x14]
jmp fcn.102fff0a
Function at 0x102d5e7b
Capabilities:
Encode data using base64

Disassembly:
dec ecx
adc edi, edi
dec eax
mov dword [esp + eax + 0x80], edx
dec esp
mov dword [esp + eax], esp
dec eax
mov dword [esp + eax*2 + 0x88], ebx
push esi
inc edx
rol byte [esp - 0x12083], 1
dec eax
cwde
dec esp
lea ecx, [esp + eax + 0x10]
shr al, 0x86
neg word [esp + eax + 5]
inc eax
and ch, ch
dec ecx
lea eax, [ecx + eax*4 - 0x1e8]
dec edx
dec dword [esp - 0x240a]
jae 0x102e5744
sal dword [esp], 0x90
adc edi, 2
push 0x30185824
push 0x472acf86
call fcn.10329db8
mov edx, 0xe291dba7
movsx ebp, dl
mov eax, edx
mov edx, dword [esi]
btc eax, ebp
or ebp, ebp
sbb bp, ax
mov eax, dword [esi + 4]
rol ebp, 0xd9
mov ebp, dword [esi + ebp*2 - 0x3fffc8a]
push 0xf5956f8b
adc esi, 3
dec dword [esp]
jle 0x10401754
pop eax
neg dl
xor dl, 0x9d
mov eax, 0x8f87eabf
ror dl, 1
push eax
jmp 0x1048eb3c
jge 0x1036bfd3
div ebp
call fcn.103f7bda
xor dl, 0xb3
pop eax
inc dl
ror dl, 1
add eax, 0x5c2d82a7
dec al
xor bl, dl
lea edx, [esp + edx + 4]
mov eax, dword [edx]
sub esi, 4
push 0xe810e897
call fcn.102c8e93

Function at 0x102d779b
Capabilities:
Encode data using base64

Disassembly:
sbb dword [eax], edi
and byte [esi - 9], ah
push esp
and al, 6
jmp 0x10425bff
call fcn.1034a458
pop ebp
cli
loop 0x102d7763
or al, 0xec
jmp 0x991253bc
dec eax
lea esp, [esp + 0x20]
jmp fcn.1040d023

Function at 0x102e5754
Capabilities:
Encode data using base64

Disassembly:
jmp 0x104b29a6
lea esp, [esp + 0xc]
jmp fcn.103d20c0

Function at 0x102f10e6
Capabilities:
Encode data using base64

Disassembly:
push 0xe5bcee83
dec eax
lea esp, [esp + 0x20]
jmp fcn.1041e7ec

Function at 0x102f3981
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x10]
jmp fcn.103d20c0

Function at 0x102f55fd
Capabilities:
Encode data using base64

Disassembly:
inc cx
mov dword [ecx], ecx
dec eax
lea esp, [esp + 8]
jmp fcn.1041e7ec

Function at 0x102f5a43
Capabilities:
Encode data using base64

Disassembly:
dec eax
lea esp, [esp + 0x30]
jmp fcn.1041e7ec

Function at 0x103492d9
Capabilities:
Encode data using base64

Disassembly:
jmp 0x104c28e7
dec eax
lea esp, [esp + 0x18]
jmp fcn.1041e7ec

Function at 0x1035290b
Capabilities:
Encode data using base64

Disassembly:
mov eax, dword [esp + 0xc]
mov word [esi + 4], dx
push 0xf888d11a
push 0xc2b8df30
jmp 0x1049bd6e
mov dword [esi], eax
call fcn.10487b75
invalid

Function at 0x103530a0
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x10]
jmp fcn.102fff0a

Function at 0x103533fc
Capabilities:
Encode data using base64

Disassembly:
or eax, edx
call fcn.10324c77
push 0xd987e814
dec ecx
mov eax, dword [ecx]
jmp 0x103d09a6
inc ecx
mov ebx, 0x3807893d
dec esi
mov ebx, dword [eax + ebx - 0x3807893d]
dec ebp
mov dword [ecx], ebx
dec eax
lea esp, [esp + 8]
jmp fcn.1041e7ec

Function at 0x10357096
Capabilities:
Encode data using base64

Disassembly:
sub esi, 2
push 0xa8feb08
mov word [esi], dx
lea esp, [esp + 0x18]
jmp fcn.102fff0a

Function at 0x10377ff4
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x18]
jmp fcn.102fff0a
Function at 0x10381d20
Capabilities:
Encode data using base64

Disassembly:
not dl
setae byte [esp]
jae 0x102ce023
test eax, esp
mov dword [ebp - 0x48], esi
btc esi, edi
cmove si, bx
and si, 0x878b
mov esi, dword [eax]
cmp ebp, 0x1784b3a1
jmp 0x1034846e
xor dl, 0x23
xor bl, dl
rol byte [esp + 0xc], 0x82
sbb edi, 1
jmp 0x103500e2
mov dword [esp + 0x10], 0xb42f2737
dec dl
push 0xe39d5f35
ror word [esp + 9], 0x26
jae 0x102ccbc1
rep stosd dword es:[edi], eax
adc ecx, ecx
jmp 0x10361ff4
mov dword [ebp - 0x28], edi
jmp 0x1045732f
mov dword [ecx], ebx
mov ecx, dword [ebp + 0x14]
mov dword [ecx], ebx
xor ecx, 0x15930383
mov ecx, dword [eax + 4]
cwde
add ecx, esi
cmc
shrd eax, esp, 0x93
rcl eax, cl
mov eax, 0x300
shl eax, cl
cmc
mov dword [ebp - 0x3c], esi
test esi, 0x108b770a
cmc
mov dword [ebp - 0x14], ebx
cmp si, si
mov dword [ebp - 0x10], edi
stc
add eax, 0x736
jmp 0x103184e8
push 0xe2b8fa00
mov dword [esp + 0x14], 0xc12276b2
mov word [edi], dx
lea esp, [esp + 0x1c]
jmp fcn.104a3efa
adc dl, 0xe
inc byte [esp + 8]
rol dl, 1
jmp 0x102d793e
or eax, edx
shr ecx, 1
jmp 0x102e8796
shl edx, 0x10
test dx, dx
cmp di, 0x87bf
jmp 0x103e554c
mov dword [ebp - 0x2c], edi
jmp 0x104c15ae
mov dword [ebp - 0x24], edi
jmp 0x10412ca3
je 0x10361fff
mov ecx, eax
mov eax, 0x400
mov edi, edx
and dx, si
shr dh, 0x87
rcl edx, cl
movzx edx, ax
add eax, 0x66186426
or ah, 0xb3
and ah, dh
mov eax, edx
jmp 0x103f66e9

Function at 0x103940d9
Capabilities:
Encode data using base64

Disassembly:
push edi
or edi, edi
mov edi, edx
inc word [esp + 6]
cld
call fcn.102d7962
inc ecx
mov ebx, dword [ecx + ecx*2 - 0x72154602]
inc esi
mov ebp, dword [ecx + ecx - 0x390aa2fd]
dec eax
xor ecx, ecx
dec eax
adc ecx, 0xd30ee3aa
inc ecx
mov cl, byte [ecx + ecx*2 + 0x59e238b4]
push 0xef80689e
sal dword [esp + 4], 0xde
jne 0x104951cc
mov dword [esp + edi - 0x284e198a], 0xb08e1b01
mov esi, eax
jmp 0x1030ef01
dec ecx
adc ecx, 5
inc esp
shld ebx, ebp, cl
inc ecx
mov dword [ecx], ebx
dec eax
lea esp, [esp + 8]
jmp fcn.1041e7ec