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

Disassembly:
pop edx
neg ecx
call fcn.01762da0
call fcn.017008ee
dec esp
add edi, ecx
inc ecx
sal al, 0x22
js 0x17058a4
xchg word [esp + edx*2 - 0x7478806], bp
inc bx
not bx
inc bx
inc esp
and byte [esp + edx - 0x3a3c3ff], al
inc sp
xor edx, ebx
sal byte [esp + edx - 0x3a3c3fd], 0xa7
push ebp
dec eax
lea ebx, [esp + ebx + 0x10]
dec eax
mov esi, dword [eax + ebx - 0xc404]
dec eax
sbb edx, ecx
jnp 0x17ad00a
dec esp
lea eax, [esi - 0x51cfb8cf]
inc cx
mov ebx, dword [esi + edi*2 - 0xbd20]
inc cx
ror ebp, 6
dec eax
sbb edx, edi
dec eax
lea ebp, [edi + 0x4b357897]
inc dx
mov ecx, dword [edi + esi - 0x5e8e]
jae 0x17bc146
inc ebp
sub ebx, eax
dec esp
adc edi, eax
dec ecx
sal esp, cl
dec eax
lea eax, [ecx + 0x6bb27e8f]
dec ebp
adc ebx, edi
inc ecx
jmp ebx
inc ebp
mov eax, dword [ecx + edx*2 - 0x74422f4]
dec eax
neg dword [esp + edx*2 - 0x74422ec]
dec ebp
add ecx, ebx
inc ebp
xor eax, edx
push ecx
dec esp
add ebx, edi
inc ecx
bswap eax
mov esi, 0x1094bcb0
dec ecx
cmovae esi, ebx
inc ecx
neg eax
inc ax
inc ecx
not eax
inc ecx
sete bl
seto byte [esp + edx - 0x3a2116a]
dec eax
inc edx
inc esi
lea eax, [eax + eax - 0x7d2507d4]
inc ecx
neg eax
inc eax
inc dh
dec esp
mov dword [esp + edx - 0x3a2116b], edx
or dword [esp + edx - 0x3a21173], 0x4205f324
dec ecx
inc esp
mov edx, ebp
inc esp
xor dword [esp + edx*4 - 0xe8845dc], eax
dec eax
or esi, ecx
dec eax
rol ebp, 0x78
dec esp
mov edx, dword [esp + edx - 0x3a2116b]
inc esp
movzx ebp, cx
dec ebp
arpl ax, ax
and ebp, dword [esp + edx*2 - 0x74422ed]
dec ebp
adc edi, eax
inc ecx
pop eax
pop esi
pop ecx
jmp fcn.012669aa
dec ebp
lea esi, [esi + edx*2 - 0x74422fc]
dec ecx
mov dword [esi + edx - 0x3a2117a], esi
sar eax, 0x64
jne 0x173913c
inc ecx
ror ch, 0xa5
setns dl
dec ebp
lea esi, [esi + edi*2 - 0xbd1e]
call fcn.01261dd5
not ecx
push ecx
mov edi, dword [esp + esi*2 - 0x40]
call fcn.0122c589
inc cx
mov edx, dword [esi]
mov edi, 0x3f304f30
dec eax
sar edi, 0x67
inc dx
mov ebx, dword [edi + esi + 2]
js 0x125a8e8
dec esi
lea esi, [edi + esi + 2]
inc eax
movsx esi, bh
dec eax
dec esi
dec eax
lea eax, [esi + edi*4 + 0x4032199b]
xor dx, si
push edi
xor bx, si
inc esp
movzx ebp, al
dec eax
shl dword [esp + edi], 0x76
dec edx
lea ebp, [ebp*2 - 0x4b474c69]
or dx, bx
neg ebp
inc esp
movsx eax, ax
inc cx
mov dword [esi + edi*2], edx
dec ebx
lea edx, [ebp + eax - 0x25f3e955]
dec eax
add dword [esp + edi], 0x412ce31
inc edx
mov edx, dword [edi + ecx]
dec ebp
lea ecx, [ecx + edi + 4]
inc ecx
xor edx, edx
xor edx, 0x2587921b
inc ecx
pop ebx
bswap edx
dec edx
lea ecx, [ebx*8 - 0x2e63bcf5]
dec eax
or eax, 0xe8192aac
inc ecx
bswap eax
neg edx
call fcn.01794441
Function at 0x1241635
Capabilities:
Encode data using base64

Disassembly:
shr ecx, cl
lea eax, [ecx + ecx*8 + 0x63391f3f]
mov dword [eax + esi - 0x67b91ec5], edx
mov dword [esp + ecx*8 - 0x3ffff90], eax
pop ecx
mov edx, dword [edi + ecx - 0x67b91eb9]
neg ax
lea edi, [eax + edi - 0x67b9e133]
pop eax
xor edx, ebx
mov dword [esp + eax*2 - 0x47cbf5aa], ecx
jmp 0x126719b
lea edx, [edx + eax*2 - 0x71da0263]
neg edx
not ax
xadd word [esp + eax - 0x23e50523], cx
ror edx, 2
pop ecx
neg ax
not cl
lea edx, [edx + eax - 0x20d362c6]
sar eax, 0x76
sar cl, 0xa3
xor ebx, edx
mov dword [esi + eax - 0x97], edx
add ax, ax
lea esi, [esi + eax - 0x126]
movzx edx, al
jo 0x1315ca7
rol eax, 0x3c
pop eax
pop ecx
jns fcn.0171e965
jmp ebp
Function at 0x1243cbf
Capabilities:
Encode data using base64

Disassembly:
call fcn.0173c1e5
inc eax
rol bh, 0x83
inc ecx
ror ch, 1
push esi
inc ecx
xor ch, 0x2d
inc ebp
xor dl, ch
dec eax
sub dword [esp + ebx*2 - 0x57da0000], eax
push ecx
dec al
dec esi
lea ebp, [esp + ebp + 0x28]
dec eax
sar esi, cl
inc esp
add esp, esi
inc cx
add esi, dword [ebp + ebx*2 - 0x57da0000]
inc esp
mov eax, dword [esp + ebx - 0x2bed0000]
inc ecx
sal al, cl
dec esp
sbb esi, ecx
inc cx
mov dword [esi + ebx*2 - 0x57da0000], esi
call fcn.017bf7e8
mov edx, 0xe8149b94
mov edi, edx
jmp 0x17b7d29
not eax
not ecx
push edx
or eax, ecx
mov dword [edx + esi - 0x7ffff], eax
movsx eax, word [esp + edx - 0x7ffff]
xor ax, word [esp + edx - 0x7fffd]
jbe 0x17c8180
mov dword [esp + edx - 0x7ffff], ebp
ret 8
movsx edx, ax
push eax
mov dword [esi + eax - 0x671bdb35], ecx
xor dword [esp + eax - 0x671bdb35], edx
rol edx, 0xbb
mov edx, dword [edi + eax - 0x671bdb35]
setne al
sub eax, eax
lea edi, [eax + edi + 4]
movsx ecx, ax
dec byte [esp + eax*2 + 1]
xor edx, ebx
not cl
xadd byte [esp + eax], al
sbb eax, 0x66810834
not edx
not eax
shr cl, 0x81
and word [esp + eax - 0x66810831], ax
neg edx
push ecx
dec ecx
bswap edx
sar cx, 0x42
inc ecx
ror edx, 1
sub ecx, 0xd69f1d21
or ecx, eax
lea edx, [edx + eax - 0x6463c90c]
push ecx
and dword [esp + eax - 0x66810832], eax
adc ecx, 0xb0809ca3
xor ebx, edx
add ebp, edx
mov eax, esi
jmp 0x173c5b9
and byte [esp + ecx - 0x20628797], cl
mov dword [esi + ecx - 0x206287a6], eax
movzx edx, cl
rol cx, 0x49
shr dword [esp + ecx - 0x20624507], cl
lea esi, [esi + edx*2 - 0x148]
shr byte [esp + ecx - 0x2062450f], 0x47
call fcn.016f7f70
inc esi
ret 0x3968
inc ecx
mov cl, byte [esi + 4]
inc esp
movsx esp, dx
dec ecx
lea edi, [esp + edx*8 + 0x782c5582]
dec eax
lea ebp, [edx - 0x284b1de1]
dec ecx
add esi, 4
dec eax
lea ebx, [ebp + 0x62225198]
dec eax
sar edi, 0x4c
dec esp
lea ebp, [edi*2 - 0x3042b9c7]
inc cx
shld ebx, eax, cl
inc eax
movzx eax, ch
dec eax
ror edi, 0x3b
dec eax
shl edi, 0xe7
inc bp
mov dword [esi + eax*2 - 0x166], ebx
dec esp
lea ebx, [ebx*2 - 0x56eb7565]
inc ecx
mov eax, dword [ecx + eax*2 - 0x166]
jae 0x1234ada
dec eax
neg eax
mov edx, ecx
ror cl, 0xa5
jb 0x1342b9f
xor eax, 0x1da2408e
and dword [esp + ecx - 0x350c8b52], edx
sete dl
bswap eax
sar byte [esp + ecx - 0x350c8b4f], 0xa1
mov word [esp + edx*2 - 0x6a1915ff], 0x8880
xor ebx, eax
not edx
sar edx, cl
add ebp, eax
and word [esp + ecx*2 - 0x6a1916a2], cx
lea eax, [edx*4 - 0x205b9872]
or cl, 0xb2
mov eax, dword [esi + ecx*2 - 0x6a1917e4]
sal byte [esp + ecx*2 - 0x6a1917e4], 0x63
mov dword [esp + ecx - 0x350c8bee], edx
setne byte [esp + ecx*2 - 0x6a1917e3]
mov ecx, dword [ecx + esi - 0x350c8bee]
adc esi, 4
shr edx, 0xd
jp 0x133cdb6
dec esi
lea ecx, [esi + ecx - 0x338c7f10]
call fcn.01739314
inc bp
mov ebx, dword [esi]
inc cx
mov eax, dword [esi + 2]
jmp 0x179c5ee
mov dword [esp + eax], ebp
ret 8

Function at 0x12484f6
Capabilities:
Encode data using base64

Disassembly:
inc eax
push ecx
pop eax
pop edx
pop eax
jno fcn.0171e965
Function at 0x124a21d
Capabilities:
Encode data using base64

Disassembly:
or dword [esp + 8], edx
xor ebx, ecx
sal dx, 0x24
add eax, edx
add ebp, ecx
call fcn.0172f8e6
ror byte [esp + edx*2 - 0x217], 7
mov dword [esp + edx - 0x107], edx
pop eax
pop eax
pop ecx
pop ecx
jne fcn.0171e965
jmp 0x1773ef4
lea eax, [eax + ecx*2 - 0x7e3b90be]
xor eax, 0xc41ce10f
lea eax, [eax + edx + 0x3d757415]
bswap eax
sub cx, cx
shl dword [esp + ecx*2 + 4], 0x8f
not eax
lea eax, [edx + eax - 0x61e28e86]
xor ebx, eax
not dword [esp + ecx*2 + 1]
not cx
jmp 0x17927c4
mov edx, 0x937ad03
mov eax, dword [edi + edx*2 - 0x126f5a06]
push edx
add word [esp + edx*8 - 0x49bd6817], dx
lea edi, [edx + edi - 0x937acff]
push edx
sar byte [esp + edx - 0x937acfe], 0xa1
xor eax, ebx
lea edx, [edx + edx*4 + 0x6b07bd16]
movsx ecx, byte [esp]
dec byte [esp + ecx - 2]
xor eax, 0x181e6f2d
jmp 0x17559bb
add ebp, eax
mov eax, dword [esi + ecx*4 - 0x3fffc]
lea ecx, [ecx - 0x48d70be9]
not dl
or dword [esp + 4], 0xbf96b19d
mov dl, byte [esi + 4]
adc esi, 6
call fcn.016f37d7
inc ecx
xor edi, edx
dec edx
lea eax, [esi + ebx*4 + 0x2a9d4bbf]
sub edi, 0xa9be972c
sar dx, 0x26
inc esp
movsx eax, bp
inc ecx
mov ebx, ebx
not edi
dec al
inc edi
call fcn.01793694

Function at 0x124a645
Capabilities:
Encode data using base64

Disassembly:
inc edx
call fcn.0126a7b5
mov ebx, 0x2d8122ba
movsx ebp, bl
movsx edx, bl
dec esi
mov esp, dword [ebx + esi - 0x2d8122ba]
movsx eax, dx
inc esp
movzx ebx, bx
inc esi
mov ebp, dword [ebx + esi - 0x2d8122b2]
dec edi
lea esi, [esi + ebx*2 - 0x4568]
inc ecx
sal bl, 1
dec eax
dec edx
mov edi, 0x7310220c
inc ebp
mov dword [esp + ebx - 0x2d8122ba], ebp
dec esp
lea ebp, [ebp + 0x4a2333a7]
dec eax
lea eax, [ebx + edx + 0x66267f11]
inc ecx
mov ebp, dword [ecx + ebx*2 - 0x5b024574]
ror dl, 0xa5
jbe 0x173df3a
xor edx, 0x7b244f82
xor ecx, ecx
movzx eax, cl
call fcn.0123530d
add edi, 4
xor edx, ebx
ror edx, 2
sar cl, 0x21
sar ecx, 0x1b
add edx, 0x6b967e15
jmp 0x1274030
call 0x1229dd8
mov ecx, 0x77255faa
lea edx, [ecx*8 - 0x24e842ee]
mov edx, dword [edi + ecx - 0x77255faa]
shl ecx, 0x2f
sar ecx, 0xf3
jb 0x16ff236
dec ecx
add ecx, 4
inc ecx
mov esp, 0xf93d7122
inc ecx
xor edi, edx
inc cx
rol esp, 0xea
dec ecx
shr esp, 0x6d
inc ecx
movzx ebp, sp
bswap edi
dec eax
lea edx, [ebp + ebp - 0x31fb15e7]
dec edi
lea ebp, [esp - 0x5d0ed60]
not edi
jp 0x16ff416
inc ecx
dec ch
dec ebp
lea ecx, [ecx + ebx - 0x2d8122b6]
inc ecx
xor ebp, edx
dec edx
lea ecx, [ebx*2 + 0x140d9699]
shr di, 0x6c
not ebp
shr edx, 0x22
ror ebp, 2
inc ecx
neg ebx
inc ecx
dec ch
dec ebp
ror ebp, cl
xor dl, 0x15
inc ecx
push edx
xor dword [esp + edx - 0x3fffffe6], ebp
push ebx
call fcn.01788c74
inc esp
movzx esp, si
mov ecx, dword [edi + eax*8 - 0x298a0]
jbe 0x17001dd
Function at 0x124b95a
Capabilities:
Encode data using base64

Disassembly:
call 0x125702b
sub cx, 0x408
pop eax
pop edx
pop ecx
ja fcn.0171e965
dec edx
rol dword [esp - 0x111d0f2a], 0x86
inc ebp
lea ebx, [ebx + ebx*2 - 0x1d33548f]
dec edx
lea edx, [ebx + ebp*4 + 0x5b10f001]
inc ecx
neg ebx
dec edx
shl dword [esp - 0x111d0f2a], cl
rol ebx, 0xcf
dec edx
sub ecx, dword [esp - 0x111d0f29]
dec esi
mov dword [esp - 0x44743cbc], edx
call fcn.0172790c
inc cx
xor edx, edx
sub dx, 0xde2f
neg dx
inc cx
sub edx, eax
dec eax
shl esi, 0xdb
call fcn.0121bba2
call fcn.017b61ae
add byte [eax], al
insb byte es:[edi], dx
cwde
cwde
or cl, byte [edi - 0x2a]
mov ss, edi
ja 0x124b9cb
mov dl, byte [edx - 0x5d]
mov ch, 0x96
ror edx, cl
jmp 0x124ba16
rol byte [edi - 0x70], 0xec
ret

Function at 0x1260b54
Capabilities:
Get number of processors

Disassembly:
dec eax
lea ebp, [ecx*4 - 0x12f959e5]
inc ecx
ror ebx, 3
add ebx, 0xa4032fae
push ecx
dec esi
mov dword [esp + ebp - 0x43158aed], edx
or word [esp + esi - 0xffe3], 0x5181
shl ebx, cl
jnp 0x16f60dc
inc esi
xor dword [esp + ebp - 0x43158aed], ebx
call fcn.0126cd58
adc bp, ax
ror bl, 0x83
xor ax, dx
inc esi
xor dword [esp + eax], esp
jmp 0x175d1d2
inc ecx
pop edx
xadd bp, si
dec ebp
arpl sp, sp
inc ebp
movzx ebp, al
dec eax
sal esi, cl
inc ecx
setb ch
dec ebp
adc edi, esp
dec ebp
add eax, edi
inc ecx
jmp eax

Function at 0x1261582
Capabilities:
Encode data using base64

Disassembly:
add cl, dh
xor ebx, eax
add ebp, eax
xor ecx, ecx
mov esi, dword [esi + ecx*8]
pop eax
pop ecx
jle fcn.0171e965
dec esp
mov dword [esp + esi - 0x101cc], edx
inc esp
xor dword [esp + esi*2 - 0x20398], esp
dec ecx
rol ebp, 0x8c
inc ecx
shl bl, 0x81
jl 0x175f424

Function at 0x1261c28
Capabilities:
Encode data using base64

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

Function at 0x126597a
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + edx*4], edx
inc eax
or ecx, ecx
dec dword [esp + edx]
jl 0x16fc8ff
bswap eax
bswap ecx
pop edx
adc dx, cx
lea eax, [edx + eax - 0x21f928ff]
ja 0x17a6f92

Function at 0x12677c3
Capabilities:
Encode data using base64

Disassembly:
inc eax
call fcn.01256fc7
js fcn.0171e965

Function at 0x126b303
Capabilities:
Encode data using base64

Disassembly:
mov eax, dword [ebp]
call fcn.016f559b
test ebx, ebx
lea esp, [esp + 8]
je 0x1261c33
mov eax, 0x7a12e11
ror eax, 0x6f
dec eax
mov eax, dword [ebp + ebx*4]
push eax
call fcn.01261c28

Function at 0x126c5b5
Capabilities:
Encode data using base64

Disassembly:
mov eax, dword [esi + eax*4 - 0x9ffffc]
sub edx, 0x78bfb5b7
or ecx, eax
not ecx
mov dword [esi + 8], ecx
sub esi, 0xfffffff8
dec word [esp + 0xa]
lea ecx, [edx*8 - 0x66ebb65a]
pop edx
pop ecx
pop edx
jmp ebp
xor ebx, edx
mov dword [esp + ecx - 0x541997cd], ecx
and dword [esp + eax - 0x280000], 0xb9a02d28
adc ebp, edx
xadd al, ah
movsx edx, byte [esp + eax - 0x27fffc]
sub dx, dx
mov ecx, dword [ecx + esi - 0x541997c9]
inc ax
jns 0x1254427
call fcn.01263e8d
xor dword [esp + eax - 0xffbd], edx
dec esp
lea ebx, [ebx + 0x573eb43f]
call fcn.01773d10
xor ecx, 0xb408ea05
inc ecx
movsx eax, bp
Function at 0x1270f8c
Capabilities:
Encode data using base64

Disassembly:
inc cx
and ebx, 0x4366b633
mov ebx, dword [esi]
jns 0x132545a
inc ecx
push ebx
inc edx
sbb dword [esp + 2], 0x31932ba0
dec edi
lea esi, [esp + esi + 2]
inc ecx
xadd eax, edi
inc ebp
movzx ebx, byte [ecx + edi*2]
call fcn.01259b52
ror esi, 0xc
inc ecx
xor eax, edx
dec eax
mov edi, dword [esp + 0x10]
dec eax
add edi, 0xfffc1384
jmp edi
dec esp
adc edi, ecx
dec ecx
sal ebp, 0x69
pop ecx
pop ebp
jne fcn.012669aa
inc ecx
mov eax, 0x850c130c
inc ebp
movsx esp, ax
inc ebx
movzx eax, byte [ecx - 0x2618]
jmp fcn.0125a924

Function at 0x12728bb
Capabilities:
Encode data using base64

Disassembly:
movzx eax, byte [edi]
xor al, bl
inc al
mov ecx, 0x99b454a8
ror al, 1
add al, 0xbf
neg al
call fcn.01720723
xor dl, bl
not ecx
neg ecx
sal cx, cl
ror dl, 1
sub dl, 0x21
not ecx
neg dl
and ecx, 0x45aeb997
adc cl, cl
xor dl, 0x92
xor bl, dl
or cx, cx
xor cl, 0x17
adc edx, esp
jmp 0x1774b55
call int.0179ab7f

Function at 0x1273aad
Capabilities:
Encode data using base64

Disassembly:
inc edx
dec eax
ror ebx, 0xc4
dec word [esp + eax*2 - 0x1ff6c]
pop ecx
ror edx, 1
inc ecx
rol ebp, 0x5b
dec edx
inc ecx
ror ebp, 0x6f
dec edx
neg dword [esp + ebp*2 - 0x7717bf20]
dec esi
mov dword [esp + ebp - 0x3b8bdf90], edx
movzx ecx, bx
inc ecx
mov esi, ebp
jge 0x126c5ee
dec ecx
add ecx, 4
inc ecx
xor eax, edx
bswap eax
inc ebp
mov ebp, esp
inc cx
or edi, ebp
rol eax, 3
jmp 0x16ead56

Function at 0x127411e
Capabilities:
Encode data using base64

Disassembly:
pop ecx
mov dword [esi], eax
movzx eax, dl
pop eax
pop ecx
pop eax
jmp fcn.0171e965

Function at 0x1276fa3
Capabilities:
Encode data using base64

Disassembly:
dec eax
arpl ax, ax
dec ecx
add eax, 0xbcbd471c
dec esp
add edi, eax
dec ebx
mov ecx, dword [esi + eax - 0x7545f14e]
dec esi
lea eax, [eax*4 - 0x5df305df]
inc ecx
inc bl
dec ebp
mov ebx, dword [esi + edx - 0xaa]
inc ecx
dec ah
dec ebp
lea esi, [esi + edx - 0xa2]
movzx ebp, dx
dec esp
mov dword [edx + ecx - 0xb2], ebx
inc eax
inc ch
js 0x172f086
mov dword [esi], edx
pop eax
pop edx
pop ecx
jb fcn.0171e965
inc edx
lea eax, [eax + eax + 0x419ceccb]
dec esp
mov dword [esp + edx*4 - 0x2c8], edx
inc esp
mov ebx, ebx
inc esp
movsx edx, bx
inc cx
rol eax, 0xaf
xor dword [esp + edx*8 - 0x590], eax
movzx ecx, dl
inc ebp
xor ch, dl
inc ecx
pop edx
jne 0x121b7c7
inc bp
add ebp, eax
inc ecx
jmp edi

Function at 0x12772e6
Capabilities:
Encode data using base64

Disassembly:
cmova eax, ecx
xor ebx, edx
xor byte [esp + ecx - 0x17], 0x87
adc ebp, edx
shl ecx, cl
lea edx, [eax + ecx*8 + 0x55b83121]
mov edx, dword [ecx + esi - 0x80000000]
mov dword [esp + ecx - 0x80000000], ecx
inc eax
mov eax, dword [esi + ecx - 0x7ffffffc]
inc cl
mov ecx, dword [esi + ecx - 0x7ffffff9]
jno 0x16eb092
call fcn.017304e5
add esi, 4
div ecx
mov ecx, dword [esp + 1]
not ecx
mov dword [esi], edx
pop edx
mov dword [esi + edx - 0x7ffffffc], eax
dec byte [esp + edx - 0x80000000]
pop ecx
mov dword [esp + edx - 0x80000000], ebp
ret
Function at 0x12793ce
Capabilities:
Encode data using base64

Disassembly:
dec edx
mov dword [esp + ebx*8 - 0x108], 0x96896184
lea ebx, [ebx + esi - 0x21bd3370]
dec edx
mov dword [esp + ebx*8 - 0x110], esi
rol si, 0xaf
inc edx
not dword [esp + ebx - 0x18]
bswap ebx
jb 0x177cfd2
inc edx
neg byte [esp + ebx*4 - 0x80]
not ebx
inc ebx
pop eax
inc edx
movsx edx, word [esp + ebx - 0x20]
bswap ebx
call fcn.0133eb5c
dec ebp
lea ecx, [ecx + edi + 4]
inc cx
xor esi, edx
dec edx
mov dword [esp + eax - 0x693bc5c8], 0x4908270b
dec esp
xchg dword [esp + 0x20], eax
dec ecx
add eax, 0x433e3c
inc ecx
jmp eax

Function at 0x1316afe
Capabilities:
Encode data using base64

Disassembly:
xchg cx, si
inc ecx
movzx edx, word [ecx]
and eax, esi
dec esp
lea esp, [edi + edi*8 + 0x2e9fdf00]
mov ebx, ecx
dec ebp
lea ecx, [ecx + eax - 0x5d80]
inc cx
xor edx, edx
or bp, 0xc010
inc dx
neg dx
call fcn.0178407a
mov ecx, 0xe815f516
mov eax, ecx
movzx cx, byte [esi]
lea edx, [eax + eax*8 - 0x2959e879]
ror dx, 0xa3
inc eax
mov dl, byte [esi + 2]
not cl
not dl
and cl, dl
and eax, eax
movzx edx, ax
mov word [esi + edx - 0xf515], cx
lea ecx, [esi + edx - 0xf515]
ja 0x1778b73
mov dword [esi + edx*2 - 0x1ea30], ecx
lea esi, [edx + esi - 0xf519]
shl al, 0x84
lea eax, [eax*2 + 0x2e258529]
dec eax
mov edx, dword [edi + edx - 0xf517]
movsx ecx, al
lea edi, [edi + ecx*2 - 0xc]
push ecx
xor edx, ebx
pop eax
inc cl
rol edx, 1
sal al, 0xa7
xadd ecx, eax
neg edx
call fcn.017ac1f3
inc dx
sar dword [esp + ebx*8 - 0x494de], 0xb
dec ecx
lea eax, [eax - 0x6ffc7364]
dec ebp
adc edi, esp
inc edx
movzx ecx, word [esp + ebx - 0x9290]
inc ecx
rol ebp, 0x7d
dec esi
mov dword [esp + ebp - 0x1e30f240], edi
ret 0x18

Function at 0x1316d0c
Capabilities:
Encode data using base64

Disassembly:
xor ebx, eax
ror ecx, 0x42
adc ebp, eax
shl ecx, cl
add dword [esp + ecx - 0x76980000], edx
lea eax, [edx + edx*8 - 0x25c0e4cf]
mov esi, dword [esi + ecx - 0x76980000]
dec edx
not dl
pop eax
jl fcn.0171e965
adc edi, 4
mov dword [esp], ecx
lea edx, [ecx + 0x159e8cb5]
xor eax, ebx
xor edx, dword [esp + edx - 0x10de1440]
not eax
inc edx
ror eax, 2
xchg dword [esp], edx
inc dword [esp]
lea ecx, [edx*2 + 0x610bb59d]
not eax
add dl, 0
neg ecx
inc eax
shl dx, 7
js 0x12784d0
call fcn.01751ef8

Function at 0x1319a1c
Capabilities:
Encrypt data using rc4 prga

Disassembly:
inc ecx
movzx ecx, byte [esp]
xor ecx, ebp
and ecx, 0xff
mov ecx, dword [esi + ecx*4]
shr ebp, 8
xor ebp, ecx
dec ecx
inc esp
xor ebp, 0xc22a6c82
jmp 0x1321454

Function at 0x131b4a2
Capabilities:
Encode data using base64

Disassembly:
inc edx
xor dh, byte [esp - 0x978]
neg bx
dec esp
add edi, ecx
inc edx
and byte [esp - 0x97c], dh
inc esi
movsx ebp, word [esp - 0x4c27]
pop ebx
pop edi
ja fcn.012669aa

Function at 0x13252d3
Capabilities:
Encode data using base64

Disassembly:
pop eax
neg cx
bswap edx
sbb ecx, 0xee091303
jl 0x17945c7
Function at 0x13285cc
Capabilities:
Encode data using base64
Encode data using xor

Disassembly:
mov edx, ecx
dec cl
mov edx, dword [ecx + esi - 0x1e127680]
inc cl
and cl, ch
adc byte [esp + ecx - 0x1e127602], cl
adc eax, edx
bswap ecx
mov edx, eax
mov cx, word [esi + ecx*8 - 0x23b090e8]
add esi, 0xa
xor byte [esp + 3], 0x81
jno 0x1712313
inc edx
xadd dword [esp + ebx*4 - 0x1aa], edx
adc bx, 0x602f
rol bx, 1
inc bp
or ebp, eax
inc sp
xor edx, ebx
inc edx
movsx eax, byte [esp + ebx*2 - 0xd4]
inc esi
or byte [esp + ebx*8 - 0x356], ch
dec eax
lea ebx, [esp + ebx + 8]
inc dx
mov dword [ebx + ebx - 0x6b], ecx
dec ebx
lea ecx, [ebx + eax*4 + 0x614b1a3]
inc ebx
mov ebp, dword [ecx + ebx - 0x6b]
call fcn.01769a0c
adc ebp, edx
pop eax
bswap ecx
neg byte [esp + ecx - 0x1e127682]
mov eax, dword [esi + ecx*2 - 0x3c24ed0a]
jle 0x124a6ef

Function at 0x132a850
Capabilities:
Encode data using base64

Disassembly:
inc ecx
pop edx
inc ebp
add ch, al
jp 0x1703e61
dec eax
lea esi, [ebx + ebx*2 + 0x3811c60c]
inc esp
movsx eax, dh
or ax, cx
mov edx, edi
not ax
inc dx
mov dword [edi + esi - 0x71007695], eax
inc esp
movsx ebp, si
inc edx
mov edx, dword [edi + ecx - 0x71007695]
inc ebp
movzx ebx, bp
mov ebp, ebx
shl esi, 0x5a
dec esi
lea ecx, [edi + ecx - 0x71007691]
inc eax
movzx ecx, bh
inc cx
shr ebx, 0xa6
inc ecx
xor edx, edx
jmp 0x12769d2
inc cx
inc esp
inc edx
lea ebp, [ebp + eax*4 + 0x14ce2179]
rol ebp, 2
inc ecx
movzx edi, al
dec esi
mov dword [esp + eax*2 - 0x6324d160], esp
inc edx
neg dword [esp + eax - 0x319268ac]
dec esi
mov dword [esp + eax - 0x319268b0], edx
inc ecx
mov ebp, 0xcc13baa9
inc ecx
sar al, 0x21
inc edx
xor dword [esp + eax - 0x319268d8], ebp
movzx ecx, dl
inc esp
mov edx, ecx
jmp 0x1265dda
inc cx
sar eax, 0x6c
dec ebp
lea esi, [esi + eax*2 - 0xd164]
inc ecx
rol ebp, cl
ja 0x16fba62
inc edx
mov dword [eax + esi - 0x68b0], ebp
ror bl, 0xc1
ror ebx, 0x9f
inc ecx
mov edx, dword [ecx + eax - 0x68b0]
call fcn.01743940
mov eax, 0x970e7e83
push eax
inc ecx
mov ecx, dword [ecx]
dec ecx
add ecx, 4
jmp 0x175be84
pop esi

Function at 0x1337a40
Capabilities:
Encode data using xor

Disassembly:
dec eax
mov dword [esp + ebp*4 - 0xd230], ebx
inc eax
adc byte [esp + ebp*8 - 0x1a45d], ch
inc ecx
not eax
inc ecx
neg eax
inc eax
movzx esi, bh
inc esp
movsx ebp, ch
inc ebp
lea eax, [eax + ebp*2 + 0x1d9a1c68]
dec eax
shr dword [esp + ebx - 0x754448c3], 0x5d
dec esp
lodsb al, byte [esi]
sbb al, 0x3d
mov bh, 0xbb
mov bl, byte [ebp + 0x4c]
adc dword [esp + ebp*2 - 0x6918], edx
inc esp
xor dword [esp + ebp - 0x348c], eax
ror bx, cl
inc esp
mov edx, ebx
inc ecx
pop edx
dec ebp
arpl ax, ax
dec eax
ror ecx, 0xcb
dec ebp
add edi, eax
inc esp
add ch, ch
inc ecx
push ebx
movzx eax, di
dec ecx
mov esi, dword [esi + ebp*8 - 0x1a460]
inc cx
and ebx, 0x8cfea9b5
sbb al, 0xd0
jae 0x1337a68
mov cl, byte [ecx - 0x75]
xchg esp, eax
push ds
aam 0x73
mov ebx, 0xc5d3668a
dec ebp
lea esi, [esi + ebp*2 - 0x4612]
inc ecx
xor al, ch
rol ebp, cl
xadd ebp, eax
dec eax
not esi
dec esp
add dword [esp + ebx - 0x75448c34], ebx
dec eax
not edx
dec eax
dec dword [esp + eax*2 - 0x118680]
call fcn.017a0ed5
Function at 0x1338b08
Capabilities:
Encode data using base64

Disassembly:
inc esp
mov eax, dword [esp + 9]
inc ebp
movsx ebp, al
inc ecx
mov dword [esi], esi
dec esp
mov dword [esp], ebp
inc ecx
mov eax, dword [ecx]
dec ecx
add ecx, 4
inc ebp
movsx ebx, bp
inc ecx
sub ebp, 0x580e02c
jb fcn.01795851
inc ecx
xor eax, edx
dec edi
lea esp, [ebx + eax*2 - 0xde32262]
pop ebp
neg eax
sub dword [esp + 2], 0x4d03ae8d
inc ecx
pop eax
ror eax, 2
dec esp
lea eax, [ebp + 0x108ffeb4]
inc ecx
mov esi, ebp
sub eax, 0x9da6191d
inc ecx
movsx edi, bl
neg eax
mov ebx, 0x3318b136
inc eax
call fcn.0122fc2a

Function at 0x133d009
Capabilities:
Encode data using base64

Disassembly:
sub eax, 0xed037805
inc ebp
movzx ebp, bl
neg eax
inc dx
sal dword [esp - 0x1b044], 0xe3
xor eax, 0xd2b73f1b
inc ecx
lea eax, [esp + eax + 0x77127288]
call fcn.017ad550

Function at 0x133d066
Capabilities:
Encode data using base64

Disassembly:
dec ecx
neg ecx
mov edx, 0x3024a086
sar ax, 0xe6
dec ecx
neg ecx
not dl
inc al
xor ebx, ecx
sub dx, word [esp + edx - 0x3024a070]
call fcn.0132bcf3
shl ecx, 0x3b
jns 0x12413bd
xor bl, cl
lea ecx, [esp + ecx + 8]
jmp 0x1338f3d
inc eax
dec dh
inc eax
rol dh, 1
call fcn.016ff5b8
pop edi
inc ecx
pop esp
inc ecx
pop eax
jmp fcn.012669aa
mov dword [ecx], edx
call fcn.01323433
inc ecx
mov edi, ebp
not al
not byte [esp + esi*4 - 0x380]
not edx
dec esp
and ebp, ebp
neg al
dec al
call fcn.013251a7
or esi, ebp
invalid
mov dword [esi], edx
mov ecx, 0xf6890e03
mov dword [esi + 4], eax
mov ecx, dword [edi]
mov dword [esp], 0x62b2d885
add edi, 4
xor ecx, ebx
push 0x68ac3b6
sal word [esp + 6], 4
mov eax, 0x4a9f278d
not ecx
push eax
jns 0x122df44
inc cx
xor ebp, 0x44fe0728
pop esp
jecxz 0x133d032
jecxz 0x133d005
pop ecx
inc cx
inc ebp
dec eax
lea ebp, [eax*8 + 0x719672bb]
mov dword [esp + ebx*2 - 0xa80000], edx
inc cx
not ebp
sal byte [esp + ebx*4 - 0x1500000], 3
dec eax
dec ebx
inc eax
xadd bl, ch
inc cx
inc ebp
inc bp
xor edx, ebp
add word [esp + ebx*2 - 0xa7fe53], 0x7f80
call fcn.0174dcc6

Function at 0x16f7f70
Capabilities:
Encode data using base64

Disassembly:
pop edx
pop eax
pop ecx
pop edx
jne fcn.0171e965
mov ecx, 0x272e9ea7
mov edx, dword [edi + ecx*2 - 0x4e5d3d4e]
sar cx, 0xac
lea eax, [ecx + ecx*2 + 0x419e14a6]
ror cx, 0x89
lea edi, [edi + ecx*2 - 0x4e5df9fa]
dec ecx
xor edx, ebx
sal ecx, 0x7c
add edx, 0x15872508
not edx
jmp 0x1726122

Function at 0x170835e
Capabilities:
Encode data using base64

Disassembly:
inc ecx
rol ebp, 1
dec eax
mov dword [esp + edi - 0xca3], esi
movsx edx, word [esp + edi - 0xca2]
jmp 0x17285af

Function at 0x1709967
Capabilities:
Encode data using base64

Disassembly:
and edi, 0xff
inc ecx
mov edi, dword [edi + edi*4]
jmp 0x17a86b1

Function at 0x170b99d
Capabilities:
Encode data using base64

Disassembly:
xor ebx, edx
add ebp, edx
ror ecx, 0xb
movsx edx, cx
pop edx
jae fcn.0171e965

Function at 0x170c7bb
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + eax*4 - 4], 0xd384bb18
shr dword [esp + eax - 1], 0xe1
bswap edx
shl byte [esp + eax*4 - 2], 0x24
xchg dword [esp + eax*4 - 4], eax
xor ebx, edx
add ebp, edx
pop eax
jmp fcn.0171e965