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

Disassembly:
sbb edi, 8
shr dword [esp + 6], 0xe6
mov dword [esp], 0x6d2ff928
shr dword [esp + 1], 0x59
mov dword [edi + 0xc], eax
shl word [esp + 7], 0xa1
mov dword [edi + 8], ebx
mov dword [edi + 4], ecx
jae 0x93d724
xor byte [ecx - 0xa], ch
add dword [edx + 0xb49525], ebp
int 0xf4
xor bl, ah
ljmp 0x7364
mov ebx, dword [esp + ecx - 0x2020]
pop ecx
pop edx
pop eax
ja fcn.00c9bff2
pop ecx
lea eax, [ecx*2 + 0xc1c21ac]
mov dword [edi + ecx - 0x2028], edx
sar dword [esp + ecx - 0x2024], cl
adc word [esp + ecx - 0x2025], ax
jp 0x921cf2

Function at 0x8ada50
Capabilities:
Encode data using base64

Disassembly:
sbb eax, 0x8d88a506
mov dword [esp + ecx*2 - 0x7eb20000], ecx
imul edx, ecx
sub cl, 0x22
rol eax, 2
not ecx
not cx
inc eax
xor dword [esp + edx - 0x65000000], 0x8cb26a9f
xor word [esp + edx - 0x64fffffe], cx
jne 0x92f3c2
mov eax, 0x8483d597
lea ecx, [eax*8 - 0x6a6421cf]
mov eax, dword [ebp]
movzx edx, cx
ror ecx, 0x70
rol edx, cl
adc ebp, 3
xor eax, ebx
and edx, edx
adc cx, 0x9c1b
neg eax
add edx, edx
ror eax, 1
add ecx, edx
rol edx, cl
dec eax
ror eax, 3
call fcn.0096d4e8

Function at 0x8add8d
Capabilities:
Encode data using xor

Disassembly:
cwde
lea ecx, [ecx + eax*8 + 0x14971b1a]
cmovp edx, eax
lea edx, [edx + edx*2 + 0x13a99092]
imul eax
rol ecx, 1
call fcn.00c7c1d8
invalid
mov eax, 0x71bdaaac
movsx ecx, ax
lea esi, [esi + eax - 0x71bdaab0]
mov dword [esp + eax - 0x71bdaaac], eax
or eax, 0x8a1b070c
xchg ch, al
pop edx
pop eax
jne fcn.00909547
rol ecx, 3
shl eax, 0xc6
bts edx, edx
cdq
xor ecx, 0x4ca49038
shl eax, 0x88
jne 0x83bc2d
cmp dword [edi], esp
jbe 0x8addf3
add ah, ah
add esp, dword [ebp + 0x51]
ljmp 0x7f57
imul edi, edi, 0x89ebd265
mov bl, 0xd1
add esp, dword [esi + 0x4dff2ff0]
xchg esi, eax
nop
inc ebx
xor cl, bh
popal
rol byte [esp + eax*4], 5
popal
push ebp
sub byte [edi + 0x4a], cl
and esi, dword [ebp + 0x56]
call 0x34526122
invalid

Function at 0x8b05c8
Capabilities:
Encode data using base64

Disassembly:
inc esi
mov dword [ebx + eax*4 - 0x30d50], edi
inc ecx
pop ebp
pop edx
inc ecx
pop eax
pop ebx
inc ecx
pop ebp
jl fcn.0073c0e6

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

Disassembly:
lea ebp, [ebp + ecx*2 - 0xe0]
mov dword [esp + ecx*8 - 0x368], ecx
inc ecx
shr al, 0x84
xor edx, ebx
xadd word [esp + ecx - 0x6e], cx
mov byte [esp + ecx - 0x6d], cl
inc edx
add al, byte [esp + ecx - 0x6a]
ror edx, 3
xor cx, 0xb1b9
inc edx
ror cx, 4
rol dword [esp + ecx*2 - 0x963a], 0xec
pop ecx
rol edx, 2
call fcn.00cd9f03
Function at 0x8b26c7
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
lea esp, [esp + 4]
je 0x89a44f
mov eax, 0x3887970f
and ax, ax
sar al, 0xe7
mov eax, dword [ebp + ebx*4]
jae 0x7b01ab
mov eax, 0x3b4e83f
imul eax
mov eax, dword [ebp + edx*2 - 0x1b7a90]
mov ecx, dword [edx + ebp - 0xdbd44]
neg dx
lea ebp, [ebp + edx - 0xd42b4]
add eax, ecx
lea ecx, [edx + edx*8 + 0x3635dc38]
bts edx, 0xb2
bts edx, 0x3c
mov dword [edx + ebp - 0x100d42b8], eax
inc edx
lea esi, [esi + edx - 0x100d42bd]
dec ecx
mov eax, dword [edx + esi - 0x100d42b9]
xor eax, ebx
sub ecx, ecx
inc eax
inc ecx
btr ecx, 0xa5
ror eax, cl
inc ecx
jp 0xc5f902
inc eax
add dx, dx
rol eax, 3
and ecx, edx
bts ecx, edx
xor ebx, eax
dec dx
jno 0x809a88
mov eax, 0x7327d422
mov ecx, dword [edi + eax - 0x7327d422]
bswap eax
jmp 0xcfb2ba
mov edx, 0x420deaa5
mov ebp, dword [esp + esi*4 - 0x5f4454c]
lea eax, [ecx*4 + 0x25abb321]
mov esi, dword [esp + esi - 0x17d1149]
div dword [esp + edx - 0x420deaa1]
neg edx
sar ecx, 0xd8
lea esi, [esi + eax - 0x5dd44cfb]
bts ax, ax
mov eax, dword [eax + esi - 0x5dd44cf7]
xor eax, ebx
xadd edx, ecx
shl edx, cl
lea eax, [ecx + eax - 0x5779fe94]
push ecx
ror ecx, cl
seta byte [esp + edx*4 - 0x12b2b5f6]
rol eax, 2
xor cx, word [esp + ecx - 0x4eb012ab]
shl dx, 0xe6
dec dword [esp + edx*2 - 0x958bff9]
lea eax, [eax + edx*4 - 0x6064fc8b]
rol eax, 2
call fcn.00cc1980
push eax
push 0x1c1b1b04
dec byte [esp + 1]
neg dword [esp]
dec ebx
jmp 0x8bd44b
sbb eax, eax
xor ecx, ebx
ror ax, 0x42
neg ecx
movsx edx, al
call fcn.008e5550
lea esp, [esp + 4]
call eax
mov ecx, 0xb43852a3
mov ebp, dword [ebp - 4]
lea esi, [ecx + ecx*8 - 0x547dd666]
mov dword [ebp + esi - 0x17d1155], eax
mov edi, ebp
sal cl, cl
movzx ebp, cl
push esi
mov ebx, dword [esp + esi*4 - 0x5f44550]
mov dword [esp + esi - 0x17d1151], ecx
jns 0x7995f6
mov eax, 0xcb9f81ab
mov eax, dword [ebp]
push 0x74bbab08
jmp 0x8914ff
mov ebp, edi
and ax, ax
mov ebx, edx
mov edx, ebx
pop eax
push 0x81be0730
shl edx, 2
mov eax, ebp
add eax, edx
add dword [esp], 0x7c85770b
mov dword [ebp - 4], eax
ja 0xca1839
push 0xce9166b2
call fcn.0089a445
mov eax, 0xf209b8a4
mov eax, dword [esi]
mov ecx, dword [esi + 4]
mov edx, 0xe891ef39
sub edx, edx
jb 0x86351b
push ebx
cpuid
call fcn.008f6f44
mov edx, 0x718cec8c
bts edx, 0x18
mov ecx, dword [ebp + edx - 0x718cec8c]
movzx eax, dx
and edx, eax
cdq
mov eax, dword [ebp + edx*2 + 4]
xadd dl, dh
sar edx, 4
lea ebp, [edx + ebp + 8]
setp dl
neg edx
mov dword fs:[ecx], eax
mov eax, dword [edi]
adc edi, 3
xor eax, ebx
movsx ecx, dl
rol eax, 1
sub dx, dx
bt edx, ecx
sub dx, cx
add eax, ecx
rol dx, 0x4b
xor eax, ecx
sub dl, 0xb6
sar dx, 0xa2
sub ecx, ecx
neg eax
inc edx
push edx
sal edx, 0xd
xor ebx, eax
xor word [esp + ecx + 1], dx
dec cx
adc esi, eax
inc word [esp + ecx - 0xfffd]
mov dword [esp + ecx - 0xffff], esi
ret
btr eax, edx
mul dx
add edi, ecx
cwde
mov ecx, dword [esi + eax*2 - 0x53cc]
sal ax, 0xe8
mov dl, byte [esi + eax - 0xe5fc]
lea esi, [esi + eax - 0xe5fa]
shr eax, 0xad
mov byte es:[ecx + eax*2 - 0xe], dl
test ebx, ebx
jmp 0x780f0e
Function at 0x8b8a13
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov dword [esp + edx - 0x280201], edx
bswap eax
neg dword [esp + edx - 0x280201]
call fcn.0096db3b

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

Disassembly:
sub ebp, 4
mov ecx, dword [ebp]
mov dword [esp], 0x883a680d
pop edx
lea eax, [edx + edx - 0x7c526cd3]
xor ecx, ebx
rol ecx, 1
neg ecx
bswap edx
sar eax, 0xdf
sbb ecx, eax
dec dl
mul dl
rol ecx, 3
xor ebx, ecx
sar dx, 0xc2
inc edx
add esi, ecx
movsx ecx, al
xadd dx, cx
xchg edx, ecx
mov di, word [edi + edx*2 - 0x1d44]
rol ax, 0xaf
jne fcn.00c9bff2

Function at 0x8bca10
Capabilities:
Encode data using base64

Disassembly:
add cl, byte [ecx + esi]
cwde
or dl, cl
mov dword [esp + eax*2], 0xa424a839
not dl
mov word [esi + eax], dx
lea ecx, [eax + eax + 0x3f8b52b4]
neg dword [esp + eax]
or eax, dword [eax + ebp - 4]
shr byte [esp + ecx*2 - 0x7f16a568], 0xe4
add ecx, 0x4b3c6e38
xor eax, ebx
neg ecx
not eax
mov edx, dword [esp + ecx - 0x75383f14]
lea eax, [eax + edx - 0x6e816a2b]
ror eax, 1
sub cx, 0x6ea6
jbe 0x99e7dc
xor eax, 0xc8b77909
xor ebx, eax
xor edx, 0xa2a69528
and edx, dword [esp + ecx - 0x7538d06e]
shr byte [esp + ecx - 0x7538d06d], 0x83
add edi, eax
shl ecx, 0xa5
and ecx, ecx
movzx ecx, byte [ebp + edx - 0x59594209]
movsx eax, word [esp + edx - 0x59594204]
shr word [esp + edx - 0x59594203], 0xa1
lea ebp, [ebp + eax - 0xa11]
dec dword [esp + edx - 0x59594204]
sal byte [esp + edx - 0x59594204], 0x24
xor cl, bl
push eax
not byte [esp + eax - 0xa0a]
dec cl
xchg word [esp + eax*2 - 0x1418], dx
sub eax, 0x58a8cca4
setg al
not cl
mul dword [esp + edx - 0x59590a08]
sal ax, 0x22
bt ax, ax
sbb cl, 0xbb
not cl
call fcn.00cd2e9e
Function at 0x8c0a04
Capabilities:
Encode data using base64

Disassembly:
not eax
xor ebx, eax
call fcn.00c60ca5

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

Disassembly:
jb 0x9885d6
mov word [esi + ecx - 0x5fb2ce49], ax
movsx eax, cx
or dx, 0x6838
mov cx, 0xb
push edx
mov word [esi + edx*2 - 0x5855d4f6], cx
cwd
pop ecx
imul ecx, dword [esp + ecx - 0x2c2aea75]
lea esi, [esi + edx - 0x2c2b0003]
mov dword [esp + ecx - 0x3d83a96a], 0xae8ee0bd
mov edx, dword [edx + ebp - 0x2c2b0005]
jb 0x96060d
pop ecx
lock add dword [ebp + 2], ecx
cmp eax, 0x70aa00b2
cmp eax, 0xb23dd2
adc dh, bl
push ebp
cmp bh, byte [0xf18e00b2]
adc eax, 0xb23dba
or bh, byte [ecx]
adc eax, 0xcf83c26b
call 0xa1d90006
invalid
and ecx, ecx
lea ebp, [ebp + ecx*2 - 0x7b0752da]
and dword [esp + ecx*2 - 0x7b0752d4], ecx
xor edx, ebx
rol eax, cl
jb 0x82d84c
not edx
ror dword [esp + ecx - 0x3d83a968], cl
sub ecx, eax
neg eax
lea edx, [eax + edx - 0x136cf320]
setge byte [esp + eax*2 - 0x18dc001]
ror edx, 1
pop eax
bt eax, ecx
xchg dword [esp + ecx*2 - 0x7c9512d6], eax
xor edx, 0xc8b77909
neg byte [esp + ecx*2 - 0x7c9512d5]
sar ecx, cl
neg ecx
xor ebx, edx
add edi, edx
sar word [esp + 2], cl
pop edx
ja fcn.00c570a1

Function at 0x8c9675
Capabilities:
Authenticate hmac

Disassembly:
shr ebp, 0x2d
mov edi, ecx
lea ecx, [ebp*4 - 0x49dd7bcf]
ror ecx, cl
not cx
mov ebp, esi
lea eax, [ecx + ecx*8 - 0x4be066cb]
jnp 0xc657ca
ja 0x907161
xor bl, al
lea eax, [esp + eax + 8]
bt ecx, ecx
mov byte [eax + ecx], dl
mov dword [esp + ecx*2], ecx
jb 0x84454a
lea ecx, [ecx + ecx*2 - 0x3ae028f7]
mov ecx, dword [ebp + 2]
push 0xcf2bf00b
mov edx, dword [esp + 6]
pop eax
lea ebp, [eax + ebp + 0x30d40ffb]
xor ecx, ebx
ror eax, 0x30
sub byte [esp + eax + 0xff430d7], dl
bswap ecx
or byte [esp + eax*2 + 0x1fe861b1], ah
setge dl
inc dword [esp + eax*4 + 0x3fd0c354]
rol ecx, 1
cbw
lea ecx, [ecx + eax*2 - 0x1cca90c]
push eax
jmp 0x94ffc7
inc edx
bswap ecx
jnp 0x7d8f9b

Function at 0x8ce990
Capabilities:
Encode data using xor

Disassembly:
inc ecx
movzx edi, sp
xadd di, ax
rol cl, 1
mul byte [esp + edi - 0xf1e4]
inc esp
xor cl, cl
dec eax
lea ecx, [esp + ecx + 0x18]
dec esp
mov dword [esp + edi - 0xf1f6], eax
inc esp
xadd dword [esp + eax - 0x7948968c], eax
inc sp
mov eax, dword [ecx + eax - 0x7948969c]
inc sp
mov dword [esi + edi - 0xf1f8], eax
dec edx
lea edx, [esi*8 + 0x5a32580d]
rol byte [esp + edi - 0xf1df], 0x44
dec ecx
lea ebx, [esp + edx*2 + 0x13b41230]
dec eax
lea esi, [esi + eax - 0x7948969e]
mov ecx, ebx
je 0x841d47
inc esi
mov edx, dword [edi + ebx - 0xf1f5]
dec eax
btc eax, 0x80
inc ebp
xor edx, ecx
inc ebp
mov eax, esi
call fcn.0083e332
mov ah, 0x42
lock add dword [esi + 0xb2be09], esp
rcr ecx, 0x86
sub dword [esi + 0x12e500b2], edi
mov esi, 0xb2be51
xchg ebp, eax
jnp 0x8cea0c
dec ecx
mov esi, 0xd0f500b2
fsubrp st(0)
inc ecx
add ch, dh
rcr dh, 1
loopne 0x8cea70
or edi, 0x7f
xor eax, 0x51a2af2d
mov ebx, dword [ebx - 0x7b64e216]
jbe 0x8cea29
adc al, dh
adc ecx, dword [ecx + 0x1af9d655]
cld
fdivr qword [esi - 0x29]
fiadd word [esi + ebp]
rcr dword [esp + ebp*8 - 0x35], cl
mov byte [esi], bl
xchg edx, eax
invalid
daa
invalid
Function at 0x8d19a5
Capabilities:
Authenticate hmac
Encode data using base64
Manually build aes constants

Disassembly:
xor dl, 0x30
and eax, 0xdf28f220
and eax, eax
dec ax
xor bl, dl
call fcn.007853a1
not byte [esp + 0xe]
add al, 0x92
mov ecx, 0xbcb2bd2e
rol byte [esp + 0xb], 0xc5
ror al, 1
pop ecx
neg al
sar byte [esp + 9], 0xa5
push 0x66b4fd84
xor al, 0x19
neg al
not al
xor bl, al
mov ecx, 0x5e19cf1c
mov dword [esp + ecx - 0x5e19cf18], 0xf9b952aa
lea eax, [esp + eax + 0x10]
inc cx
sets cl
imul ecx, ecx
mov dword [eax], edx
jo 0x968010
pushfd
add dword [esp + 0xc], 0xff70a93c
neg byte [esp + 8]
jb 0xc38ee2
lea edi, [edi + eax - 0x690b]
ror eax, 0xe2
xor dl, bl
inc ax
rol dl, 1
idiv al
lea eax, [eax + eax + 0x11a887ad]
dec dl
not dl
not ax
and ax, 0xf69b
jae 0x7a2615
push ecx
pop eax
pop ecx
pop edx
pop eax
pop eax
jmp edi
mov dword [esp + 0xc], 0x999171fe
push dword [esp]
popfd
lea esp, [esp + 0xc]
call fcn.009178bb
Function at 0x8d3908
Capabilities:
Encode data using base64

Disassembly:
jmp ebp
adc ecx, 0xba9be228
rol edx, 3
jmp fcn.00990907
inc ecx
sub al, dl
bswap ecx
sub edx, eax
dec dx
mov dword [esp + eax + 0x51c], 0x35b97ab1
sbb ecx, 0xdf95e8a3
xor ebx, ecx
dec dl
push edx
or byte [esp + eax*8 + 0x28e7], 0x3b
adc edi, ecx
mov eax, dword [ebp + edx - 0x389a0214]
lea ebp, [edx + ebp - 0x389a0210]
xor eax, ebx
ror edx, 0xc7
bswap eax
lea ecx, [edx - 0x27ea8754]
setae dl
shl ecx, 0x18
sbb eax, 0xd9943d82
neg eax
and edx, 0x9c169904
neg cx
or dx, dx
ror eax, 1
dec eax
rol dl, 0x61
xor ebx, eax
xadd dword [esp + edx*4 - 0x40403ffc], ecx
push edx
mov edx, eax
mov ecx, dword [esi + ecx*2 - 0x7f72f55e]
not edx
mov eax, 0x4f2abdb8
not ecx
and edx, ecx
cbw
movsx ecx, byte [esp + eax - 0x4f2affb0]
mov dword [eax + esi - 0x4f2affb4], edx
add ecx, 0xb2b31007
js 0xcb6be7
sub esi, 1
mov edx, 0xa0159026
movzx edx, byte [esi]
mov eax, 0xaf05822c
cwde
xor dl, bl
inc dl
and al, ah
xor dl, 0x3c
lea eax, [eax + eax*8 + 0x280e2711]
sar ax, 0xf
sbb dl, 0x17
add al, ah
rol al, 0xe2
jnp 0x998a21
mov ecx, 0x1186ca7
add ecx, 0x853a9827
neg ecx
mov eax, dword [esi + ecx - 0x79acfb32]
movzx edx, cx
imul edx, edx
xor dx, 0x1a0c
mov dx, word [esi + ecx - 0x79acfb2e]
lea esi, [esi + ecx - 0x79acfb2c]
sal cl, 1
jo 0x918155
jo 0xcebb7a
mov word ss:[eax + ecx - 0x79acfb64], dx
lea ebp, [ebp + ecx - 0x79acfb68]
mov eax, dword [ebp + ecx - 0x79acfb64]
jno 0xcabca9
neg dl
xor bl, dl
lea ebp, [ebp + eax*2 - 0x5013fff8]
sub al, al
mov word [ebp + eax - 0x2809ff00], dx
or eax, 0x4a3589a0
movzx ecx, ax
imul eax
lea esi, [esi + ecx*2 - 0x1ff44]
or ecx, eax
add cl, dl
bt edx, ecx
mov ecx, dword [esi + eax - 0x51802400]
or eax, edx
and dx, dx
xor ecx, ebx
mul eax
ror edx, 0x33
bswap edx
sbb ecx, 0x8d88a505
rol ecx, 2
inc ecx
sub eax, eax
sbb eax, eax
add dx, ax
neg ecx
imul edx
xor ebx, ecx
shr dl, 0x63
adc edi, ecx
imul al
or dl, dh
jbe fcn.00754c95
adc edx, 0x1134fc37
shl ecx, cl
jp 0x75cb50
jmp 0x7501e9
btc cx, cx
xor eax, ebx
mov edx, 0x8c99ba28
xor edx, edx
rol eax, 1
not eax
lea ecx, [edx + edx*4 - 0x306d50f9]
xchg ecx, edx
and cl, cl
sbb eax, 0xa82cc993
lea esi, [esi + eax - 0x4f2affb4]
call fcn.00ca9d7c
mov eax, 0xf80524b4
bts ax, ax
sbb edi, 3
movzx ecx, al
mov eax, dword [edi + ecx*4 - 0x2d0]
movzx edx, cl
sar dx, 0x61
push edx
xor eax, ebx
and edx, dword [esp + ecx*2 - 0x168]
sub ebp, 4
or ecx, 0xd5a74985
mov edx, dword [ebp]
sal cl, 0xe4
xor edx, ebx
btr ecx, 0x18
inc edx
bswap edx
and eax, eax
cbw
jnp 0x9b263f

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

Disassembly:
jae fcn.00c9bff2
or eax, 0x9badd63e
sbb al, 0x3f
adc edi, ecx
push eax
mov ecx, dword [esi]
add al, al
mov eax, dword [esi + 4]
jb 0x82d751
ja 0xca5f33
call fcn.0098de4d
adc esi, 4
xor edx, edx
test eax, eax
call fcn.0093c7b2
mov edx, 0x1796fe3c
movsx eax, dx
lea edx, [edx + edx*4 - 0x2edcd500]
mov eax, dword [edi + edx - 0x4716222c]
mov ecx, edx
bswap ecx
lea edi, [edi + edx - 0x47162228]
dec ecx
xor eax, ebx
inc edx
xor eax, 0x11a46889
btc ecx, ecx
sbb eax, 0xf39f6c2a
lea edx, [edx + ecx*8 - 0x3f623bc4]
call fcn.0086e787
Function at 0x8d9f29
Capabilities:
Encode data using base64

Disassembly:
mov word [edi + ecx*2 - 0x82], dx
lea esi, [esi + ecx*2 - 0x86]
mov edx, dword [esi + ecx - 0x41]
pop eax
shl word [esp + ecx*4 - 0xfe], 0xe3
lea eax, [ecx + ecx - 0x4c6b2e45]
xor edx, ebx
xor edx, 0xe83e6313
not al
and cl, byte [esp + ecx - 0x3c]
not edx
ror edx, 1
xor eax, 0xb826e837
sub eax, eax
bswap edx
dec dword [esp + ecx + 4]
neg eax
xor ebx, edx
lea ecx, [ecx - 0x66f6106d]
add dword [esp + eax + 4], ecx
adc ebp, edx
pop eax
lea eax, [ecx + ecx + 0x403b4713]
call fcn.0074e254

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

Disassembly:
ror cl, 1
and byte [esp + 1], dh
sbb dword [esp], edx
sbb cl, 0xa2
xchg byte [esp + 2], dl
xor bl, cl
sar word [esp], 0xe9
lea ecx, [esp + ecx + 4]
setns byte [esp]
setne dl
mov dword [ecx], eax
movsx eax, byte [esp]
lea ecx, [eax + edx*4 - 0x7be9f8c3]
jp 0x740a55
mov dword [esp + eax*2 - 2], ebp
ret
lea edi, [edx + edi - 0x11bf455d]
shr cx, cl
sar edx, cl
lea esi, [esi + edx*2 - 0x237f]
or cx, 0xde3e
push edx
jb 0xcfa91d
movzx ecx, byte [esi + edx*4 - 0x46fc]
sbb dword [esp + edx*2 - 0x237e], edx
xor cl, bl
ror cl, 1
or edx, edx
not edx
inc cl
inc word [esp + 2]
jg 0x73d6cb
ja 0x8b0a3f
pop edx
pop ecx
jno fcn.007ab5dc
btc ecx, 0x8c
dec eax
bt dx, cx
rol eax, 2
or cx, dx
neg eax
sub edx, ecx
xor eax, 0xf1056a9c
rol ecx, 0x21
xor ebx, eax
or edx, edx
jb 0x8a6dc0
adc ebp, eax
neg dl
btc edx, edx
mov eax, dword [edi + edx - 0x2d13f001]
lea edx, [ecx*2 + 0x113c7d15]
jae 0x8ab917
pop esi
push 0x2d16e1a2
not dword [esp]
push 0x4a93d835
lea esp, [esp + 8]
ret

Function at 0x8db76b
Capabilities:
Encode data using base64

Disassembly:
xor ecx, ebx
rol dword [esp], 0x65
not edx
push eax
ror ecx, 3
and word [esp + edx - 0x2491c53], 0x9b16
not ecx
sal byte [esp + edx - 0x2491c52], 0x26
sbb eax, 0xbc0fb088
sub dword [esp + edx - 0x2491c51], 0x4038ce83
inc ecx
sub ax, dx
neg ecx
cwde
cdq
sal edx, 0x61
xor ebx, ecx
shr dword [esp + edx*4 + 3], 0x1b
cdq
mov dword [ebp - 4], eax
mov dword [esp], 0xe1a0ab28
call fcn.00c8f89d
mov ecx, dword [ebp]
mov edx, 0x1219c00c
shr edx, 0x35
lea ebp, [ebp + edx*8 - 0x47c]
btc edx, 0x39
xor ecx, ebx
movzx eax, dx
xor ecx, 0xd9a2e2d
sar al, 1
sbb ecx, 0xc6ace5b5
sub ax, dx
ror ecx, 1
shr eax, 0xba
xor ecx, 0x4fbb64a9
ror ecx, 2
inc dx
neg al
idiv dl
xor ebx, ecx
bts ax, 0x1b
sbb ax, dx
adc edi, ecx
push edx
add edx, 0x3692ba1d
mov dx, word [esi + edx*2 - 0x7125755c]
pop eax
mov ax, word [eax + esi - 0x200008f]
jg 0x9c2229
mov edx, 0xac9e6728
push edx
mov dx, word [ebp]
sar dword [esp], 0x30
mov cx, word [ebp + 2]
shr word [esp], 0x23
sar byte [esp + 3], 0x62
setae byte [esp]
adc ebp, 1
not dx
not cx
not word [esp + 2]
mov eax, dword [esp]
add eax, 0x8f9083a4
or dx, cx
btr eax, eax
bswap eax
mov ecx, eax
mov word [ebp], dx
mov edx, dword [edi]
jae 0xc9f5af
mov cl, byte [esi + 4]
ja 0xcebbf7
bswap ecx
shr byte [esp + 2], 0x44
adc edi, 4
call fcn.009a99ba
mov edx, 0xa1b6a2a8
push edx
sub ebp, 4
neg dword [esp]
lea ecx, [edx + edx + 0x6f3aab2e]
or edx, 0x5c80e3aa
mov ecx, dword [ebp]
dec dword [esp]
movsx eax, dx
jae 0x8be921
Function at 0x8deffe
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
bswap ecx
ror edx, 0x8c
call fcn.00c62b93
sub dx, cx
mov cl, byte [esi + ecx*2 - 0x1bb38]
shl edx, 0xa8
mov dword [esp], 0x4738fa09
neg word [esp]
adc esi, 5
ror dl, 1
xadd dword [esp], edx
neg dl
mov byte es:[edx + eax - 0x47380509], cl
bt edx, edx
setae byte [esp + edx - 0x47380509]
mov ecx, dword [edx + ebp - 0x47380509]
rol dword [esp + edx - 0x47380509], 0xd0
lea ebp, [edx + ebp - 0x47380505]
mov eax, edx
sub word [esp + eax - 0x47380507], ax
xor ecx, ebx
sub ecx, 0x390be003
sal eax, 0xf5
push edx
inc dl
xor ecx, 0xdf9b039b
call fcn.00874503
movzx ebx, al
inc ecx
sbb ebp, 0xc98e6119
inc ecx
xor ebp, 0xbbb57c16
dec esp
lea esp, [ebx + ebx*2 - 0x3cf5036c]
inc cx
ror esi, 0xa3
inc edi
lea ebp, [esp + ebp - 0x5ac0233b]
call int.008f9cb3
sub ebp, 4
mov eax, 0xfaa4f525
movsx edx, al
mov ecx, dword [edx + ebp - 0x25]
dec eax
and dl, dl
bswap eax
xor ecx, ebx
rol ax, 0x6c
btc edx, 9
cbw
sbb ecx, 0xd2b7198b
and al, 0x99
sbb al, 0xa9
xor ecx, 0x88a81eb6
shl ax, 0x85
ror al, 0x61
dec ecx
not eax
rol al, 4
jb 0x73bffe

Function at 0x8e035a
Capabilities:
Encode data using base64

Disassembly:
jbe 0xc67e25
jb 0x786640
push dword [esp + 4]
popfd
lea esp, [esp + 0xc]
call int.007ca602
mov edx, 0x3f0e723a
mov eax, dword [ebp + edx - 0x3f0e723a]
btr edx, 0x28
inc dl
lea ebp, [ebp + edx - 0x3f0e7237]
movzx ecx, dx
adc cl, dh
jl 0xcfea8f
push eax
popfd
add dl, ch
lea esi, [esi + edx*2 - 0x7e1ce55e]
inc cl
mov edx, dword [esi + edx*2 - 0x7e1ce55a]
xor edx, ebx
or ecx, ecx
movzx eax, cl
rol edx, 2
neg edx
lea edx, [ecx + edx - 0xc94f9db]
xor eax, eax
rol edx, 1
sar cx, 0xaa
neg cx
inc cx
not edx
add cl, ch
not ecx
ror cx, 0xa1
adc edx, eax
rol edx, 1
inc eax
sub eax, ecx
xor ebx, edx
add edi, edx
jmp edi
call fcn.0078662c
cbw
bswap edi
movsx ecx, ax
rol edi, 1
mul edx
inc ecx
push ecx
xor dword [esp + edx*2 - 0x80e], edi
dec esi
lea ecx, [ebp*8 + 0x342818a3]
inc esp
movsx eax, dl
inc ecx
pop ecx
call fcn.009129c9
Function at 0x8e36e2
Capabilities:
Encode data using xor

Disassembly:
ror cl, 1
sub ax, 0x16a2
dec cl
xor bl, cl
neg al
call fcn.00c8bdc4
lea edx, [eax*4 - 0x40c1d448]
lea edi, [edi + edx*2 - 0x704ed3bc]
shl al, 0x85
not al
add word [esp + edx*2 - 0x704ed3ae], 0x95ae
xor ecx, ebx
lea eax, [eax + eax*4 - 0x1bdce9ca]
ror ecx, 3
dec ecx
cbw
not ecx
neg dl
sbb edx, dword [esp + eax - 0x3b46ff85]
xchg word [esp + eax - 0x3b46ff83], dx
xor ecx, 0x7083cba7
idiv dl
ror dword [esp + eax - 0x3b469100], 1
sbb ecx, 0x62266c8b
xor ebx, ecx
mul dword [esp + eax*2 - 0x768d21f4]
and dx, 0x660f
adc ebp, ecx
mov dword [esp + edx - 0x1fa56207], ebp
ret 0xc
lea esp, [esp + 8]
call eax
mov edi, 0x7eb44d39
xor di, di
mov ebp, dword [ebp + edi - 0x7eb40004]
movsx ebx, di
ror edi, 0x76
mov dword [ebp + ebx*4], eax
movsx edx, di
sub di, dx
lea esi, [edx + ebx*2 + 0x5c1c3d9d]
pop ebx
pop esi
xor edi, 0x1d226c34
mov eax, edx
mov ecx, edx
pop edi
call fcn.009a7a00
mov edx, 0x8a94c51f
neg edx
movzx dx, byte [edx + edi - 0x756b3ae1]
mov ecx, 0xd79e6f05
mov al, byte [edi + 2]
inc ecx
and dl, al
not ecx
lea eax, [ecx + ecx*2 + 0x6b88a996]
push eax
not dl
bt ecx, 0x9d
sal eax, 0x24
mov word [edi + eax - 0x4ad5c80e], dx
movzx ecx, byte [ecx + esi - 0x286190fa]
xor cl, bl
not cl
shr word [esp + eax - 0x4ad5c80e], 0xe4
mov edx, dword [esp + eax - 0x4ad5c810]
adc cl, 0x1c
or dl, al
rol dx, 0xe
sub dx, 0x43a3
not cl
xchg dx, ax
jp 0x81c9f6
xor cl, bl
sar eax, 0x9f
rol eax, 0x6d
sar eax, 0x9f
rol cl, 1
ror eax, 0x78
rol ax, 0x87
adc cl, 0x84
xor eax, 0x531cb2bb
lea eax, [eax*8 + 0xc073bb6]
jp 0x77fce9
cmp eax, dword [edi]
or al, 0xf
mov dh, byte [0xe8ffe9c5]
cli
pop edx
add al, 0
call fcn.009292b3
test al, 0xd6
xor eax, ebx
cld
jo 0x8e37ab
adc eax, 0x3da88347
invalid

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

Disassembly:
sar dx, 0x4d
mov dword [esp + edx*2 - 0x1c7dfff8], ecx
lea ebp, [edx + ebp - 0xe3efffd]
xchg byte [esp + edx - 0xe3efff9], ch
sar edx, 0x76
lea eax, [ecx + 0x3f236d95]
mov dl, byte [ebp + edx - 0x38]
add cl, byte [esp + ecx*2 - 0x161]
dec eax
xor dl, bl
xchg byte [esp + ecx - 0xf], cl
inc al
add dl, 0x39
neg eax
xor dl, 0x96
shl cx, 0x2e
neg dl
xchg al, cl
sub cl, byte [esp + ecx*2 - 0x10171]
sets byte [esp + ecx - 0x80a9]
ror dl, 1
mov word [esp + ecx*2 - 0x10150], 0x3133
xor dl, 0xb
btr ecx, 0x87
not eax
shr ecx, 0x61
xor bl, dl
lea edx, [esp + edx + 4]
or ecx, 0xf2908398
dec al
mov cx, word [edx + eax*2 - 0x7e46ddfc]
lea esi, [eax + esi - 0x3f236f00]
mov word [esi + eax*2 - 0x7e46ddfc], cx
movzx edx, al
btc edx, 0x31
shl byte [esp + edx - 0x200fd], 0x47
pop eax
jp fcn.00c570a1