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

Disassembly:
jae 0x2e12c57
lea esi, [esi + ecx - 0x77238bd5]
imul dl
neg dword [esp + ecx - 0x77238bd7]
sbb dword [esp + ecx - 0x77238bd7], ecx
jnp 0x2e1e390
add ebp, edx
and cl, 0xaf
sub cx, 0x958c
lea edx, [ecx + eax*8 - 0x78ccb0f6]
movzx ecx, byte [edx + edi - 0x291c8a3a]
lea edi, [edx + edi - 0x291c8a3a]
xor cl, bl
or eax, 0x994f8bd
dec al
jl 0x2e762dd
not dword [esp + ecx - 0x3c13cf01]
xor bl, dl
xor byte [esp + ecx - 0x3c13cf01], cl
push ecx
lea edx, [esp + edx + 8]
jae 0x2e70a2c
mov ecx, 0xca380402
push ecx
call fcn.021c2130
lea eax, [esp + eax + 0xc]
mov byte [eax + ecx*8], dl
call fcn.0219e7e8
salc
scasd eax, dword es:[edi]
sub ch, byte [ecx]
cmp dword [0xc564289d], esp
adc dword [ebp - 0x13], edx
sub byte [ebp + eax*8 + 0x51], ah
add dword [ecx + 0x29c56428], edi
invalid
mov eax, 0xf11cab28
dec ecx
xor ebx, ecx
sal byte [esp + 1], 0x83
movsx edx, ax
adc ebp, ecx
call fcn.02e84eae
rol ecx, 1
pop edx
add edx, 0xff3393a4
jmp edx
add ebp, eax
or dx, 0x4790
mov dword [esp + ecx - 0x9d18], edx
mov ax, word [esi + ecx*8 - 0x4e8e0]
movzx edx, byte [edi + ecx*4 - 0x2746c]
call fcn.021ba761
dec al
mov dword [esi - 4], edx
movzx ecx, al
lea edx, [eax + eax*2 - 0x7a6f53e9]
mov edx, dword [ecx + edi - 0x15]
lea ecx, [ecx + eax*4 + 0x5e807593]
not ecx
xadd ax, cx
xor edx, ebx
shr ecx, 0xbf
ror edx, 3
sal al, 0xc6
inc edx
inc cx
push eax
inc cx
bswap edx
or eax, ecx
lea eax, [ecx + ecx*4 + 0x7a3d1a23]
lea edx, [edx + eax + 0x1077bbee]
jno 0x1b82fa9
mov ecx, dword [edi]
add edi, 4
xor ecx, ebx
mov edx, 0x6d891137
mov eax, edx
dec ecx
sar dl, 0x47
lea eax, [edx + edx*4 + 0x73999330]
rol ecx, 3
lea ecx, [ecx + edx*2 - 0x3f6b31f0]
neg eax
shr dl, 4
ror ecx, 1
not dx
add edx, 0x99a70181
sbb ax, 0x4612
dec ecx
inc ax
shl edx, 0x5c
xor ebx, ecx
add ebp, ecx
lea ecx, [eax + 0x653a0b08]
add ecx, 0xa92faf11
xor dl, byte [edx + esi]
sar eax, 0x5d
mov al, byte [esi + ecx - 0x77238bd5]
push ecx
jp 0x1ba991b
rol eax, 8
xor edx, 0x8a36e1b3
pop ecx
shr ax, 0x46
dec cl
neg edx
sal ecx, 0x7b
sal cx, 0x68
ror eax, 8
xor edx, 0x230b060e
inc eax
dec cl
xor ebx, edx
jmp 0x1bedb12
mov word [esi + ecx - 0x77238bd7], ax
dec ecx
lea eax, [ecx + 0x449a329e]
mov dword [esp + ecx - 0x77238bd6], ebp
ret
sal cl, cl
rol dword [esp + ecx - 0x3c13cf02], cl
mov byte [edx + ecx*2 - 0x78279e04], al
mov dx, word [esi + ecx*2 - 0x78279e02]
lea esi, [esi + ecx*2 - 0x78279e00]
movzx eax, byte [edi + ecx - 0x3c13cefd]
sete byte [esp + ecx*2 - 0x78279dff]
ja 0x2ed1446
inc cl
neg cl
call fcn.01ba3d1f
xor ecx, ecx
lea edi, [edi + ecx*2 + 6]
ror cl, 0x87
mov byte [esp + ecx*4 + 6], ch
ror cl, 0xa1
xor al, bl
ror al, 1
jmp 0x2ee7947
add cx, 0x120a
sbb cl, 0xb2
sub al, 0xbf
ror cx, 0x4d
jae 0x21bea9e
neg al
rol dword [esp + ecx - 0x92bc], 0x65
rol al, 1
not al
push ecx
ror al, 1
add al, 0x94
rol al, 1
xchg word [esp + ecx*2 - 0x1257d], cx
shl cx, 0xc7
xor bl, al
jmp 0x21ac0ae
Function at 0x21e7682
Capabilities:
Get number of processors

Disassembly:
mov eax, dword [edi + 1]
add edi, 5
xor eax, ebx
mov ecx, dword [esp]
dec ecx
bswap eax
or dword [esp], 0x1caba5
call fcn.02e41077
mov dword [esp], eax
add dl, 0xf
xor bl, dl
push eax
rol word [esp + 2], 0x68
lea edx, [esp + edx + 8]
neg ax
pop eax
lea eax, [eax + eax - 0x4dd1507f]
mov dword [edx], ecx
jbe 0x21d6d5b

Function at 0x21ec0fd
Capabilities:
Get number of processors

Disassembly:
xor bl, dl
rol cl, 0x41
lea edx, [esp + edx + 4]
jae 0x2e3af3a
mov dword [esp + ecx - 0x5e5bb9fd], 0xecb9d1a3
rol dword [esp + ecx - 0x5e5bb9fd], cl
mov dword [edx + ecx - 0x5e5bb9fd], eax
adc dword [esp + ecx - 0x5e5bb9fd], ecx
or byte [esp + ecx - 0x5e5bb9fb], ch
add word [esp + ecx - 0x5e5bb9fc], 0xfc2e
mov eax, dword [esi + ecx - 0x5e5bb9f9]
lea esi, [esi + ecx - 0x5e5bb9f5]
dec cx
shr cl, 0xe4
mov edx, 0xf9abab31
movzx edx, byte [edi + ecx - 0x5e5bb90e]
xor dl, bl
sar dword [esp + ecx - 0x5e5bb90f], 0xfe
adc dword [esp + ecx - 0x5e5bb90f], ecx
dec dl
not dl
or ecx, dword [esp + ecx - 0x5e5bb90f]
jno 0x2e75ca4
jb 0x2edd3f6
rol dl, 1
add dl, cl
add dword [esp + ecx - 0x5e5bb90f], 0x80a8f41f
setb cl
dec word [esp + ecx - 0x5e5bb8ff]
xor bl, dl
or word [esp + ecx - 0x5e5bb8ff], 0x1e01
sal ecx, 0x3e
lea edx, [esp + edx + 4]
call fcn.02ee07ac
neg eax
neg cl
sub dword [esp + ecx*4 - 0x4e4e479c], ecx
dec eax
or ecx, 0x1c32adb7
mov byte [esp + ecx - 0x1fb3bdf5], ch
rol eax, 1
xor edx, dword [esp + ecx*4 - 0x7ecef7dc]
not eax
dec eax
sub word [esp + ecx*4 - 0x7ecef7da], dx
setae byte [esp + ecx - 0x1fb3bdf4]
xor ebx, eax
rol dword [esp + ecx*2 - 0x3f677bee], cl
add ebp, eax
sal dx, 0x83
inc edx
movzx ecx, byte [edi + ecx - 0x1fb3bdf7]
movsx eax, byte [esp]
lea edi, [edi + eax*2 - 0xfd]
shl word [esp + eax*2 - 0xfe], 0x8a
xor cl, bl
pop edx
jmp 0x2efef0a
mov ah, byte [ebx]
pop ebp
mov esp, 0x4f0fe82a
stc
inc dword [ecx + 0x1d0501e2]
inc ebp
and edx, 0x451d0501
neg cl
call fcn.02eaa9b7
inc ebx
test al, 0xb8
js 0x2efef00
bound ebx, qword [ecx]
mov ch, 0xfe
invalid

Function at 0x21ef767
Capabilities:
Encode data using xor

Disassembly:
call fcn.02e7d0d5
neg cx
inc ecx
pop ebx
dec esp
lea edx, [ebp + ecx - 0xdd42942]
call fcn.01bba4cc
lcall 0x3ce0, 0xb85d7179
nop
xor ebx, dword [edx - 0x5192fa63]
cli
scasb al, byte es:[edi]
call 0xfce530b0
scasb al, byte es:[edi]
call 0xfd1518da
scasb al, byte es:[edi]
call 0xfc5584fc
scasb al, byte es:[edi]
call 0xfc25dd72
scasb al, byte es:[edi]
call 0xfc2d7920
scasb al, byte es:[edi]
call 0xfc95c91e
insd dword es:[edi], dx
sal dword [esi - 6], 1
scasb al, byte es:[edi]
call 0xfd1d4d40
scasb al, byte es:[edi]
call 0xc0ff091a
pop ebp
dec ecx
test byte [ecx - 0x1d7e], 0xff
inc dword [ecx + 0x18]
clc
mov cs, word [edi - 0x19455549]
or al, 0xd1
or dword [esi - 0x4a], eax
push esi
jae 0x21ef7ad
or dword [esi - 0x4a], ebp
push esi
jae 0x21ef7ab
popfd
invalid
Function at 0x21f0ff9
Capabilities:
Get number of processors

Disassembly:
dec edi
mov esp, dword [ebp + eax*4 - 0x1ac]
rol eax, 0x6f
inc edx
sbb dword [esp + ecx*2 - 0x139ab26], ecx
inc ecx
sar edx, 0x68
dec esi
mov dword [esi + ecx - 0x9cd59d], esp
dec ecx
lea esi, [ecx + esi - 0x9cd59d]
pop ebp
inc ecx
pop eax
jae fcn.02e1aa1a

Function at 0x21f6f38
Capabilities:
Encode data using base64

Disassembly:
ror ax, 0xe5
inc eax
inc dl
ror eax, 0x1d
mov dword [esp + eax - 0x67b24b7f], eax
xor dl, 0x30
inc byte [esp + eax - 0x67b24b74]
mov word [esp + eax - 0x67b24b7a], 0xe9b5
xor bl, dl
pop eax
call fcn.02f0596b

Function at 0x221352a
Capabilities:
Encode data using base64

Disassembly:
sets cl
add cx, word [eax + edx - 0x874b]
sar dx, 0x86
shr word [esp + edx*8 - 0x7f0e3], 6
lea ebp, [ebp + edx*8 - 0x7f0ea]
mov word [ebp + edx*2 - 0x1fc3a], cx
xchg dword [esp + edx - 0xfe19], edx
mov ecx, edx
sub esi, 4
xor dword [esp + 4], edx
mov ecx, dword [esi]
mov dword [esp], edx
adc dx, dx
sbb dword [esp + 4], edx
xor ecx, ebx
mov eax, dword [esp + 4]
bswap ecx
call fcn.0223d692

Function at 0x221357d
Capabilities:
Encode data using base64

Disassembly:
shr ecx, 8
xor ecx, ebx
inc edx
xor ecx, 0xe90b012d
dec byte [esp + 6]
dec eax
push 0x96273996
jmp 0x1b9fc2e
jmp 0x2203e1a

Function at 0x2216296
Capabilities:
Encode data using base64

Disassembly:
sub esi, 4
mov dword [esp + 4], 0x8c114185
pop eax
xor ecx, ebx
mov edx, dword [esp + 4]
xor ecx, 0x17896c04
bswap ecx
inc byte [esp + 2]
neg dl
add byte [esp + 2], 0xbc
xor ecx, 0x15848902
push edx
inc dword [esp + 2]
ror ecx, 3
rol edx, 0x3c
movsx eax, dl
xor ebx, ecx
add edx, 0xf8323827
add edi, ecx
lea edx, [edx + ebp - 0x122a4497]
not eax
mov dword [ebp - 2], edx
call fcn.021ed5ce

Function at 0x2217378
Capabilities:
Get number of processors

Disassembly:
dec eax
neg ebp
jne 0x21f4708
or cl, al
dec dl
bswap edx
not cl
mov eax, 0x310e6f2c
rol dl, 0xc1
mov word [eax + edi - 0x310e6f2a], cx
mov edx, dword [eax + esi - 0x310e6f2c]
xor edx, ebx
rol ax, 0x8e
lea edx, [edx + eax*4 - 0x87d636d]
movzx ecx, al
not edx
ror edx, 1
sal eax, 0xda
xadd eax, ecx
sbb edx, 0xf4002fa3
call fcn.02e482ea
inc esi
xor dword [esp + edi*2 - 0x1a270000], edx
shr ebp, 0x9e
inc ecx
pop ebx
inc cx
shl edi, 0x6c
inc ecx
setnp dh
dec ebp
arpl dx, dx
inc ebp
adc al, ah
inc cx
sar esp, 0xc3
inc bp
adc eax, eax
dec ecx
adc edi, edx
call fcn.02e3cdee
dec ebp
lea ecx, [esi - 0x377d2cc8]
dec ecx
rol esp, cl
inc ecx
xor edx, 0x913acc19
inc edi
lea edx, [edx + edi*2 - 0x69d784b5]
dec ebx
lea ebp, [esp + ecx*2 + 0x4d9cdc25]
dec edx
mov dword [esp + edi*4 - 0x344e0000], eax
dec ecx
not eax
inc ecx
xor edx, 0x3190f05
inc esi
xchg dword [esp + edi*4 - 0x344dfffc], eax
dec eax
shl ecx, cl
dec edx
xor dword [esp + edi*4 - 0x344e0000], 0xe3b51714
inc ecx
ror edx, 2
dec edx
rol dword [esp + edi*2 - 0x1a270000], 0xf2
inc ecx
xor edx, 0x653f7003
dec esi
xor dword [esp + edi*2 - 0x1a270000], ebp
inc dx
neg dword [esp + eax*2 + 4]
dec esi
mov dword [esp + edi - 0xd138000], ebx
jne 0x21c1bc4
Function at 0x221744f
Capabilities:
Get number of processors

Disassembly:
sub dword [esp + ecx - 0x58fa7d98], 0x383c41a0
jno 0x21ae568
inc word [esp + eax*2 - 0x19e]
lea ecx, [eax*8 + 0x4d0ac939]
xor edx, 0xd99ab09f
sub eax, eax
xor al, al
xor ebx, edx
add ebp, edx
mov dword [esp + eax*4], ebp
ret
mov eax, dword fs:[ecx]
mov ecx, dword [esp + 1]
shl byte [esp + ecx - 0x1e58fa7a], 0x64
mov dword [ecx + esi - 0x1e58fa7d], eax
jne 0x2e56817
adc ebp, edx
mov ecx, dword [esi + ecx - 0x58fa7d9c]
jmp 0x1b91552
rol edx, 2
lea ecx, [eax*4 + 0x6d9ae09b]
lea edx, [edx + eax*4 + 0x1baab3b4]
xor edx, 0x24b69c09
not word [esp + eax - 0x766e]
neg edx
push eax
xor ebx, edx
add edi, edx
mov dword [esp + eax*2 - 0xece2], eax
sal al, cl
pop ecx
pop edx
pop eax
jbe fcn.021b7ec4
ror edx, 2
push ecx
inc edx
ror edx, 3
xor ebx, edx
jmp 0x1b75277
mov dword [esp + ecx*2 - 0x3cb1f4fa], ebp
ret 4

Function at 0x221ad5f
Capabilities:
Get number of processors

Disassembly:
mov dword [esp], 0x85c2f2ca
call fcn.022040b8
invalid

Function at 0x221e789
Capabilities:
Encode data using base64

Disassembly:
mov ecx, 0xefb28097
jmp 0x22bfbd0
lea esp, [esp + 8]
jne 0x2f05d89
jmp 0x21ca7a8
pop edi

Function at 0x22216f6
Capabilities:
Encode data using base64

Disassembly:
movzx ecx, byte [esi + edx*2 - 0x7e7baed4]
mov dword [esp + edx - 0x3f3dd76a], 0x4614029d
ror dx, 0x87
xor cl, bl
inc cl
dec dword [esp + edx*2 - 0x7e7bab5c]
mov eax, 0xc803be14
sal dword [esp + edx - 0x3f3dd5ae], 0xa5
not cl
ja 0x1ba59f1

Function at 0x222abc2
Capabilities:
Encode data using base64

Disassembly:
mov edx, dword [esi + 4]
sub cx, word [esp + 9]
mov dword [esp], ecx
shr ecx, 0x68
mov cl, byte [esi + ecx*2 - 0x17db99e]
jne 0x21e0e97

Function at 0x222c4a7
Capabilities:
Encode data using base64

Disassembly:
sal ax, 0xa3
lea edx, [ecx + edx + 0x699485dc]
call fcn.021adec8

Function at 0x222c4be
Capabilities:
Encode data using base64

Disassembly:
lea esi, [eax + esi - 0x617048b1]
movsx edx, ax
pop eax
pop edx
pop edx
jno fcn.02e8367f

Function at 0x223d479
Capabilities:
Encode data using base64

Disassembly:
lea edx, [esp + edx + 0xc]
sar ecx, cl
sbb ecx, 0x5285cfa5
mov byte [edx], al
mov dword [esp + 4], ecx
mov dword [esp + 8], ecx
push ecx
movzx eax, byte [esi + 1]
xor al, bl
xor al, 0xbd
sub al, 0xa1
movzx edx, byte [esp + 0xc]
xchg edx, ecx
neg al
sub dl, dl
neg edx
not al
sar edx, 0x4e
inc al
neg al
xor ecx, edx
sub cx, cx
sbb ecx, ecx
not al
adc dl, 0x22
sub cl, cl
call fcn.02e464a5
movzx edx, byte [edi]
mov eax, 0x7e246001
xor dl, bl
shr byte [esp + eax - 0x7e245ffe], 0x66
ror dl, 1
jmp 0x2eb2faf
ror al, 7
sbb dl, 0xbf
call fcn.02ec68ab
Function at 0x224083c
Capabilities:
Encode data using base64

Disassembly:
sar eax, 0x7c
mov ebx, dword [esp + ecx*8 - 0x214f0]
dec dl
bswap edx
mov ebp, dword [esp + ecx*4 - 0x10a70]
push ecx
mov esi, dword [esp + ecx - 0x428b]
jo fcn.02ed84fc
sbb edx, 0xa12d26af
dec edx
mov ecx, dword [esi + ecx - 0x429f]
mov dword [esp + edx - 0x7ad5d944], edx
mov dword [esp + edx - 0x7ad5d94c], eax
lea edx, [eax + eax*4 - 0x63ed1e77]
lea esi, [esi + eax + 4]
adc al, al
xor ecx, ebx
ror edx, 0x1a
sub al, byte [esp + edx - 0x4b86262]
setp al
xor ecx, 0x879117a5
not edx
sal ax, 0xab
mov dword [esp + eax + 8], eax
ror ecx, 3
or eax, 0x838582e
ror edx, 0x9c
jp 0x2ed5ece
lea ecx, [ecx + eax - 0x6cf4c3e3]
rol ecx, 3
sar dx, 0xc1
sal byte [esp + eax*2 - 0x1070b056], 5
push edx
neg ecx
sal dword [esp + eax*2 - 0x1070b059], 0x44
rol word [esp + eax - 0x8385822], 0x2f
sub dx, ax
xor ebx, ecx
sal byte [esp + eax*2 - 0x1070b05a], 0x41
lea eax, [eax*8 + 0x24b0e8a6]
adc ebp, ecx
add dword [esp + eax - 0x6673aa09], edx
movsx ecx, byte [esp + eax - 0x6673aa14]
mov dword [esp + eax - 0x6673aa16], ebp
ret 0x18
Function at 0x2e1a3d5
Capabilities:
Encode data using base64

Disassembly:
mov ecx, dword [edi + eax*8 - 0x7ec]
lea eax, [eax*2 + 0x220732a0]
call fcn.021b1b7b
call fcn.02ed0cba
mov dword [ebp], eax
xor dword [esp], 0x6b895a30
sbb esi, 4
jmp 0x2e2466a
mov ecx, dword [esi]
jmp 0x2eae8ca

Function at 0x2e1ca69
Capabilities:
Get number of processors

Disassembly:
mov dword [edx], ecx
mov edx, dword [edi - 4]
pop eax
mov ecx, 0x263c7210
xor edx, ebx
and cx, cx
not edx
xor edx, 0x3295fb15
inc edx
jmp 0x2ef7f5d
jmp fcn.02e3af8c

Function at 0x2e1d134
Capabilities:
Encode data using xor

Disassembly:
shr ecx, 0xd7
xor ebx, eax
call fcn.01b78758
invalid

Function at 0x2e22324
Capabilities:
Encode data using base64

Disassembly:
bswap edx
call fcn.021f2c7d
mov byte [ecx], dl
mov ecx, dword [esp]
movsx eax, byte [esp]
call fcn.01b9789c
inc ecx
pop esi
dec edx
jmp 0x2e64384
dec ebp
arpl di, di
dec ecx
add edi, edi
dec eax
mov dword [esp + eax - 0x7e711b16], edi
ret
jmp 0x22092f7
inc bp
movzx esi, byte [esp + ecx*2 - 0x208b8]
inc ecx
shr ebp, cl
inc sp
mov dword [esi + ecx*4 - 0x41172], esi
dec eax
mov dword [esp + ecx - 0x1045c], 0x7e966b2c
xadd al, ah
inc esp
movzx esi, dl
inc ecx
mov edx, dword [ebp + ebx - 0x14]
dec esp
mov dword [esp + ecx - 0x10454], ebp
dec eax
lea ebx, [ebx + ecx*2 - 0x208bd]
dec esp
lea esp, [ebp + ecx*8 - 0x5b724c50]
inc ecx
xor edx, ebx
jmp 0x2228af9
xor edx, 0x57121d92
ror dword [esp + ecx*2 - 0x208ac], 0xc6
bswap edx
dec eax
sub eax, 0x2f0d638f
ror edx, 1
dec eax
sar dword [esp + ecx*2 - 0x208b0], 0xa2
dec esi
lea eax, [ecx*2 + 0x61a8f30c]
jns 0x1be5651
dec al
ror ecx, 1
bswap ecx
call fcn.01b801a0
inc ebp
mov edi, dword [esi + ebx - 0x929a]
inc esp
xor ebp, edx
inc eax
xor ch, 0xa3
inc ebp
xor edi, ebx
inc ecx
neg edi
inc ecx
bswap ebp
inc ecx
xor edi, 0xc0f042f
inc ecx
mov ecx, 0xb4905597
inc esi
lea edi, [eax + edi + 0x257d66ec]
dec esi
lea esi, [ecx*4 - 0x53d03b43]
inc ecx
sub al, cl
inc bp
xadd ebp, ecx
inc ecx
neg edi
inc ebp
and ebp, ebp
inc ecx
not edi
dec eax
lea ecx, [ebp + ebp*8 + 0x308b9fa8]
inc ebp
xchg esi, ecx
inc cx
shl ebp, 9
inc ecx
inc edi
or dl, 0x2b
setg cl
dec ecx
xchg ecx, eax
inc ecx
bswap edi
inc ebp
mov esp, ecx
inc ecx
not edi
inc ecx
shr esp, 0x67
inc ebp
lea edi, [edi + eax - 0x2cc18b7b]
inc ecx
shr esp, 0xf8
inc ecx
sbb al, cl
inc esp
movzx edx, ch
inc ecx
push ebx
inc ecx
neg dl
inc esp
xor dword [esp + eax - 0x7e711b16], edi
inc ecx
pop ebx
push ebp
jmp 0x221779e

Function at 0x2e29291
Capabilities:
Encode data using xor

Disassembly:
not ecx
not edx
dec dx
xor ebx, ecx
call fcn.021e15cb
Function at 0x2e32bb1
Capabilities:
Get number of processors

Disassembly:
jge 0x2ef1294
call fcn.02efa735
mov eax, dword [esi]
mov edx, 0xad3e148f
lea ecx, [edx + edx*2 - 0x21528943]
movzx cx, byte [eax]
inc edx
add esi, 2
mov eax, edx
add eax, edx
sbb dx, dx
mov word [esi + eax - 0x5a7c2920], cx
lea edi, [edi + eax - 0x5a7c2924]
movzx ecx, dx
sar edx, 0xff
mov edx, dword [edi + ecx*2 - 0x1fffe]
add ecx, eax
push eax
pop ecx
xor edx, ebx
dec cl
rol ecx, cl
jne 0x2e2e6a6
dec eax
lea ebx, [eax + ebx - 0x50a0]
call fcn.02e42496
inc edx
bswap edx
sub eax, ecx
sbb eax, eax
inc edx
or cx, cx
call fcn.021ee487
sbb dword [esp + 0xf], 0x59399303
inc esp
xor bl, al
pop ebp
inc sp
xchg dword [esp + 0xb], eax
dec eax
lea eax, [esp + eax + 0x10]
inc sp
mov esi, dword [eax]
dec eax
sub esi, 2
inc ecx
push eax
inc esp
xadd byte [esp + 0xa], al
mov eax, dword [esp + 0x13]
inc sp
mov dword [esi + eax*8 - 0x284e0], esi
dec eax
adc dword [esp + eax*2 - 0xa137], eax
jl 0x2219cd2
inc ebx
mov byte [ecx + edx - 0x780], al
inc bp
or esp, eax
inc ecx
mov edx, ebp
inc ecx
mov eax, dword [ecx + ebx - 0x785]
jns 0x1b78edb

Function at 0x2e32fc2
Capabilities:
Get number of processors

Disassembly:
mov dword [esp + ecx], ebp
ret 4
mov dword [esp], eax
neg ecx
bswap ecx
shr edx, 0x66
lea edx, [edx*2 - 0x2241cdfa]
not ecx
neg ecx
lea eax, [edx + eax - 0x3d021d5]
xor ecx, 0x4b1ce439
not eax
lea eax, [edx*4 - 0x44c1abef]
xor ebx, ecx
add ebp, ecx
mov edx, dword [esi + eax - 0x484e8075]
mov eax, dword [esi + eax - 0x484e8071]
add edx, eax
mov eax, 0xe0272036
movsx ecx, ax
mov dword [esi + ecx - 0x202e], edx
shr ecx, cl
lea esi, [esi + ecx*8 + 8]
adc byte [esp + ecx + 2], al
shl al, 0xa5
jp 0x1bd5603

Function at 0x2e342e0
Capabilities:
Authenticate hmac

Disassembly:
mov dword [esp + 4], ecx
not ax
rol dl, 1
not eax
neg dl
call fcn.0222c6bb

Function at 0x2e3ab8c
Capabilities:
Encode data using base64

Disassembly:
shr cx, 0x2a
mov dword [esp + ecx - 0x26e90004], eax
neg edx
neg byte [esp + ecx*2 - 0x4dd20008]
and dword [esp + ecx - 0x26e90004], eax
lea edx, [edx + ecx*4 - 0x6a9ffe5f]
shr dword [esp + ecx*2 - 0x4dd20008], cl
call fcn.02e0d740

Function at 0x2e3af40
Capabilities:
Get number of processors

Disassembly:
inc al
not al
and cx, word [esp + ecx*2 - 0x79337293]
shr ecx, cl
not cx
sub al, 0xaf
ror word [esp + ecx - 0xe1a1], 0x4e
pop ecx
neg al
mov dword [esp + 4], 0x6f86f12c
xor bl, al
mov ecx, 0xf23a57a8
and cl, 0xbd
lea eax, [esp + eax + 0x14]
shr cl, 0xe5
xor ecx, ecx
mov word [eax + ecx], dx
lea edi, [edi + ecx*2 - 4]
ror byte [esp + ecx + 0xe], 0xa1
call fcn.01bafb4f
Function at 0x2e3b7d4
Capabilities:
Encode data using xor

Disassembly:
xor ebx, ecx
xchg dx, ax
jmp 0x1b8664a
add ebp, ecx
not edx
jmp 0x21a8eb9
call fcn.02e17a23
push ecx
pushfd
mov ecx, 0xf0bf4c31
mov ecx, dword [esp + ecx*2 + 0x1e8167a2]
mov dword [esp + 4], 0x805d8767
push dword [esp]
popfd
lea esp, [esp + 4]
call fcn.02f05847
inc eax
xor ecx, 0x1abb2b25
sub eax, 0xb7addf2c
lea ecx, [ecx + eax - 0x436dea1d]
push edx
ror ecx, 1
pop edx
xor ebx, ecx
add edi, ecx
shr dl, 0x46
lea edx, [edx + edx*8 + 0x7e344725]
movzx eax, byte [esi + edx - 0x6a8f472a]
mov ecx, edx
lea esi, [esi + ecx - 0x6a8f472a]
inc dl
neg ecx
xor al, bl
sub al, 0xbb
xor al, 0xae
ror al, 1
ror cx, 0x2d
inc cl
bswap ecx
sub al, dl
rol edx, cl
lea ecx, [ecx + ecx*4 + 0x32228f13]
neg edx
rol al, 1
xadd edx, ecx
sar cx, 0xcf
add dx, 0xeb1a
neg al
inc edx
xor bl, al
inc edx
push edx
lea eax, [esp + eax + 4]
call fcn.02e16241
dec ebp
lea edx, [edi + 0x5729ba93]
inc dx
sal dword [esp + ecx - 0x1e], 0x46
dec edx
lea esi, [esi + ecx - 0x20]
inc ecx
pop eax
dec ecx
lea ebp, [ebp - 0x5dd0c341]
shl ax, cl
dec ecx
xchg ecx, ebp
inc dx
shl dword [esp + ecx + 0x5dd0c33f], 0xe
inc cx
mov dword [ecx + esi + 0x5dd0c339], eax
inc edx
or byte [esp - 0x7ba7], 0x19
call fcn.02e82a9b
shr cx, 0x44
call fcn.0219333d
mov edx, dword [esi]
ror eax, 0xe1
movsx ecx, al
mov eax, dword [ecx + esi - 0xb]
shr ecx, 0x6e
neg ecx
lea esi, [esi + ecx*2 + 8]
sub ecx, 0x4a8d688
setle cl
mov dword [edx], eax
jmp ebp
shr edx, 0x9b
dec ecx
not ecx
neg al
not eax
lea ecx, [ecx + eax - 0x4e9d58d0]
neg ax
adc al, al
seto al
rol ecx, 1
bswap ecx
rol eax, 0x75
jb 0x1b852da
mov ecx, 0x62ad2d2b
mov ecx, dword [ecx + esi - 0x62ad2d2b]
mov eax, 0x3994a006
movsx edx, ax
mov eax, dword [esi + eax*2 - 0x73294008]
dec dl
mov edi, 0x46848bd0
clc
mov edi, 0xcafe8cd6
xchg dh, dl
not ecx
not eax
shl dx, 0x85
or ecx, eax
movsx eax, dl
mov dword [esi + eax + 4], ecx
mov edx, dword [edi + eax*4 - 4]
xor edx, ebx
xor al, 0x9d
adc eax, eax
bswap edx
ror eax, 0x19
sar ax, 0x69
rol edx, 3
call fcn.02e6e29c
lahf
stosd dword es:[edi], eax
mov dword [0x1c4f3375], eax
cmp bh, cl
push ebx
popal
sub ebx, dword [esp + 0x2b6103c0]
pushfd
mov esp, 0xcb1c28a9
push eax
mov dl, 0x93
pop eax
mov bl, 0xc6
adc al, 0xa6
mov dh, 0xaa
xchg byte [edx + 0x18], bh
xchg esi, eax
mov dh, 0xe2
cmp bl, byte [eax]
xchg esi, eax
imul dl
sub bl, byte [eax]
xchg esi, eax
out 0xde, al
push esi
sbb byte [esi], ah
xchg esi, eax
lcall 0xfe96, 0x261832d6
jno 0x21f4d05
in al, 0xfe
rol ecx, cl
xor edx, ebx
dec edx
or cl, ch
neg edx
movzx eax, cx
dec edx
ror ax, cl
neg edx
lea edx, [edx + ecx*4 - 0x42d1a506]
push eax
not edx
xor ebx, edx
push ecx
add ebp, edx
call fcn.01b97089
jg 0x1b95d14
inc cx
ror esp, 0xce
call fcn.01b91763
mov ecx, dword [edi]
mov eax, 0x8637b73e
or eax, eax
push eax
xor ecx, ebx
jmp 0x2edb134
xor word [esp + 1], 0xee2c
dec ecx
pop edx
inc dx
neg ecx
not edx
ror ax, 0x47
rol ecx, 2
add edx, eax
ja 0x21f4ccd
movzx ax, byte [edi]
mov edx, 0x29acf9a
mov dl, byte [edi + edx*2 - 0x5359f32]
mov ecx, 0x5e059da4
shl ecx, cl
add edi, 2
add al, dl
call fcn.021b0b1b
lea esp, [esp + 0x14]
jmp 0x1bc988d
Function at 0x2e45c0b
Capabilities:
Encode data using base64

Disassembly:
xor ebx, eax
push ecx
add ebp, eax
mov dword [esp + ecx - 0x720f8000], ebp
ret 8
dec edx
jmp 0x2ea1adb
jmp ebp
lea esp, [esp + 0xc]
jne 0x2ef8ca8
pop esi
mov ecx, 0xef0776b5
lea ecx, [ecx + ecx*2 + 0x2028f49e]
movzx edx, cx
not eax
mov dword [esi + edx*2 - 0xb17a], eax
xadd cl, dl
je 0x2e15ec4
mov edx, dword [edi + edx - 0x58bd]
add edi, 4
movzx eax, cx
bswap eax
xor edx, ebx
lea edx, [eax + edx + 0x66b2db3b]
sub cx, cx
ror edx, 1
not edx
or eax, eax
not cl
sbb edx, 0x9c1d5d3e
xor ebx, edx
add ebp, edx
jmp 0x2e845b7
mov esi, 0xa322cd8e
dec esi
rol esi, 0x4f
movzx esi, byte [esi + ecx - 0x66c6d191]
Function at 0x2e4d2f6
Capabilities:
Encode data using base64

Disassembly:
add edx, 0x669b14a0
xor ebx, ecx
add ebp, ecx
pop ecx
jmp 0x2ec215e
mov eax, dword [edi + ecx - 0x7265c130]
sbb byte [esp + ecx - 0x7265c126], cl
movzx edx, cl
sub dword [esp + ecx - 0x7265c128], ecx
lea edi, [edi + ecx - 0x7265c130]
jne 0x2e33a9d
sub dx, 0x368c
mov edx, esi
push eax
ror al, 0xe1
mov word [esi - 2], dx
lea ecx, [eax + eax*8 + 0x7280b3a8]
and eax, eax
js 0x2e61a9c
call fcn.021b7939
shr word [esp + edx - 0x3eff1651], 0xc3
xor ebx, ecx
jmp 0x1bab687

Function at 0x2e52413
Capabilities:
Encode data using base64

Disassembly:
not cl
bswap eax
mov dword [esp + edx*4], 0x9c3d5eba
rol dword [esp + edx*2 + 2], cl
rol eax, 1
or ecx, 0xd90dd72d
neg eax
jmp 0x1bc20be

Function at 0x2e5582b
Capabilities:
Get number of processors

Disassembly:
inc ecx
ror edx, 1
dec edx
mov dword [esp + eax - 0x2413990d], edx
dec esi
mov dword [esp + eax - 0x2413990d], ebx
inc ecx
mov ecx, 0x9f226eae
inc cx
ror esp, 3
shr ebp, 0x9d
inc esi
xor dword [esp + eax - 0x2413990d], edx
inc ecx
pop ebx
dec ebp
arpl dx, dx
inc cx
inc ecx
dec eax
lea ecx, [ebp*2 + 0x7f942611]
jne 0x1b7dd58