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

Disassembly:
not edi
xor ax, cx
movsx edx, cx
mov qword [rsp + rcx*4 - 0x2081c], rcx
or r8d, edi
bt eax, 0x88
bts edx, ebx
idiv byte [rsp + rcx - 0x81fe]
mov dword [rsi + rcx*2 - 0x1040e], r8d
mov edi, dword [rsp + rcx - 0x8206]
neg ebx
lea r10, [r10 + rbx - 0x3bde7dfd]
mov r8d, 0x1432db09
jge 0x1400f9f90
sal eax, 0x29
movsxd rcx, ecx
bt eax, edx
and al, 0x3f
adc rbx, rcx
btc ax, 0x1a
mov esi, dword [r8 + r11 - 0x40000000]
btr rdi, 0x3d
mov eax, dword [r11 + r8*2 - 0x7ffffffc]
and r8d, edx
lea rcx, [rbp + rbp - 0x4a463378]
mov cl, byte [r11 + r8 - 0x3ffffff8]
call fcn.1401e19a9
btr rcx, rbx
mov ecx, dword [rbx + r10 - 0x3bde7df9]
shl dword [rsp + rbx - 0x3bde7ded], 0xf0
setae dil
and word [rsp + rbx*2 - 0x77bcfbe8], 0x3f3e
xor ecx, r9d
add edx, ebx
js 0x14009678d
shl r8b, 0x86
lea ecx, [rcx + rbx*4 - 0x15645eae]
movsx r11d, bx
rol ecx, 3
shl bx, 0x2c
adc ecx, edi
shr rbx, 0x8a
cmovb edi, dword [rsp + rbx*4 - 0x3bde87]
bswap rax
ror ecx, 1
xchg qword [rsp + rbx - 0xef79d], rbx
not rbx
dec ecx
neg ecx
sal ebx, 0x3c
jne 0x14020223b
neg dl
rol r9b, 0xc1
sbb qword [rsp + rax*2 - 0x4f0bf928], 0xffffffffbab2d11c
xor r11b, dl
xor word [rsp + r8 - 0x50362f37], r9w
lea rdx, [rsp + rdx + 0x10]
cwde
not byte [rsp + r8 - 0x50362f37]
je 0x14019617a
mov byte [r10 + rdx - 0x71089386], cl
mov r10d, dword [r10 + rdi - 0x71089386]
lea rdi, [rdi + r9*2 - 0xe2]
movsx edx, r8w
adc sil, byte [rsp + r9 - 0x70]
or r8, 0xffffffffa21686ae
xor r10d, r11d
pop rsi
lea r10d, [r10 + r8*4 - 0x7b5d3815]
dec al
imul dx, r9w
rol r10d, 2
cdq
add r10d, edx
xor r10d, 0x199c4b0e
sar eax, 0xb5
shl qword [rsp + r8 + 0xdc95041], 0xb1
jne 0x1401a585b
mov eax, dword [r10]
add r10, 4
xor eax, ebp
mov ecx, 0xf4942b96
dec ecx
lea eax, [rcx + rax - 0x30563964]
movsx ebx, cl
mov esi, ebx
rol eax, 3
not esi
shr ecx, 9
bswap eax
movzx r11d, cl
jae 0x1400e0219
rol eax, 1
lea eax, [rax + rcx*8 - 0x657b6d39]
bswap eax
xchg bl, cl
lea rdx, [rsi*8 + 0x6501353a]
inc r11w
neg eax
btc cx, 0x25
lea eax, [rax + rcx - 0x48979b74]
not cx
dec cl
not eax
shr rbx, cl
sal r11w, cl
dec eax
xchg rcx, rsi
ror r11, 0x7d
inc cl
push rbp
xor dword [rsp + rcx*4 - 0x1ac], eax
pop rbp
btc si, 0x83
bt rcx, 0xa
movsxd rax, eax
shl cx, cl
movsx edi, cl
add r9, rax
mov r11, qword [r8 + rcx*2 - 0xb000]
jmp 0x14021580d
mov qword [rsp + r8*8 + 0x6e4a8208], r11
xor dword [rsp + r8*8 + 0x6e4a8208], r10d
inc r9w
pop r11
movsxd r10, r10d
add r9w, r9w
adc rbx, r10
jmp rbx
dec ebx
lea ecx, [rcx + rdx + 0xecbcf18]
sal r11w, 7
cbw
sub rdi, qword [rsp + rdi*2 + 8]
mov qword [rsp + rdi*2 + 0x1df6], r9
shr di, 0xc1
xor dword [rsp + rdi + 0x8784], ecx
cdq
or edi, r8d
inc r8w
mov r9, qword [rsp + rdx + 8]
movsxd rcx, ecx
mov qword [rsp + rdx*4 + 8], rdx
xadd r8w, ax
adc rbp, rcx
ror r11w, 0xc9
mov qword [rsp + rdx], rbp
ret 8
sar ebx, 0x92
mov rax, qword [r8 + rcx*2 - 0xaff8]
shl rsi, 0x43
not esi
lea r8, [r8 + rcx - 0x57f8]
bts rbx, 0x9a
or si, cx
sar rsi, 0x68
adc r11, rax
movsx eax, sil
inc rsi
cdqe
mov qword [r8 + rcx*2 - 0xb000], r11
movzx r11d, dil
jo 0x140208143
or rdi, r9
jmp rdi
Function at 0x1400a4d95
Capabilities:
Encode data using base64
Resolve function by parsing pe exports

Disassembly:
shr ax, 0x81
mov word [rsi + rdi*2 - 0x522ad314], bx
mov qword [rsp + rdi - 0x2915698a], 0x3a0d3ba7
lea r10, [r10 + rdi - 0x2915698e]
sar r11d, cl
lea rdx, [rdi + r8*8 - 0x55eccc76]
add eax, dword [r10 + r8 - 0x15a]
xor eax, r9d
lea eax, [rax + rdx*4 + 0x7b8c147]
imul edx, r11d
lea r8, [rdi + 0x6cb84b8c]
bts dx, 0xa1
xor eax, 0xcb388a5
xor cl, 0x8e
neg r11
sub di, 0x568d
lea eax, [rdi + rax - 0x2b4a7c15]
sar cl, 0x86
sar byte [rsp + rdi*2 - 0x522a25f9], cl
setae cl
rol eax, 1
pop r8
jmp 0x1401c1e2c
Function at 0x1400acdf8
Capabilities:
Encode data using base64

Disassembly:
rol ecx, cl
lea ebx, [rbx + rcx*4 + 0x57c3416d]
dec byte [rsp + r8*2 + 0xb]
lea rax, [r8 + 0x19922b2a]
xor ebx, 0x75186d07
mov qword [rsp + r8*2], rax
bswap r8
imul rdi, rcx
lea ebx, [rbx + r8*2 - 0x6d346a0c]
or r8d, 0xde8353a6
sub rcx, rcx
mov byte [rsp + rcx + 0xa], cl
not ebx
xor ebx, 0x97bb29a0
dec dword [rsp + rcx + 5]
neg qword [rsp + rcx*2 + 7]
mul r8
neg ebx
xadd qword [rsp + rdx*2 + 7], rcx
mov qword [rsp + rdx + 8], r9
movsx r9d, byte [rsp + rdx*8 + 3]
movsx r11d, al
xor dword [rsp + rdx*2 + 8], ebx
mov r9, qword [rsp + rdx*2 + 8]
not word [rsp + rdx*2 + 6]
not dword [rsp + rdx*4 + 1]
movsxd rbx, ebx
inc r8b
xchg byte [rsp + rdx + 6], r8b
add rbp, rbx
mov esi, dword [rdx + rsi]
pop r11
pop rax
jmp fcn.140158ba3

Function at 0x1400af5fd
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rdi], rsi
ror ebx, 1
inc edi
call fcn.1401e09c4
Function at 0x1400b0135
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rbp - 0xfd01], r11
xor al, 0xa
rol al, 1
sub al, 0xa4
xor r8b, al
pop rsi
sub rcx, rsi
add rax, rsp
jmp 0x1401e50c6

Function at 0x1400b318c
Capabilities:
Encode data using base64

Disassembly:
shl r11, cl
mov qword [rsp + r8], rbx
xor dword [rsp + r8*2 + 8], eax
xchg byte [rsp + r8 + 2], r8b
rol bx, 0x41
mov r9, qword [rsp + r8*8 - 0x250]
jb 0x140122320
movsxd rax, eax
inc r11b
adc rdi, rax
pop rax
pop rcx
jmp fcn.1400bd550

Function at 0x1400b450f
Capabilities:
Encode data using base64

Disassembly:
mov dword [rsi + r8*2 - 0x20000000], edi
pop rcx
jp fcn.140158ba3
Function at 0x1400b5e56
Capabilities:
Encode data using base64

Disassembly:
and rax, 0xfffffffffffffff0
sub rax, rcx
bswap rdi
mov rsp, rax
call fcn.14020c8e6
btr edi, ecx
lea r11, [rdi*8 + 0x48bb8a8b]
add rbp, rbx
and dl, byte [rsp + rdi - 0xfbfa]
sal qword [rsp + rdi*2 - 0x1f7fc], cl
js 0x1400e6cb8
lea r10, [r10 + rdi*8 - 0x7dff1]
sal ecx, cl
xor dword [rsp + rdi*4 - 0x3eff7], r11d
add dl, byte [r10 + rdi*4 - 0x3eff8]
pop rbx
imul bx, r8w
or bl, bl
xor dl, r9b
ror r8b, 0x24
mov eax, ecx
shr cl, 0x87
inc dl
rol dl, 1
and r11, rbx
adc dl, 0x88
and al, dil
xor r8, 0xffffffff8b21bbb0
rol dl, 1
shr al, 0x87
xor r9b, dl
add rdi, 0xffffffffb49c20a1
adc rdx, rsp
sal ebx, 0xb7
push rdi
movzx ax, byte [rdx + rdi + 0x4b62e361]
js 0x14007690c
lea rsi, [rcx + rsi - 0x733ca802]
and r11d, ebx
mov word [rdi + rsi + 0x4b62e361], ax
ror r8d, 0xb1
ror cl, 0xa1
pop rbx
jns fcn.140158ba3
mov ebx, 0x8b2bb4ae
mov edx, ebx
jmp 0x14019c616
neg cl
sub dx, 0xd43a
mov word [rdx + r11 - 0x2bc6], di
cmovp rcx, rdx
mov esi, dword [r9 + rcx - 0x2bc6]
jge 0x14022c6ab
lea r10, [r10 + rsi - 0x361a3eb4]
rol si, 0xa7
ror rax, 0x7e
sbb sil, dl
sal r11b, cl
mov word [r10 + rdx - 0x361a3eb6], r11w
mov ecx, 0xa62fbfa5
lea r9, [r9 + rdx - 0x361a3eba]
call fcn.140139fa1
movzx r11d, dx
dec rcx
lea esi, [rsi + rax + 0x5bbf4f1f]
bswap esi
lea esi, [rsi + rax + 0x2599259d]
dec cx
inc ebx
not esi
push r10
setp r11b
xchg r11b, bl
neg cx
xor dword [rsp + rax*2 - 0xb308], esi
jmp 0x14020b900
jmp rdi
mov edx, dword [r8 + riz]
movzx esi, bl
mov ecx, 0xa0a4fc3e
movzx eax, cl
lea r8, [r8 + rsi*2 - 0x158]
lea r11, [rax + 0x3491f73d]
xor edx, r10d
xchg r11w, bx
dec edx
bswap edx
movsx r9d, cx
dec rcx
neg edx
rol edx, 2
neg edx
lea edx, [rdx + rsi*4 + 0x3ca087cb]
push r10
bts cx, 0x89
btr ecx, 0xaf
rol ebx, 0x75
xor dword [rsp + rsi*2 - 0x15c], edx
ror al, 0xe6
xchg r9w, r11w
pop r10
sub r11, rcx
add cl, cl
xchg esi, eax
movsxd rdx, edx
adc rdi, rdx
xchg rcx, rbx
mov r9, qword [rsi + rbp - 0xf8]
mov dx, word [rbp + rsi*4 - 0x3d8]
sal ax, 0x49
not ax
lea rbp, [rbp + rsi*4 - 0x3d6]
bswap rax
btc ax, ax
mov word ss:[r9 + rsi*2 - 0x1f0], dx
jae 0x140171bfe
mov ecx, 0xaaa1ac9c
lea r9, [rcx*2 - 0x3f606bf1]
push rcx
mov r9d, dword [rbp + riz]
shr cl, 3
lea rsi, [rcx + rcx*8 - 0x4f511e5b]
mov r8d, dword [rbp + riz + 4]
mov eax, esi
mov edx, ecx
mul dl
mov cl, byte [rbp + riz + 8]
call fcn.14014a2e8
mov edx, 0x361a3eb6
mov esi, edx
mov eax, esi
movzx r11w, byte [r10 + rdx - 0x361a3eb6]
mov cl, byte [rdx + r10 - 0x361a3eb4]
jmp 0x14012f8d3
xchg cx, ax
pop r10
cbw
movsxd rsi, esi
add r11b, cl
sal r9w, 0xc7
adc rdi, rsi
push r9
inc ebx
inc dword [rsp + r9 - 0x237f]
mov bp, word [rax + rbp - 0x7e]
neg dword [rsp + rax*2 - 0xfc]
pop r11
sar dx, cl
jp fcn.1400a6a7c
sub dl, 0xa7
sbb r10, 3
lea rbx, [r11*4 + 0x8214b00]
movsx r8d, bx
sub rbx, rdx
mov r11d, dword [r10 + riz]
rol bx, 0x84
ror r8d, 0xab
sar bx, 0x21
xor r11d, r9d
sal dil, 0xa6
dec r11d
rol r11d, 2
imul di
dec r11d
bswap r11d
push r9
xor dword [rsp], r11d
movsx ecx, al
add r8, rbx
jnp 0x1401dc721
Function at 0x1400b8f57
Capabilities:
Encode data using base64

Disassembly:
movsxd r9, r9d
or al, 0x82
inc eax
call fcn.14009f4e9
mov eax, 0xb48a9e06
movsx esi, al
mov ebx, dword [r9 + rsi*4 - 0x18]
cqo
lea r10, [rsi*4 - 0x464532d7]
lea r9, [rsi + r9 - 2]
movzx edi, r10w
or ax, dx
xor ebx, ebp
rol rsi, 0xaa
adc r10d, edx
and eax, 0xdbbb83a0
bswap ebx
mov ecx, edi
inc dil
sar ax, cl
lea ebx, [rbx + rdx*2 + 0x2f0588a4]
shr rsi, 0x9d
sar ecx, cl
rol ebx, 1
shl edx, 0x53
cbw
inc ebx
bt rsi, rdx
setae dl
not ebx
jae 0x1400de065
mov ecx, 0x1f14baa5
mov rbx, qword [r8 + rcx*2 - 0x3e29754a]
mov ax, word [r8 + rcx*2 - 0x3e297542]
lea r10, [rcx - 0x355bb551]
mov edi, ecx
lea rsi, [rdi*2 + 0x70244ca9]
lea r8, [r8 + r10 + 0x1646fab6]
shr r10d, cl
push rdi
mov word ss:[rbx + rcx - 0x1f14baa5], ax
mov edx, dword [rbp + rcx - 0x1f14baa5]
mov ebx, dword [rsp + rcx - 0x1f14baa3]
je 0x140170d0c
lea rbp, [rbp + rcx*4 - 0x7c52ea90]
js fcn.1400ddb9e
setbe sil
neg bx
xor edx, r11d
jmp 0x14015676f

Function at 0x1400bb633
Capabilities:
Encode data using base64

Disassembly:
neg di
xor r9w, di
add edx, 0xf78c6789
lea rdi, [rsp + rdi + 0x20]
and bx, dx
movzx cx, byte [rax + rdi - 9]
lea rsi, [r8 + rsi - 0xb]
mov word [rsi + rax - 9], cx
dec qword [rsp + rax*8 - 0x3b]
pop r11
pop rbx
pop rdx
pop rdi
jg fcn.140158ba3
cdq
inc ebx
xor ebx, 0x81be5626
lea ebx, [rbx + r11 + 0x772f427]
mov ecx, r11d
btc r11, rax
shr byte [rsp + r11 + 0x51ad1de1], cl
not ebx
sub r11b, r11b
dec ebx
pop rcx
movsx edi, dx
call fcn.14018fc6b
mov edi, 0x1e012da8
mov rax, qword [r11 + rdi*4 - 0x7804b6a0]
lea rsi, [rdi + rdi*4 - 0x7877f0c4]
movsx r8d, di
mov rbp, qword [rax + rsi*2 - 0x3b1be708]
jmp 0x1400819dc

Function at 0x1400bc0cd
Capabilities:
Encode data using base64

Disassembly:
mov cl, byte [r11 + rcx - 0x7bbd7b33]
mov esi, 0x7b0ca0bd
mov qword [rsp + rsi - 0x7b0ca0bd], 0xffffffffc08fccbb
not eax
lea r11, [r11 + rax - 0x6b73ccd6]
pop r10
bt si, si
shl dl, cl
movsx ecx, ax
mov word [r11 + r10 + 0x3f703345], dx
lea rax, [r10*2 - 0x536fcfe0]
add al, r10b
movzx ebx, cx
mov edi, dword [r9 + rsi - 0x7b0ca0bd]
adc rsi, rcx
lea r9, [rbx + r9 - 0xccd4]
jae 0x1401793a2
shr sil, 0xa6
xor edi, ebp
btc eax, ecx
shr esi, cl
rol edi, 1
call fcn.140214486

Function at 0x1400bcc7b
Capabilities:
Encode data using base64

Disassembly:
lea ecx, [rcx + rsi*4 - 0x7d3e6eb6]
mov qword [rsp + rsi], r8
mul esi
shl r9, 0x54
rol ecx, 1
idiv word [rsp + rax*2 + 8]
dec sil
dec ecx
btr r9w, 0xe
push rax
rol ecx, 3
sal byte [rsp + rax + 0xc], 0x82
bswap ecx
pop r10
bt ax, r9w
dec r9b
mov qword [rsp + rax + 8], r11
xor dword [rsp + rax*2 + 8], ecx
xor r9d, 0x41b65521
mov r11, qword [rsp + rax*2 + 8]
not word [rsp + rax*4 + 6]
cdq
cdqe
movsxd rcx, ecx
neg r10w
adc rdi, rcx
or esi, 0x8501b81c
sar byte [rsp + rax*4 + 1], 0xa4
pop rcx
pop rsi
je fcn.1400e339e
Function at 0x1400bfb5f
Capabilities:
Encode data using base64

Disassembly:
mov bx, word [r10 + rax*4 - 0x6e1ffffe]
and byte [rsp + rax*2 - 0x370ffff5], 0xbb
lea r10, [r10 + rax*4 - 0x6e1ffffe]
cbw
adc cx, bx
movzx r11d, dl
call fcn.1401741a8
mov ebx, 0x727ab85
lea rdx, [rbx*4 + 0x2695ec3d]
mov r10d, dword [rbp + rbx*8 - 0x393d5c28]
mov ecx, 0x1c01ae93
lea rbp, [rbp + rbx - 0x727ab81]
xor r10d, r11d
shr rdx, 0x1b
not r10d
lea r10d, [r10 + rbx*2 + 0x5ec97b26]
mov edi, edx
movsx eax, bx
not r10d
push rcx
add word [rsp + rbx*4 - 0x1c9eae0f], 0x9521
pop rsi
dec r10d
add bl, cl
btc rbx, rbx
push r11
xor dword [rsp + rbx - 0x627ab18], r10d
btr esi, ecx
pop r11
ror bl, 0x27
idiv si
movsxd r10, r10d
bt rdx, rax
shl rdx, cl
adc r9, r10
movzx edx, byte [rbx + rbp - 0x627ab30]
lea rbp, [rbp + rbx*2 - 0xc4f565f]
push rbx
mov qword [rsp + rbx*2 - 0xc4f5660], rdi
xor dl, r11b
xor dil, byte [rsp + rcx*2 - 0x38035d1f]
ror dl, 1
mov r10d, 0x642c2915
xor dl, bl
shl qword [rsp + rbx*8 - 0x313d5980], 0xa4
inc dl
dec dword [rsp + rbx - 0x627ab2e]
not dl
call fcn.14016cc9e
Function at 0x1400c4b0d
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rax - 0x60a5], r11
movzx r11d, dx
sub r11w, di
dec di
xor dword [rsp + rax*2 - 0xc14a], r10d
pop r11
shl esi, 0xd2
movsxd r10, r10d
add r9, r10
mov r8, qword [r8 + rax - 0x60a5]
ror sil, 0x82
not bl
jae fcn.1400e29ec
Function at 0x1400c89b5
Capabilities:
Encode data using base64

Disassembly:
imul edx
adc r9b, r8b
push r8
sal rax, 0xba
rol r9b, 1
or si, r8w
xadd rsi, r8
neg r9b
xor r11b, r9b
lea r9, [rsp + r9 + 0x30]
and r8d, 0x8235d5bd
mov qword [rsp + r8*2 - 0x407ff8], 0xffffffffbe1b75b7
pop rcx
movzx dx, byte [r8 + r9 - 0x204000]
lea rbp, [r8 + rbp - 0x204002]
imul si, r8w
bt r8w, ax
jae 0x1401861ab
mov word [rbp + r8 - 0x204000], dx
pop rsi
pop rsi
pop r8
pop rax
pop rax
jae fcn.1400e339e

Function at 0x1400cb796
Capabilities:
Encode data using base64

Disassembly:
inc si
pop r10
not r9d
xor r9d, 0x5c8ecd0f
xor word [rsp + rdx - 0x2395fffe], dx
dec byte [rsp + rdx - 0x2395fffe]
mov qword [rsp + rdx*2 - 0x472c0000], r11
movsx r11d, cx
lea rax, [rcx + rdx*8 + 0x7b08db17]
inc r11w
xor dword [rsp + rcx*8], r9d
or cl, 0xb2
movzx r10d, ax
mov r8d, 0x92b76f26
pop r11
and ecx, 0x9cb7cc25
btr r10d, r10d
shr esi, 0xa1
movsxd r9, r9d
inc r10w
adc rbx, r9
bts eax, 7
bt eax, r10d
mov rdx, qword [rdx + rbp - 0x23960000]
imul r10w, cx
call fcn.1400a7a26
Function at 0x1400d09ca
Capabilities:
Encode data using base64

Disassembly:
btc rdx, 0x9f
lea r9, [r9 + rdx - 0x5fb23d8b]
mov ebp, dword [r9 + rdx - 0x5fb23d87]
xor ebp, r8d
movzx ecx, byte [rsp + rdx - 0x5fb23d6b]
call fcn.14016ddfc

Function at 0x1400d12ae
Capabilities:
Encode data using base64

Disassembly:
call fcn.14015f3e4
mov eax, 0x1a38fcbe
mov ecx, dword [rbp + rax*4 - 0x68e3f2f8]
jmp 0x1401dbfd2
movsx edx, ax
mov eax, dword [rbp + rax - 0x1a38fcba]
add rbp, 4
lea rbx, [rdx*4 - 0x8dde760]
not dx
movsx r9d, bx
and ecx, eax
not ecx
mov esi, 0xcca14310
mov dword [rbp + r9*8 - 0x5cc0], ecx
shl r9w, 0xa
or dl, 0xa2
sal r9, 0xd4
mov r11d, dword [r8 + riz]
inc rdx
movzx ecx, r9w
call fcn.14013d338

Function at 0x1400d1864
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rdi*4 - 0x254], rax
xor si, 0x1e18
rol word [rsp + rdi - 0x8c], 0xa9
mul r10w
not si
setno byte [rsp + rdi*4 - 0x24b]
call fcn.140138225
sbb rbx, rdi
add r9, rsi
mov r10, qword [rax + r8 - 0x1a2d8cab]
xor cx, cx
bts rdx, rcx
jae 0x1401ba73c
mov r8d, dword [rbp + riz]
mov eax, 0xc18a1f27
movsx r10d, al
lea rbp, [r10 + rbp - 0x23]
lea rcx, [r10 + rax*2 + 0x732df0b1]
push rcx
movzx eax, word [r10 + rdi - 0x27]
lea rdx, [r10*4 + 0x52b2a825]
movzx esi, cx
lea rdi, [rdi + rsi - 0x2f24]
pop rdx
mov r9d, 0x873bd60d
mov rax, qword [rax + r8 - 0x1a2d8ca3]
jae 0x14022d988

Function at 0x1400d37e5
Capabilities:
Encode data using base64

Disassembly:
rol edx, 1
not edx
sal rax, cl
rol ax, 0xc7
dec ax
dec edx
mov qword [rsp + r10 - 0x39], rsi
xor r9w, ax
ror r8b, 0xa1
mov qword [rsp + r10 - 0x39], r11
xor dword [rsp + r10 - 0x39], edx
lea r11, [r9*4 - 0x3d4895fa]
xchg r8, r9
pop r11
imul r8, rax
neg sil
sete r8b
movsxd rdx, edx
setbe cl
jne 0x1400e819f
xor rcx, r8
adc rdi, rdx
xadd r8b, sil
sbb r8b, 0x92
mov rdx, qword [rbp + r10 - 0x39]
dec r9d
lea rbp, [rbp + r10*2 - 0x6a]
lea rcx, [rsi - 0x6769a2e8]
btr rsi, r10
push r10
mov qword [rsp + r10 - 0x39], rdx
popfq
jmp rdi

Function at 0x1400e126c
Capabilities:
Encode data using base64

Disassembly:
mov r10d, 0xbb50f87
jmp 0x1400f01f7
mov esi, dword [rdx + r9 - 0x5fbd4314]
call fcn.140228cf1
mov ecx, 0x9595b6bd
movzx esi, cl
movsx eax, cl
mov ebx, dword [r10 + rsi - 0xbd]
mov r11d, 0xf107d69d
shl rcx, cl
btc r11w, 0xd
lea r10, [r10 + rsi*8 - 0x5e4]
sar eax, 0xa4
ja 0x14007c7ad
bswap r11
xor ebx, ebp
imul ecx, r11d
neg ebx
movsx edx, al
btr cx, 0x33
bswap ebx
dec ebx
movsx edi, dx
sub dx, si
xchg edi, eax
bswap ebx
bswap r11
mul r11w
push rbp
shl dl, 2
xor si, r11w
xchg rsi, rdx
xor dword [rsp + rcx], ebx
xchg ah, dl
call fcn.1401d1166
mov ebx, 0xe125df03
mov rax, qword [rsi + riz]
mov edi, ebx
movsx edx, bl
mov r8d, dword [rax + rdx - 3]
lea rsi, [rsi + rdx*2 - 2]
mov dword [rsi + rdx*2 - 6], r8d
neg rbx
movsx ecx, di
lea r10, [r10 + rdx*4 - 0x10]
movzx r8d, cl
call fcn.1401a383e
mov rdx, rbp
call fcn.1401e07b9

Function at 0x1400e166c
Capabilities:
Encode data using base64

Disassembly:
push rbx
mov qword [rsp + r9 - 0x2e32c894], r8
mov qword [rsp + r9 - 0x2e32c89c], r10
jmp 0x14018a2a8
push r15
xchg ebx, r9d
push rsi
mov ecx, r9d
push rdi
Function at 0x1400e1769
Capabilities:
Encode data using base64

Disassembly:
jae 0x1400a2113
xor r9d, 0xfda2e01b
lea r9d, [rsi + r9 + 0x54986f67]
mov qword [rsp + rsi - 0x592e], r11
mov r11d, 0x3d234837
xor dword [rsp + rsi - 0x592e], r9d
mov r8d, 0x10b2f08d
mov edx, 0x7e32cdbd
pop r11
sub r8d, esi
rol rdx, 0xe6
rol ecx, 0xa8
movsxd r9, r9d
mov eax, r10d
setae r8b
adc rdi, r9
movzx r8w, byte [rsi + rbp - 0x592e]
mov dl, byte [rsi + rbp - 0x592c]
lea rbp, [rsi + rbp - 0x592c]
movzx r9d, cx
push rax
or r8b, dl
sar r9b, 0xe2
inc al
not r8b
call fcn.14022e9a7
push r10
xor si, word [rsp + r10 + 0x5effddaa]
not r9d
sbb dx, word [rsp + rax*2 + 0x47b61003]
add r10, 0x13b43e29
mov qword [rsp + rax + 0x23db0808], r11
jno 0x1400d01fa

Function at 0x1400e82f5
Capabilities:
Encode data using base64

Disassembly:
neg edx
inc sil
not sil
dec sil
mov r10d, dword [rsp + rdx - 0xf6d5843]
rol sil, 1
mov qword [rsp + rdx - 0xf6d5856], rcx
movzx edi, bl
xor r11b, sil
btc r10w, bx
adc edi, ebx
pop rdx
lea rsi, [rsp + rsi + 0x10]
mov qword [rsp + r10 - 0x4f0], r10
mov eax, dword [rsi + r10 - 0x4f0]
sal ecx, 0x76
movsx esi, bx
lea r8, [r8 + r10*2 - 0x9e4]
not edx
lea r10, [rsi + rdx*8 - 0x38f41860]
seta cl
mov dword [rdx + r8 - 0xf6d5854], eax
pop rax
cbw
xor rdx, rcx
mov edx, dword [rbp + rax*8 - 0x7ff80]
btc ecx, 0x1f
sbb sil, 0x34
dec sil
lea rbp, [rbp + rax - 0xffec]
cbw
xor edx, r11d
inc word [rsp + rax*4 - 0x3ffba]
add edi, 0x11204926
lea edx, [rbx + rdx - 0x7100997]
push rbx
not edx
jns 0x1401199c6
mov r8d, 0x7d884d92
movzx ecx, r8b
mov r8w, word [r8 + rsi - 0x7d884d92]
push rcx
movzx edi, cl
lea rsi, [rsi + rcx*4 - 0x246]
jmp 0x140191d05
call fcn.140169653
Function at 0x1400f0003
Capabilities:
Encode data using base64

Disassembly:
sbb r10, 4
shl r8d, 0xc5
mov ecx, dword [r8 + r10 - 0x5c757fa0]
mul ax
jo 0x1400cae68
mov esi, 0x73110f11
lea rcx, [rsi + rsi*2 - 0x46ddadce]
movsx ebx, si
mov rdx, qword [rsi + r11 - 0x73110f11]
jmp 0x140104c4d
shr ecx, cl
movzx di, byte ss:[rdx + rcx*4 - 0x24aafec]
setb cl
push rsi
xor rsi, 0x7607dd9a
lea r11, [r11 + rsi - 0x516d285]
push rsi
mov word [r11 + rsi*4 - 0x145b4a2c], di
mov ebx, dword [r9 + rsi - 0x516d28b]
jae 0x1401474d7
xor dword [rsp + rsi - 0x516d07b], ebx
rol di, 0xc8
lea rbp, [r10*2 - 0x7c690972]
xadd dword [rsp + rsi - 0x516d080], edi
mov rbp, qword [rsp + rsi*8 - 0x28b68448]
mov qword [rsp + rsi - 0x516d07b], rsi
cqo
imul di, dx
movsxd rbx, ebx
not byte [rsp + rsi*4 - 0x145b422a]
adc r8, rbx
mov byte [rsp + rsi*2 - 0xa2da102], 0xae
mov qword [rsp + rsi - 0x516d08b], r8
ret 0x10
xchg qword [rsp + rsi - 0x516d283], rcx
lea r9, [r9 + rsi - 0x516d287]
jge 0x140219966
neg ecx
movzx edi, word [rsp + rsi*2 - 0xa2da50f]
xor ebx, ebp
and si, cx
not cx
lea ebx, [rsi + rbx - 0x3618c698]
lea rax, [rcx + 0x179cfb24]
bswap ebx
rol ebx, 2
btc ax, cx
movsx r10d, cx
lea ebx, [rcx + rbx - 0x4a3feada]
mul byte [rsp + rsi - 0x516d07f]
sar r10b, 0xc6
not ecx
not ebx
ror qword [rsp + rsi - 0x516d087], 0x2a
push r10
mov qword [rsp + rdi*2 + 0x10], rbp
jns 0x14012fede

Function at 0x1400f585a
Capabilities:
Encode data using base64

Disassembly:
and si, dx
lea r8, [r8 + rdx - 0x36]
add dx, 0x338d
movsx eax, dx
xor ecx, r10d
xor ecx, 0xb4069a25
sub ecx, 0x930178bb
mov r11d, esi
mul rdx
rol ecx, 1
imul rdx
rol si, 0xca
inc ecx
push r10
movzx ebx, sil
xor dword [rsp + rdx], ecx
shl esi, 0x54
pop r10
sar esi, 0xb6
mov r9d, eax
movsxd rcx, ecx
adc rdi, rcx
shl ax, 0x81
mov rsi, qword [rdx + rbp]
add r9, qword [rbp + rdx + 8]
movzx ecx, ax
mul ecx
sal rdx, 0x84
lea rbp, [rbp + rdx*2 + 8]
imul al
and rsi, r9
sub ebx, edx
xor eax, 0xf49b3591
bts ebx, ebx
not rsi
mov qword [rbp + rdx*4], rsi
xchg r11d, eax
not rcx
and rcx, rcx
adc rdx, rdi
jmp rdx
not rsi
xor r8d, edx
sar rdx, 0x13
push r9
shl ax, 0x2d
rol si, 0x6e
shr dl, 0x47
xor dword [rsp + rdx*2 + 0x1fe], r8d
call fcn.1401d6a8f
mov ebp, 0xc11a9b8a
shl bpl, 0x66
sbb r10, 4
movsx esi, bpl
mov edx, dword [r10 + riz]
lea r8, [rsi*2 + 0x1d316813]
movzx edi, r8b
xadd esi, ebp
xor edx, r9d
btc di, r8w
push r8
push r8
rol edx, 2
xor dil, bpl
lea rcx, [rbp + rsi - 0x5dd5af5]
dec word [rsp + rdi - 0x92]
xor edx, 0x6737b7a6
ror edx, 1
call fcn.140082ba3
bswap r8d
rol dx, 0x2f
not r8d
cqo
pop rcx
bts ebx, eax
bswap r8d
and rax, 0xffffffffcab4b294
jp 0x14009bc0b
dec word [rsp + 1]
mov r11, qword [rsp + 8]
jo 0x14016e0cd
movzx ebx, byte [rsp + 4]
setnp byte [rsp + rbx + 3]
movsxd rdi, edi
mov esi, edx
add r9, rdi
lea rsi, [r10 + rsi*8 - 0x1162007e]
shl cl, cl
mov qword [rsp + rbx*2 + 8], rdx
movzx cx, byte [r8 + rbx]
call fcn.1400bdca6
inc r8w
btr ecx, 3
mov r8w, word ss:[rdx + riz]
mov r9d, ecx
adc rbp, 5
cbw
mov word [rbp + riz], r8w
mov eax, dword [rbx + riz]
movsx r10d, cl
lea rbx, [rbx + r10*2 - 0x62]
xor eax, r11d
call fcn.14020ad48
mov esi, 0x6704723a
movzx edx, sil
mov ecx, dword [r8 + rsi - 0x6704723a]
jmp 0x14007f9d9