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

Disassembly:
call fcn.101f5f03
push 0xf496fc26
pushfd
sub dword [esp + 4], 0xaa353d08
add word [esp + 4], 0x270e
add dword [esp + 4], 0x33150abf
jge 0x101cd102
jmp 0x10181ae2
das
cmp dl, byte [0x123de0f1]
push esi
invalid
push edx
mov edx, 0xa8a291be
mov edx, dword [esp + edx + 0x575d6e42]
mov dword [esp], 0xc5f74444
call fcn.101e6f82
sub esi, 1
movzx ecx, byte [esi]
mov edi, 0x133ec28d
call fcn.1020e077
add byte [eax], al
dec eax
popal
jo 0x101b9a83
jae 0x101b9ab6
jb 0x101b9ab3
jns fcn.101b9a46
pop es
add byte [ecx - 0x45], al
mov dh, 0x14
in al, dx
inc ecx
mov ebp, 0x49207e0c
dec ecx
rol ebp, 0x92
dec ecx
sbb ecx, 1
inc ebp
add ch, ch
inc ebp
movzx ebp, byte [ecx]
inc esp
xor ch, bh
mov dh, 0x2c
and dword [edx + esi - 0x11], eax
inc ecx
dec ch
inc ecx
rol bl, 0x67
inc ecx
ror ch, 1
inc cx
bts ebx, 0x27
inc ecx
dec ch
dec ecx
sal ebx, 0x5f
jne 0x101d56c9
mov byte [edx], al
add byte [ecx - 0x3e], dl
outsb dx, byte [esi]
jg 0x101b9a65
push ecx
ret 0x7f6e
test dword [ecx + 0x70], esp
cmp eax, 0x8adfce12
movsd dword es:[edi], dword [esi]
pop ecx
dec eax
xor eax, 0x1c38fc9b
cmp byte [esi + 0x35], 0xb9
test al, 0xd
and ah, dh
outsb dx, byte [esi]
cld
xchg dword [esi + 0x2f82ed8b], ebx
inc ebp
test eax, 0x53f095b8
invalid
push ebx
jae 0x101d6e59
jmp 0x101b9a0b
inc bp
adc ebx, ebx
inc ecx
rol ch, 1
dec ecx
ror ebx, 0x9c
inc ecx
xor ch, 0xa8
dec ebp
imul ebx, ebx
inc cx
ror ebx, 0xe6
dec ecx
dec ebx
inc ecx
xor bh, ch
call fcn.10204596

Function at 0x101ba74b
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0x55bb699c
call fcn.1021bc51

Function at 0x101ba758
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 4]
jmp fcn.101e22c9

Function at 0x101bdb34
Capabilities:
Encode data using base64

Disassembly:
call fcn.10203891
mov dword [edi], eax
jmp 0x101a4493

Function at 0x101bded1
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.101e22c9

Function at 0x101bdf80
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x14]
jmp fcn.101e22c9

Function at 0x101bf7c5
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + 4], 0xc6a29c35
mov byte es:[eax], dl
jmp 0x101b35f9

Function at 0x101c0268
Capabilities:
Encode data using base64

Disassembly:
push 0x653e2c23
jmp 0x101bf9a3
push 0xbd18f027
add edi, 4
jmp 0x1023a5b6
shld ax, bp, cl
jmp 0x101850e7
mov word [edi], ax
call fcn.101d201c
jmp 0x1018a084
jmp 0x101bf776

Function at 0x101c17f0
Capabilities:
Encode data using base64

Disassembly:
push 0x29290314
mov dword [esp + 4], 0xff13e993
sub ebp, 4
jmp 0x101e0f26
jmp 0x1022c463
mov dword [ebp], edi
lea esp, [esp + 8]
jmp fcn.10188d08

Function at 0x101c29d7
Capabilities:
Encode data using base64

Disassembly:
push 0x6c9b5111
mov word [edi], cx
push 0xd6989019
lea esp, [esp + 0x18]
jmp fcn.101e22c9
Function at 0x101c3448
Capabilities:
Encode data using base64

Disassembly:
neg ax
lea eax, [eax + eax*2 + 0x1d1d6190]
movzx ax, byte [eax + edi - 0x37764142]
jbe 0x101d8482
add eax, edx
mov dword [ebp], eax
jmp 0x101f791e
mov dword [esp], 0x97a9ff29
adc edi, 1
neg dword [esp]
sbb word [esp], 0x53a1
imul dl
mov word [edi], ax
lea esp, [esp + 4]
jmp fcn.101e22c9
lea esp, [esp + 8]
jmp fcn.101b99a1

Function at 0x101c382d
Capabilities:
Encode data using base64

Disassembly:
shr ebp, cl
call fcn.101baaf5
mov dword [edi], edx
push 0x97803eb3
call fcn.101bd874
mov ebp, 0x7bd3d10
lea ecx, [ebp + 0x2f8d2d19]
inc cl
mov ebp, dword [ebp + edi - 0x7bd3d10]
sal ecx, cl
imul ecx, ecx
xor cl, ch
add cl, byte [edi + 4]
jmp 0x1020ba00
push 0x99388c8e
add edi, 2
push 0x8dbdab1c
sal dword [esp + 2], 0x1f
ja 0x101a449d
cmp edi, dword [ecx]
cdq
cmp ch, byte [edi + 0x48]
xor ebx, dword [edx]
test al, 0x3f
pop bp
adc cl, byte [ecx]
mov ebp, 0x33605f34
mov al, 0x91
invalid

Function at 0x101c4ee1
Capabilities:
Encode data using base64

Disassembly:
mov ebp, dword [edi]
shr cl, 0x21
xchg ch, cl
or cl, cl
mov cl, byte [edi + 4]
jne 0x10181fa5
ror ebx, 0x41
rcl byte [edi + 0x50e8f7a6], cl
int1
mov byte [0x59efca87], al
sar byte [ebx + 0x48ccc78c], 1
jnp 0x101c4f57
mov cl, 0x65
and ah, ah
inc esi
push ecx
push esi
add eax, eax
mov ebp, 0x56f5ce5b
out 0xf, al
in al, 0xbb
sub eax, 0x53e1e1f
xor eax, dword [esi]
sub al, byte [0x9022c1f]
das
or al, 0x12
aaa
sub esi, ebx
jmp 0x101c4f98
mov dh, 0xc3
ret 0x7748
cmp esp, ecx
push esp
push ebx
popal
pushal
inc eax
jns 0x101c4fb2
jle 0x101c4fc7
push ecx
jge 0x101c4fb4
pushal
inc ebx
pop ebp
push esi
jo 0x101c4f71
add ecx, dword [ebp + 0x1f4e7f2c]
pop ds
push cs
mov ah, 0x39
pop esi
retf
pop edi
test eax, 0xdeff9af9
invalid
bnd jae 0x101c4f41
mov esi, cs
into
mov ch, 0x5c
fadd st(1), st(0)
cmp edi, dword [edi - 9]
in al, 0x8d
mov eax, 0xbd2ff6eb
pop eax
cmp cl, byte [ebp + 0x14]
inc ecx
dec ebp
adc al, 0x41
sbb ch, byte [edx]
div dword [esi + 0x26a08683]
dec esi
enter 0x2b82, 0xfffffffffffffff4
adc cl, cl
push ss
mov ebx, 0x97d41812
fild word [eax + edi*2 + 0x52]
inc ebx
pop edi
cld
ret 0x9a1d

Function at 0x101c853a
Capabilities:
Encode data using base64

Disassembly:
mov dword [ebp - 0x24], edi
mov dword [ebp - 0x2c], edi
je 0x101ef0c7
mov ecx, eax
inc di
shr edi, 0x96
bts edi, edx
mov eax, 0x400
sub edi, ebp
mov edi, edx
bsf dx, sp
movzx edx, ax
xor ax, sp
mov eax, edx
test edx, edx
shl edx, 0x10
clc
or eax, edx
cmp bx, sp
shr ecx, 1
jmp 0x10212e6a
jl 0x101f1ee1
mov dword [ebp - 8], ecx
bts edx, ebx
cwd
lea esp, [esp]
mov edx, 0x2f8e0ca4
call fcn.102180b7
mov dword [ebp - 0x28], edi
jmp 0x1016c183
adc ecx, ecx
jmp 0x101ef0be
inc edi
cmp edx, 0x8ae389f
or esi, edx
jmp 0x101e67aa
inc ecx
cmp edi, 5
jmp 0x101a799a
rep stosw word es:[edi], ax
movsx ecx, di
shr cx, cl
mov ecx, dword [ebp + 8]
lea eax, [ecx - 1]
cmp bx, sp
mov dword [ebp - 0x40], eax
xor esi, esi
cmp sp, bp
test di, di
or eax, 0xffffffff
xor edi, edi
cmp edx, ebp
jmp 0x101f1ee1
cmp ecx, dword [ebp - 0x40]
je 0x101c5533
movzx edx, byte [ecx]
shl esi, 8
jmp 0x101e4b12
rep stosd dword es:[edi], eax
jmp 0x101d3dff
Function at 0x101c9141
Capabilities:
Encode data using base64

Disassembly:
not edx
mov dword [edi], edx
mov dword [esp], 0xd4b69882
lea esp, [esp + 4]
jmp fcn.101e22c9

Function at 0x101c9283
Capabilities:
Encode data using base64

Disassembly:
mov word [edi], bp
mov dword [esp + 8], 0x390d321d
push 0xd9b78ba
lea esp, [esp + 0x18]
jmp fcn.101e22c9
not dx
push 0x3011022a
ror byte [esp + 0x11], 0x27
and bp, dx
jmp 0x101e581c
jmp 0x101a3449

Function at 0x101c9e43
Capabilities:
Encode data using base64

Disassembly:
shl dword [esp + 4], 0x4c
adc edi, 6
shld edx, eax, cl
mov dword [edi], edx
lea esp, [esp + 8]
jmp fcn.101e22c9

Function at 0x101ca341
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0x13b09538
add edi, 4
ror dword [esp], 0x96
push 0xb28bd515
sbb dword [esp + 4], 0x67a03e8a
xor ecx, ecx
jmp 0x101f6d40

Function at 0x101cc1f5
Capabilities:
Encode data using base64

Disassembly:
push dword [esp + 0x10]
popfd
lea esp, [esp + 0x14]
call int.10192d80

Function at 0x101cc203
Capabilities:
Encode data using base64

Disassembly:
mov eax, dword [ecx]
mov dword [edi], eax
lea esp, [esp + 4]
jmp fcn.101e22c9

Function at 0x101cc6ba
Capabilities:
Encode data using base64

Disassembly:
mov word [edi], dx
mov dword [esp], 0x9d837b85
call fcn.10211335

Function at 0x101cc6ca
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + 4], 0x299ecfab
neg cl
inc cl
ror cl, 1
xor bl, cl
sub ebp, 2
push 0x978fb3b4
mov word [ebp], cx
call fcn.1023f5e0
jns 0x101cd11d
dec eax
lea esp, [esp + 0x20]
jns fcn.101b835a
mov dword [edi], ecx
call fcn.10229de8

Function at 0x101cc6ff
Capabilities:
Encode data using base64

Disassembly:
inc dl
mov dword [esp + 4], 0xd61ebb3b
call fcn.102085f3

Function at 0x101ce27c
Capabilities:
Encode data using base64

Disassembly:
mov dword fs:[edx], ebp
jmp fcn.101bf533
add edi, 8
jmp 0x1016b35f

Function at 0x101cee75
Capabilities:
Encode data using base64

Disassembly:
not cx
push 0x8180f688
jmp 0x1021d368
adc ebp, 1
mov dword [esp + 8], 0xe79da022
and cx, ax
push 0x7a077d06
jmp 0x1018bd82
jno 0x101a30db
mov word [ebp], cx
push 0x21bc93bf
lea esp, [esp + 0x18]
jmp fcn.101b99a1

Function at 0x101cf1fc
Capabilities:
Encode data using base64

Disassembly:
neg word [esp + 0x1b]
dec ebp
lea esp, [esp + 0x24]
jne 0x101740e6

Function at 0x101cf230
Capabilities:
Encode data using base64

Disassembly:
mov word [edi], ax
jmp 0x1020fee5
push 0x282cc711
jmp 0x101ca330
mov dword [esp + 4], 0xdb12723
call fcn.101a3440

Function at 0x101d0c86
Capabilities:
Encode data using base64

Disassembly:
mov word [edi], bp
lea esp, [esp + 0xc]
jmp fcn.101e22c9

Function at 0x101d100b
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.101e22c9
Function at 0x101d108a
Capabilities:
Encode data using base64

Disassembly:
inc ecx
neg dl
call fcn.101850b9
add byte [eax], al
add byte [ebp + 0x72], dh
insd dword es:[edi], dx
imul ebp, dword [esi + 0x61], 0xba006574
movsb byte es:[edi], byte [esi]
or eax, 0xbe0f420b
ret 0xc00f
inc ecx
xor dl, 0x2a
inc ecx
rol dl, 1
dec eax
sal dword [esp + 0x26], 0xa
sbb dword [esp + 0x26], 0xee305728
jp 0x101d1075
inc ecx
mov esi, 0xb3a68d8e
inc ecx
neg dh
dec ecx
sbb ecx, 0
call fcn.1022ea00

Function at 0x101d1fcc
Capabilities:
Encode data using base64

Disassembly:
sal byte [esp + 1], 1
inc cx
inc esp
ror word [esp + 4], 0xaa
dec word [esp]
ror dword [esp + 1], 0x68
inc cx
xor esp, 0x4166c892
rol esp, 1
inc cx
not esp
call int.1017473d
adc edi, 8
call fcn.10200852
lea esp, [esp + 0x10]
jmp fcn.10188d08
add byte [ebp + 0xf040444], cl
test byte [edi + 0x45], cl
add eax, 0x202c8b00
sbb edi, 4
not dword [esp]
call fcn.101fa8ef
jmp 0x1022e38c
mov dword [esp], edx
call fcn.10217d79
mov dl, 0x21
push esp
sbb ah, byte [esi]
stosb byte es:[edi], al
mov esp, 0x2acc1d0
pop eax
mov eax, dword [0x840918d4]
loop 0x1018e23f
add bl, byte [eax - 0x5f]
aam 0x18
or dword [edx - 0x78246fda], eax
xchg esi, eax
sar esp, cl
mov byte [ecx - 0x59488ca4], bl
nop
fild dword [edi - 0x77032c6a]
cdq
pop esp
jae 0x1018e1db
cmpsb byte [esi], byte es:[edi]
push ebx
jl 0x1018e210
stc
aam 0xfb
out 0xf6, eax
sub edi, dword [eax + 0x58c14582]
cmp byte [ecx + 0x598a4a41], dl
mov eax, 0x8fc0d5a2
mov dword [0x816bafd5], eax
inc ebx
inc ecx
inc ebp
mov al, byte [0x6aebf568]
call 0x72a7a8c9
cmc
pushal
das
add eax, 0x65bf1994
pop eax
invalid
aad 0xaf
imul eax, dword [ecx - 0x5fbabebd], 0x68
cmc
jmp 0x1018e2b5
enter 0x6afa, 0x5d
cmp dl, byte [ebp - 0xc]
push cs
fdivr st(3)
sub al, ch
iretd
adc ebp, 3
push 0x84b646ad
jmp 0x1018e1fd
mov esi, dword [esi*4 + 0x101d205c]
sar word [esp + 5], 0x6d
shr ebp, 8
xor ebp, esi
push 0x5528751e
mov dword [esp + 4], 0x5a84fa9a
inc eax
not dword [esp + 8]
neg dword [esp + 8]
setl byte [esp + 2]
xor ebp, 0xfeaaf38c
call fcn.10173464
mov edx, 0x13b04ab1
ror edx, 0x51
bts edx, edx
mov edx, dword [ebp + edx*2 - 0x4ab113b0]
jb 0x101a3109
inc ecx
or ah, 0xb0
inc ebp
movzx esp, word [ecx]
inc sp
xor esp, edi
inc cx
sub esp, 0x41667b8e
ror esp, 1
inc cx
neg esp
ror byte [esp + 3], 0xe3
jb 0x1017f784
inc bp
mov edx, dword [edi]
inc cx
sal esp, 6
dec ecx
adc edi, 2
inc ecx
push esp
dec ecx
sub ecx, 2
inc ecx
sar ah, 1
jl 0x101f9efd
inc ecx
mov esp, 0xd7864387
jmp 0x1022829a

Function at 0x101d201c
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x10]
jmp fcn.101e22c9

Function at 0x101d247f
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x18]
jmp fcn.101e22c9
Function at 0x101d29dc
Capabilities:
Encode data using base64

Disassembly:
mov word [edi], bp
lea esp, [esp + 8]
jmp fcn.101e22c9

Function at 0x101d2d2f
Capabilities:
Encode data using base64

Disassembly:
shl edi, 0xcd
movzx di, byte [edx]
sbb ebp, 1
jmp 0x101a8629
push 0xd711091e
push 0xf7a15096
mov word [ebp], di
mov dword [esp + 3], 0xd50e1326
lea esp, [esp + 0x14]
jmp fcn.10188d08
add dl, 0x27
push edi
ror dl, 1
inc dl
not dl
push edi
dec dl
xor bl, dl
lea edi, [edi - 0x6b53d1dc]
lea edx, [esp + edx + 0xc]
ror di, 0xed
jae 0x10166288

Function at 0x101d3e1b
Capabilities:
Encode data using base64

Disassembly:
mov dword [edi], edx
push 0xf01c23a8
lea esp, [esp + 0x10]
jmp fcn.101e22c9
rcr edx, cl
jmp 0x10234ec1
jmp 0x101b9aa6

Function at 0x101d691d
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.10188d08

Function at 0x101d6dbd
Capabilities:
Encode data using base64

Disassembly:
push 0xff934885
push 0xd1987484
mov dword [ebp], eax
lea esp, [esp + 0x14]
jmp fcn.10188d08
mov eax, dword [esi + eax*4 - 0x5227b38c]
xor eax, ebx
xor eax, 0xcb88e7b1
mov dword [esp], 0x7906ad1b
rol byte [esp + 2], 1
ror eax, 1
sub eax, 0xaa225b91
xor eax, 0x65800692
push 0x6e09a9b1
push 0x4b2d1097
neg eax
xor ebx, eax
sar dword [esp + 8], 0xb9
adc dword [esp + 2], 0xc8800112
sbb ebp, 3
jmp 0x1016f78e

Function at 0x101d9d1e
Capabilities:
Encode data using base64

Disassembly:
call fcn.101e55c2
mov dword [esp], 0x1729d2b1
add edi, 6
mov byte [edx], cl
push 0x6a1fee0e
lea esp, [esp + 0xc]
jmp fcn.101e22c9

Function at 0x101d9d9e
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + 8], 0xee01549f
mov dword [esp], 0xde059888
add ax, 0xc113
shl dword [esp + 0x10], 0x1d
rol dword [esp + 0xa], 0xf9
xor byte [esp + 0xf], 0x1f
ror ax, 1
xor bx, ax
sub ebp, 2
Function at 0x101d9ddb
Capabilities:
Encode data using base64

Disassembly:
dec eax
lea esp, [esp + 0x38]
jb fcn.101b835a
jb 0x1017cebb
mov word [ebp], ax
lea esp, [esp + 0x14]
jmp fcn.10188d08
jb 0x101a2d50
dec eax
inc dword [esp + 1]
jne 0x1021a19d
add byte [esi + 0x6c], ah
insb byte es:[edi], dx
sbb ecx, dword [edi + 0x7844379d]
pop es
pop edx
and al, 0x86
lcall 0x3b48, 0x2c5a4b3a
xchg dword [ebp - 0x6efdf16a], ebx
loope 0x101d9dcd
pop edi
aad 0x11
popal
add eax, 0x3187aff9
outsb dx, byte [esi]
push 0xffffffffffffffa3
mov dl, 0x9b
push 0x1a9f2957
test byte [edi], dh
daa
mov bh, 0x69
cwde
cld
adc eax, 0xe5339ca5
xchg ebx, eax
mov word [ebx], gs
add ebx, edi
jae 0x101d9e78
xchg edx, eax
and dword [ecx + 0x3e], edx
jne 0x101d9e77
jecxz 0x101d9e3a
xchg edi, eax
xor dword [ecx + 3], edi
mov dword [0xa62addaf], eax
mov bh, 0x88
imul ah
lcall 0x9126, 0x70ef369
jecxz 0x101d9e8d
mov al, 0xa2
or byte [ebx - 0x66], bh
jnp 0x101d9deb
call 0x4abdd8d
lahf
out dx, eax
out 0x4b, eax
ror dword [ebx], 0x12
or edx, dword [edx]
sar byte [esi + 0x41], 0x51
jl 0x101d9e5b
add dh, ah
or byte [ebp - 0x43], cl
adc ebp, 0xbc3d4f12
push ss
pop ss
sub dword [edx - 0x3a], ecx
add al, 0xf2
in eax, dx
xchg esi, eax
push ds
mov ah, 0x16
pop es
and dword [edx], edi
ret 0x486c
pop ecx
sti
out 0x48, eax
cmp ah, byte [ecx + edx*2]
lcall 0xa188, 0x1e6b8806
aas
mov edx, dword [eax + 0x3e99b885]
and ecx, edi
push ds
mov byte [ecx - 0x7a6f74c1], ah
mov eax, 0xf9213e99
js 0x101d9e4f
test eax, 0xe369b05a
loop 0x101d9e98
pop edx
mov al, 0x69
jecxz 0x101d9e8d
in al, dx
lahf
cmp esi, ecx
add edi, dword [edx]
jnp 0x101d9eaf
jns 0x101d9ea5
salc
int3
inc cx
sub esi, 0xf7487b8e
push esp
and al, 8
dec eax
rol dword [esp + 3], 0x5a
inc cx
ror esi, 1
shr byte [esp + 0xf], 0x81
call fcn.101c58ad
add byte [eax], al
push esp
insb byte es:[edi], dx
jae 0x1021a203
insb byte es:[edi], dx
insb byte es:[edi], dx
outsd dx, dword [esi]
arpl word [eax], ax
add cl, ch
and eax, 0xe8fffdd8
scasd eax, dword es:[edi]
mov eax, dword [0x8013fffb]
int3
xor esi, 0xffffffca
pop ecx
mov esp, 0x5ac5d0d5
jle 0x1021a23a
insd dword es:[edi], dx
pop ecx
lahf
loope 0x1021a1a8
loope 0x1021a26f
cmovge esi, dword [edx - 0x18804daf]
sti
salc
inc ebx
xchg ebx, eax
cld
mov esi, 0xf3441d1c
std
mov esp, 0xb11c8421
push ebx
mov dword [0x4c6e499e], eax
invalid
sal byte [ebx + ecx], 0xd6
add dword [ebx], edx
aam 0x77
or esp, ebx
fidivr dword [ecx]
jno 0x1021a25f
pop edi
loop 0x1021a1d3
cmc
jp 0x1021a234
leave
out 0x42, al
push ebx
scasb al, byte es:[edi]
add dword [0x42664914], 0x45290653
sub eax, 0xd1347f5f
invalid
neg cl
adc eax, 0xeaf6d904
sti
mov gs, eax
pop esi
loope 0x1021a26b
call [esi + ecx*8]
sbb al, 0xce
xor al, 0x48
dec eax
fbstp tbyte [esi + 2]
sbb dword [esp + edi*4 - 0x40000001], esi
push esi
push ebx
aad 0xc8
xchg ebp, eax
cmp dword [ebp - 0x32], ebx
mov byte [ebp + 0x42], 0x13
jg 0x1021a279
invalid
cmp bh, byte [esi - 0x54]
retf

Function at 0x101da25e
Capabilities:
Encode data using base64

Disassembly:
push 0x15a4a5b7
add edi, 6
mov byte [eax], cl
not dword [esp]
mov word [esp + 2], 0x1280
lea esp, [esp + 0xc]
jmp fcn.101e22c9
Function at 0x101df591
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push ecx
jge 0x101755bb
je 0x101755ca
mov dword gs:[edi + 8], 0
test edx, edi
cmp cl, 0x2d
jmp 0x1018951f
clc
add dword [eax], eax
add ebp, 8
or byte [eax], al
add byte [eax], al
mov dword ss:[eax], ecx
push 0x3808c507
call fcn.1022d24a
lds ecx, [eax]
cmp al, ch
js 0x1017564c
or eax, dword [eax]
test eax, 0xf08ac3bb
outsb dx, byte [esi]
jle 0x101755c1
wait
mov dh, 0xcc
mov dh, 0xc3
inc ebx
push ebp
loope 0x10175577
test al, 0xd7
mov esp, 0x3fe2f4cc
scasb al, byte es:[edi]
mov ah, 0xbb
push ebp
jge 0x10175650
sbb dh, bl
pop es
test eax, 0x6f73d66d
mov ebx, esi
adc byte [esi - 0x11], bh
sbb eax, 0x3201e6a8
into
mov eax, gs
cdq
jns 0x10175621
stosd dword es:[edi], eax
and dword [esi - 0x26b76f57], edi
ret
sahf
push edi
call 0x4c1afe92
fisub word [edx]
aad 0xa5
push edx
xor byte [eax - 0x11f77de5], ch
lcall 0x6c16, 0xc2d096b6
xor dl, byte [esi]
lcall 0x1590, 0x872a3961
mov ebx, dword [edx]
pushal
popal
out dx, eax
sbb eax, 0x70ef5dc7
invalid
retf
jb 0x10196091
push esi
bsf edx, edx
add dx, dx
movzx esi, cl
and dx, 0x1e9e
mov eax, 0x6c16c16d
mul esi
clc
mov eax, esi
shrd esi, ecx, 0x88
dec esi
bts si, sp
sub eax, edx
rcl esi, 0xb9
adc si, dx
shr eax, 1
lea eax, [eax + edx]
rol dl, cl
shr eax, 5
movzx eax, al
add dl, 0x30
cmp dx, 0x3f91
mov edx, eax
bt si, 0x39
test esi, ecx
or esi, 0xac0a3e2a
pop esi
add cl, 0xd3
test si, dx
sub eax, 1
jmp 0x10196085
jne 0x10189574
mov dword [edi + 8], edx
test ax, sp
mov dword [edi + 4], 0
jmp 0x1020458e
jb 0x101ea17a
movzx edx, cl
mov eax, 0x38e38e39
cmp bp, di
mul edx
xor al, 0x8c
add ax, sp
shr edx, 1
btc ax, si
jmp 0x101ea14d
mov dword [esp], 0xf715b225
jmp 0x101755bf
movzx eax, dl
and dx, sp
sub edx, eax
cmovnp edx, ecx
mov edx, eax
lea ecx, [ecx]
cmp edi, esp
jmp 0x1021e04b
jne 0x1021e04b
mov dword [edi + 4], edx
adc eax, esi
cbw
cmovg ax, bp
movzx eax, cl
cmc
jmp 0x1020fed7
cmp cl, 9
jmp 0x101d9a90
add cl, 0xf7
stc
test edi, ebp
cmc
sub eax, 1
jmp 0x101ea169

Function at 0x101e0417
Capabilities:
Encode data using base64

Disassembly:
mov word [edi], dx
push 0x21a1ba87
lea esp, [esp + 8]
jmp fcn.101e22c9

Function at 0x101e0e6f
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0xbe1d272e
push 0xc8a33384
shld dx, ax, cl
push 0xbda04aa1
call fcn.1017ca44
lea esi, [ecx + esi - 0x5f098114]
movzx edx, byte [esi + ecx - 0x5f098113]
not cl
xor dl, bl
rol dl, 1
lea ecx, [ecx + ecx*4 + 0x1f854f07]
xor ecx, ecx
setnp cl
neg dl
bswap ecx
shl byte [esp + ecx*2 + 3], 0x21
sar word [esp + ecx + 2], 0xab
xor dl, 0x21
not cl
rol dl, 1
add dl, cl
sub ecx, 0xbd911834
sbb cx, cx
bswap ecx
xor bl, dl
not dword [esp]
xor ecx, ecx
lea edx, [esp + edx + 4]
dec word [esp + ecx]
lea ecx, [ecx + ecx*2 + 0x1db556a1]
add ecx, 0x7f209510
mov ecx, dword [edx]
sub byte [esp + 3], 0x2f
or dword [esp], 0xbc113587
not dword [esp]
sbb ebp, 4
mov dword [ebp], ecx
lea esp, [esp + 4]
jmp fcn.10188d08
Function at 0x101e0f57
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0xb4abf22f
add al, dl
jmp 0x10208d55
call 0x1021c4cf
mov edx, 0x8d351438
movzx eax, dx
mov ecx, 0xc19eabbc
lea esi, [esi + eax*2 - 0x2871]
and eax, eax
shr ax, 0x42
bts cx, dx
movzx ecx, byte [esi + eax*4 - 0x1438]
xor cl, bl
shl edx, 0x3d
rol cl, 1
xchg dl, al
neg cl
xor ax, 0xc696
btr edx, eax
not cl
inc cl
xor cl, 0xbc
bt edx, 0x8c
not cl
xor edx, edx
xor bl, cl
push esi
bt edx, 0x95
push ebx
sar al, 7
and edx, edx
adc al, 0x3f
mov ebx, ecx
or edx, ebx
shr ax, 0x24
shl ax, 0x4f
not ax
sal edx, 2
mov eax, ebp
add eax, edx
push 0xcc2467a9
sar byte [esp + 2], 0xa3
mov dword [ebp - 4], eax
push 0xa7074a3d
push 0x3eac5a3f
test ebx, ebx
push 0xcbb56190
jmp 0x1019f4b9

Function at 0x101e2037
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.101e22c9
mov dword fs:[ecx], ebp
push 0xb495e82a
jmp 0x1016a4de

Function at 0x101e22a0
Capabilities:
Encode data using base64

Disassembly:
adc edi, 2
not cx
push 0xad21e53f
mov dword [esp + 4], 0x73ba6b2b
call fcn.101ac9a9
rcr dword [ecx], 0xb0
invalid
jle 0x1019f10f

Function at 0x101e733b
Capabilities:
Encode data using base64

Disassembly:
not byte [esp + 8]
push 0x658a7e89
mov dword [edi + 4], eax
jmp 0x10230cdd
mov dword [edi], edx
jmp 0x101e57fc
lea esp, [esp + 0x10]
jmp fcn.101e22c9
jmp 0x101faa23

Function at 0x101e75d4
Capabilities:
Encode data using base64

Disassembly:
seto dl
add dword [esp + edx + 4], 0xefe907f1
lea edx, [edx + edx*8 - 0x45431ccc]
call fcn.102307a0
lea esp, [esp + 0x10]
jmp fcn.101e22c9

Function at 0x101e82c3
Capabilities:
Encode data using base64

Disassembly:
push 0xf4317d36
mov word [edi], bp
jmp 0x101cf227

Function at 0x101e94c7
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.101e22c9
jmp 0x101b3670
mov word [edi], cx
jmp 0x101df239

Function at 0x101e9619
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0x8bbc9019
mov dword [edi], eax
lea esp, [esp + 4]
jmp fcn.101e22c9

Function at 0x101e9a75
Capabilities:
Encode data using base64

Disassembly:
mov dword [edi], ecx
push 0x13ae24be
lea esp, [esp + 0x10]
jmp fcn.101e22c9

Function at 0x101ea183
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 8]
jmp fcn.101e22c9

Function at 0x101ecc10
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x14]
jmp fcn.101e22c9

Function at 0x101eed18
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0xc]
jmp fcn.101e22c9

Function at 0x101ef116
Capabilities:
Encode data using base64

Disassembly:
sub ebp, 2
mov word [ebp], dx
lea esp, [esp + 0x10]
jmp fcn.10188d08

Function at 0x101f0088
Capabilities:
Encode data using base64

Disassembly:
adc edi, 8
mov dword [esp], 0xd2a5c309
jmp 0x101e585b