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

Disassembly:
add ecx, 0x993a1cbc
xor al, 0x2f
inc ecx
xor bl, al
lea eax, [esp + eax + 8]
ror ecx, cl
mov word [eax], dx
lea eax, [ecx + ecx - 0x6a76ec6f]
mov edx, dword [esi - 5]
sub esi, 5
ror cl, 0x42
xor edx, ebx
dec ecx
pop ecx
lea edx, [eax + edx + 0xe7e0965]
mov dword [esp], eax
lea ecx, [eax*2 + 0x4e3a1706]
inc cl
not edx
sal ax, 0xe6
sar dword [esp], cl
call fcn.00b21e64

Function at 0xb5181d
Capabilities:
Encode data using base64

Disassembly:
call fcn.01000faa
mov edx, 0xf8866a3e
mov ecx, edx
call fcn.01144268
Function at 0xb53330
Capabilities:
Encode data using base64

Disassembly:
inc ecx
not ecx
dec esi
mov dword [esp + eax*4 - 0x14c], edi
inc ecx
dec ecx
call fcn.0101754b
add esi, 4
mov eax, 0xcb23f87
xor ecx, ebx
bswap ecx
call fcn.01136d64

Function at 0xb5673c
Capabilities:
Encode data using base64

Disassembly:
xor edx, ebx
rol eax, cl
lea edx, [edx + ecx - 0x60680b77]
jae 0xfced40
jmp 0xfafd1d
mov eax, 0xcb39ff20
movsx ecx, al
movzx edx, byte [esi + ecx*2 - 0x40]
sar al, 0x27
or ecx, 0x6aad617
lea esi, [esi + ecx*8 - 0x3556b1b7]
rol cl, 1
xor dl, bl
sub ecx, eax
lea ecx, [ecx*8 - 0x27d4205e]
neg dl
neg ecx
xchg ecx, eax
rol dl, 1
inc ecx
setp cl
ror ecx, 0xc3
inc dl
neg dl
xor ecx, 0xb4a90a08
inc cl
xor bl, dl
add edx, esp
and ecx, ecx
movzx ax, byte [edx + eax - 0x4c4d64ee]
ja 0x10b0c95
xor eax, ebx
neg ecx
rol eax, 1
movsx edx, cl
sar ecx, 0x14
not eax
call fcn.00b9fee0
inc edx
mov eax, dword [esp + 4]
add eax, 0xffa40d6d
jmp eax
neg edx
push ecx
rol ecx, cl
call fcn.010a17d3
mov edx, dword [esi]
add esi, 4
mov eax, 0x89a39696
movzx ecx, ax
xor edx, ebx
neg cx
xor edx, 0x5da9f92c
movsx edx, cx
lea ebp, [ebp + edx - 0x35eb]
call fcn.00b5adb2

Function at 0xb58ace
Capabilities:
Encode data using base64

Disassembly:
inc ecx
xor ecx, 0x892e6b35
push edx
sal eax, 0x83
mov dword [esp + edx - 0x77e8f10], eax
dec ecx
ror ecx, 2
or eax, eax
jno 0x1162cb2
ror edx, 3
and word [esp + eax - 0x2f], ax
not dword [esp + eax - 0x2f]
bswap edx
mov word [esp + eax*2 - 0x5c], cx
jns 0x114322d

Function at 0xb59ce2
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + eax - 0x998], edx
and byte [esp + eax - 0x996], dh
adc ebp, ecx
pop ecx
sub eax, ecx
xadd dx, cx
mov ecx, dword [eax + esi - 0x1fff7f52]
adc edx, 0x10888723
sbb edx, eax
sal eax, 0xff
lea esi, [esi + eax - 8]
rol edx, 0x25
lea edx, [edx + edx*4 - 0x1ee1f0c2]
xor ecx, ebx
xor edx, edx
not edx
dec ecx
xor ecx, edx
add edx, eax
jne 0x10a8804
jge 0x111bac7
or byte [ebp - 0x191edb8], ch
pop ecx
and dword [eax + 0x58], ecx
mov dh, 0x62
adc dword [ecx], esp
dec eax
pop eax
mov esi, 0x482129aa
pop eax
invalid
sub ecx, 0xc711f40f
lea eax, [eax + eax*8 - 0x5666ccd0]
rol ecx, 1
sub eax, 0xc738d9ab
xor ebx, ecx
shl dl, 0xe1
xadd eax, edx
mov dword [edi - 4], ecx
lea ecx, [eax*2 - 0x1a4ef6f3]
add edi, 0xfffffffc
jmp 0x11a1aa2
xadd ax, dx
neg ecx
xchg dx, ax
jmp 0xfb1a9e
sal edx, cl
inc eax
jne 0xb13e88
sub edx, edx
jno fcn.00fa3df3
inc cx
mov ebx, dword [ebx]
inc ecx
mov eax, 0xc82df19
inc edi
movzx edx, byte [eax + esi - 0xc82df1a]
inc esp
xor dl, dh
inc ecx
dec dl
dec edx
lea edx, [eax*4 + 0x937f910]
call fcn.00b64a42

Function at 0xb5aa98
Capabilities:
Encode data using base64

Disassembly:
ror dl, 1
mov dword [esp + ecx - 0x106], 0x4b911507
shl ecx, 0xd7
neg dl
shr ecx, 0x1f
xor bl, dl
lea edx, [esp + edx + 0x10]
call fcn.00fc9e12
mov edx, 0xc4b2d3b3
mov ecx, dword [esi]
add esi, 4
xor ecx, ebx
mov eax, 0xf5965220
inc al
setns al
sub ecx, 0x2695fea7
Function at 0xb5ca30
Capabilities:
Encode data using base64

Disassembly:
xor bl, al
lea eax, [esp + eax + 4]
mov ecx, dword [eax]
shl dx, 0xef
mov dword [ebp - 4], ecx
mov eax, dword [esi + 1]
mov dword [esp], edx
neg dl
lea ecx, [edx + edx*4 - 0x28551adb]
lea esi, [esi + ecx*2 - 0x49ebca45]
shr edx, 0x50
xor eax, ebx
bswap eax
shl dword [esp + edx*4 - 0x2a43c], 0xbd
js fcn.0102dc41
shl dx, cl
dec eax
or dword [esp + edx*2 - 0x43c0], edx
ror dword [esp + edx*8 - 0x10f00], 0xfc
xor eax, 0xc9054319
rol eax, 1
xor ebx, eax
add edi, eax
rdtsc
bswap ecx
dec ecx
dec ecx
mov dword [ecx + ebp - 0x25e5f52a], eax
lea ecx, [ecx + ecx*8 - 0x517539ee]
movzx eax, cx
mov dword [ecx + ebp - 0x3a06450], edx
jl 0x1181111
movzx edx, ax
shl dword [esp + ecx - 0x3a06444], cl
lea ebp, [ebp + ecx*2 - 0x740c894]
xchg edx, eax
neg al
pop ecx
jnp fcn.010a18ab
inc edi
ja 0xb5cb1d
jge 0xb5cb10
dec esi
daa
call 0x66dd3a55
mov eax, dword [edi + 2]
add edi, 2
and cx, ax
mov edx, 0x2400eb11
inc dx
movzx eax, dl
not cx
inc al
mov word [edx + edi - 0x2400eb12], cx
add ax, ax
lea esi, [esi + edx - 0x2400eb16]
push edx
jnp 0xfa8e56
mov edx, 0x7ea2dd20
movsx eax, dl
mov edx, dword [esi + eax - 0x20]
lea eax, [eax + eax*4 + 0x2a1ee60a]
not eax
add esi, 4
not eax
lea ecx, [eax*2 - 0x737f0258]
and cl, 0x9e
xor edx, ebx
push ecx
sub dh, bh
rol byte [ecx + 0x4c6], 1
add bh, dh
ror byte [ebp - 0x257baf4], 1
or byte [eax + eax*4 - 0x2ccc611f], 0x51
or word [esp + eax - 0x2a1ee6a9], cx
or al, cl
lea edx, [edx + eax*2 + 0x70ed4c3e]
sar byte [esp + eax - 0x2a1ee6be], 0xc4
rol eax, 1
xor edx, 0xaebd1d13
shl al, 0x45
ror ecx, 0xc9
lea edx, [edx + eax + 0x15fc6c99]
sub dword [esp + eax - 0x543dcd80], 0xc08e5388
push ebx
mov es, eax
xor edx, 0x881e7bae
xor cx, cx
xor ebx, edx
add edi, edx
pop ecx
push eax
mov edx, dword [ebp + ecx*2 - 0x40e116e2]
ror dword [esp + eax - 0x543dcd80], cl
add al, 0x80
xor al, dl
stosd dword es:[edi], eax
call fcn.0100970a
push ebx
adc edx, dword [ebx + 0x5e8f6978]
mov dword [0x8f051420], eax
pop esi
mov dword [0x8f2d5c3c], eax
pop esi
mov dword [0x8f617000], eax
pop esi
mov dword [0x26945444], eax
or dword [edi + 0x4c23b8d8], ecx
pushfd
mov eax, 0x7a2f5363
jne 0xb5cb6b
jecxz 0xb5cbe6
pop esp
jbe 0xb5cba9
dec esp
movsd dword es:[edi], dword [esi]
adc dword [edi - 0x26974f68], ebx
fdivr st(4), st(0)
loop 0xb5cb86
sbb edx, esp
xor ecx, edx
add esp, edi
sbb ch, byte [ebx - 0x5f]
push eax
push 0x64
invalid
xchg ecx, eax
test dword [ebp - 0x5a], ecx
iretd
push eax
mov eax, dword [esi + edx - 0x2400eb12]
not edx
jge 0x11a5cca
iretd
mov ecx, 0x353bac8b
mov dword [esp + ecx - 0x353bac8b], edi
ret
movzx ecx, dl
xor eax, ebx
shl edx, 0x90
sete cl
bswap eax
rol eax, 1
xor byte [esp + edx*4 - 0x53b3fffc], dl
dec eax
ror eax, 1
dec edx
xor eax, 0xfd231192
call fcn.0117beff
mov ebp, 0x99b6231f
mov edx, ebp
jmp 0xb94ea9
Function at 0xb5d0b7
Capabilities:
Encode data using base64

Disassembly:
inc esi
xor dword [esp + ecx*2 - 0x2461953c], edi
dec esi
xor dword [esp + ecx - 0x1230ca9a], eax
call fcn.00b6f22b
dec ecx
sub esi, 4
inc ecx
mov ecx, 0x1230caaa
inc edi
mov edi, dword [esi + ecx - 0x1230caaa]
inc esp
xor edi, esi
inc ecx
mov eax, 0xe61c9d3c
inc ecx
push ecx
dec edx
lea ecx, [eax*4 + 0x40003da7]
inc ecx
xor edi, 0x7b2c2b0b
dec edx
mov dword [esp + ecx*2 - 0x2461954c], 0xe82fef2d
inc ecx
rol edi, 1
inc ecx
bswap edi
inc edx
dec dword [esp + ecx*4 - 0x48c32aa7]
dec edx
dec dword [esp + ecx*2 - 0x24619552]
inc edi
lea edi, [edi + ecx*4 - 0x2828b9a4]
inc ecx
push ecx
inc esi
movsx edx, byte [esp + ecx*2 - 0x24619551]
inc edx
not dword [esp + edx*2 - 0xc]
inc ecx
neg edi
dec edx
mov dword [esp + edx*2 - 0xc], esi
inc esi
movsx esp, byte [esp + ecx*2 - 0x24619546]
jmp 0xaf2a69

Function at 0xb602f7
Capabilities:
Encode data using xor

Disassembly:
dec eax
mov dword [esp + ebx*4], 0x17b0d581
inc ecx
inc ecx
call fcn.00b1fe50
add byte [edx + ecx + 0xc], al
mov bl, 0xd9
test al, 0x24
push ss
lcall 0x9a16, 0xbc91b7b2
mov dl, 0x78
xchg ecx, eax
mov esp, 0x78b29a16
outsb dx, byte [esi]
sbb al, 0x16
lcall 0x9a16, 0xd4d9b6b2
mov dl, 0xb0
xor ah, bh
push ss
lcall 0x9a16, 0x7cd0f6b2
mov dh, 0xd9
aam 0x16
lcall 0x9a16, 0xfc30b0b2
mov dl, 0xf6
sar byte [esi + edx - 0x66], 1
mov dl, 0xae
inc edi
xor al, 0x16
lcall 0x9a16, 0x9c6e78b2
mov dl, 0x61
js 0xb60313
push ss
lcall 0x9b65, 0x1bb440b2
inc eax
sub eax, 0x815c2d0e
leave
mov esp, 0x2bf6c407
je 0xb6031e
mov bl, al
call 0xfff3c431
ljmp 0x6121

Function at 0xb6088f
Capabilities:
Encode data using base64

Disassembly:
dec edx
mov dword [esp], eax
jmp 0xf9adef
xor ebx, edx
and cx, ax
jge 0x117ca27
adc ebp, edx
dec dword [esp + 4]
call fcn.00ffbec9

Function at 0xb65031
Capabilities:
Encode data using base64

Disassembly:
mov edx, dword [esi]
lea eax, [ecx*2 + 0x59b28d17]
or eax, eax
setbe cl
xor edx, ebx
push ecx
xchg dword [esp], eax
inc edx
rol ecx, 0x6e
ror edx, 1
neg byte [esp + ecx*2 - 0x5d8052f5]
not edx
mov dword [esp + ecx*2 - 0x5d8052fc], eax
xor edx, 0x381b100a
neg eax
bswap edx
xor ebx, edx
add edi, edx
call fcn.00b09598

Function at 0xb65180
Capabilities:
Encode data using base64

Disassembly:
neg eax
ror dl, 0x64
and dx, dx
sbb eax, 0xa4987d02
mov dword [esp], edx
sal byte [esp + 5], 0x82
jne 0x1031149
bswap eax
movzx ecx, dl
ror eax, 2
jmp 0xb62b07
Function at 0xb698fb
Capabilities:
Encode data using base64

Disassembly:
mov dword [edx + eax - 0x49dd90f8], ecx
mov ecx, 0xd88ec609
mov ecx, dword [esi + eax - 0x49dd90f7]
mov dword [esp + eax - 0x49dd90f8], 0x3c3fda9a
lea esi, [eax + esi - 0x49dd90f3]
shl eax, 0x41
call fcn.00fffb07
inc esp
xor eax, esi
inc edi
lea eax, [eax - 0x59de9888]
inc cx
xor edx, 0x8d48d6a5
test byte [ecx - 0x187c777c], dl
dec ecx
lea ebp, [esp + eax*2 + 0x1a8773b6]
inc ecx
xor eax, 0xeb285ba8
inc eax
rol ch, 0x82
inc ecx
rol eax, 2
and cx, dx
inc ecx
sete ah
dec ecx
lea ebx, [esp + edx*4 - 0x1fe07bc1]
inc ecx
not eax
jae 0xadff93
add byte [ecx - 0x3f], 0xc0
add ah, byte [esi + 0x23]
retf 0xf41
push ebx
ja 0xb699c1
imul esp, dword [ebx + 0x72], 0x7fcf2c4b
insd dword es:[edi], dx
dec ecx
aaa
jp 0xb69953
leave

Function at 0xb69996
Capabilities:
Encode data using base64

Disassembly:
mov eax, 0xaf1d6207
ror edx, 3
call fcn.00ad0384

Function at 0xb6a63b
Capabilities:
Encode data using xor

Disassembly:
rol dl, 1
neg dl
rol dl, 1
or ecx, ecx
sal ecx, cl
add ecx, ecx
xor dl, 0x2f
rol cx, 0xa8
xor bl, dl
ror cx, 0xe1
adc edx, esp
lea ecx, [ecx*8 + 0x4993e10a]
sal ecx, 0x54
mov word [edx + ecx*2 - 0x4f400000], ax
lea edx, [ecx + 0x409bc5a9]
lea esi, [ecx + esi - 0x27a00004]
call fcn.00accc90
add ecx, eax
and edx, edx
mov dword [edi + edx - 0x542d2199], ecx
movsx ecx, dx
mov eax, 0xdda99dad
movzx ecx, byte [esi + ecx*8 - 0x10ce8]
not edx
add eax, eax
xor cl, bl
inc eax
js 0xb8e230
sub esi, 1
mov dword [esp], ecx
movzx edx, byte [esi]
pop ecx
xor dl, bl
neg cl
jno 0xb2a2dd
neg dx
dec cl
neg cl
ror dl, 2
xchg ah, dl
not al
inc cl
ror dx, 0xd
rol eax, 0xac
push edx
not cl
shl dx, 0x43
ja 0xf9c065
sal byte [esi], cl
imul ecx, dword [ecx + 0x6e5d2445], 0x77
pop ds
inc esp
std
insd dword es:[edi], dx
jle 0xb8e2da
pop ds
inc esp
xchg edx, eax
lcall 0xf32b, 0x441f7776
pop esi
ja 0xb8e28f
inc esp
sub ecx, dword [esi + edi*4]
ja 0xb8e295
inc esp
add ch, byte [ebx + 0x441f77c6]
pushfd
invalid
inc esp
mov esp, 0x1e04d146
mov dh, 0xe7
outsd dx, dword [esi]
out 0x6f, eax
test al, 0xaa
clc
je 0xb8e28e
cmpsb byte ss:[esi], byte es:[edi]
in eax, dx
invalid
lcall 0x35, 0x8616bbd4
dec ecx
mov ch, 0xce
mov ch, 0x42
invalid
dec cl
sub dl, ah
xor cl, 0xbf
shr dx, 0xe3
ror edx, 0x57
not edx
xor bl, cl
mov word [eax + edi - 0x3a7a4bb3], cx
call fcn.00fffa72
Function at 0xb6af8c
Capabilities:
Encode data using base64

Disassembly:
inc ecx
cmp dh, ah
clc
cmp edi, 5
jmp 0xfe6041
bswap ecx
jg 0x1151077
inc al
jne 0xb4a7ea
lea eax, [ecx - 1]
clc
mov dword [ebp - 0x40], eax
cmp di, 0xaa35
xor esi, esi
or eax, 0xffffffff
cmp bp, si
test ebp, ecx
sub edi, edi
cmp cl, 0x2f
cmp ecx, dword [ebp - 0x40]
jmp 0x1151c10
mov edx, dword [ecx + ebp - 0x28fffffc]
and ecx, ecx
inc cx
adc eax, edx
mov dword [esp + ecx - 0x28fffffd], ecx
movzx edx, cx
mov dword [ecx + ebp - 0x28fffffd], eax
movsx eax, word [esp + edx + 7]
lea ebp, [ebp + ecx*2 - 0x51fffffe]
shl ecx, 0x9e
jbe 0xb5aad7
sar byte [esp + ecx*2 - 0x7ffffff7], 0xe5
mov dword [esp + ecx - 0x40000000], edi
ret 8
inc edi
cmp ebx, ebx
or esi, edx
jmp 0xb1d2cc
jl 0xb5aafa
mov dword [ebp - 8], ecx
lea esp, [esp]
shl dl, 0xe2
bswap eax
xor ecx, 0xc337cc8f
dec ecx
call fcn.010b1424
mov ecx, 0xf2134fac
call fcn.0111cbc0
je 0xaecd47
movzx edx, byte [ecx]
test sp, 0x1818
shl esi, 8
jmp 0xb9fc81

Function at 0xb6fa4a
Capabilities:
Encode data using base64

Disassembly:
call fcn.00faa00a
inc ecx
mov edi, 0xfc3abd33
inc bp
movzx edi, byte [ebx]
inc ecx
mov cl, byte [ebx + 2]
inc ecx
not bh
inc ecx
mov ebp, 0x2c183935
not cl
inc ecx
mov ecx, 0xc40d4092
inc ecx
shl ch, 1
dec ecx
lea ebx, [ebp - 0x9733cd4]
inc esp
and bh, cl
call fcn.00b03220
mov eax, 0x1e9c4619
movzx ecx, ax
jmp 0x10204b6
mov ecx, dword [esi + eax - 0x1e9c4619]
sub al, ah
movsx edx, al
sub eax, edx
lea esi, [esi + eax - 0x1e9c46fc]
xor ecx, ebx
ror ecx, 3
not ax
add eax, eax
sal ax, 0xa1
xor ecx, 0x71b5ac09
bswap ecx
sub ecx, 0x5691e9ac
ror ecx, 1
sub edx, edx
cmovbe edx, eax
shl ax, 0x89
bswap ecx
push edx
jb 0x101326a

Function at 0xb73548
Capabilities:
Encode data using base64

Disassembly:
xadd byte [esp + 8], al
xor bl, cl
mov dword [esp], eax
pop edx
lea ecx, [esp + ecx + 8]
mov edx, dword [ecx]
jmp 0x115eee4
movsx ecx, ax
mov dword [edi + ecx*4 - 0x440c], edx
lea edi, [ecx + edi - 0x1109]
call fcn.00b41df8
Function at 0xb73a72
Capabilities:
Encode data using base64

Disassembly:
xor ebx, ecx
movzx edx, byte [esp + eax - 0x72000154]
shr eax, 0xad
mov dword [edi + eax*4 - 0xe4002], ecx
adc edx, 0x97ba0f2a
lea ecx, [eax*2 + 0x4f8f11b7]
pop edx
lea edi, [eax + edi - 0x39002]
sbb dword [esp + eax - 0x38ffc], 0x2c0fd32c
neg cx
pop edx
pop eax
jb fcn.00fa3df3
call fcn.01188729
pop ss
mov ecx, 0xa07f0876
push esp
cdq
fsubr dword [eax]
dec edi
pushal
fisub dword [ecx + 0x605bf8e8]
fisub dword [ecx + 0x60432c3c]
fisub dword [ecx + 0x605b282c]
fisub dword [ecx + 0x2c6c70b4]
mov al, 0x33
add eax, 0x87d99f58
in eax, 0x58
out 0xe0, eax
or ah, byte [ecx + 0x24]
sbb dword [edi - 0x5d], esp
mov ah, 0x97
clc
pop ecx
cmpsb byte [esi], byte es:[edi]
dec edi
or ebp, dword [ebx]
insd dword es:[edi], dx
xor dword [eax - 0x5cbb7f9d], ebx
cmpsd dword [esi], dword es:[edi]
xchg ecx, eax
jae 0xafbb70
retf
jne 0xafbbd7
add bl, byte [edi - 0x56]
add byte [ebp - 0x55a0f17f], ch
add byte [ecx - 0x67], ch
cmp bl, byte [edi - 0x56]
add byte [ebp + 0x52c8cdb9], al
scasb al, byte es:[edi]
movsd dword es:[edi], dword [esi]
sub bh, dl
mov cl, 0x39
stosd dword es:[edi], eax
dec edi
jecxz 0xafbbe6
popal
leave
leave
sub dl, byte [ebx]
sti
adc edi, ebx
leave
insb byte es:[edi], dx
add byte [ebx + 0x5e069192], dl
adc byte [0xc82e9a18], cl
outsb dx, byte [esi]
jmp 0xafbb95
mov eax, 0xe912ee33
inc ecx
movzx ebx, al
inc ecx
mov edx, dword [esi + ebx*8 - 0x198]
dec ecx
lea ebp, [eax + ebx*2 + 0x129d337]
dec ebp
lea esp, [eax + ebp*4 - 0x1c4bf755]
inc ebp
movzx ebp, ax
xor edx, esi
lea edx, [edx + ebx - 0x1eaa5cc9]
inc ecx
ror ah, 0x41
inc esp
movzx edx, ch
not edx
mov ecx, ebp
neg edx
inc ebp
movzx edi, ax
rol edx, 2
jmp 0xb34214
invalid
movsx eax, cl
inc ebp
movzx edx, ch
sub dl, 0x39
dec esi
mov dword [esp - 0x13c], ebp
not cl
inc ebp
and ch, ah
ror dl, 1
jmp 0x1178b0b
inc ecx
movzx ebp, bp
dec edi
lea esi, [esi - 0x27d]
jne 0xb145c3
push eax
inc esp
movzx edi, word [esp + eax - 0x24]
neg ecx
mov ebx, 0x3233b8b7
ror al, 0xe3
neg dword [esp + eax - 0xe4]
sbb ecx, 0x9cab8a3d
ror ecx, 2
inc esp
or byte [esp + eax*4 - 0x393], bh
bswap ecx
dec eax
or dword [esp + eax - 0xdd], 0x4f2371b4
or byte [esp + eax*2 - 0x1be], 0x13
inc ebp
movsx eax, di
dec eax
mov dword [esp + eax*2 - 0x1c2], esi
dec eax
sal ebx, 0x4e
xor dword [esp + eax - 0xdd], ecx
jmp 0x1123d3d
dec edx
inc dword [esp - 0x9e]
inc edx
inc dword [esp - 0x9a]
inc eax
xor dh, dl
dec eax
lea edx, [esp + edx + 8]
dec eax
not eax
inc ecx
movzx ebx, dx
dec edx
sal dword [esp - 0x278], 0x34
inc edx
mov dword [edx - 0x9e], ebp
inc esi
xchg dword [esp - 0x9d], edx
inc dx
rol dword [esp - 0x9e], 6
inc edi
mov eax, dword [esi - 0x4f5]
inc cx
cmovb ebx, edx
jb 0x11773b9
push ebx
ja 0x1178baa
jge 0x1178be5
inc edx
daa
clc
push esp
jno fcn.01178bc2
sbb dword es:[esp + ebp*4 + 0x4cee990a], ebx
adc edi, eax
rol ecx, 1
shr eax, 0x84
ror eax, 9
jne 0xafba9d
movsd dword es:[edi], dword [esi]
fnstenv [ebx]
fst dword [eax + 3]
jmp 0xc5a442ff
Function at 0xb7572b
Capabilities:
Encode data using base64

Disassembly:
not al
dec al
mov dword [esp + edx*2 - 0x134], edx
neg al
pop ecx
jmp 0x10384ba
adc edx, ecx
neg al
sub eax, eax
jae 0x1169e98
test si, dx
bswap edx
add al, 0x2f
xor bl, al
neg cx
add eax, esp
xor cx, dx
mov edx, dword [ecx + eax - 0xff66]
mov eax, ecx
sar eax, 8
mov ecx, dword [ecx + edi - 0xff66]
bswap eax
sub eax, eax
jle 0xb923f3
mov dword [edi + eax*8], edx
movzx ecx, ax
xor eax, dword [esi + eax*4 - 5]
jmp 0x119b380
lea esi, [ecx + esi - 5]
xor eax, ebx
movsx edx, cl
lea eax, [eax + ecx*4 - 0x312178b1]
call fcn.0102b38b

Function at 0xb76777
Capabilities:
Encode data using base64

Disassembly:
not eax
mov edx, dword [esi + ecx*2 - 0x73100000]
call fcn.0118f006
lea ecx, [esp + ecx + 8]
sub dx, dx
rol dword [esp + 4], 0x36
mov eax, dword [ecx]
jae 0xb25fe9
shr ax, 9
lea esi, [esi + edx*2 - 0x5e6]
shl eax, 0x72
xor ecx, ebx
and dl, dh
inc eax
bswap ecx
lea eax, [edx + eax*2 - 0x64c8f75b]
not ecx
bswap ecx
jno 0xb7e021
xor dl, dh
not ecx
inc eax
dec ax
inc ecx
dec al
xor ebx, ecx
add ebp, ecx
rol edx, 0xea
setae al
rol dx, 7
jmp ebp

Function at 0xb7b0fd
Capabilities:
Encode data using base64

Disassembly:
lea esp, [esp + 0x14]
jne 0xb131ad
mov edx, 0x2728b701
lea ecx, [edx + edx*4 + 0x6c884393]
xor dx, dx
pop ebx
not eax
mov edx, 0xda02cd23
call fcn.00ae48f3
mov ebx, 0x719e0127
sar bl, 0x24
movzx ebx, byte [ecx + ebx - 0x719e0102]
jnp 0x11aa165
push 0x5d
fnstcw word [ebx - 0xe]
arpl word [esi + ebp - 0x61], ax
clc
call 0x9fdf7645
invalid
inc ecx
xor eax, 0x2b9e6215
dec edx
jmp 0xaec1d8
push 0xb8fcb0c
mov ebx, dword [ebx*4 + 0xae7f60]
shr eax, 8
call fcn.00b7d825
and ebx, 0xff
jmp 0x1002e24
xor ebx, eax
jmp 0x119a5a4

Function at 0xb8bcf6
Capabilities:
Encode data using base64

Disassembly:
pop ecx
xor bl, al
rol byte [esp + edx*2 - 0x4f2273e6], 0x23
mov ecx, edx
mov dword [esp + edx - 0x279139ef], edx
mov word [edx + edi - 0x279139f7], ax
lea edi, [edi + edx - 0x279139f7]
lea eax, [ecx*4 - 0xcde6e8]
setae dl
ror byte [esp + edx - 0x279138fc], 0x26
pop edx
pop ecx
jb fcn.00fa3df3
shl eax, cl
inc edi
lea edx, [edx - 0x6b5a6ede]
inc cx
add eax, eax
movsx ebx, ax
dec eax
shl ecx, cl
push esi
inc esi
xor dword [esp - 0x26df6785], edx
inc cx
sal esp, 0x4b
call fcn.00adf175

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

Disassembly:
inc ecx
shl ax, 0x69
jae 0x117c6b1
call fcn.0118144d

Function at 0xb8e3c7
Capabilities:
Encode data using base64

Disassembly:
dec ecx
xor edx, 0x3894bb16
mov dword [esp + ecx - 0xaa], eax
inc edx
sub ecx, eax
xor eax, eax
neg edx
jmp 0x102b28c
jmp 0xfb1074

Function at 0xb92dc8
Capabilities:
Encode data using base64

Disassembly:
push edx
ror ecx, 2
push eax
sar edx, 0x78
sub ecx, 0xd308ef8e
mov dword [esp + eax - 0x5a189cef], eax
xor ecx, edx
sub ecx, 0x7a2ac310
rol al, 0x21
bswap ecx
xor ebx, ecx
xadd word [esp + eax - 0x5a189ce7], dx
not dl
add ebp, ecx
lea eax, [eax*2 + 0x5d25e12d]
call fcn.00b81c4f

Function at 0xb9702d
Capabilities:
Encode data using base64

Disassembly:
inc bx
mov dword [ebx - 0x14379cf8], eax
pop ebp
jno 0x1163aa8
Function at 0xb9af9c
Capabilities:
Encode data using base64

Disassembly:
push 0xeb93bd8d
push 0x3014de2b
dec ecx
dec esp
dec eax
lea esp, [esp + 0x28]
jne 0xb44a62
mov ebp, 0xa6051135
push ebp
dec eax
mov esi, dword [esp + 8]
dec eax
lea esp, [esp + 0x10]

Function at 0xb9afcc
Capabilities:
Encode data using base64

Disassembly:
or eax, 0xac9da53a
bswap edx
not cx
xor ebx, edx
add edi, edx
mov dword [esp + ecx - 0xffe5], eax
mov edx, dword [ecx + ebp - 0xffe5]
ror dword [esp + ecx - 0xffe1], cl
jb 0x115637b
mov cl, byte [ebp + ecx*2 - 0x1ffc6]
add ebp, 2
not dword [esp + 3]
shl edx, cl
mov dword [ebp], edx
movzx edx, byte [esp + 2]
sub word [esp + edx*2 - 0x139], dx
pop edx
pop ecx
jmp edi

Function at 0xb9fc53
Capabilities:
Encode data using base64

Disassembly:
xchg dword [esp + ecx*2 - 0x5d1c5cf6], ecx
inc dl
inc dword [esp + ecx - 0x1aad5d04]
not dl
mov eax, 0xe1023992
mov dword [esp + ecx - 0x1aad5d0c], 0x7b3dfbb8
dec dl
shr eax, cl
xor dl, 0xbf
call fcn.00fe7a51

Function at 0xba008c
Capabilities:
Encode data using base64

Disassembly:
rol ecx, 0xec
movzx edx, byte [esi + ecx - 0x4928111d]
mov dword [esp + ecx - 0x49281118], 0x67b8ba95
lea esi, [esi + ecx - 0x4928111d]
xor dl, bl
sub dl, 0x96
mov dword [esp + ecx - 0x49281114], ecx
lea eax, [ecx + ecx*8 - 0x326e45e2]
not dl
sal cl, 0x61
dec dl
neg dl
add dword [esp + ecx - 0x4928112d], 0x850aa8bb
rol byte [esp + eax - 0x5ffa53f6], 0xe4
adc cl, 0x14
adc dl, 0x2f
ror eax, 0x93
ror word [esp + eax - 0x4a7ecbf8], 0x85
push eax
xor bl, dl
call fcn.00ade212
neg edx
movsx eax, word [esp + ecx - 0x78]
jmp 0x117f903
shr dword [esp + ecx*8 - 0x3f8], 0x4d
sbb edx, 0xc711f40f
rol edx, 1
rol byte [esp + ecx - 0x7f], 4
xor ebx, edx
mov dword [ecx + edi - 0x88], edx
and dword [esp + ecx - 0x79], 0xe494609d
lea edi, [edi + ecx - 0x88]
pop eax
dec cx
xor eax, ecx
mov edx, dword [esi + ecx - 0x8b]
sar ecx, cl
bswap ecx
lea esi, [esi + ecx - 0xc]
xor edx, ebx
add cx, 0xb518
not edx
shl al, 0xa2
xchg word [esp + ecx*2 - 0x16a2d], ax
sub edx, 0xd48f57b5
mov word [esp + ecx - 0xb517], 0x862f
neg word [esp + ecx - 0xb515]
neg edx
shl cl, 0x41
rol edx, 1
xor ebx, edx
and word [esp + ecx - 0xb52b], cx
xor ax, word [esp + ecx*8 - 0x5a97c]
xor ax, 0x25bb
adc ebp, edx
pop edx
pop eax
jmp fcn.00fa3df3

Function at 0xba1c91
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + eax], 0x19821fa2
inc edx
xor byte [esp + eax*8 + 1], ah
xor ebx, edx
not dword [esp + eax*8]
add ebp, edx
lea edx, [eax + 0x2e3f608c]
lea edx, [edx + eax*2 + 0x8307dab]
mov edx, dword [eax + edi]
sal ax, 0xed
adc eax, dword [edi + eax + 4]
add edi, 4
sar dword [esp], 0x4b
sal word [esp + 1], 0xe3
xor ecx, ecx
jmp 0xb72dd7