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

Disassembly:
and cx, 0xfb7
xor edx, ebx
jmp 0xed3874
movsx eax, cx
bts ax, cx
not edx
neg edx
call fcn.00ca9329
jmp 0x117c698
add eax, edx
call section..a_
xor ecx, edx
lea edi, [edx + edi - 0x9243b0e]
mov ecx, dword [edi + edx*4 - 0x2490ec28]
shl dl, 0x41
inc edx
xor ecx, ebx
call fcn.00c1ee45
mov ecx, 0x9132fab4
mov edx, ecx
movsx eax, dx
mov eax, dword [edi]
sar ecx, 0xb8
shl dx, 1
mov edx, dword ss:[eax]
jb 0x117cdfd
mov ecx, 0x898eceac
inc ecx
mov edx, dword [ebp]
add ebp, 4
sub ecx, ecx
mov eax, ecx
xor edx, ebx
lea eax, [ecx + ecx*8 - 0x304d5cf9]
call fcn.00ef151a
lea esi, [esi + edx - 0x7bb2da04]
rol edx, 0x87
bt edx, 0xaf
mov edx, dword [esi]
mov ecx, 0x209019b2
lea eax, [ecx*2 - 0x4bc3a7cd]
bts ecx, ecx
xor edx, ebx
neg edx
inc al
sal ecx, cl
bts eax, ecx
lea edx, [edx + ecx*2 + 0x2e8b1f3d]
adc eax, ecx
sar eax, 6
sbb ecx, eax
ror edx, 2
not ecx
and cl, 0x3a
ror al, 0x47
xor edx, 0x1bdee2a
ror edx, 2
sal al, 0xc6
btr eax, eax
xor edx, 0x8424028a
ror al, 0xa4
bswap edx
dec al
xor ebx, edx
add al, cl
cwde
add edi, edx
movzx edx, cl
and edx, ecx
sar ecx, cl
mov dl, byte [ebp + edx*8 - 0x140]
mov cl, byte [ebp + 2]
cbw
neg eax
inc eax
lea ebp, [eax + ebp - 0xffd8]
bts ax, 0x16
shr dl, cl
push eax
mov word [ebp + eax*2 - 0x1ffb4], dx
lea ecx, [eax*4 - 0x2755ff6f]
push ecx
mov dword [esp + eax*8 - 0x7fed0], edi
ret 4
btc ecx, 0x8e
mov dword [edi], edx
mov edx, dword [esi]
sbb esi, 0xfffffffb
lea eax, [ecx*8 - 0x3841f8f6]
lea ecx, [eax*2 + 0x7f225922]
cwde
xor edx, ebx
inc ecx
shr cl, 0x61
xor edx, 0xdd9f449c
neg edx
lea ecx, [ecx + ecx*8 - 0x40770263]
ror edx, 1
xor edx, 0x22b4daac
sub al, 0x96
btr ecx, eax
add ecx, ecx
xor ebx, edx
call fcn.00b8e513
mov ecx, 0xfa082832
and cl, cl
mov edx, dword [esi]
lea ecx, [ecx*2 - 0x3adcf2f8]
adc esi, 4
sal cl, 0xc4
jae 0xe653b1

Function at 0xee898f
Capabilities:
Encode data using xor

Disassembly:
neg ecx
call fcn.00c8cf36
ror eax, 1
shl dl, 5
sbb dl, dh
shl dl, 1
bswap eax
movsx ecx, dl
neg eax
neg ecx
xor ebx, eax
call fcn.00bfaf54
mov eax, 0x4fa36b1c
movzx edx, al
neg al
lea ebp, [ebp + edx*2 - 0x3c]
or eax, eax
mov ecx, eax
mov eax, dword [ebp + edx - 0x1c]
xor eax, ebx
imul dx, dx
sbb eax, 0x96a6aa92
or edx, 0xe21aaa28
sal edx, cl
lea edx, [ecx + edx*2 + 0x409ece96]
neg eax
and dx, cx
imul ecx, ecx
inc eax
bswap ecx
rol eax, 1
shr edx, 0xc1
xor dx, 0x5f8f
ror edx, cl
dec eax
or cl, cl
push edx
not eax
sbb cx, word [esp + ecx - 0x1063d049]
xor ebx, eax
neg ecx
add edi, eax
mov eax, dword [esi]
call fcn.00ca6a7d
inc edi
xchg edi, eax
cdq
jp 0xee89a1
outsb dx, byte [esi]
invalid
Function at 0xeeb3c6
Capabilities:
Encode data using base64

Disassembly:
cbw
xor dl, bl
shr ax, 0x6f
inc dl
shl cx, 0xc5
ror dl, 1
xchg cx, ax
sub dl, 0x9c
ror dl, 1
xchg cx, ax
xor bl, dl
lea edx, [esp + edx + 4]
rol cx, 5
lea ecx, [eax*8 + 0x7aa258b7]
push eax
mov ecx, dword [ecx + edx - 0x7aa258b7]
mov dword [esp + eax + 4], eax
mov dword [esi + eax*8 + 6], ecx
lea esi, [eax + esi + 6]
imul byte [esp + eax + 2]
jno 0xef159d
mov eax, 0x291e22ae
lea edi, [edi + eax*2 - 0x523c4560]
push eax
mov eax, dword [edi + eax*2 - 0x523c455c]
xor eax, ebx
add eax, 0xae309314
neg word [esp + 1]
jno 0xef4138
mov ecx, 0xde3759b6
mov edx, dword [ebp]
or cx, 0x3b0c
ja 0xe8d6a7
outsd dx, dword [esi]
lahf
cdq
jp 0xee8286
xchg edi, eax
invalid
cld
sbb al, 0x89
mov byte [esi], ah
in al, dx
loop 0xee82ce
inc eax
int 0
lodsd eax, dword [esi]
dec ebx
cmp dword [edi - 0x264158ee], ebp
popal
jne 0xee8309
jmp [ebp - 0x75083c8d]
xor bl, bh
push 0x63a8c1e4
xor eax, 0xb9dc29f0
or eax, 0xfa000134
add dh, bl
in eax, dx
mov edi, 0xa35444ff
imul ebp, ebx, 0x51554e50
sub byte [eax], cl
out 0x53, al
push ebx
sbb eax, dword [ebx - 0x1eee91ec]
or ebx, 0x20
xor dword [esi - 0x4b5ec16c], ebx
jo 0xee8355
int3
dec edi
scasd eax, dword es:[edi]
adc ebx, esi
dec ebp
mov dl, 5
inc esi
push cs
adc dword [ebx + 0x6626e2b5], esi
adc dword [ebx - 0x61b9354b], esi
adc dword [ebx - 0x4b45ad4b], esi
push es
scasb al, byte es:[edi]
jne 0xee82ac
mov esp, 0xe580a40c
mov edx, 0xef00a0c2
dec esp
dec edx
cmp al, 0xa0
and dword [eax + 0x50], 0xffffffba
push cs
mov ebp, 0x8f003d10
xchg ebx, eax
xchg ebx, eax
and al, byte [esi - 0x3c]
adc al, 0xaf
add bh, ah
adc dword [ebp + 0x3feb94be], edi
fidiv word [edi + 0x57]
call [edi]
stosd dword es:[edi], eax
mov edx, 0x5c3315b7
dec esi
ljmp 0x408c
movzx edx, byte [ebp + ecx - 5]
lea ebp, [ebp + ecx - 5]
mov eax, ecx
jp 0xee81b8
adc dword [esp + eax], edi
ret 4
xor eax, 0x63be6cbe
mov ecx, 0x2bc438c
dec eax
bswap ecx
call fcn.00ebef95
Function at 0x1164699
Capabilities:
Encode data using base64

Disassembly:
push 0x1e1a0e38
push 0xef94aa8c
lea esp, [esp + 0x10]
jne 0xb8039f
mov esi, 0x38132c19
lea esi, [esi*4 - 0x134e27d6]
pop esi

Function at 0x11658d2
Capabilities:
Hash data using murmur3

Disassembly:
inc edx
xor dword [esp + eax - 0x44a5c70b], edi
dec esi
mov esp, dword [esp + esi + 0x10]
call fcn.00c5c388
inc ecx
xor edi, esp
xor edi, 0x1418eb3e
inc ebp
mov ebp, ebx
or al, 0x1a
inc edx
mul dword [esp + esi - 7]
neg edi
dec edx
xor eax, dword [esp + eax - 0x44a5c70b]
ror edi, 2
imul dx
neg edi
dec esi
mov dword [esp + esi - 0xb], esp
dec ecx
sar esi, cl
inc ecx
inc ebp
jge 0xc0834e
movsx ecx, byte [esp + eax*2 - 0xf148]
btc eax, 0xac
movzx eax, byte [ebp + eax - 0x68aa]
xor al, bl
add cl, 0x82
rol al, 1
movsx edx, cx
rol edx, 0xd
sub al, dl
sub ecx, edx
ror al, cl
xor al, 0xb9
xchg byte [esp + ecx - 0x1bdf16], cl
imul edx, ecx
xor bl, al
sub cx, 0x712d
lea eax, [esp + eax + 0xc]
not word [esp + ecx - 0x1b6de9]
xchg word [esp + ecx - 0x1b6de7], dx
mov dx, word [eax + edx*2 - 0x29364818]
mov word [esi + ecx*4 - 0x6db7be], dx
imul ecx, ecx
dec dword [esp + ecx - 0x5fd640f8]
movsx eax, cl
lea esi, [esi + ecx - 0x5fd640fe]
shr dword [esp + eax*8 + 4], 0xa4
mov ecx, dword [ebp + eax - 6]
mov edx, eax
shr eax, 0x1b
or al, dh
lea ebp, [eax + ebp - 6]
xor ecx, ebx
not byte [esp + eax + 8]
sub ecx, 0xcd358225
lea edx, [eax*4 - 0x6ad4695b]
imul edx
not eax
neg ecx
inc word [esp + edx + 6]
bswap ecx
bt edx, 0xf
neg ecx
xor ebx, ecx
add edi, ecx
shl word [esp + edx + 2], 0x66
mov dword [esp + edx*4], edi
ret 8

Function at 0x11675f4
Capabilities:
Encode data using base64

Disassembly:
rol ecx, 1
dec ecx
dec esi
call fcn.00c61071

Function at 0x1169184
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp], 0x83d175fd
call fcn.00c0905c
Function at 0x1169191
Capabilities:
Encode data using base64

Disassembly:
mov edi, dword [edi*4 + 0xc18aac]
shl byte [esp + 2], 0x63
not dword [esp]
shr ecx, 8
push 0xfe8c4001
xor ecx, edi
inc edx
add dword [esp + 2], 0x83d8d2d
shl word [esp + 6], 0x4b
xor ecx, 0xb0bce699
shl dword [esp + 4], 0xfc
push 0x37329b0c
neg dword [esp + 5]
dec eax
push 0xfda40d1e
lea esp, [esp + 0x10]
jne 0x116919d
mov edi, 0xe909ca30
movsx eax, di
pop edi
movzx edi, byte [edx]
js 0x1194e14
cbw
mov dword [eax + ebp - 0xffa2], ecx
mov dx, word [edi + eax - 0xffac]
lea edi, [eax + edi - 0xffac]
xor dx, bx
movsx ecx, al
sub dx, 0x7b85
ror ecx, 0xd
bts eax, eax
sar ecx, 0xee
not dx
adc dx, 0xf095
xor dx, 0x5c96
neg ax
xor bx, dx
mov word [ebp + eax*2 - 0x32], dx
movzx edx, ax
shr eax, 0xfe
ror edx, 0x5f
lea ebp, [ebp + edx*4 - 0xce]
neg edx
not edx
add eax, esi
jmp eax
mov dword [esp], 0x7c0954a3
mov dword [esp], edi
mov edi, 0x952d7301
inc edi
jle 0xc27e26
push 0x738520b3
xor edi, ecx
ror word [esp], 0x62
neg dword [esp]
and edi, 0xff
shr byte [esp + 1], 0x26
jb 0x11daa65
jbe 0xb98804
mov eax, dword [edi - 4]
mov edx, 0x1285bc02
movsx ecx, dx
xor eax, ebx
lea ecx, [edx - 0x4b730447]
bswap eax
ror eax, 2
btc edx, ecx
bt ecx, ecx
rol edx, cl
lea eax, [eax + ecx + 0x3291647f]
add ecx, ecx
lea ecx, [ecx*4 + 0x69229f12]
xor eax, 0x8633aa10
ror edx, 0xf1
inc eax
neg eax
not edx
xor ebx, eax
or edx, 0x50989c84
adc esi, eax
not edx
bts ecx, edx
mov ecx, dword [ebp + edx*2 - 0xcc000d4]
movzx eax, dl
mov edx, dword [ebp + edx - 0x6600066]
or eax, eax
ror al, 4
add ecx, edx
mov edx, eax
jmp 0x1167104

Function at 0x116a493
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
test eax, eax
jmp 0xc7dbeb
push 0x798804bf
push 0xb3276393
lea esp, [esp + 0x14]
je 0xb5ab7b
push 0x92a880a1
mov dword [esp], ebx
ror word [esp + 8], 0xe1
xor edx, edx
jmp 0xc5ac08

Function at 0x116e674
Capabilities:
Encode data using base64

Disassembly:
or edx, dword [esp + ecx - 0x82]
imul ecx, ecx
adc ebp, eax
mov dword [esp + ecx*4 - 0x11890], 0x1c9b3285
xor byte [esp + ecx - 0x461b], 0x14
movzx eax, byte [esi + ecx*4 - 0x1188b]
lea esi, [esi + ecx*4 - 0x1188a]
push ecx
xor al, bl
not edx
add cl, 0x9e
neg al
xchg dword [esp + ecx*4 - 0x11afc], edx
xadd word [esp + ecx - 0x46bd], cx
ror al, 1
add ecx, edx
sar cl, cl
neg al
or cx, 0xdf14
rol al, 1
ror edx, cl
shl ecx, 0x61
dec al
xor bl, al
dec dx
sar cx, 9
lea eax, [esp + eax + 0x10]
mov cx, word [eax]
movsx eax, dx
mov word [edi + eax - 0x1f40], cx
bswap edx
sal byte [esp + eax*2 - 0x3e6a], 0xa6
lea edi, [edx + edi - 0x3c1f9dfa]
sal dl, 0xa2
sal byte [esp + edx - 0x3c1f9dd2], 0xe1
pop edx
pop ecx
pop edx
pop ecx
jnp fcn.00c19dd7
xor ecx, ebx
not ecx
btr ax, ax
mov edx, eax
jb 0xbfa47a
neg ecx
dec ecx
neg ecx
btr edx, 0x88
xor ebx, ecx
add edi, ecx
movzx ecx, ax
sub ecx, eax
mov dx, word [eax + ebp - 0x268f51a2]
not eax
add cl, byte [ebp + 2]
add ebp, 2
shr dx, cl
lea ecx, [eax + eax - 0x32eaa7e0]
dec ecx
mov word [ebp + ecx - 0x7ff6b4d9], dx
ror ax, 0xa3
jmp edi
Function at 0x11716f0
Capabilities:
Encode data using base64

Disassembly:
lea ecx, [eax + 0x4bb5188d]
cwde
lea edx, [esp + edx + 4]
mov eax, dword [edx + ecx - 0x4c41bad1]
mov dword [esp + ecx - 0x4c41bad1], ecx
or ecx, ecx
lea edi, [ecx + edi - 0x4c41bad5]
inc dword [esp + ecx - 0x4c41bad1]
or cx, cx
sub byte [esp + ecx - 0x4c41bacf], ch
mov dword [edi + ecx - 0x4c41bad1], eax
shl dword [esp + ecx - 0x4c41bad1], cl
inc ecx
mov edx, dword [esi + ecx - 0x4c41bad2]
mov eax, 0x44b1de1d
push eax
lea esi, [ecx + esi - 0x4c41bace]
btc ecx, eax
xor edx, ebx
bt ecx, 0
push ecx
call fcn.00ede995

Function at 0x117cb06
Capabilities:
Encode data using xor

Disassembly:
movsx ecx, byte [esp + edi - 0x7ffffff6]
inc ecx
bts ecx, edi
inc sp
xor esp, eax
dec eax
lea eax, [esp + eax + 0x10]
dec eax
mov dword [esp + edx - 0x9601], edx
and di, word [esp + edi - 0x7ffffff4]
dec esp
mov dword [eax + edi - 0x80000000], edx
inc esp
and ecx, dword [esp + edx - 0x95f8]
and byte [esp + edi - 0x7ffffffc], 0xb1
inc ebp
mov ebx, dword [edi + edx*2 - 0x12c02]
neg ecx
dec ebp
lea edi, [edi + edx*4 - 0x25800]
inc ecx
setno al
inc ebp
xor ebx, esp
call fcn.00b74780
jp 0x117cb08
invalid
sbb byte [eax - 0x4efb931f], 0x8e
int3

Function at 0x117ce64
Capabilities:
Encode data using base64

Disassembly:
lea eax, [eax + ecx + 0x4836d920]
mov dword [esp + ecx*4 - 0x2fb82044], 0x588fcb15
call fcn.00ee22f3
xchg word [esp + eax - 0x797c], ax
xor eax, eax
neg cl
cwde
call fcn.00e9bba4

Function at 0x117ce8d
Capabilities:
Encode data using base64

Disassembly:
inc ecx
sbb ecx, 0xa7b3091c
dec eax
cdq
dec ebp
lea edi, [edi + eax*2 - 0x494c]
call fcn.00ca4d28
push ecx
btc cx, cx
lea esi, [esi + ecx*2 - 0x78ffbef4]
jae 0x11e1b45
dec edx
mov dword [esp + ebp - 0x33], 0xe106fab8
inc edx
not byte [esp + ebp*2 - 0x5f]
inc ecx
inc al
sal cl, 0x25
inc ecx
rol al, 1
dec esp
xadd ecx, ebp
inc ecx
neg al
inc ecx
xor al, 0x25
dec esp
lea ebx, [ecx + eax*8 + 0x1f843733]
inc ebp
xor ah, al
dec eax
lea ebp, [ebp + eax*4 - 0xce]
inc cx
not ebp
mul byte [esp + eax*4 - 0xcc]
inc sp
mov dword [ebp + edi*2 - 0x66], eax
dec word [esp + eax - 0x24a8]
dec esp
cmovp ebx, dword [esp + eax*2 - 0x4950]
inc ebp
mov eax, dword [edi + eax*8 - 0x12540]
jbe 0xe54e4c
ror ecx, 2
cwde
sub ecx, edx
xor ebx, eax
add ebp, eax
btc ecx, ecx
xchg dword [esp + ecx - 0x253f8efc], ecx
movzx edx, cl
pop eax
pop eax
pop eax
pop ecx
pop ecx
pop edx
jae fcn.00c19dd7
mov eax, ecx
mov ecx, dword [ecx + esi - 0x3c7fdf78]
sal eax, 0x68
lea edx, [eax + eax*8 + 0x1aa90925]
bts eax, 0xa
xor ecx, ebx
lea ecx, [ecx + eax*2 - 0x342c12c1]
shl eax, 8
sub dword [esp + 4], edx
push edx
rol ecx, 3
inc word [esp + 6]
sar edx, 0x81
bswap ecx
shr dx, 0x87
jbe 0x11b0fce
lea edx, [eax*4 + 0x61128319]
inc ecx
xor ax, ax
xor ebx, ecx
mul dword [esp + 8]
ror eax, 0x3f
adc edi, ecx
mov dword [esp + eax - 0x2680001], edi
ret 8
Function at 0x117ddaf
Capabilities:
Encode data using base64

Disassembly:
dec ecx
mov edx, dword [esi + ebp - 0x68091a]
inc cx
btc ebx, eax
inc dx
mov edi, dword [edx + esi - 0x68091a]
dec edx
lea ebp, [ebp + esi - 0x680914]
xor ax, 0x9708
inc ecx
push esi
inc dx
mov dword [ebp + esi - 0x68091a], edi
dec edx
mov dword [esp + esi - 0x68091a], ebx
ret 8
mov word [esi + edx*2 - 0x5e5ca0a2], ax
and dword [esp + edx*2 - 0x5e5ca0a0], 0x5d9fe3be
shl dword [esp + edx*2 - 0x5e5ca09a], 0xd4
xchg dword [esp + edx - 0x2f2e504b], edx
mov edx, dword [ebp + edx*2 - 0x6434]
mov eax, dword [esp + 8]
mov ecx, dword [esp + eax - 0x41a02f28]
xchg byte [esp + ecx*2 - 0x5e5ca098], al
lea ebp, [eax + ebp - 0x41a02f9c]
lea eax, [eax*8 + 0x782387a9]
lea eax, [eax + ecx - 0x4d6ddcc6]
xor edx, ebx
lea eax, [ecx + ecx*4 - 0x2d44a244]
bswap edx
shr dword [esp + ecx - 0x2f2e504d], 0x41
sar ax, 0x85
ror edx, 1
not edx
rol cl, 7
not eax
inc ecx
sbb edx, 0xd60a66a0
shr ax, 9
xchg dword [esp + ecx*2 - 0x5e5ca150], ecx
bswap edx
rol edx, 1
inc edx
xor edx, 0xf826a686
call fcn.00b62021
dec eax
arpl di, di
inc ecx
shr eax, 0xe2
dec ecx
dec eax
dec esp
mov dword [esp + eax - 0xa3], edx
dec eax
add ebx, edi
neg byte [esp + eax*4 - 0x2c5]
inc ecx
bts ecx, 0xb6
inc ecx
pop ebp
pop eax
inc ecx
pop ebp
jb fcn.011a3bd5
inc ecx
mov ebx, 0x8a8684b0
inc ecx
mov eax, dword [edi]
inc ecx
shr ebx, 0x4f
dec edi
lea edi, [ebx + edi - 0x11509]
inc ebp
movsx esi, bl
inc ecx
mov ecx, ebx
push ecx
inc ecx
xor eax, esp
not eax
dec ecx
and esi, 0x4f0721a0
jnp 0xe7151e
inc ecx
setno dh
ror eax, 3
mov esi, 0x29b0f29e
call fcn.00e555c3
mov cl, byte [esi]
push 0x321a8b0a
push 0x2021ad3c
mov dword [esp + 8], 0x2c28541a
movzx ax, byte [esi + 2]
add esi, 2
push 0x4a107db7
pop edx
xadd byte [esp + edx - 0x4a107dac], dl
imul cl
lea edx, [edx - 0x1ae22cdb]
jmp 0x1168ff1

Function at 0x118c1da
Capabilities:
Encode data using base64

Disassembly:
cpuid
jne 0x11cbd23
jns 0xc9d001
dec eax
cdq
not edi
and dl, 0xbb
inc ecx
rol ebp, 0xfd
not al
inc ecx
push esp
inc edx
xor dword [esp + eax*8 - 0x1b8], edi
inc ecx
rol ebp, 0x46
cbw
inc ecx
mov ecx, 0x41a3631a
inc ecx
pop esp
inc ebp
movsx ebx, ch
sal ax, 0x86
inc cx
inc ebx
dec eax
arpl di, di
dec eax
cwde
dec eax
add ebx, edi
inc ecx
imul ecx
cdq
inc dx
mov eax, dword [ebp + ebp - 0x1f8]
inc edx
mov cl, byte [ebp + ebp*2 - 0x3ee]
add edx, 0x8b99bcb4
inc cx
sbb eax, 0x4166eb0c
sal ecx, 0x66
dec ecx
lea ebp, [ebp + ebp - 0x1f6]
inc cx
sbb ebx, 0x44664824
imul ebp, esi
inc ecx
not cl
sal ax, cl
inc bp
add ebp, ebp
adc dl, 0x21
inc dx
mov dword [ebp + ebp - 0xe890], eax
inc ecx
push ecx
dec edx
mov dword [esp + ebp - 0xe890], ebx
ret
Function at 0x118ca47
Capabilities:
Encode data using base64

Disassembly:
dec eax
mov dword [esp], edi
pushfd
pop esi
dec eax
mov dword [esp], esi
dec eax
mov esi, eax
inc eax
add bh, bh
or di, di
dec eax
shr edi, 0x79
dec eax
adc edi, edx
call fcn.00eac85f
bts dx, dx
neg edx
adc cl, 0x8d
neg edx
or edx, edx
shl edx, 0x7a
xor bl, cl
or dx, dx
rol edx, 0x33
adc ecx, esp
mov dword [ecx + edx*2 - 0x4000], eax
movzx ecx, dl
lea ecx, [edx + ecx - 0x6277d1e0]
lea edx, [edx*2 - 0xb4a23f2]
movzx ecx, byte [esi - 6]
sub esi, 6
movsx eax, dl
not ax
xor cl, bl
sub cl, 0x2b
rol cl, 1
and edx, 0xe7b4ba88
not cl
btc edx, eax
adc cl, 0x9c
sar eax, 0x41
call fcn.00c5343c

Function at 0x1194b89
Capabilities:
Encode data using base64

Disassembly:
movzx edi, byte [eax]
jmp 0xef4f29
xor edi, edx
call fcn.011799e3
push 0x4998371e
mov ecx, dword [esp]
jmp 0xee4305
lea esp, [esp + 0x14]
jne 0xeb5f38
mov edi, 0x3891d3c
pop edi
mov eax, 0xa73c74a6
bt ax, ax
lea ecx, [eax + eax*2 - 0x45d673fd]

Function at 0x1198fae
Capabilities:
Encode data using base64

Disassembly:
pop eax
xor ebx, ecx
and al, 0xc
adc edi, ecx
lea edx, [edx + eax*2 - 0x6046855d]
neg edx
rdtsc
call fcn.00e7894e
shl eax, 0xa8
rol ecx, 1
mov dword [esp + eax*4], 0x8db12b09
jmp 0xc418cd

Function at 0x119df71
Capabilities:
Encode data using base64

Disassembly:
mov eax, ecx
inc ecx
dec esi
dec esi
mov dword [esp + ebx - 0xa08], esp
dec eax
cdq
inc esi
xor dword [esp + ebx - 0xa08], esi
inc ebp
movsx eax, cl
inc cx
xchg eax, edi
dec esi
mov esp, dword [esp + ebx*8 - 0x5078]
dec ecx
lea ecx, [ecx + edx + 0x29b5dbbe]
inc sp
bt edx, ebx
inc eax
or cl, bh
dec ebp
arpl si, si
movzx esi, dx
inc ebp
movsx ebp, ax
inc ecx
sets ch
dec ecx
adc ebx, esi
inc si
mov ebx, dword [ebp + ebx*8 - 0x5080]
push esi
dec eax
mov dword [esp + eax - 0x76177b94], edi
rol dl, 0x24
inc sp
mov ebp, dword [eax + ebp - 0x76177b9a]
inc esp
xchg dword [esp + eax - 0x76177b9c], eax
inc esp
movzx esi, byte [esp + edx + 7]
call fcn.00c9739e

Function at 0x11a637e
Capabilities:
Encode data using base64

Disassembly:
bswap eax
mov dword [esp + edx], 0x9a9a459f
not cl
neg eax
sal edx, 0x94
xor eax, 0xf13c2594
or edx, 0xfda8f52e
jno 0xc24156
inc ecx
not ebx
inc ebp
add ebx, eax
dec eax
shr ecx, 0x7f
inc ecx
ror ebx, 1
dec ecx
div ebp
cwd
inc esp
movzx esi, dl
inc edi
lea ebx, [ebx + ebp*8 - 0x7a6e42a]
movzx esi, byte [esp + eax*2 - 1]
dec esp
mov dword [esp + eax*2 - 2], esp
inc esp
movzx esp, dx
inc sp
sub ecx, ecx
inc esp
xor dword [esp + eax*4 - 4], ebx
cbw
inc ecx
pop esp
inc ecx
movsx edi, cl
dec ebp
arpl bx, bx
inc ecx
imul edx
dec ecx
adc ebx, ebx
inc cx
ror esi, 0xc7
dec eax
or eax, ebx
jmp eax
Function at 0x11a920c
Capabilities:
Encode data using base64

Disassembly:
cbw
imul edx, edx
neg edx
or cx, ax
not cx
mov eax, edx
shl dl, 0xa5
mov word [edi + edx - 0x10735100], cx
not edx
lea ecx, [edx*8 + 0x7b105705]
and eax, edx
mov ecx, dword [esi + eax - 0xc0]
seto al
lea esi, [esi + eax*8 + 4]
xor ecx, ebx
bts ax, dx
neg ecx
bswap eax
lea ecx, [ecx + edx + 0xf14cb8c]
lea eax, [edx + edx*4 + 0x2897aa3c]
shl edx, 0x97
not ecx
xor ecx, 0x751f023d
shl ax, 0x8a
xor ebx, ecx
or dx, 0x232c
jo 0xc0e955
adc ebp, ecx
cwd
bts ax, dx
dec dx
jmp ebp
not edx
xor ecx, edx
mov dword [esp + eax*2 - 0x50], eax
shr byte [esp + eax - 0x27], 0x44
ror ecx, 1
call fcn.00c2bba1
mov edx, 0x7c1d5faf
xchg dh, dl
lea edi, [edi + edx - 0x7c1daf63]
push edx
xadd byte [esp + edx - 0x7c1daf5c], dh
and edx, dword [esp + edx - 0x7c1d7c5f]
mov edx, dword [edi + edx*2 - 0x503a58be]
xor edx, ebx
sub edx, 0xb85950f
rol edx, 3
push 0xcfb7412c
pop eax
inc al
add edx, 0x921d052b
call fcn.00b5634b
not edx
add edi, eax
movzx eax, dx
or dl, 0x91
adc cx, cx
mov eax, dword [esi + edx*4 - 0x3000]
neg dx
sbb dx, dx
mov ecx, dword [esi + edx*2 - 0x1fffe]
xor edx, edx
push ebx
cpuid
push 0x16971ea5
call fcn.01191edb
mov ecx, 0x819d4420
movsx eax, cl
mov cx, word [edi + eax - 0x20]
shl eax, 0x87
dec eax
lea edx, [eax + 0x4fbda4a9]
mov ax, word [edi + eax*8 - 0x7ff6]
lea edi, [edi + edx - 0x4fbdb4a6]
jno 0xe6d9b4
add byte [eax], al
add byte [ebx + 0x6c], dl
jo 0x11a92c8
Function at 0x11a9d01
Capabilities:
Encode data using xor

Disassembly:
inc ecx
add ebx, 0xff068003
inc ecx
movzx edi, dx
dec al
dec eax
lea esi, [edi + 0x14b0832d]
inc ecx
neg ebx
inc ecx
bswap ebx
dec esp
lea esi, [esi*8 - 0x30f6dfd1]
inc esp
movsx eax, bh
inc ecx
dec ebx
inc edx
inc dword [esp + ecx*4 - 0x371bc3d0]
dec esi
mov dword [esp + ecx - 0xdc6f0e3], esp
inc ecx
mov esp, 0x9725dc38
inc esi
xor dword [esp + ecx*2 - 0x1b8de1de], ebx
call fcn.00c64419
mov edx, 0x3597dc13
inc esp
mov ebp, dword [ebp + edx*2 - 0x6b2fb826]
xchg dh, dl
inc esp
mov edx, edx
movsx eax, dl
inc ebp
movzx ecx, byte [edi + edx - 0x359713dc]
inc ebp
xor cl, ah
inc ecx
inc cl
inc esp
movzx ebx, al
inc ecx
ror cl, 1
movsx esi, al
inc ecx
shl ebx, 0xbd
inc ecx
neg cl
inc ecx
xor cl, 0x32
mov edi, 0x1f281cb9
inc cx
sar edx, 0xe1
inc ebp
xor ah, cl
dec eax
bswap eax
dec eax
bt esi, esi
dec esp
add ecx, esp
dec eax
or edi, edi
bts ax, 0x3c
shl dl, 5
inc ebp
mov dword [ecx + edx*2 - 0x6b2e2700], ebp
inc ecx
mov edi, dword [edi + edx - 0x3597137f]
inc esp
movzx ebp, al
inc ebp
movzx ecx, ch
inc ecx
xor edi, esp
dec esp
lea eax, [eax*4 + 0x1c099a39]
dec eax
cdq
rol edi, 2
inc ecx
shr ebx, 8
mul al
inc ecx
inc ch
sbb edi, edx
dec esp
and edx, esi
ror edi, 1
dec eax
sar esi, 0x7d
xor edi, edx
inc ecx
div dl
inc ecx
push esp
dec ebp
bt edx, eax
inc eax
and dh, 0xb7
shr dl, 7
xor dword [esp + edx*8 + 0x7f8], edi
cdq
dec ecx
imul esi, edx
inc ecx
pop esp
dec ebx
lea ecx, [ecx + ebp - 0x7ec987fe]
inc ebp
movzx esi, cl
neg dl
dec eax
arpl di, di
dec ebp
xor edx, esi
dec eax
adc ebx, edi
inc esp
xchg cl, ch
dec esp
sub ebp, eax
inc ecx
push eax
dec esp
add esi, dword [ebp + edx*8 + 4]
inc ecx
push ebp
inc ecx
movzx edi, bl
dec eax
lea ebp, [ebp + edx + 0xc]
dec eax
xadd dword [esp + edx*4 + 8], esi
inc ecx
not edx
inc si
add ecx, dword [edx + edi + 5]
dec eax
ror dword [esp + edx*4 + 1], 0x3e
dec ebp
lea edi, [edi + edx*2 + 7]
inc bp
xor ecx, esp
dec ebx
lea ecx, [ebp + ebx*4 - 0x435d3273]
inc ecx
xchg ch, dl
inc cx
dec ecx
cdq
inc ecx
shl edx, 0x8f
or dword [esp + edx + 2], esi
inc cx
xor ecx, 0x81482ca6
adc al, 8
or ch, byte [ebx + 0x1d]
jnp 0x11a9e61
shr byte [edx + 0x3242ffae], cl
invalid

Function at 0x11b3b1d
Capabilities:
Encode data using base64

Disassembly:
dec eax
mov dword [esp + edi*2 - 0x74380156], ebx
ret
dec edx
mov dword [esp + ecx - 0x75a87eaf], 0x3a1c00ab
dec eax
lea edx, [esp + edx + 0x10]
dec ecx
add edx, 0x70b798b1
pop edi
inc edx
mov dword [edx + eax - 0x5eba60f7], eax
inc sp
adc eax, dword [esp + edi - 0x3a1c00a8]
inc edx
movsx eax, byte [esp + eax - 0x5ebaf99f]
jae 0xca0467
Function at 0x11babd5
Capabilities:
Encode data using base64

Disassembly:
add ax, ax
rol cl, 1
and al, 0xa5
call fcn.01176a30
movzx ecx, byte [esi + eax - 0x6af9e203]
rol al, 0x21
xor cl, bl
bswap eax
push eax
lea eax, [eax + eax*8 + 0x3434ed21]
ror cl, 1
add cl, 7
add ax, word [esp + eax - 0x602fb1d6]
rol ax, 0x62
sar eax, 0x61
not cl
shr ax, 4
ror cl, 1
add cl, 0xae
cbw
inc word [esp + eax*2 - 0x602e0091]
neg cl
pop eax
neg word [esp + eax - 0x4e2f96a]
ror cl, 1
xor bl, cl
inc dword [esp + eax - 0x4e2f96a]
sub eax, eax
lea ecx, [esp + ecx + 4]
setb al
mov dword [ecx + eax], edx
sar word [esp + eax*4 + 1], 0xa8
call fcn.00c64edb
movzx edx, ax
mov edx, dword [ebp + edx*2 - 0x1c480]
or ax, cx
bt ecx, ecx
mov dword [esp + ecx - 0x6af9e242], 0xbb207d91
lea ebp, [ebp + ecx - 0x6af9e23a]
and al, 0xbf
jne 0x1182270
mov ecx, 0x7a95b91c
lea eax, [ecx + ecx - 0x69c5adeb]
movzx ecx, byte [ebp + ecx - 0x7a95b91d]
mov ebp, 0x27118da5
sal ebp, 0xd
xor cl, bl
bt eax, ebp
imul al
not cl
btr bp, 0x80
movsx edx, al
cwde
sbb cl, 0xc
idiv ebp
jmp 0xc360a8

Function at 0x11c807e
Capabilities:
Encode data using base64

Disassembly:
dec dword [esp + eax*2 - 0x65a2280a]
lea esi, [esi + eax*2 - 0x65a22806]
inc eax
mov dword [esp + eax*2 - 0x65a2280c], edx
jbe 0xc8b356
mov edx, dword [esi + edx - 0x20c160c7]
jg 0xc1e11c
inc edx
mov dword [esp + eax*2 - 0x13b688c2], eax
xor ecx, 0x3d878003
dec al
mul dword [esp + eax - 0x9db4460]
dec ecx
sub dl, dh
sal dword [esp + edx*4 - 0x18499d8], 0xd0
sar eax, 0x64
ror ecx, 1
btr eax, edx
mul eax
xor ecx, 0x59ac282e
sar dword [esp + eax*2 - 0x65a21c48], 0x56
shl byte [esp + eax*2 - 0x65a21c47], 5
div al
ror ecx, 2
lea ecx, [ecx + eax + 0x76de1820]
add edx, 0x25af7118
mov dword [esp + eax*2 - 0x65a228c8], edx
inc dl
xor ebx, ecx
add edi, ecx
mov ecx, 0xe9a1c935
add al, 0xa1
jp 0xc53068