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

Disassembly:
dec edx
mov dword [esp + edx], ebp
dec esi
mov ebx, dword [esp + edx*4 + 8]
dec edx
mov dword [esp + edx*2 + 8], ebx
shr dl, 3
dec eax
arpl cx, cx
pop eax
dec eax
cdq
dec esp
adc ebp, ecx
dec ecx
add ecx, 0xd7acde16
dec ecx
lea ebx, [edi - 0x34506155]
inc sp
adc edx, dword [edi + ebx + 0x34506124]
dec eax
rol dword [esp + ebx + 0x34506124], 0xf0
inc ebp
bt eax, ecx
dec eax
lea edi, [edi + ebx + 0x34506126]
inc edx
movzx ecx, word [esp + ecx + 0x285321b3]
inc esp
sub ecx, eax
inc bp
xor edx, ebx
inc cx
ror edx, 1
inc cx
add edx, 0x41668fbb
not edx
or bp, word [esp + eax*2 + 6]
inc ebp
btr eax, ecx
inc cx
dec edx
bts ebp, 0xa8
inc bp
xor ebx, edx
dec eax
inc dword [esp + ebx + 0x34506124]
dec esi
lea edx, [esp + edx + 8]
inc dx
add edx, dword [ebx + edx + 0x34506124]
dec eax
sar dword [esp + ebx + 0x34506124], 0xd
dec eax
lea esi, [ebx + esi + 0x34506122]
inc esp
cmovns eax, ebp
mov word [ebx + esi + 0x34506124], dx
ror cl, 0xc5
inc si
xor esp, dword [esp + edi*2 - 0x61]
movsx edx, cl
inc ecx
pop edx
jle fcn.00cc0ab0

Function at 0xce7cc2
Capabilities:
Encode data using base64

Disassembly:
dec al
mov dword [esp + eax - 0x688d26bc], 0x1f9e819f
not dl
shl al, 0xa7
shl eax, 0x99
sar word [esp + eax*2 + 5], 0xe2
and cl, dl
mov word [ebp + eax*2 + 4], cx
sal byte [esp + eax*2], 0x44
lea ebp, [ebp + eax*2 + 4]
movsx edx, ax
adc eax, eax
xchg dword [esp + eax + 3], edx
mov eax, dword [esi + eax - 5]
movsx ecx, byte [esp + edx*4 - 0xfd5521c]
lea esi, [edx + esi - 0x3f5548c]
xor eax, ebx
dec eax
shr cl, 0xa1
not byte [esp + edx - 0x3f55486]
xor word [esp + edx - 0x3f55482], cx
bswap eax
lea edx, [edx + edx + 0xd1b4d0a]
jae 0xcd6853
Function at 0xd39fcf
Capabilities:
Encode data using base64

Disassembly:
lea esi, [esi + eax - 0x1f]
dec cl
jle 0x14fd494
neg dl
mov eax, dword [esi + eax*2 - 0x36]
xor eax, ebx
sub eax, 0xe5924601
add cl, 0x31
sal ecx, cl
not eax
rol edx, 0xa1
or cx, cx
neg eax
add ecx, 0x4733f7a4
imul edx, ecx
jo 0x158ebc7
mov edx, 0x843602a0
movsx ecx, dl
mov ax, word [ebp]
sar ecx, 0x1f
mov dx, word [ebp + 2]
and cl, ch
xor ax, cx
shr cl, 0xa1
setle cl
shl cl, cl
not dx
bts ecx, ecx
jae 0xd66152
not ecx
neg al
setno dl
or dx, 0x49ad
ror ecx, 1
dec ecx
ror edx, 0x99
neg ecx
shr al, 0xc1
add eax, 0xd8b9380c
xor ecx, 0x3e2caa0c
and eax, eax
jo 0x151f150
xor ebx, ecx
jmp 0xd4a708
neg dword [esp + edx + 4]
mov byte [ecx + edx*4], al
mov dword [esp + edx*2], edx
movzx ecx, dl
lea esi, [esi + edx - 4]
and dl, cl
mov eax, dword [edx + esi]
lea ecx, [ecx + edx*8 + 0x441a7ea5]
sbb dx, dx
and word [esp + edx + 3], cx
xor eax, ebx
lea eax, [eax + edx*2 + 0x13b45b9e]
dec edx
jg 0x15bdefb
bswap eax
call fcn.0157d4a4
shr edx, 0x91
adc edi, ecx
movzx ax, byte [edx + ebp - 0x24fa]
lea ecx, [edx + edx*4 + 0x268cae01]
ror dl, cl
inc cx
mov cl, byte [ebp + edx - 0x245d]
push edx
pop edx
xor dl, dl
lea ebp, [ebp + edx - 0x23fe]
sal dx, 0xc8
shr al, cl
movzx ecx, dl
mov word [ebp + edx*4], ax
add edx, edi
jmp edx
neg ecx
and ax, dx
movzx edx, cx
mov word [ebp + ecx*2 - 0x1f2], ax
mov eax, dword [esi + ecx - 0xfe]
not dx
lea esi, [esi + ecx*8 - 0x7d4]
btc cx, 0x81
call 0x1510a33
mov cx, word [ebp]
mov edx, 0x5c8c920b
mov dx, word [ebp + edx - 0x5c8c9209]
add ebp, 2
mov eax, 0x3cbdf101
ror eax, 0x59
or cx, dx
not cx
lea eax, [eax + 0x2a3395a1]
xor ax, ax
rol ax, 0xe3
mov word [ebp], cx
sbb esi, 4
or al, 0xa3
cdq
mov edx, dword [esi]
xor edx, ebx
sal eax, 0x56
cwde
not edx
movsx ecx, al
lea edx, [edx + eax*4 - 0x528a740a]
dec ax
bt ecx, eax
cbw
not edx
sub eax, ecx
dec ecx
bswap edx
xor eax, ecx
cbw
or eax, eax
xor ebx, edx
and al, 0x23
adc edi, edx
jmp edi
xor edx, 0xb2359baf
neg al
or dx, 0x2a87
neg dx
push edx
adc al, 0x2d
sub dword [esp], 0xc0238408
neg edx
xor bl, al
xor edx, edx
jge 0x1562664
add ah, cl
sbb dword [edx], edx
ret 0x6d17
sbb eax, 0xe38b7f32
shl ecx, cl
rol cl, 0x83
btc edx, edx
not eax
ror ecx, 0x63
rol edx, 0x69
ror edx, 0xc8
xor ebx, eax
btc ecx, ecx
adc edi, eax
movsx eax, dx
fadd qword [ebp + edx*4 - 0x14191864]
call fcn.01588ee1
rol eax, 3
call fcn.00d71005
call fcn.00d7a34d
mov ecx, 0x2a9c6986
mov edx, 0x3ead909f
lea esi, [esi + ecx - 0x2a9c698a]
shr cx, 0xef
sbb cx, 0xb518
neg dx
mov eax, dword [esi + ecx*2 - 0x553895ce]
lea ecx, [edx + edx*2 - 0xcd037cc]
setnp dl
ror ecx, cl
xor eax, ebx
lea eax, [eax + ecx + 0xe5bf733]
inc ecx
jle 0xcc8b48
sal cl, 0xe5
ror eax, 3
sub eax, 0x4c08a9b2
ror eax, 2
bts dx, cx
xor ebx, eax
add edi, eax
movzx eax, dx
shl al, 0x21
mov eax, dword [ebp + edx*2 - 0x7d5ade02]
adc dx, cx
mov edx, dword ss:[eax + edx*2 - 0x7d5a3dc2]
movsx eax, cl
add eax, 0xba09e609
sub ecx, eax
mov dword [ebp], edx
and ax, ax
mov edx, 0x535be3c
jmp edi
movzx ecx, dx
and ecx, edx
bts edx, 0xa6
dec eax
btc ecx, edx
adc dx, 0xf89d
bswap eax
btc edx, 0x82
jae 0x15bde54
Function at 0xd3d3fd
Capabilities:
Encode data using base64

Disassembly:
dec ecx
not esi
dec esi
lea edi, [esp + edi + 8]
inc cx
inc eax
inc esp
xor edx, ebp
jno 0xdacfdd

Function at 0xd42a05
Capabilities:
Encode data using base64

Disassembly:
inc cx
rol esp, 0x86
inc ecx
add dl, 0xba
dec ecx
mov dword [esi + esi - 0xbc], eax
jp 0xd59f16
invalid
inc ecx
movsx ecx, cl
inc cx
ror edi, 0xe3
not bp
inc ecx
mov eax, edi
inc ebp
cmovb eax, ecx
ror bp, 1
dec esi
mov dword [esp + edi - 0x56286cd4], eax
not bp
inc esp
movzx esi, cl
add bp, 0x428f
dec ebp
xchg ecx, edi
mov edx, 0x29ab8d8f
cwd
inc sp
xor ebx, ebp
inc ecx
bswap ecx
inc ecx
mov esp, 0xe21e4c29
dec eax
xchg dword [esp + eax - 0x56286cd4], ecx
dec eax
lea ebp, [esp + ebp + 8]
inc cx
bts eax, 0x19
inc ecx
pop edx
inc esp
or ah, cl
dec eax
mov eax, dword [eax + ebp - 0x56286cd4]
inc cx
add edx, esp
dec ecx
or edx, 0xcb1a44ba
dec edx
lea esi, [esi + esi*4 - 0x2f8]
jno 0xd3b6f7
xor ecx, ebx
neg ecx
ror eax, 0x79
jae 0x154f99d
dec ebx
lea eax, [eax + eax*8 + 0x42b81303]
inc esi
mov esi, dword [edi + esi*2 - 0x178]
dec eax
lea edi, [edx + edi - 0x29ab4cf5]
inc ebp
xor esi, ebx
dec eax
lea edx, [edx + 0x57b8719e]
bt dx, 0x35
inc ebp
and bh, cl
inc ecx
xor esi, 0x4fb3a62b
inc ecx
sar esp, cl
inc ecx
movzx ebp, ah
inc ecx
bswap esi
inc ecx
ror esi, 3
jmp 0x155a718
and ax, ax
Function at 0xd48620
Capabilities:
Encode data using base64

Disassembly:
pop edx
pop eax
jae fcn.015b9a99
inc ecx
push edx
inc esp
add edi, dword [esp + ebp - 0x169]
inc bp
mov edx, dword [eax + ebp*2 - 0x2d6]
inc esp
movzx eax, word [esp + ebp*4 - 0x5ab]
inc ecx
push esp
dec eax
lea esi, [ebp + esi - 0x16d]
mov byte [esp + ebp*2 - 0x2c8], bh
inc sp
mov dword [esi + ebp*8 - 0xb58], edx
jne 0x157c8a7
cwde
mov dword [esp + edx - 0x563e0200], eax
bswap ecx
xor ebx, ecx
add eax, 0xefa59d8f
and eax, edx
adc edi, ecx
or dx, 0x9c90
fld qword [ebp + eax - 0x46240200]
movsx ecx, al
mul cl
mov edx, dword [eax + ebp - 0x46240000]
pop ecx
lea ebp, [ebp + eax - 0x4623fffc]
jo 0x15370af
cbw
rol cl, 0xe2
movzx eax, byte [esi + eax - 0x46240005]
sbb esi, 5
xor al, bl
and ecx, ecx
xor ecx, ecx
not al
and ecx, ecx
bts ecx, ecx
adc al, cl
call fcn.015401aa
lea esp, [esp + 4]
call eax
mov ebx, 0xbeb50a02
mov ebp, dword [ebp - 4]
lea edx, [ebx*8 - 0x444b31d3]
btr edx, 0x8b
lea edi, [ebx + edx*8 - 0x41ee9958]
mov dword [ebp + edi - 0x7af2292], eax
pop ebx
lea esi, [edx + edx - 0x41fd47d9]
pop edi
movsx eax, si
movzx ecx, si
pop esi
sbb cx, 0x5d23
lea esi, [esi + ecx - 0x8781]
mov edx, dword [esi + ecx - 0x877d]
sar cx, 0xef
neg al
bts eax, 0x86
xor edx, ebx
rol edx, 2
not ax
cbw
dec ax
lea edx, [edx + ecx - 0x3d3df388]
push eax
call fcn.00d5aac9
clc
rol ecx, 1
or eax, edx
xchg dx, ax
lea ecx, [edx + ecx + 0x16005411]
btc dx, 0x2d
ror ecx, 1
lea edx, [edx + edx - 0x10c58fec]
add dl, dh
xor ebx, ecx
btc dx, 0x26
add edi, ecx
push eax
call fcn.01585a3f
dec edx
lea edx, [ecx + edi*2 - 0x526ffbf8]
inc edx
ror byte [esp - 0x5a811584], 0x61
inc ebp
xor bl, cl
inc edx
inc dword [esp - 0x5a811588]
inc ecx
rol ah, 0xe2
dec esi
lea ecx, [esp + ecx + 8]
inc ecx
add esp, 0x13ae913b
inc edx
sal dword [esp + edx - 0x5a8115b2], 0xd7
inc cx
adc edi, 0x4366303f
mov ecx, dword [ecx + eax*4 - 0xb0800]
cbw
inc esp
xchg dl, dl
inc cx
mov dword [eax + esi - 0x2c1fe], ecx
dec edx
lea esi, [esi + eax*2 - 0x583fe]
dec esi
mov dword [esp - 0x6e2fa65d], ebp
ret
Function at 0xd4b9d9
Capabilities:
Encode data using xor

Disassembly:
inc cx
rol eax, cl
inc si
mov esi, dword [esi - 0x1a]
movzx eax, cl
inc bp
mov esp, dword [esp + edi + 2]
inc esp
movsx ecx, bl
dec eax
lea edi, [edi + eax*2 - 0x57]
movzx edx, cx
inc ecx
shr al, 0x44
inc bp
xor esp, ebx
inc cx
rol esp, 1
inc sp
xadd ebp, ecx
sbb ax, 0x198c
dec eax
idiv ecx
inc cx
inc esp
inc ebp
movzx edi, cl
inc eax
add ch, 5
inc cx
neg esp
inc cx
add esp, 0x8d480392
or al, 0x6d
cmpsd dword [esi], dword es:[edi]
add dword [edx], 0x39
inc bp
xor ebx, esp
inc esp
movsx edx, cl
inc dl
shr bl, 0x62
dec esp
adc esp, esp
inc edi
mov byte [esp + ecx*2 - 0x16e00], dh
dec ebp
xor edi, ebp
inc ecx
jmp edi
inc ebp
xor eax, esi
call fcn.015b41a3
xlatb
inc edi
xor ebp, ebx
jne 0xd4ba4d
dec ebp
sub eax, 0xf22bcab9
mul dword [esi - 0xe7f6a14]
xor eax, 0xf18095ec
fld xword [edi + 0xcf2eb16]
mov ecx, 0xf2eb0acb
or al, 0x93
out dx, eax
jle 0xd4b9ef
or al, 0xb2
invalid
jb 0xd4ba6f
and ecx, edi
mov dword [0xd4cc892d], eax
mov edi, 0xffb9f281
pop ds
dec ebx
mov fs, word [esi - 0x3d0007eb]
push esi
sub esp, ebx
jle 0xd4bae3
push eax
add byte [edx - 0xe74ba5a], dh
add dl, 0x9b
inc ecx
movsx ecx, dh
neg dl
dec ecx
lea ebp, [esi + 0x791aa3bc]
movzx ebx, bp
inc esp
movzx esp, bl
rol dl, 1
inc esp
xadd ecx, ecx
dec dl
dec ebp
sub eax, esp
xor dl, 0x8f
inc ecx
xchg al, ch
rol dl, 1
inc ebp
xadd esi, eax
inc esp
xor bl, dl
bts ebx, ebp
dec ecx
sbb esi, 0xe7983e28
inc ecx
shr ah, 6
inc cx
mov dword [ecx + esi - 0x31], edx
dec ecx
bt esi, ebx
inc ecx
ror esi, 0xdd
inc esi
mov ecx, dword [edi + ecx*2 - 0x5d]
inc eax
setae ch
dec eax
sal ebx, cl
inc ecx
push esp
inc ebp
xor ecx, ebx
inc ecx
neg ecx
inc ecx
inc ecx
inc ecx
neg ecx
dec esi
sub dword [esp - 6], esi
dec edx
adc dword [esp - 6], 0xc7ae6115
inc ecx
ror ecx, 2
inc cx
sub ecx, eax
dec esi
mov dword [esp - 3], ebx
inc esp
movsx ebx, bx
inc esi
xor dword [esp - 6], ecx
inc ecx
pop ebx
inc sp
btr ebp, esp
inc cx
dec eax
dec ebp
arpl cx, cx
dec ebp
adc ebp, ecx
jmp 0xce3ae6

Function at 0xd50c6d
Capabilities:
Encode data using xor

Disassembly:
xor bp, 0xf584
dec ecx
dec esi
shl cx, cl
inc sp
xor ebx, ebp
dec eax
lea ebp, [esp + ebp + 8]
inc dx
movzx edx, byte [ebp + edi*2 - 0x8a]
inc dx
mov dword [esi + edi*4 - 0x116], edx
call int.00ce4af6

Function at 0xd58514
Capabilities:
Encode data using base64

Disassembly:
dec cx
bswap eax
not edx
bswap eax
xor ebx, edx
sal ecx, cl
add edi, edx
call fcn.00d3b152
Function at 0xd5a3e7
Capabilities:
Encode data using xor

Disassembly:
inc cx
xor eax, ebx
dec esp
xadd ecx, ecx
dec eax
mov dword [esp], edx
sub edx, 0xcb2a4315
neg ax
inc cx
sar edi, cl
rol ax, 1
inc ecx
xchg ah, dl
and bp, dx
dec eax
not ebp
neg ax
dec eax
btr ebp, 0x18
adc ax, 0xa9e
push ebx
rol ax, 1
inc sp
xor ebx, eax
dec esi
lea eax, [ecx + 0x7319a3f]
dec ecx
neg esi
dec eax
lea eax, [esp + eax + 0x18]
add al, 0x18
inc byte [esp + edx - 0x34d526c0]
inc ecx
pop esi
bt bx, cx
inc sp
movzx esi, byte [eax + edx*2 - 0x69aa4dac]
dec dword [esp + edx - 0x34d526d6]
and ecx, dword [esp + edx - 0x34d526d0]
call fcn.0150d20d
movzx ecx, byte [esi - 1]
mov eax, 0x9c378726
xor cl, bl
sal eax, 0x8d
dec cl
neg cl
add cl, 0xa5
lea edx, [eax*2 + 0x3e138119]
sar dl, 0x21
rol cl, 1
sub cl, 0x96
inc dx
call fcn.00d78728
fst dword [ecx + 7]
call 0x820ee03
mov byte [0x85f414c3], al
jecxz 0xd5a42f
inc ebx
and al, 0xbe
lds edi, [esi + 0x43dd685f]
xchg ebx, eax
test byte [ebx + 0x68], 0xdd
inc ebx
mov ecx, 0xdd684bda
inc ebx
mov ah, 0xce
xor ebp, dword [eax - 0x23]
inc ebx
xchg ebx, eax
pop ds
sbb al, 0xbc
invalid

Function at 0xd5e364
Capabilities:
Encode data using base64

Disassembly:
mov word [ecx + ebp - 0x3d55186], dx
mov dword [esp + ecx - 0x3d55188], ecx
jns 0xd7965a

Function at 0xd61d51
Capabilities:
Encode data using base64
Encode data using xor

Disassembly:
dec esp
mov dword [esp + edx - 0x1411acc3], ebx
je 0xd94587
dec eax
mov dword [esp + edx - 0x1411accb], eax
dec ebx
lea ebx, [ecx + edi*8 + 0x369c011b]
inc esp
xor dword [esp + edx*2 - 0x2823598e], eax
dec esp
mov ebx, dword [esp + edx - 0x1411acc3]
inc cx
dec edx
dec ebp
arpl ax, ax
dec ebp
sub edx, edi
add bp, word [esp + edx*4 - 0x5046b326]
dec ebp
adc ebp, eax
dec esp
mov dword [esp + edx - 0x1411accb], ebp
ret 8

Function at 0xd62f14
Capabilities:
Encode data using base64

Disassembly:
dec edx
dec al
bswap edx
not cx
call fcn.015b3954
ror ecx, 1
lea edx, [eax + 0x552a6d1e]
dec dx
sub ecx, 0x633ecc37
inc al
bts ax, ax
call fcn.00ce87af
lea esp, [esp + 4]
call eax
mov ebp, dword [ebp - 4]
mov esi, 0xf507dd00
mov dword [ebp], eax
movzx ecx, si
lea ebx, [esi*2 - 0x5c71c863]
pop ebx
jmp 0xd67e01
pop edi
sar ecx, 0x18
pop esi
bts ecx, ecx
lea esi, [esi + ecx - 5]
mov edx, dword [ecx + esi - 1]
sbb ecx, 0xd32fd537
sbb ecx, ecx
xor edx, ebx
movzx eax, cl
rol edx, 2
or eax, 0xd1a7953c
adc ecx, 0x481a6f1c
sbb edx, 0x3d3cf388
shr al, 0x46
xor eax, 0x20aa0bb1
btr eax, eax
not edx
btc eax, eax
jae 0x15b8aa9
invalid
jae 0xcccff1

Function at 0xd67fac
Capabilities:
Encode data using base64

Disassembly:
inc ecx
xadd ecx, ecx
dec esp
adc ebp, ebx
bts ax, bp
dec eax
mov dword [esp + edx*2], 0x1c25b103
pop ecx
jae fcn.00cc0ab0
dec ecx
lea edx, [edx + edx*8 - 0x6e73b7ff]
btr eax, eax
sal eax, 0xe4
ror ecx, 1
not ecx
bswap edx
and edx, eax
shl al, 0x46
dec ecx
sar dx, 0xad
rol ecx, 1
inc dl
call fcn.01507a0d
Function at 0xd70f2e
Capabilities:
Encode data using base64

Disassembly:
mov word [esp + edx - 0x5ea6ca32], 0xff11
rol eax, 1
neg dl
mov dword [esp + edx - 0x5ea6cac8], ecx
neg eax
xadd byte [esp + edx - 0x5ea6cac3], ch
jo 0xd4b44a
xor ebx, eax
shl cl, 0xc4
adc dl, 0x8e
add edi, eax
and edx, 0x4e9f1503
and byte [esp + ecx - 0x49b7ca4c], dl
pop edx
pop ecx
pop ecx
jbe fcn.015b9a99
mov bx, word [esi]
call fcn.00cd0fe9

Function at 0xd78922
Capabilities:
Encode data using base64

Disassembly:
inc ebp
movsx ecx, si
dec edx
lea esi, [esi + edi - 0x4df5a07f]
dec edx
mov dword [esp + edi - 0x4df5a07d], 0xa72f1b1b
inc ecx
sub ecx, edi
xchg byte [esp + ecx - 0x7eb4f518], bl
mov word [esi + ecx - 0x7eb4f51a], dx
inc esp
sub bh, bl
jae 0x15b6337
inc esp
movsx esp, word [esp + ecx - 0x7eb4f516]
inc esi
mov edx, dword [edi + edi - 0x4df5a04e]
mov eax, 0xa217bb86
dec edx
lea edi, [edi + edi - 0x4df5a04a]
not cx
dec ecx
xor eax, edi
inc ebp
xor edx, ebx
inc esi
xchg byte [esp + edi - 0x4df5a049], al
inc ebp
add edx, eax
dec eax
sub ecx, 0xc29c5882
cbw
inc edx
mov edx, dword [esp + edi - 0x4df5a04c]
inc ecx
neg edx
dec eax
inc ebx
inc ecx
sub edx, 0x5788fcbc
dec ecx
neg edi
dec eax
shr eax, 0x81
inc ecx
ror edx, 1
dec esi
mov dword [esp + edi + 0x4df5a04e], ebx
inc esi
xor dword [esp + edi + 0x4df5a04e], edx
inc ebp
xor ecx, ecx
inc ecx
pop ebx
dec ebp
arpl dx, dx
inc ecx
xadd eax, ebp
inc ecx
push esp
inc ecx
push esp
dec ebp
add ebp, edx
dec eax
lea ebx, [ebx*2 - 0x116a56da]
imul edx
inc esi
mov edx, dword [esp + ecx*2 + 6]
inc ecx
pop edi
inc ecx
pop edx
jb fcn.00cc0ab0

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

Disassembly:
mov edx, 0x32385a14
mov ecx, dword [esi + edx*2 - 0x6470b428]
pop edx
mov dword [esp], 0x74846e9c
mov eax, 0x839c0490
xor ecx, ebx
not byte [esp + 3]
call fcn.00d3c82a
salc
push eax
and ah, ch
push ebp
jo 0xd7a3c8
pop es
movsb byte es:[edi], byte [esi]
leave
sub ch, ch
xchg edx, eax
invalid
Function at 0xd7a3ae
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
dec esp
adc ebp, edx
not cx
inc sp
mov ecx, dword [esi + ebx - 0x3761]
ror al, cl
dec eax
lea esi, [esi + ebx*2 - 0x6ec0]
dec eax
mov dword [esp + ebx - 0x3751], eax
dec eax
mov dword [esp + ebx - 0x3761], eax
inc edx
movzx ecx, byte [edi - 0x47108]
dec eax
lea edi, [edi + ebx - 0x3760]
bt eax, 0x91
inc ecx
xor cl, bl
imul ebx
dec edi
lea esi, [eax + edi*2 + 0x21cc5a6]
inc cl
ror cl, 1
dec cl
neg cl
cwd
dec eax
mov dword [esp + ebx - 0x3759], ebp
inc cx
ror edx, 0x8b
sbb cl, dl
dec eax
shl dword [esp + ebx - 0x375d], 0xaf
inc ebx
neg cl
add cl, 0xa8
neg cl
inc ecx
shr eax, 0x5c
inc ecx
pop edi
and ebp, ebx
inc esp
xor bl, cl
inc byte [esp + ebx*2 - 0x6ebe]
inc esp
or edi, dword [esp + ebx - 0x3759]
dec eax
lea ecx, [esp + ecx + 0x10]
dec ebp
bts edi, esi
jae 0xda0649
call fcn.0154249e
mov ecx, 0xbfac8922
jmp 0xd7e451
dec esp
lea edx, [edx + ebx + 0x14390ab3]
inc ecx
movzx ecx, sp
inc ecx
xor al, 0x2d
inc ecx
imul esp
inc ecx
sbb al, 4
dec ecx
xchg esp, ebx
inc ecx
not al
inc esp
xchg cl, dh
inc sp
xadd eax, ecx
inc ebp
xor bl, al
dec esp
add eax, esp
inc di
movzx esp, byte [eax + esi*2 - 0x1123a]
dec esp
xadd ecx, edi
jnp 0xda82a0
movsx ebp, cx
inc esp
movzx eax, byte [edi]
inc esp
movzx esi, cx
inc eax
ror ch, 0xe7
inc ebp
xor al, bl
btr ecx, 0xbb
inc ecx
movzx ebx, si
dec esi
lea ecx, [ebx + esi*2 - 0x3fe88978]
inc ecx
xor al, 0xc
inc ebp
movzx esp, cl
inc ecx
not al
inc ecx
xor al, 0xac
dec ebp
lea esp, [esp - 0x36c4c5d1]
inc cx
inc esi
inc esp
movsx edx, bp
inc ecx
neg al
inc ebp
xor bl, al
inc esp
movzx edi, bp
dec esp
add eax, esp
inc ecx
movsx eax, cx
mov edx, 0x5b333b26
dec esp
xor ecx, ecx
inc bx
movzx ecx, byte [eax + esi*8 - 0x44918]
inc dx
mov dword [esi + esi - 0x8925], ecx
dec ecx
ror ecx, 0x15
dec ecx
sal edx, 0xd6
inc esi
movzx eax, byte [edi + esi - 0x8922]
inc ebp
xor al, bl
dec ecx
btr esi, ebp
inc ecx
inc al
inc ecx
mul dh
bts ebp, 0x11
inc ecx
xor al, 0x10
dec ebp
sub edi, edi
inc ebp
adc al, cl
jmp 0xd7d869
inc sp
mov dword [ecx + ebx - 0x3762], ecx
inc cx
rol edx, 8
dec esp
mov dword [esp + ebx*2 - 0x6ec4], ebp
ret 8
inc si
mov dword [esi + esi*2 - 0x1123e], esp
sub bl, 1
dec eax
sub ebx, ebx
call fcn.01595426

Function at 0xd87331
Capabilities:
Encode data using base64

Disassembly:
mov ecx, eax
neg ax
mov dword [ebp + eax - 0xb025], edx
mul ecx
mul ecx
lea ebp, [ebp + ecx - 0x4fe7]
xchg word [esp + ecx - 0x4fdd], dx
shl eax, 0xf
pop eax
pop eax
pop eax
jae fcn.015b9a99
Function at 0xd8c0b9
Capabilities:
Encode data using base64

Disassembly:
shr edx, 0x59
bswap ecx
neg ecx
inc ecx
cdq
sub byte [esp + edx*4], 0x21
xor ebx, ecx
mov dword [esp + edx + 4], 0xff03c6b6
call fcn.015aa37c
sbb dword [esp + 4], eax
sal ax, 0x47
mov word [ecx], dx
mov ecx, dword [esi - 5]
mov dword [esp], eax
sbb esi, 5
mov edx, eax
xor ecx, ebx
shr eax, 0x33
neg ecx
lea eax, [eax*2 - 0x42d3d178]
cwde
sar dword [esp + edx*2 - 0x7ffffffc], 0x9b
bswap ecx
cbw
add dword [esp + edx*2 - 0x80000000], 0x7957524
sub edx, dword [esp + edx*2 - 0x7ffffffd]
ror ecx, 1
ror dword [esp + edx - 0x400008b7], 0x4a
xor ecx, 0xf0167ba3
xor edx, 0x8902572f
not ecx
sub edx, eax
jl 0xd75a1e
mov ecx, dword [ebp]
mov eax, dword [ebp + 4]
mov edx, 0x5e8d9100
not edx
or ecx, eax
call fcn.015a40b2

Function at 0xd98773
Capabilities:
Encode data using base64

Disassembly:
mov bh, 0xd8
invalid
test ebx, ebx
call fcn.0154c181
push edx
mov cl, 0x52
pop edx
pop ecx
adc dh, byte [ecx - 0x1c]
jns 0xcd4394
movsb byte es:[edi], byte [esi]
xor ebx, dword [ecx - 0x10]
jns 0xcd439a
movsb byte es:[edi], byte [esi]
js 0xcd43fb
loopne 0xcd4475
jns 0xcd43a0
mov dword [0x9c4d23a4], eax
movsb byte es:[edi], byte [esi]
and ecx, dword [ebp - 0x64]
jns 0xcd43a6
movsb byte es:[edi], byte [esi]
xchg ecx, eax
xchg esp, eax
shr dword [ebp - 0x7dbbf447], cl
invalid
dec ecx
retf 0x3ade
mov dword [esp + edx*2 - 0x433c0000], edi
xchg dx, ax
btc eax, edx
ror al, 6
push ebx
mov ebx, ecx
mov edx, ebx
shr ax, 0x4f
not ax
shl edx, 2
sar al, 1
xor eax, eax
sub eax, 0x9338f282
mov eax, ebp
push 0xa026168a
add eax, edx
mov dword [ebp - 4], eax
jmp 0xcd43e0
Function at 0xda7b2f
Capabilities:
Encode data using base64

Disassembly:
adc edi, ecx
sar dl, 0xe3
jmp edi
push 0xfc1c63aa
lea esp, [esp + 0xc]
call eax
mov edi, 0x35883736
mov ecx, 0x9c309432
movzx ebx, di
mov ebp, dword [ebp + ebx*2 - 0x6e70]
mov dword [edi + ebp - 0x35883736], eax
movsx esi, bl
pop ebx
pop edi
mov edx, ecx
inc edx
pop esi
dec edx
lea eax, [ecx*4 + 0x66bf2f8d]
sub esi, 4
mov ecx, dword [esi]
cbw
bts edx, 0x92
xor ecx, ebx
not dl
rol ecx, 2
sub ecx, 0x3d3cf389
btr eax, 2
jb 0x159b71e
mov ecx, 0x528de07
lea esi, [esi + ecx*8 - 0x2946f03c]
dec ecx
not ecx
or ecx, ecx
mov ecx, dword [esi]
xor ecx, ebx
push 0xa2be2d1c
push 0xda8c1bf
dec dword [esp + 4]
add ecx, 0x99146aa9
xor ecx, 0xb6867f8e
ror dword [esp + 4], 0x1c
sbb ecx, 0xd8838933
and byte [esp + 7], 0x36
rol ecx, 1
dec ecx
ror word [esp + 6], 0xe9
shr word [esp + 1], 0x65
xor ebx, ecx
shr dword [esp + 4], 0x3a
neg dword [esp + 4]
call fcn.014fab42
xlatb
inc edi
xor edx, ecx
inc eax
push edi
push edi
or byte [ecx + 0x7317f8a6], bh
repne movsb byte es:[edi], byte [esi]
movsd dword es:[edi], dword [esi]
retf
not ecx
dec ecx
bswap ecx
shr al, 0x61
dec edx
xor ebx, ecx
bt eax, edx
jae 0xd758d0

Function at 0xda81ee
Capabilities:
Encode data using base64

Disassembly:
sbb eax, eax
xor ebx, edx
shl eax, 0xde
sbb eax, eax
add edi, edx
dec ecx
mov eax, dword [ebp + ecx*2 - 0x64474296]
movsx edx, cx
imul ecx, ecx
shl ecx, cl
adc ebp, 3
push eax
xor dl, 8
push edx
shr dword [esp], 0x68
push dword [esp + 4]
popfd
mov dword [esp + 4], 0xaafa5bb
pop eax
pop ecx
jmp edi
jns 0x159ec00
int1
adc cl, dl
xor byte [ebx - 0x4f], dh
fidiv dword [ebx - 0x1f]
leave
invalid
pushfd
pop edi
dec eax
mov dword [esp], edi
mov edi, 0xe994232c
dec eax
mov esi, eax
shl di, 0xcd
shr edi, 0x24
jp 0x1551ad7
dec eax
mov edi, ebx
jne 0xd8cc86
call fcn.00da574b
push 0x807e238
sub esi, 4
mov eax, dword [esi]
xor eax, ebx
ror word [esp], 0xe8
jb 0xcc0be9
push 0xbc995795
adc eax, 0x99146aa9
add dword [esp + 3], 0x4e152188
xor eax, 0xb6867f8e
neg byte [esp + 3]
call fcn.00cc161a

Function at 0x14f39ab
Capabilities:
Encode data using base64

Disassembly:
inc bp
bt ecx, ecx
dec edx
lea edi, [edi + ecx - 0x523dfa3a]
inc ecx
xor ebp, ebx
sub ebp, 0x6f9fd913
inc ebp
movsx eax, cx
dec esi
mov dword [esp + ecx - 0x523dfa3e], eax
inc ecx
mov ecx, ecx
ror ebp, 1
call fcn.00d5a7fb
setno bl
Function at 0x14f4964
Capabilities:
Encode data using xor

Disassembly:
mov dword [esp + 4], 0x2ecba630
lea esp, [esp + 4]
call fcn.00d58528

Function at 0x14fce2f
Capabilities:
Encode data using base64

Disassembly:
bt cx, cx
mov dword [ebp + 4], eax
mov edx, dword [esp + 8]
neg cx
dec ecx
sbb esi, 3
pop ecx
mov eax, dword [esi]
lea ecx, [edx + 0x631a28ba]

Function at 0x15005b1
Capabilities:
Encode data using base64

Disassembly:
inc ecx
xor edi, 0x7da87d88
dec ebp
xchg eax, esi
dec edx
mov dword [esp + eax*4], edx
inc ecx
rol edi, 2
dec eax
rol ebx, 0x22
inc ebp
mov esp, eax
dec esi
xor dword [esp + eax*2], ebx
call fcn.014fcc53
mov ecx, dword [ebp]
mov edx, 0x4dbea825
movzx eax, dl
mov dx, word ss:[ecx + edx - 0x4dbea825]
or ax, ax
lea ebp, [ebp + eax*2 - 0x48]
shr eax, 0xa
sete al
lea ecx, [eax*4 + 0x4694a131]
mov word [ebp + eax*2 - 2], dx
add ax, cx
lea esi, [esi + eax - 0xa13a]
imul ax, cx
lea ecx, [eax + 0x69399196]
dec eax
mov edx, dword [eax + esi - 0x562d]

Function at 0x150455b
Capabilities:
Encode data using base64

Disassembly:
dec word [esp + eax - 0x1b2a371e]
inc edx
sal al, cl
mov dword [esp + ecx - 0x43ff0a41], ecx
call fcn.00ce1493

Function at 0x150efca
Capabilities:
Encode data using base64

Disassembly:
neg ecx
bswap edx
not ecx
xor ecx, 0x47b90d06
call fcn.015068e9
cmp ch, byte [ecx + 0x7de07f18]
cmc
clc
xor eax, dword [esi - 0x73b2dae3]
xor eax, dword [esi - 0x6bdab5e3]
xor eax, dword [esi - 0x5fbac1e3]
xor eax, dword [esi - 0x6c5bdde3]
out 0x9c, eax
mov dl, 4
enter 0xffffffffffffa4db, 7
enter 0x7690, 0xffffffffffffffb9
adc dword [ebx], 0x72121ede
invalid
bswap edx
cwde
and eax, eax
xor edx, 0x3d1ef70c
xor ebx, edx
mov dword [esp + eax], 0x1022b912
shl byte [esp + eax + 2], 6
bts ecx, ecx
adc edi, edx
inc ecx
shr cx, cl
mul dword [esp + eax]
lea esi, [eax + esi - 1]
or dl, byte [esi + edx*8]
dec cx
jp 0x158751e
lea ecx, [ecx + edx*2 - 0xb74ab39]
or edx, dword [esp + edx - 0x5511051d]
ror ecx, 1
xor edx, dword [esp + edx - 0x55111d3d]
movsx eax, dx
jne 0xd80d20
inc eax
xor dl, bl
not dword [esp + eax]
add cx, 0xb6bc
adc dl, 0x3c
xor dl, 0x8f
jmp 0x1556adb