joyce8/EMBER2024-capa huggingface dataset:
Function at 0x79c278
Capabilities:
Encode data using xor

Disassembly:
sub edx, 0x8d9bea81
cbw
bswap eax
xor ebx, edx
shr ecx, 0xf9
inc ecx
adc edi, edx
call fcn.00836250
mov ecx, dword [eax + esi - 0x6a0a023c]
sbb eax, eax
xor ecx, ebx
xor ecx, eax
xor al, 0x93
inc al
adc ecx, 0x78a91cbb
not ecx
rol ecx, 3
neg ecx
and al, ah
not ecx
inc ax
inc ax
shl eax, 0x2c
rol ecx, 3
neg al
neg ecx
rol eax, 0x3f
xor ebx, ecx
add ebp, ecx
movzx ecx, al
ror al, 0x23
add ecx, dword [ecx + edi]
and al, al
call fcn.00d0b3a6
pushal
push 5
add edx, esi
pop ebp
xchg esi, eax
inc edi
add byte [ecx - 0x6932bd6b], bh
inc edi
add byte [ecx - 0xb], dl
adc bh, byte [ebp + 0x1004796]
xchg edx, edi
jne 0x79c28a
inc edi
add cl, dh
pop ds
mov edx, 0x4796f5
push ecx
lcall 0x19b2, 0xe571665
jbe 0x79c34f
iretd
mov eax, 0x7490db21
mov dword [ebp + eax - 0x7490db21], edx
mov dword [esp + eax - 0x7490db1d], 0xcf11ffb8
mov dword [esp + eax - 0x7490db21], esi
ret 0x10
and al, 0x6f
mov eax, edi
test byte [ebx], al
and al, 0x6f
mov edi, dword [eax - 0x7630ee01]
mov ah, 4
fbld tbyte [edi + ebp*2]
mov eax, edx
adc byte [eax], al
call fcn.00874483
or ebx, dword [edi]
jmp 0x79c371
lodsd eax, dword [esi]
mov dword [0x69e62aff], ebx
mov ah, 0x3b
add ch, dl
rcl byte [esi]
pop ecx
mov ah, 0x3b
add byte [ecx - 0x4b16f9c7], ch
cmp eax, dword [eax]
cmp eax, 0x4ba0fe01
or cl, bh
jg 0x79c346
lodsd eax, dword [esi]
lahf
test al, 0xd8
mov esi, ebx
pushfd
mov eax, 0x467789d2
xor al, 0xb8
ror byte [ecx - 0x47f3c545], cl
ror byte [ecx - 0x47336539], cl
ror byte [ecx - 0x4713ede1], cl
ror byte [ecx - 0x4763c9d5], cl
ror byte [ecx - 0x478b11f1], cl
ror byte [ecx - 0x277bd91d], cl
pop edi
mov dword [0x132304b9], eax
retf 0x4c8b

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

Disassembly:
or dx, dx
not cx
movzx ecx, byte [ebp + ecx - 0xffff]
not dl
lea ebp, [edx + ebp - 0xfe]
xor cl, bl
mov dword [esp + edx - 0xff], 0x95968312
bts edx, edx
neg cl
rol cl, 1
xor cl, dl
push edx
sub cl, dl
add word [esp + 1], dx
bt edx, edx
or dword [esp + 4], edx
ror cl, 1
sal byte [esp + 0xb], 0x21
sub cl, dl
bswap edx
push edx
ror word [esp + 4], 0xc1
xor bl, cl
call fcn.00c9af61

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

Disassembly:
sbb ebp, 4
cdq
cdq
xor ecx, ebx
neg ecx
mov dword [esp], 0x831eb5
bswap ecx
push edx
mul dx
ror ecx, 2
shr dl, 0xe7
adc dword [esp + 8], 0xbf17c9a4
or dword [esp + 8], edx
xor ecx, 0x551ea6bc
xor dword [esp + 8], edx
inc eax
neg edx
sbb ecx, 0x803c2d29
ror eax, 0x2a
adc edx, dword [esp + edx*2 - 0x1fff6]
inc word [esp + edx - 0x1ca64]
xor ebx, ecx
add esi, ecx
sar edx, 0x89
jb 0x987004
lea eax, [esp + edx*2 - 0x17a]
add word [esp + edx - 0xdf], dx
movzx cx, byte [eax + edx*4 - 0x394]
lea eax, [edx + edx*8 + 0x1cb8ca0f]
shl ax, 0xc9
mov word [edi + edx*2 - 0x1ca], cx
div dl
lea ecx, [edx - 0x1ffb865b]
mov dword [esp + edx - 0xe5], esi
ret 8
dec ecx
invalid
ret
add al, 0
invalid
Function at 0x7a7841
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
dec ebp
arpl dx, dx
dec edx
mov dword [esp + edi - 0x3cd9c562], 0xd203afb1
movzx edx, bl
dec ecx
rol esi, cl
dec ecx
adc ebp, edx
and al, ah
inc dx
mov ebx, dword [esi + edi - 0x3cd9c562]
inc bp
xor esi, dword [edi + esi - 0x3cd9c560]
dec ecx
sal ebp, cl
jb 0x81e3d0
inc ecx
mov cl, byte [edi + esi - 0x3cd9c55e]
inc edx
sar dword [esp - 0x25], 0x15
inc ecx
and dl, ch
call fcn.008d887b
mov eax, 0x6c9c6894
lea esi, [eax + esi - 0x6c9c6898]
mov edx, dword [esi + eax - 0x6c9c6894]
xor edx, ebx
push eax
bts eax, 0x94
sbb edx, 0x8d88a505
cwde
add dword [esp + eax - 0x6894], 0x62a7df0e
jbe 0x909bb3
rol edx, 2
shl dword [esp + eax - 0x6894], 0xda
sub dword [esp + eax - 0x6894], 0x8b72206
movsx ecx, byte [esp + eax - 0x6894]
inc edx
neg edx
xor ebx, edx
xor dword [esp + eax - 0x6894], eax
adc edi, edx
shr ecx, cl
mul ecx
bt edx, ecx
lea esi, [esi + eax*2 - 0x3378d9]
pop ecx
movzx eax, byte [esi + eax - 0x19bc6c]
rol cl, 0x87
xor al, bl
inc al
inc cx
xor al, 0x3c
and ecx, ecx
xadd dl, ch
setne cl
sbb al, 0x17
bts ecx, 0xa0
sar cl, 0x86
neg al
inc ecx
imul cx, cx
xor bl, al
xor ecx, edx
not dl
call fcn.008f8ed6
mov cl, dl
push es
add dword [edx], esp
int 0x2d
inc esp
add byte [ecx], dl
push edi
sub al, byte [ebp + 0x2d]
inc esp
add byte [ecx + 0x2de56aed], dh
inc esp
add byte [ebp + 0x66], dl
mov edx, 0x442d35
int1
invalid
dec eax
lea esi, [ebx + esi - 0x299d]
inc esp
movsx eax, word [esp + ebx*2 - 0x533b]
inc sp
mov dword [ebx + eax - 0x29a7], esi
mov eax, dword [esp + ebx - 0x29a7]
dec eax
adc dword [esp + ebx - 0x29a7], ebp
ret 0x10
jmp 0x90fd28
movsx ecx, byte [esp + edx - 0x1c21112d]
sub al, 0x21
ror cl, 0xc6
sar edx, cl
rol ecx, cl
xor al, 6
btc edx, 0xb8
btc edx, 0x94
inc al
lea ecx, [ecx + ecx*4 - 0x9667edf]
add dx, dx
xor al, 0x82
xor bl, al
sar word [esp + edx - 0x1f11111], cl
sar dl, 0x64
lea edi, [edi + edx - 0x1f11103]
bswap ecx
sar dl, 7
jne 0x8b0661
mov word [edx + edi - 0x1f11100], ax
sub dword [esp + edx*4 - 0x7c44400], 0x800e9c86
not cx
pop ecx
jnp fcn.00c9bff2
mov edx, 0xfb8d7986
lea edx, [edx*8 - 0x51e78643]
sub ebp, 4
shl edx, 0xf0
movsx ecx, dl
mov eax, dword [ebp + ecx*4]
sal ecx, 0xcd
xor eax, ebx
btc dx, cx
xor dl, cl
lea eax, [edx + eax - 0x699d688f]
push ecx
or dl, ch
ror eax, 1
add ecx, dword [esp + ecx*4]
xor edx, edx
sbb ecx, ecx
lea eax, [eax + edx - 0x54a0a6b3]
sar dword [esp + edx*8], 0x92
shr ecx, 0xc4
xor eax, 0xb002ec94
call fcn.00cdbd00
sub edi, 4
push 0x85326684
mov eax, 0xa31098b1
mov ecx, dword [edi]
xor ecx, ebx
sub ax, ax
rol ecx, 1
movzx edx, word [esp]
neg eax
ror byte [esp + edx*8 - 0x3341e], 1
inc ecx
push eax
sal ax, 0x22
call fcn.008cc7b0
jmp fcn.0087f7d5
Function at 0x7a819b
Capabilities:
Encode data using base64
Encode data using xor

Disassembly:
mov dword [esi + 0xc], eax
mov eax, 0xb99cd3a4
mov dword [esp], 0x20ada98c
mov dword [esi + 8], ebx
mov dword [esi + 4], ecx
movzx ebx, word [esp]
mov dword [esi + ebx*8 - 0x54c60], edx
mov ebx, dword [esp + ebx - 0xa988]
ror byte [esp + 1], 0x27
sbb edi, 4
mov dword [esp + 4], 0x5b2b9f3c
pop edx
sub dx, dx
mov edx, dword [edi + edx - 0x20ad0000]
xor edx, ebx
ror ax, 0xa7
ror edx, 1
not edx
movsx ecx, al
rol edx, 1
ror dword [esp], 0x85
setae cl
lea edx, [edx + eax - 0x7914381e]
shr dword [esp], 2
and al, 0xba
xor ebx, edx
rol eax, 0x78
push eax
add ebp, edx
inc eax
ror dword [esp + 3], 0x58
pop eax
pop edx
jae fcn.00909547
mov ecx, 0x5fb2c984
mov ecx, dword [ebp + ecx - 0x5fb2c984]
mov dx, word [ecx]
add ebp, 2
mov eax, 0x5d87dd98
mov word [eax + ebp - 0x5d87dd98], dx
lea ecx, [eax + eax*4 + 0x5e3421ab]
lea esi, [ecx + esi - 0x31db75a7]
mov eax, dword [esi + ecx - 0x31db75a3]
xor eax, ebx
not ecx
sub ecx, ecx
lea edx, [ecx + ecx - 0x4379bae0]
inc eax
shl dl, 0xa5
not cl
push edx
xor eax, 0xd2816f03
xadd dword [esp + ecx*8 - 0x7f8], ecx
adc dword [esp], ecx
call fcn.00852597
mov eax, 0x6eb5c1a9
mov ecx, dword [esi + eax - 0x6eb5c1a9]
mov edx, eax
add eax, edx
btc dx, 0x28
mov edx, dword [esi + edx - 0x6eb5c0a5]
and eax, 0x143a1f27
sar al, 0xa3
lea eax, [eax + eax*2 - 0x796a79ec]
or ecx, edx
not ecx
mov edx, dword [esi + 8]
not ecx
inc ax
inc eax
sar ax, 0xce
not edx
bts ax, ax
ror eax, 0xe7
and ecx, edx
mov eax, ecx
mov edx, 0xee05f42a
mov ecx, dword [esi + 0xc]
and eax, ecx
shl dx, 0x41
setno dl
movsx ecx, dl
not eax
sar edx, 0x10
sar edx, cl
jbe 0x9b8488

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

Disassembly:
mov dword [esp + edx - 0xa438], 0x650c75ac
call fcn.0093d9ac
Function at 0x7baad0
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
lea esp, [esp + 8]
je 0x98aae4

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

Disassembly:
mov word [ecx + ebp - 0x781a317f], dx
pop edx
pop eax
pop ecx
jne fcn.00754c95
add edi, edx
cwde
btc ecx, ecx
btc eax, eax
mov al, byte [ebp + ecx*8 - 0x18]
jae 0x8c0805
lea ebp, [ebp + ecx*2 - 5]
movzx edx, cx
xor al, bl
rol al, 1
add al, 0xb
bts edx, edx
ror al, 1
xor al, 0x93
inc edx
inc dx
xor bl, al
and edx, edx
adc eax, esp
mov dx, word [ecx + eax - 3]
movzx eax, cl
dec ecx
sub esi, ecx
sub ecx, eax
mov word [esi + eax*8 - 0x18], dx
mov edx, 0x56bb07bc
cmovp ecx, eax
jle fcn.009542f2
pop eax
dec ebx
lea edx, [ebp + esi*4 - 0x645495d8]
inc ecx
rol dl, 1
inc ecx
mov esp, 0xd22fae91
inc ecx
neg dl
inc ebp
xor cl, dl
inc cx
inc esp
cdq
inc cx
mul esp
dec esp
add edx, esp
inc esi
mov dword [ecx + edx - 0x7f857f86], edi
dec ecx
idiv ebp
dec ecx
bts ebp, 0xb3
inc esi
movzx ebp, byte [edx + ebx - 0x3ad1345a]
cdq
inc esp
bt eax, esp
inc ecx
add esi, 0x3600c90d
inc ebp
xor ch, cl
movzx edi, ax
inc ecx
inc ch
movzx ebx, al
idiv edi
or cl, bl
inc ecx
ror ch, 1
inc esp
movsx edx, cx
inc ebp
xor ch, dl
or bx, 0xaa04
call fcn.007a67cf

Function at 0x7c0a56
Capabilities:
Encode data using base64

Disassembly:
dec esp
btc ebx, edi
dec esp
xchg dword [esp + eax - 0x81fdf5], edi
dec eax
lea esi, [esi + eax*4 - 0x207f822]
shl ecx, 0xb
btc ebx, 0x90
inc ebp
mov ebp, dword [ebx + eax - 0x81fe06]
dec eax
or ecx, 0x7d914b3d
inc dword [esp + eax*4 - 0x207f7fe]
dec ebp
lea ebx, [ebx + eax*4 - 0x207f81a]
inc ebp
xor ebp, ecx
inc ecx
rol ebp, 3
inc ecx
pop esi
inc esp
mov esi, ebx
inc ecx
div edi
inc ecx
not ebp
inc ecx
inc ebp
xor cl, byte [esp + eax - 0x61823]
inc ecx
not ebp
dec esp
mov dword [esp + eax - 0x61820], ecx
jp 0x9167ff
inc esp
xor dword [esp + eax*2 - 0xc3068], ebp
call fcn.0092ddc6
Function at 0x7c2d35
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
neg ecx
shl eax, 0x16
xor eax, dword [esp + edx*2 - 0x8000600]
jne 0x7c7dd9
mov edx, 0x44ab921b
lea ebp, [ebp + edx - 0x44ab921f]
bts edx, edx
adc dx, dx
mov edx, dword [ebp + edx - 0x4cab2436]
call fcn.0094dbb8
movsx ecx, word [esp + edx]
mov dword [esp + edx*8], edi
ret
btr ax, ax
and dl, cl
imul eax, eax
not dl
mov word [esi], dx
mov dword [esp], eax
mov ecx, dword [ebp]
adc ebp, 3
xor ecx, ebx
mov edx, eax
bswap ecx
rol edx, 0x49
adc dword [esp + edx*4 - 0x10000cc8], edx
and dl, 0
lea ecx, [eax + ecx - 0x2364354d]
not eax
sbb word [esp + eax - 0x66fdfffe], dx
jae 0x76cb5e
mov edx, 0x1e2fc339
inc dl
mov eax, dword [esi + edx*4 - 0x78bf0ce8]
sar edx, 0x43
lea ecx, [edx*4 + 0x3e057e03]
ror ecx, cl
mov edx, dword [esi + edx*2 - 0x78bf0ca]
neg ecx
lea esi, [esi + ecx - 0x65c540be]
inc ecx
not eax
xor cx, 0xb625
ja 0x912b4f
sub ebp, 4
mov edx, 0x469ee300
or edx, 0x89bd109
mov eax, dword [ebp + edx - 0x4e9ff309]
jbe 0xc9336b
xor eax, ebx
sal dl, 0xa5
bt dx, 0x24
inc eax
mov ecx, edx
xor ecx, edx
ror eax, 3
neg cl
shl cx, 0x6a
ror cl, 2
neg eax
lea eax, [eax + edx*4 - 0x5d49d161]
rol ecx, 1
rol eax, 1
not eax
sub edx, ecx
ror eax, 3
xor ebx, eax
dec ecx
add edi, eax
lea eax, [ecx*2 + 0x47263f1c]
or ecx, ecx
mov eax, dword [esi + eax - 0x47263f1a]
add cx, 0x7a6
rol dx, 0xc2
mov edx, dword [edx + esi - 0x4e9fcc7f]
inc cl
sub cl, cl
jns 0xc99bfc
mov eax, dword [edi]
mov edx, 0x86824d38
sub dx, dx
adc edi, 4
add edx, edx
mov ecx, 0x97b8bc8f
or cx, cx
xor eax, ebx
ror ecx, cl
sub cx, 0x9495
ror eax, 2
dec eax
xadd cx, dx
sub edx, edx
not eax
imul ecx, ecx
ror edx, cl
bt dx, 0x98
bswap eax
sbb eax, 0xd58e2f97
dec ecx
ror ecx, 1
lea ecx, [ecx + edx*8 + 0x76aa1794]
xor ebx, ecx
idiv al
sar edx, 0xff
adc edi, ecx
jmp 0x7b900c
call fcn.00775aa7
rol ecx, cl
not edx
jbe 0x811906
sbb eax, eax
add cl, dl
movsx edx, al
cwd
btc dx, 0x82
mov word [ebp], cx
movsx ecx, dx
ror edx, 0x12
bswap eax
mov ecx, dword [edi]
neg ax
xor ecx, ebx
sub dx, 0x7e35
and al, dl
cbw
ror ecx, 1
sar edx, 0x10
bswap ecx
not ecx
cmovns edx, eax
add edx, edx
rol al, 0x85
ror ecx, 1
xor ebx, ecx
rol al, 5
xor edx, edx
cwde
adc esi, ecx
neg dx
movsx ecx, dl
adc al, byte [edi + eax + 4]
lea edi, [edx + edi + 5]
xchg ch, cl
btc cx, 0xae
xor al, bl
add ecx, edx
btc ecx, edx
shr cx, cl
sbb al, dl
rol al, 1
lea edx, [edx*4 + 0x249bebb1]
bt edx, edx
sbb al, cl
shr cl, 1
call fcn.00c85950
add ecx, ecx
xor edx, ebx
add al, 0xa6
sar eax, cl
sub al, ch
dec edx
add cl, byte [esi + 8]
call fcn.009336d1
Function at 0x7c2f8e
Capabilities:
Encode data using xor

Disassembly:
ror dl, 1
mov dword [esp + ecx - 0x80], 0x300f3209
xor bl, dl
shr ecx, 0xea
lea edx, [esp + edx + 4]
mov eax, dword [edx + ecx*8]
jbe 0x85fc1b
mov dword [ecx + esi - 4], eax
sbb dword [esp + ecx], ecx
call fcn.00cd7ca5
rol dl, 1
xchg word [esp + ecx*4 - 0xa], cx
sub dl, 0x22
shr dword [esp + ecx - 0xa18a], cl
xor dl, 0x3e
xor bl, dl
neg cx
dec eax
lea eax, [ecx + ecx - 0xf69ac59]
lea edx, [esp + edx + 4]
or al, al
ror word [esp + ecx - 0x5e76], 0x22
inc dword [esp + ecx - 0x5e76]
mov eax, dword [edx + ecx*2 - 0xbcec]
movsx edx, cl
inc cl
mov dword [esi + ecx*4 - 0x179e0], eax
mov eax, dword [esp + ecx - 0x5e77]
lea edx, [edx + ecx + 0x6eb011a6]
movzx edx, byte [ecx + ebp - 0x5e79]
xor dl, bl
mov eax, dword [0xd332ffff]
add dl, 0xa7
add ecx, ecx
neg ax
ror dl, 1
add dl, 0x97
lea ecx, [ecx + ecx*8 + 0x28c45a0]
xor dl, 0xbb
shr eax, 0xb1
xor bl, dl
and ecx, eax
neg dword [esp + ecx*4]
call fcn.00c5c42c
scasd eax, dword es:[edi]
out dx, al
inc esi
clc
fiadd dword [esi]
xchg esi, eax
mov eax, 0x1a383a6d
xchg esi, eax
mov eax, 0x72d0c66d
xchg esi, eax
mov eax, 0x42607e6d
xchg esi, eax
mov eax, 0x9664fe6d
je 0x85fc84
insd dword es:[edi], dx
xor byte [edi], bh
test byte [ecx - 0x7846b83b], ah
dec dword [esp + edi]
mov ecx, 0x50c20086
xor al, 0xb9
xchg byte [eax], al
add al, 0xb9
xchg byte [eax], al
loop 0x85fd65
adc eax, 0xc80076df
or eax, 0xbb9bc329
xlatb
cmpsd dword [esi], dword es:[edi]
xor esi, dword [ecx]
rol byte [edx - 0x58], 1
mov ch, 0xf8
xor eax, edx
inc edx
test al, 0xb5
clc
and eax, 0xc5d7bc76
mov bl, 0x72
mov edx, 0x6d61a1b5
loopne 0x85fcfa
test al, 0xb5
sub dword [ebx + 1], 0xb5a8ebd0
invalid
movzx ecx, word [esp]
mov ecx, dword [ecx + esi - 0x86ca]
movzx eax, dx
btc eax, 0x8c
xor eax, 0x41ac9697
movzx eax, byte [ebp + eax - 0x41ac9690]
not edx
xor al, bl
ror al, 1
bt dx, 0x38
dec dword [esp + edx - 0x10eaeff9]
dec al
pop edx
xor al, 0x94
bt edx, edx
sbb dx, dx
sar edx, 0x14
sbb al, dl
xor bl, al
add eax, esp
lea edx, [edx + edx + 0x342c7580]
mov dword [eax + edx - 0x342c737c], ecx
movsx eax, dx
mov eax, dword [esi + edx*2 - 0x6858e6f0]
lea esi, [esi + edx*2 - 0x6858e6ec]
mov ecx, 0xb730f294
lea ecx, [esp + edx - 0x342c737c]
shl edx, 0xb0
btc dx, 8
add dx, dx
mov dword [ecx + edx - 0x737c0200], eax
mov ecx, edx
movsx eax, dl
xor eax, dword [ebp + ecx - 0x737c01fe]
bt edx, edx
lea ebp, [edx + ebp - 0x737c01fa]
shr cx, 0x8e
xor eax, ebx
rol ecx, 0x33
add dl, 0xd
shl edx, 0x10
xor eax, 0xe936e95
add ecx, edx
xchg ecx, edx
adc eax, 0xa091b026
rol ecx, 0x75
bt dx, cx
btc edx, edx
rol eax, 2
not eax
and edx, edx
jo 0xcd1d7b
sbb eax, 0xb20e8383
bts edx, 0xb3
xor ebx, eax
sub dx, dx
and ecx, 0xa71a7884
imul dx, dx
adc edi, eax
push ecx
mov dword [esp + edx*8 - 0x10c00000], edi
ret
Function at 0x7c7585
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
movzx ecx, di
dec eax
lea esi, [esi + ecx - 0xd7a0]
dec eax
mov dword [esp + ecx - 0xd7ac], edi
sal edi, cl
inc ecx
mov dword [ebp + ecx*4 - 0x35eb0], edx
inc ecx
mov eax, dword [ebx + ecx*2 - 0x1af58]
mov ebx, dword [esp + ecx - 0xd7a9]
dec ebp
lea ebx, [ebx + ecx*2 - 0x1af54]
dec eax
xchg ebx, edi
inc ecx
xor eax, ecx
call fcn.007c2e7a

Function at 0x7c88c0
Capabilities:
Authenticate hmac

Disassembly:
xor cl, bl
xor ax, dx
sub eax, edx
mul ax
not cl
and eax, edx
imul dx
adc cl, dl
mov dword [esp + edx*2 - 0x3623fffe], edx
inc ax
mul ax
xor cl, 0xa8
shr byte [esp + eax - 0x95e1], 0x24
pop edx
ror cl, 1
btc edx, edx
dec dl
xor bl, cl
xchg edx, eax
shl al, 1
mul eax
add ecx, esp
mov edx, dword [ecx + edx*2 - 0x5b96404]
movzx ecx, ax
mov dword [ebp + eax - 0x8d4cb14], edx
mov edx, 0x1dad2e86
mov eax, dword [ebp + eax - 0x8d4cb14]
mov ecx, dword [ebp + ecx*2 - 0x19620]
imul dx, dx
or edx, edx
inc dl
or eax, ecx
dec dx
movzx ecx, dx
not eax
mov dword [edx + ebp - 0x1dad6e24], eax
sar dl, cl
mov eax, edx
xchg edx, ecx
mov eax, dword [edi + edx*2 - 0xdc47]
and cl, dh
xor eax, ebx
lea eax, [eax + ecx*8 - 0x21dbb3e4]
rol edx, cl
not eax
lea eax, [edx + eax - 0x70c148b6]
shr cl, 0x42
neg ecx
bswap eax
sbb dx, 0xb02f
sar dl, 0x27
xor ebx, eax
push ecx
sub cl, dl
xchg word [esp + edx*8 - 0x84000], cx
adc esi, eax
sal dword [esp + edx*2 - 0x21000], 0xe3
shl byte [esp + edx - 0x107ff], 1
mov ecx, dword [edi + edx - 0x107fb]
movzx eax, dx
push edx
lea edi, [edx + edi - 0x107f7]
not edx
adc eax, 0xf0e0432
xor ecx, ebx
jmp 0xc47934
mov edx, dword [edx + esi - 6]
mov eax, 0xee00420f
btr eax, eax
sar ax, 0x4e
xor edx, ebx
dec edx
mov ecx, dword [esp]
pop ecx
jmp 0xc3c61f
bswap edx
shl ecx, cl
sbb al, ah
add eax, 0x9000d790
lea edx, [edx + eax - 0x6ac8a366]
lea eax, [ecx - 0x1146d442]
bswap edx
not edx
shl ax, 0x67
dec edx
rol edx, 3
bswap edx
or eax, ecx
adc ecx, 0x8206bd93
neg ecx
ror edx, 2
inc edx
sub cl, ah
jp 0xc4122c
sbb dword [ebx], ebx
jbe 0xc3c676
mov al, 0
invalid
imul edi, dword [eax*2 + 0x5500b29f], 0x9d1cb6ff
pop ss
xchg esp, eax
in al, dx
add edx, dword [ecx - 0x5f37ec89]
jb 0xc3c6d5
mov ecx, 0xc67a05f9
adc edi, dword [edx - 0x39fdbc13]
adc edi, dword [edx - 0x39c5be57]
adc edi, dword [edx + 0x6b6946a5]
invalid
adc eax, 0xf7058209
fcmovbe st(0), st(3)
invalid
xor edx, 0xb8197b82
btc ecx, ecx
sub eax, 0x750bad0e
bt ax, 0xa1
xor ebx, edx
sub al, 0x2b
sbb ecx, eax
adc ebp, edx
jmp ebp
or dl, byte [esp + eax - 0xf0e0c2e]
lea ecx, [ecx + eax*4 + 0x2af06dc4]
jns 0x81b2cd
sar eax, 0x29
not ecx
add dword [esp + eax*2 - 0xf0e0a], edx
mov byte [esp + eax - 0x78701], ah
lea ecx, [ecx + edx - 0x264488e6]
adc byte [esp + eax*2 - 0xf0e08], ah
dec dword [esp + eax - 0x78706]
rol ecx, 1
dec dword [esp + eax*2 - 0xf0e0b]
lea ecx, [eax + ecx + 0x432c62a5]
bswap ecx
sal dword [esp + eax*4 - 0x1e1c18], 0x2d
dec eax
xor ebx, ecx
mov dword [ebp + eax*8 - 0x3c382c], ecx
lea ebp, [ebp + eax*8 - 0x3c382c]
pop edx
pop eax
jmp fcn.00882a69
Function at 0x7c8fe1
Capabilities:
Encode data using base64

Disassembly:
pop eax
mov eax, 0x4f8ad3a0
xor ecx, 0xc405f9a2
push eax
neg eax
adc ax, dx
adc ecx, 0x202b1b99
xor ebx, ecx
add edi, ecx
add dword [esp + 0x10], edx
movsx ecx, dx
call fcn.0079c147
call fcn.00c5bdec

Function at 0x7c900e
Capabilities:
Encode data using base64

Disassembly:
inc bp
xor edi, ecx
inc ebp
xchg dh, ch
inc cx
not edi
inc ebp
xadd ebp, edx
ror ebx, cl
inc cx
rol edi, 1
inc ecx
pop edx
inc cx
xor edi, 0xf4c301c
stosd dword es:[edi], eax
ror byte [edi], 1
sbb dword [ebp - 0x38fff5d3], 0x44
mov dword [esp], 0x63b6132e
inc dword [esp]
mov dword [ebp - 4], eax
push 0x279f86b2
test ebx, ebx
push 0xc108281b
jmp 0x930ab2
neg edx
xor al, ah
mov dword [esp + ecx - 0x1cd3], 0xad8a3596
not edx
ror ax, 0xa2
sub byte [esp + ecx*4 - 0x7346], ch
xor ebx, edx
btc ecx, ecx
setb al
adc eax, eax
mov dword [esi + ecx - 0x81cd3], edx
jle 0x7d45b9
inc cx
not ebp
inc ebp
mov esi, esp
inc ecx
push esp
inc cx
neg ebp
inc cx
not ebp
inc esp
mov edi, dword [esp + ecx - 0x575e6ee3]
dec ecx
and edi, 0x3322ab1a
inc dx
not dword [esp + edi - 0x3322ab08]
inc cx
neg ebp
inc edx
mov eax, dword [esp + edi - 0x3322ab0e]
inc ecx
shl ah, 0xa5
dec eax
cdq
inc cx
adc ebp, 0xf45f314
mov dh, 0xc4
inc ecx
bswap eax
cdq
inc bp
xor ecx, ebp
inc sp
btc edx, esp
dec eax
lea esi, [ecx + esi - 0x575e6ef0]
jb 0x79a0bf
inc si
mov dword [esi + edi - 0x3322ab10], ebp
dec eax
cdq
neg dword [esp + ecx - 0x575e6eda]
inc cx
sar edi, 0xd
inc ebx
mov ecx, dword [edi + ebx - 0x3322fffd]
inc esp
movsx ebp, byte [esp + eax*4 - 0x304e2]
dec edi
lea ebx, [ebx + edi - 0x3322fff9]
inc edx
sets byte [esp + edi - 0x3322fff5]
call fcn.008cf330
or cl, dh
setnp dl
neg eax
rol edx, cl
adc dx, cx
dec cl
xor ebx, eax
add edi, eax
not edx
ror cl, 0x87
call fcn.009b2fa6
movsx edx, word [esp + ecx - 0x81ccf]
pop eax
mov edx, dword [ebp + ecx*4 - 0x207347]
lea ebp, [ebp + ecx*2 - 0x10399d]
xor edx, ebx
push ecx
call fcn.0086aaf1
lea esp, [esp + 0xc]
je 0x8ae516

Function at 0x7cb7ac
Capabilities:
Encode data using base64

Disassembly:
inc ecx
sub esp, 0xc98e6119
pop ecx
inc ecx
xor esp, 0xbbb57c16
inc ecx
idiv esi
inc ecx
sub esp, 0x97b526a7
dec ecx
shr ebp, 0xa6
dec ecx
imul edx
inc ecx
xor esp, 0xa12afa02
inc ecx
movsx edi, bh
inc ecx
sub esp, 0x9c131625
dec ecx
inc edx
inc bl
inc ecx
not esp
inc cx
sal ebp, 0xe1
not word [esp + ebx - 0x293ecc0d]
inc ecx
neg esp
dec eax
shr eax, 0x92
call fcn.0076635e
mov edx, 0xdb94ceaf
shl edx, 0xda
mov ecx, dword [esi]
jp 0x90c91a

Function at 0x7cde15
Capabilities:
Encode data using base64

Disassembly:
mov dword [esp + 4], 0x11223126
push 0xd79ae21f
xor eax, eax
dec word [esp + 1]
mov dword [esp + 4], 0x3021c0b3
neg byte [esp + 4]
test edx, edx
push 0x7e384e8e
push 0xbc0ebf80
call fcn.0075cf74

Function at 0x7cde83
Capabilities:
Encode data using base64

Disassembly:
ja 0x9bb9c5
mov ecx, 0x18d601c
movzx eax, cl
mov ax, word [esi + ecx*8 - 0xc6b00e2]
btc ecx, 0xb8
shl cx, 0x64
bts cx, cx
xor ax, bx
call fcn.0097715d
call fcn.0083b51e
Function at 0x7ce9b4
Capabilities:
Authenticate hmac
Encode data using base64
Encrypt data using chaskey

Disassembly:
mov dword [esp], eax
not edx
xor cx, word [esp + 1]
neg edx
add byte [esp + 3], cl
ror edx, 3
rol ax, 0xc6
and ecx, 0x1c200916
ror eax, cl
not edx
rol ecx, 0x6a
jbe 0xc3c647
jns 0x749913

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

Disassembly:
cwde
sar ax, 2
mov cx, dx
inc eax
movzx cx, cl
neg ax
mov dl, byte [edi + eax*4 - 0x3d274]
mov dword [esp + eax - 0xf49d], eax
not cl
add al, 2
xadd byte [esp + eax*8 - 0x7a4f8], ah
neg eax
not dl
jbe 0x822fb3
mov ecx, 0xc92498af
movzx edx, byte [ebp]
movzx eax, cl
call fcn.008a6e54
inc ecx
mov esp, 0xfc8aab18
dec ecx
ror esp, 7
dec esi
lea eax, [0x601e629c]
inc ebp
mov esi, dword [ebx]
inc cx
dec esp
jp 0x98c330
cwde
mov byte ss:[edx], cl
movzx ecx, byte [esp]
mov dword [esp + ecx - 0xd], ebp
ret
sub word [esp], ax
and cl, dl
mov word [edi], cx
movzx ecx, word [ebp - 6]
lea edx, [eax*2 - 0x6f450ae7]
sub ebp, 6
bts eax, eax
cwde
xor cx, bx
sar eax, 0xa1
mov dword [esp + eax - 0x3131], 0x171acdb9
inc cx
jmp 0x834ca2
pop edx
rol edx, 6
ror cx, 1
neg cx
cwd
rol cx, 1
xor ax, 0x3c8c
xor ax, 0xe12b
not cx
inc dl
xor bx, cx
mov word [edi + eax - 0xec98], cx
lea ecx, [eax + 0x303388f]
lea edi, [edi + eax*2 - 0x1d92e]
sub dl, 0x97
adc eax, edx
jo 0xc7011b
jae fcn.00c9bff2
mov dword [esp + ecx - 0x7e9aa2b2], eax
shl ax, 0x66
sal cl, 0xa2

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

Disassembly:
lea esp, [esp + 0xc]
ja 0xcbca6b
mov ecx, 0x6074e89
mov edx, esp
movsx eax, cx
btr ecx, ecx
or eax, eax
lea ecx, [eax - 0x4e3d]
rol al, 0x23
lea eax, [ebp + eax*4 - 0x139b0]
push 0x99159ba0
and eax, 0xfffffffc
push 0x2b06a59e
sub eax, ecx
mov esp, eax
push 0xbdaa332d
mov dword [esp], edi
call fcn.00953840

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

Disassembly:
mul byte [esp + edx - 0x442d9894]
mov dword [edi + edx - 0x442d989d], ecx
btc eax, 0xbe
cwd
pop ecx
pop eax
pop edx
jb fcn.00c9bff2

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

Disassembly:
sub dword [esp + 6], 0xbda02437
or word [esp + 9], 0x389e
xor ecx, 0x9a270a0c
dec eax
call fcn.007da3eb
inc ecx
mov eax, 0xa932c60d
inc ebp
movsx esp, ax
inc sp
mov esp, dword [esi]
inc ebp
movsx ebp, al
mov eax, 0xeb3658b7
mov edx, eax
inc ecx
mov cl, byte [ebp + esi - 0xb]
dec esi
lea edx, [ebp*8 + 0x26b509ae]
dec esi
lea edi, [eax*2 - 0xde880cd]
movsx edi, dl
dec edx
lea esi, [esi + ebp - 0xb]
dec edi
lea esi, [edi + edi*2 - 0x46fdeb7c]
inc cx
sal esp, cl
inc bp
mov dword [ebp + esi - 0xd], esp
call fcn.00878cc8
shl cx, cl
mov dx, word [esi + ecx*4 - 0x17444800]
movzx ecx, byte [ebp + ecx*4 - 0x17444805]
rol ax, 0x4e
ror eax, 0xb5
shr al, 0x61
xor cl, bl
inc cl
sar eax, 0xb9
xor cl, 0x3b
and eax, eax
sbb cl, 0x81
shl al, 0x25
xor cl, 0x99
rol ax, 0x89
mov word [esp + eax], ax
sbb cl, 0x3f
xor cl, 0x9e
call fcn.00c9e7c3
xor ecx, edi
mov dword [esp + 8], 0x68318e13
inc edx
jmp 0x765cd6