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

Disassembly:
xor r9d, esi
movzx edi, bpl
neg r9d
lea rbx, [rbp + rdi*4 - 0x245be7c3]
call fcn.1802b9ac5
call fcn.1802ddbdb
mov edi, dword [r8]
mov eax, dword [r8 + 4]
push 0x4c0ef313
sal word [rsp + 2], 0x47
mov r9d, 0x9584ac28
mov cl, byte [r8 + 8]
adc r8, 6
movsx ebp, word [rsp + 1]
mov edx, 0x7c9c9301
shrd edi, eax, cl
pop rbx
shr dl, 0xe1
movzx ecx, dx
mov dword [r8 + rbp*4 - 0x3cc], edi
not edx
not rbp
mov edx, dword [r11 + rbp + 0xf4]
lea r11, [r11 + rbp + 0xf8]
mov eax, ebp
xor edx, esi
neg r9d
pop rdi
inc r9d
not rdx
call fcn.1802e30f7
mov ecx, 0xc820e40d
movzx r9d, cl
mov r9d, dword [r9 + r11 - 0xd]
mov eax, 0xe936823
and cl, 9
lea r11, [rax + r11 - 0xe93681f]
movzx ebp, cx
movsx ebx, al
jns 0x1802f6c37

Function at 0x1802f7b2d
Capabilities:
Encode data using base64
Hash data using murmur3

Disassembly:
mov qword [rsp + rdi*4], 0xfffffffff7317f85
jae 0x18030d92c
adc r10, rdx
ror al, 0x21
mov dx, word [rax + r8 - 0x4cbc7216]
ror dil, 0x83
mov cl, byte [rax + r8 - 0x4cbc7214]
not rax
shl al, 1
call fcn.1802cc11a
add r10, r9
jmp r10

Function at 0x1802f8d88
Capabilities:
Encode data using base64

Disassembly:
mov rbx, qword [rsp + 0x20]
movzx r15d, r13b
movsx ecx, bpl
push rcx
mov rbp, qword [rsp + r15 - 0x2e]
pop r15
not qword [rsp + r15 - 0x1e]
call fcn.180303155
mov rsi, rbp
sub dil, byte [rsp + rbx*2 + 0x5ea42fd8]
mov r8, qword [rsp + rbx + 0x2f5217f5]
lea rax, [rbx*4 + 0x1731d12b]
call fcn.1802d8d2f
lea rcx, [rbp + rbp*4 - 0x297f3656]
add r8, 0xc
mov dword [rdx], eax
call fcn.18030a4f0
mov qword [rsp + rbx + 0x2f5217e5], rbx
mov qword [rsi + rbp - 0x601b], rax
call 0x1802f8d88
mov rsp, rsi
pop rax
mov r9d, 0xc22345ab
push r9
lea r8, [r9 + r9*4 - 0x10dcb0f9]
mov r10, qword [rsp + 8]
mov r12d, r8d
mov qword [rsp + 8], 0x4f3ba50e
xor byte [rsp + 3], r9b
push qword [rsp + 0x10]
popfq
push r8
pop r13
mov ebp, 0x82bc6421
mov r8, qword [rsp + 0x18]
jmp 0x1802f8d69

Function at 0x1802f8f29
Capabilities:
Encode data using base64

Disassembly:
mov cl, byte [r8 + rbp - 0x905]
mov qword [rsp + rbp*8 - 0x4868], rax
adc rax, r9
and dx, bp
lea r8, [r8 + rbp*2 - 0x1218]
mov qword [rsp + rbp*4 - 0x242c], rax
movzx edi, dx
shr rbx, cl
xchg qword [rsp + rbp*2 - 0x1219], r9
neg byte [rsp + rdi + 0xf]
mov qword [rbp + r8 - 0x90d], rbx
jb 0x1802edc30
mov qword [rsp + rbp - 0x90d], r10
ret 8

Function at 0x1802fb5a6
Capabilities:
Encode data using base64

Disassembly:
mov r8, qword [rsp + rdi - 0x7e7c6770]
not dword [rsp + r11*8 - 0x3f9d8]
dec r11
mov qword [rsp + rdi - 0x7e7c6770], rax
movsxd rcx, ecx
lea rdi, [rbx + rdi*2 - 0x335ac356]
add r10, rcx
pop rbx
sal dx, 0x81
pop rbx
pop rcx
ja fcn.180307268

Function at 0x1802fd6a0
Capabilities:
Encode data using base64

Disassembly:
jmp 0x1802bf3d2
xor ebx, ebx
jmp 0x1802bf1c4

Function at 0x1802fe5c5
Capabilities:
Encode data using base64

Disassembly:
and r9d, 0x850f1f10
dec r11
neg eax
rol eax, 3
shr r9, cl
sal cx, 0x6d
adc eax, r9d
lea rdi, [rbx + rcx - 0x637dbbe3]
mov qword [rsp + rdx - 0xbe], r8
shl rdx, 0xd4
call fcn.1802ed2f7
Function at 0x1802fee0c
Capabilities:
Encode data using base64

Disassembly:
lea ecx, [rbx - 4]
lea rsp, [rsp + 8]
shl ecx, 3
shl edx, 3
mov eax, 0x61b05cb1
mov rax, rbp
push 0x292d821d
ror byte [rsp + 7], 0xa5
adc rax, rdx
push 0x73a58b2f
mov byte [rsp + 0xc], 0x2f
mov qword [rbp + riz - 8], rax
lea rsp, [rsp + 0x10]
mov qword [rbp + riz - 0x10], rsp
call fcn.1802da627
mov edi, dword [r11]
jmp 0x1802db2c4
add r11, 4
mov eax, 0x678320a8
xor edi, esi
rol al, 0x45
lea rbp, [rax*2 - 0x14a7de8]
jae 0x1802fbfa8
rol edi, 1
push rbp
neg edi
movsx ecx, bp
rol edi, cl
movsx ebx, word [rsp + rax - 0x67832013]
dec edi
idiv bpl
mov qword [rsp + rax - 0x67831d7c], rsi
movsx r9d, cl
movsx esi, bx
xor dword [rsp + r9*2 - 0x84], edi
sal r9d, 0x71
or r9w, 0xefb5
rol r9b, 0xa5
pop rsi
lea rdx, [rcx*8 - 0x77fa7bea]
shl ebx, cl
movsxd rdi, edi
xor r9w, 0x4687
adc r10, rdi
bts edx, 0xae
mov dx, word [r8 + r9*4 - 0x212a4c4]
xchg ecx, eax
jae 0x1802ce94a
cmp ebx, 4
lea rsp, [rsp + 0x10]
jbe 0x1802bfcbf
push 0xffffffff9a8d6015
ror qword [rsp], 0x2d
mov edx, 0x97a1691c
mov edx, 4
and dword [rsp + 2], 0xb1264ca1
mov eax, 0xf82dd00e
jnp 0x1802bfcb7
Function at 0x1803006ee
Capabilities:
Encode data using base64

Disassembly:
shl ebx, 0x3c
xor r9d, 0xba89ee05
rol r9d, 3
dec r11d
bts rdx, 0x18
push r8
xadd r11b, al
and r11b, 0x37
xor dword [rsp + rax - 5], r9d
xchg edx, eax
idiv rdi
pop r8
movsxd r9, r9d
btr ax, di
adc r10, r9
xor rcx, r10
jmp rcx
bswap edx
dec edx
ror edx, 1
xor ax, 0xea8
inc edx
xadd ax, r9w
mov ebx, 0x23bf810c
push rsi
jno 0x1802b25df
xor dword [rsp + rdi - 0x5fa7], edx
mov esi, 0x64b056be
pop rsi
movsxd rdx, edx
not ax
ror edi, 0x34
jb 0x1802e15e7
adc r10, rdx
jmp 0x1802c24f1
dec cx
and edi, 0xcc3acd90
mov rcx, qword [r8 + rdi*2 - 0x8748000]
mov ebp, r9d
movsx edx, dil
neg rbx
add dil, byte [r8 + rdi*8 - 0x21d1fff8]
cdqe
mul bpl
sal rbp, 0xe9
lea r8, [r8 + rax + 0x2ccaf443]
mov byte [rax + rcx + 0x2ccaf439], dil
lea rax, [rbx*2 + 0x2a268c06]
add rdx, r10
jmp rdx
xadd di, ax
ror ebp, 1
shr ax, cl
neg ebp
or al, dil
shl ecx, 0xca
neg ecx
not ebp
push rsi
add ebx, eax
movsx edx, di
xor dword [rsp], ebp
cdqe
movsx esi, dx
movsx r9d, di
pop rsi
movsxd rbp, ebp
xor rdi, rcx
adc r10, rbp
inc r9b
push rbx
mov ebp, edx
mov r9, qword [rax + r8 - 0x69dc00fd]
mov rbx, qword [r9 + rax - 0x69dc00fd]
inc di
cqo
mov qword [r8 + rax - 0x69dc00fd], rbx
setge byte [rsp + rax - 0x69dc00fb]
or dword [rsp + rdx*4], 0x1f17d037
mov qword [rsp + rdx*2], r10
ret
dec edi
ror edi, 1
pop rax
neg edi
mov edx, 0x38be20bf
mov qword [rsp + r9 - 0x28], r8
dec dx
xor dword [rsp + r9 - 0x28], edi
movzx eax, word [rsp + r9*2 - 0x5f]
inc ebx
mov r8, qword [rsp + r9*4 - 0xb8]
push rbx
pop rbx
add rcx, rbx
movsxd rdi, edi
dec al
ror bx, 0x89
adc r10, rdi
mov qword [rsp + r11*2 - 0x58], r11
sal r9, cl
mul ecx
mov rbx, qword [rsi + r11 - 0x30]
mov rax, qword [rsi + r11*2 - 0x58]
sal byte [rsp + r11*2 - 0x5b], 7
lea rsi, [rsi + r11*2 - 0x58]
jb 0x1802b961d
sal byte [rsp + r11 - 0x2a], 0x47
jp 0x1802eea29
mov r9d, 0xc484d23c
lea rax, [r9*4 - 0x3a61f9fa]
mov ecx, 0xd12fc0ab
mov ebx, dword [r11]
shl r9b, 5
adc r11, 3
shr r9b, 0xe1
xor ebx, esi
movzx ebp, r9b
xor ebx, 0x2894551f
sal eax, 0xe8
rol cx, cl
neg ebx
sub ebx, 0xc02f9b89
push rcx
pop rdi
xor ebx, 0xac8e6fbc
push rcx
mul r9d
bswap ebx
btr di, di
mul r9w
call fcn.1803083cd
Function at 0x180301652
Capabilities:
Encode data using base64

Disassembly:
xor ecx, ecx
call fcn.1802e73ee
jne 0x1802ce79a

Function at 0x1803018a7
Capabilities:
Encode data using base64

Disassembly:
push 0xffffffff9a92e600
cmp ebx, 1
jmp 0x1802e0ef7

Function at 0x180302e34
Capabilities:
Encode data using base64

Disassembly:
xor ebx, r8d
mov qword [rsp + r11 - 0x5e83b5be], r11
lea ebx, [rbx + r11*2 - 0x14fba67a]
dec word [rsp + r11 - 0x5e83b5ba]
movzx edi, word [rsp + r11 - 0x5e83b5bd]
ror ebx, 3
movzx eax, r11b
shr qword [rsp + rdi*2 - 0x1076a], 0xf7
inc qword [rsp + r11 - 0x5e83b5be]
bswap ebx
xor eax, dword [rsp + rdi*2 - 0x10766]
mov edx, 0xaeb32b32
lea r9, [r11*4 + 0x4a64b1a]
rol ebx, 2
lea r9, [rax + r11*8 + 0x6ba6ac93]
shr r9b, 0x23
shr qword [rsp + rdi - 0x83b5], 0xbb
xor qword [rsp + r11 - 0x5e83b5be], r8
xadd r9b, al
xor dword [rsp + r11 - 0x5e83b5be], ebx
mul rdx
pop r8
movsxd rbx, ebx
xor r11d, edi
adc r10, rbx
cqo
div eax
mov si, word [rsi + r11 - 0x5e83360b]
ror ax, 0x82
jae fcn.180307268
mov eax, 0xd5909d11
mov ecx, dword [rbp + riz]
mov r9d, eax
shr r9w, 0xc9
adc rbp, 3
mov edx, eax
xor ecx, r8d
bt edx, r9d
push rdx

Function at 0x1803050c1
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rdx - 0x4d97ffff], rbx
cdqe
lea rbp, [rax + rbp + 0x785a]
xor edi, r8d
mul ebx
lea edi, [rdx + rdi - 0x34db7df6]
neg edi
push r11
lea edi, [rdx + rdi - 0x3223f96a]
mul rax
not edi
setb byte [rsp + rdx + 0x18]
mov qword [rsp + rdx*2 + 0x18], r8
xor dword [rsp + rdx*2 + 0x18], edi
btr rbx, 0x90
sal ax, 0xe8
mov r8, qword [rsp + rdx + 0x18]
call fcn.1802c5204
lea r11, [r11 + rdi + 4]
xor dil, bl
bswap edi
movzx r9d, cl
xor edx, esi
rol edx, 1
bswap edx
not edx
btr ecx, ebx
sub di, cx
sbb edx, 0x9abe1608
not edi
btc r9d, 0x9e
xor r9w, r9w
push rsi
push rbp
movsx eax, word [rsp + rcx - 0x2a0f1c83]
neg ebp
xor dword [rsp + rcx*2 - 0x541e3900], edx
not rbx
rol qword [rsp + rcx - 0x2a0f1c84], cl
mov rsi, qword [rsp + rcx*2 - 0x541e3900]
call fcn.1802b0f84
movzx r9w, byte ss:[rbx + rax*2 - 0x43cad38]
movsx edx, r11w
bt eax, edx
lea rsi, [rsi + rax*4 - 0x8795a6a]
shl dl, 0xc5
mov word [rsi + rax - 0x21e569c], r9w
lea r11, [rdx + rax + 0x5cbdb1b4]
add al, al
mov r11d, dword [rbp + rax*8 - 0x10f2b1c0]
movsx ecx, al
movzx r9d, cx
or r9, rdx
lea rbp, [rax + rbp - 0x21e5634]
lea rdi, [rax*4 + 0x1484cc39]
jbe 0x1802b9b58
xor r11d, r8d
movsx ebx, r9b
shl ax, 3
inc r11d
cwd
bts rdi, rbx
shl rcx, cl
not r11d
xor r11d, 0x1500fda4
xadd bl, dh
cqo
dec bl
adc r11d, edx
not ax
neg cl
mul rbx
push r8
sal ax, 0x67
xor dword [rsp + rdx], r11d
cdq
pop r8
btc ax, r9w
movsxd r11, r11d
add r10, r11
add rdx, r10
jmp rdx
Function at 0x180305210
Capabilities:
Encode data using base64
Hash data using murmur3

Disassembly:
jmp 0x1802bf2d0
mov eax, 0x289053be
add al, 0x99
mov rax, qword [rbp + rbx*8]
push 0x1323b4b6
adc qword [rsp], 0x3bb5431d
cmp ebx, 1
lea rsp, [rsp + 8]
jne 0x1802c8ecc
jmp 0x1803192af
push 0xffffffffa8bf991e
not qword [rsp]
ror qword [rsp], 0x59
cmp ebx, 2
lea rsp, [rsp + 8]
jne 0x1802cb576
mov edx, 0x11125118
not dl
mov rdx, rax
jmp 0x1802f9277
cmp ebx, 3
jne 0x18030727d
call fcn.1802e0dbd
movsx ebx, cx
mov al, byte [rsi + 8]
movzx edx, bl
dec rbx
shr edx, cl
lea rsi, [rsi + rdx*2 + 0xa]
je 0x1802d5e75
jmp fcn.1802f3bf2
lea rsp, [rsp + 0x10]
jne 0x1802ad408
mov eax, 0xac858925
or eax, eax
mov rax, qword [rbp + riz]
jnp 0x1802ccaba
push 0x4f043e94
mov ecx, 0x5d123f3c
mov rcx, rax
push 0xffffffffac9bae01
push 0xffffffffcb9a8a36
lea rsp, [rsp + 0x18]
jmp fcn.1802f3bf2

Function at 0x180307a42
Capabilities:
Encode data using base64

Disassembly:
inc r9
ror word [rsp + 0xe], 0x26
jae 0x1802c98cc
shr ebx, 8
rol byte [rsp + 0x15], 0x43
xor ebx, r11d
mov qword [rsp], 0xffffffffd03b4824
jmp 0x1802d45ab

Function at 0x18030ac42
Capabilities:
Encode data using base64

Disassembly:
jb 0x1802f1f83
setae bpl
lea r8, [r8 + rbx - 0xfffa]
mov r9b, byte [r11 + rbx*2 - 0x1fffc]
jb 0x1802d5952
movsx ecx, r9w
add eax, dword [rbp + rdi - 0x31]
push rdx
jmp 0x1802d09cb
jg 0x1802f91ee
mov rdx, r8
lea r8, [rbp + r8 - 0x6d]
movzx eax, byte [rsp + rbp*2 - 0xcc]
mov word [r8 + rbp*4 - 0x1ac], dx
pop rcx
pop rax
jmp fcn.18030a981
lea r11, [rcx + r11 - 0x126f6efc]
movsx r9d, bp
xor ebx, esi
inc rdi
jp 0x1802f3c46
mov ecx, 0x4009fc26
mov edi, dword [r11 + rcx - 0x4009fc26]
movzx edx, cx
lea rbp, [rdx + rdx + 0x3c15f13e]
inc bp
lea r11, [rcx + r11 - 0x4009fc22]
movsx ebx, bpl
movsx r9d, cl
btr bx, bp
xor edi, esi
sub edi, 0xe6858a3e
lea rax, [rcx - 0x7a59e97b]
div cl
xor edi, 0x3c244ba5
lea edi, [rdi + rax - 0x523dbdbb]
dec rax
bswap ebp
jg 0x1802dc48f
not edi
neg bl
imul cx, bx
idiv ax
neg edi
sub rdx, 0xffffffff919b5b1b
or rcx, 0xffffffff91328f36
or ecx, 0xd724d6a8
bswap edi
rol ebp, cl
push rdx
mov qword [rsp + rdx - 0x6e65a4a1], rsi
xor dword [rsp + rdx - 0x6e65a4a1], edi
neg ebp
pop rsi
rol r9, 0xc1
shr dx, 1
movsxd rdi, edi
xchg cx, bx
rol bpl, 0xc1
sbb rbp, r9
adc r10, rdi
bts rdx, 0x16
movzx edi, bx
mov edx, dword [r9 + r8 - 0x4c]
xchg ebx, edi
jb 0x1802f1a06
mov rax, rsi
mov ebx, r9d
shr r11b, 0x62
and rdx, qword [rsp + r11 - 0x2118fff8]
sbb rsi, rdi
mov qword [rsp + r11 - 0x21190000], 0x4017563f
mov word [rsi + r11*2 - 0x42320000], ax
sub qword [rsp + r9 - 0x45b0697b], 0xffffffffdeabd72a
js 0x180309b13
jae 0x18030bff3
pop rbx
pop r11
jne fcn.180307268
push rbp
mov word [r8], di
movzx eax, bp
mov edi, dword [r11 + rax*8 - 0xc498]
inc word [rsp + rax - 0x188d]
lea rcx, [rbp + rbp*4 + 0x213423a9]
lea r11, [rax + r11 - 0x188f]
sal rcx, cl
xor edi, esi
xor edi, 0xe8b934a8
idiv rcx
bts ax, ax
mov r9d, ebp
dec edi
rol r9, 0xaa
rol edi, 1
sal r9w, 0x46
sbb edi, 0x2faf6d08
bswap edi
movsx ebx, r9b
push rax
rol r9b, 0xe4
xor edi, 0xe6208302
neg bl
pop rbx
call fcn.1802b5db9
Function at 0x18030b087
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rdi*2 - 0x1c60], rdi
btc eax, ecx
ror edx, 1
and cx, di
setbe byte [rsp + rdi - 0xe2b]
lea rax, [rax*4 + 0x6192f6ab]
inc edx
neg rbx
imul ecx, dword [rsp + rdi - 0xe2c]
shl rbx, 0xb5
mov qword [rsp + rcx*4], r8
xor dword [rsp + rcx*4], edx
add dil, bl
movzx r9d, cx
pop r8
cbw
sbb bl, ah
movsxd rdx, edx
adc r10, rdx
add ebx, dword [rsi + rcx*4]
ror ax, 0x61
rol dil, 3
ror di, 0xee
mov eax, dword [rcx + rsi + 4]
shl r9b, 0x81
mul ebx
neg r9d
jno 0x1802d934e
mov ebx, 0xda887906
mov dword [r8 + rax], edi
lea rbp, [rbx + rbx*2 - 0x27d301d0]
dec eax
bswap rbx
mov eax, dword [r11]
pop rbp
movzx edi, bp
lea r11, [r11 + rdi*4 - 0x16f6c]
xor eax, esi
ror rbp, 0x5a
xor eax, 0x87ad3baa
ror rbp, 9
lea eax, [rax + rdi*2 - 0x16a38ee9]
ror bx, 4
xor ebp, 0xbe23d521
rol eax, 3
not eax
xor eax, 0xb5b09836
inc eax
sar rdi, 0xa0
call fcn.180301c5f

Function at 0x18030c0c0
Capabilities:
Encode data using base64

Disassembly:
call fcn.1802d729d
mov cl, byte [r8 + rdx - 0x5a3b58a6]
movsx eax, dx
mov edi, 0xb0322a97
neg edi
lea r8, [r8 + rax*2 - 0xb156]
bts r9d, 0x2e
shrd ebp, ebx, cl
bts edx, 0x2e
mov dword [r8 + rdx - 0x5a3b58ae], ebp
ror ax, 0xa3
movzx ebx, di
mov ebp, dword [rdx + r11 - 0x5a3b58ae]
cwd
btc ax, r9w
lea r11, [rdx + r11 - 0x5a3bfffb]
xadd edx, edi
xor ebp, esi
xadd rbx, rdx
jg 0x18031971c
imul dil
xor ebp, 0x382b32a8
neg ebp
neg edi
setb dl
dec ebp
bswap ebp
call fcn.1802b0193

Function at 0x18030e004
Capabilities:
Encode data using base64

Disassembly:
neg edx
or rcx, r11
mov qword [rsp + r9*2 - 0x1fbf2], r8
add r11d, r11d
lea rdi, [rax + r11*4 + 0x2b2b7390]
xor dword [rsp + r9*2 - 0x1fbf2], edx
sar eax, 0x81
mov qword [rsp + r9*2 - 0x1fc12], rax
mov r8, qword [rsp + rax + 9]
movsxd rdx, edx
btr rcx, 0xbd
adc r10, rdx
or r9, qword [rsp + r9*2 - 0x1fc01]
movzx r9d, byte [rax + rbp - 0x17]
xchg qword [rsp + rax + 1], rdi
lea rbp, [rbp + rax*4 - 0x5b]
lea rdi, [rcx + rdi*2 + 0x5caba295]
shl eax, 0xab
movsx ebx, cx
xor r9b, r8b
sub rdi, qword [rsp + rax*8 - 0x5bfe8]
jne 0x1802e22bb
Function at 0x18030f422
Capabilities:
Encode data using base64

Disassembly:
mov ecx, dword [rbp + rcx - 0xb4]
dec r9d
lea rbp, [rdi + rbp + 4]
shr rax, 0xb6
neg ebx
sub r9w, 0x6b80
xor ecx, r8d
or bx, r11w
lea ecx, [rdi + rcx + 0xeb74784]
jae 0x1802c4ac9
call fcn.1802e78d1
mov ecx, dword [r11]
mov edx, 0x10a0d87
lea r11, [rdx + r11 - 0x10a0d83]
xor ecx, esi
push rdx
movzx eax, dx
movsx ebp, word [rsp + rdx - 0x10a0d84]
rol ecx, 1
mov ebx, ebp
sub bpl, bpl
setg dl
neg ecx
call fcn.1802e5735
xor ecx, 0x60392ebb
add r9w, bx
not ecx
xor edi, r9d
lea ecx, [rbx + rcx + 0x19345330]
sal r9b, 0xa6
dec r11
xchg r11, rdi
push r8
shr bl, 0x23
lea r8, [r11*2 + 0x5834f2b5]
btc r9w, bx
xor dword [rsp + rbx*2 - 0x3218], ecx
pop r8
sal bx, 0x63
movsxd rcx, ecx
imul edi, edi
add r10, rcx
mov ecx, r9d
rol r9b, 0xe1
jno fcn.180307268
movzx esi, r14w
pop r9
mov ecx, 0xe8379d1c
movzx r12d, sil
or r12w, 0xea9
pop rbp
movsx ebx, sil
mov r13d, r14d
movzx r8d, r12b
popfq
call fcn.1802d1dfb
movzx r9d, byte [r11 + rax*4 - 0xdc04]
jo 0x1802ded68
setl byte [rsp + rax*2 - 0x6e02]
lea r11, [r11 + rax - 0x3700]
push rdi
xor r9b, sil
lea rbx, [rdx + rax*2 + 0x158f81bb]
shr dil, 0x65
movzx ebp, ax
add r9b, al
not di
and ax, bp
not r9b
cwd
sal eax, 0xe1
inc qword [rsp + rax - 0x6dfa]
adc r9b, 0x3a
mov dword [rsp + rax - 0x6df7], 0xbeaf2b35
sub word [rsp + rax - 0x6e02], 0x7991
not r9b
ror r9b, 1
mov word [rsp + rax*2 - 0xdbfb], di
xor sil, r9b
mov ecx, ebp
lea r8, [rax + r8 - 0x6e04]
not bp
sal word [rsp + rax - 0x6df6], 0xd
mov word [r8 + rax*8 - 0x37010], r9w
pop rbp
pop rbp
jns fcn.18030a981
xor edx, r8d
rol edx, 3
mov ebx, ecx
btr ebx, edi
xor edx, 0x7701a00f
lea edx, [rdx + rdi*2 - 0x47413c00]
or r9b, cl
shr ecx, 0x69
movsx r11d, cl
bswap edx
inc r9w
push r8
or dil, r11b
xor dword [rsp + rdi - 0x46be3bff], edx
movsx r8d, cx
cwde
pop r8
sal r9w, 0x64
xor ecx, 0x1b81c6b3
movsxd rdx, edx
adc r10, rdx
sar r9d, 0xe8
sar bl, 0xc2
imul bx, r9w
jmp r10
lea r11, [r11 + r9*8 - 0x4e02c]
xor ebp, esi
sub ebp, 0xe6858a3e
mov edx, 0xc1056636
xor ebp, 0x3c244ba5
lea rax, [rbx*4 - 0x10f1b47b]
sub r9b, 0xab
sbb ebp, 0x8c8da03d
movzx edi, r9w
sar eax, 0xc2
ror r9, 0xf7
not ebp
add rbp, 4
movsx ecx, r9b
xor edx, r8d
rol edx, 3
xadd cl, r9b
mov edi, 0xf1b4ae93
mov qword [rsp], rcx
xor edx, 0xfea43cba
push rdi
not ecx
ror edx, 3
ror rdi, cl
add di, r9w
pop rdi
inc edx
sal r9, cl
mov qword [rsp + rcx*2 - 0x166], r8
jae 0x18031438c
xor dword [rsp + rcx - 0xb3], edx
mov ebx, r9d
movsx r8d, bx
rol r9w, 0x81
pop r8
neg r9d
xadd r9, rdi
lea r11, [rdi*2 - 0x7b711966]
lea rsi, [rsi + rcx - 0xb7]
lea rax, [rbx*4 - 0x294b98fd]
neg r11
mov dword [rsi + rcx*2 - 0x166], edx
btc eax, 0xb3
inc cx
jp 0x1802af4d6

Function at 0x18030f5ca
Capabilities:
Encode data using base64

Disassembly:
and ebx, 0xff
mov qword [rsp], 0xffffffffe62e33b1
jmp 0x1803136be
call fcn.1802cca70

Function at 0x1803104cb
Capabilities:
Encode data using base64

Disassembly:
mov rsi, qword [rsp + rbp + 0x7bdc0745]
movsxd rbx, ebx
not rax
add r10, rbx
rol rax, 0x43
sar rbp, cl
mul dil
pop rdi
pop rbp
jo fcn.18030a981
Function at 0x180311b96
Capabilities:
Encode data using base64

Disassembly:
adc r10, rdi
shr ax, 0x8f
xor eax, eax
mov rdi, qword [r8 + r9 + 0xd00c202]
cwd
mov ebx, dword [r9 + r8 + 0xd00c20a]
imul r9b
inc word [rsp + r9*4 + 0x3403080b]
mov qword [rsp + r9 + 0xd00c20a], rbp
lea r8, [r8 + r9*4 + 0x34030814]
dec dword [rsp + rcx*8 - 0x47b0]
mov dword ss:[rdi + r9*2 + 0x1a018404], ebx
mov qword [rsp + r9 + 0xd00c202], r10
ret 8
mov rsi, qword [rsp + rcx*2 - 0x11e6]
or r9, 0xffffffffd2b20d3c
mov qword [rsp + r9 + 0xd00c202], 0xffffffffcd938e15
movsxd rdi, edi
jnp 0x180316e74
rol bl, 0x67
pop r8
movsxd rdi, edi
xchg bx, r9w
sar eax, 0x9b
neg r9d
add r10, rdi
mov r11, rsi
movsx edi, al
lea rsi, [rcx + rsi - 0xa3]
mov qword [rbx + rsi - 0xcb05011], r11
neg r9w
bt cx, 0xa7
jb fcn.180307268
jl 0x1802de004
Function at 0x180311e9e
Capabilities:
Encode data using base64

Disassembly:
btc ax, r9w
lea rbp, [rbp + rdi*2 - 0x6a7d403d]
mul cx
sub dl, r9b
xor bl, r8b
lea r9, [rdx*4 - 0x41c710d7]
cbw
sar ecx, cl
not bl
shr rax, cl
sal rdi, cl
ror bl, 1
push rcx
dec bl
call fcn.18030f46c
btc r11w, ax
jb 0x180303d45
xor edx, r8d
movzx ecx, ax
neg ecx
ror bl, cl
sbb edx, 0xc935bebb
shl cx, cl
mov r11d, 0x6c109517
mov r9d, 0x818ca63d
ror edx, cl
dec edx
rol edx, 1
push r8
xor dword [rsp + rdi*2 - 0x6a7d403e], edx
pop r8
shr bx, cl
movsxd rdx, edx
shl bl, cl
inc r9b
rol r9b, cl
adc r10, rdx
mov r11w, word [rdi + rsi - 0x353ea01f]
movzx edx, al
div r9w
lea rsi, [rax + rsi - 0x2e]
neg edx
adc eax, 0x5f9451a2
mov bl, byte [rbp + rdi*2 - 0x6a7d403e]
ja 0x1802c8a25
mov ecx, 0xee2fce90
mov r9d, dword [r11]
lea rbx, [rcx + 0x139b2182]
mov edx, ecx
add r11, 4
mov edi, ecx
xadd ebx, ecx
xor r9d, esi
lea rax, [rdx + rdi*4 - 0x64f0e9f5]
and rbx, 0xffffffff90210bab
or al, dil
ror r9d, 1
movsx ebp, bl
sar rdi, 0x3a
bt rdx, rdx
not r9d
sbb r9d, edi
dec dil
setge bl
lea rbp, [rdx + rax*4 - 0x12c41274]
not r9d
jne 0x18030f19c
mov r11d, 0xc10b2e84
mov edi, r11d
mov r9, qword [rsi]
movsx edx, di
mov cl, byte [rsi + rdx - 0x2e7c]
shr r11b, 0x82
lea rsi, [rsi + rdx*2 - 0x5cfe]
jae 0x18031164e
xor edx, 0x58b27d9b
call fcn.1802da476
push rsi
ror rbx, 0x99
sar al, 0x21
xor dword [rsp + rcx - 0x1caf012], r9d
xadd rbp, rax
pop rsi
shr bpl, 0x62
mul ebx
add eax, edi
movsxd r9, r9d
jp 0x1802da1ca
lea rbx, [rdi*2 - 0x5b655264]
lea rbx, [rdi*4 + 0x3329b728]
mov byte ss:[r9 + rdx - 0x2e84], cl
or rdx, 0xffffffff9c326b24
call fcn.18030d158
movsx ebp, dx
mov rbp, r8
pop rdx
add rdx, 0x37292
jmp rdx
movsx r9d, bx
lea r11d, [r11 + r9*2 - 0x262c6337]
call fcn.1802caa17
mov eax, 0x1bb15202
mov ecx, dword [r11 + rax*4 - 0x6ec54808]
lea rbx, [rax + rax*8 + 0x2d85d90a]
movzx ebp, bl
lea r11, [r11 + rax*4 - 0x6ec54804]
xor ecx, esi
lea rdi, [rax + 0x2f38410d]
movzx edx, al
imul dil
lea ecx, [rax + rcx + 0x2ef8b75]
not rdx
not di
shr ebp, 0x82
xor ecx, 0xdeb23920
shr eax, 0x7a
cwd
lea ecx, [rcx + rax*8 - 0x41309259]
shr edi, 0x52
rol ecx, 2
push rsi
movzx r9d, dx
movzx esi, r9b
xor dword [rsp + rax - 6], ecx
pop rsi
dec rbx
dec edi
imul bpl
movsxd rcx, ecx
xor dil, dil
adc r10, rcx
inc rdi
movsx ecx, bpl
mov rbp, r8
xor rdi, rax
lea r8, [r8 + rax*2 - 0x56]
not edx
dec rcx
mov word [r8 + rax*2 - 0x54], bp
lea rbp, [r9*4 + 0x22023828]
neg rbx
jnp fcn.18030a981
mov edx, 0xc83d0e28
lea r11, [rdx - 0x136010c4]
mov edx, dword [rbp + riz]
add rbp, 4
mov ebx, 0x4a9dfd87
xor edx, r8d
neg edx
movsx eax, r11w
rol r11w, 0xec
btr rax, r11
dec edx
jmp 0x1802ff2f7

Function at 0x180312606
Capabilities:
Encode data using base64

Disassembly:
lea rsp, [rsp + 0x38]
je 0x1802eaf8c
call fcn.1803106a2
Function at 0x1803130d0
Capabilities:
Encode data using base64

Disassembly:
mov rax, qword [rax + rbp - 0x46125123]
sub rsp, 0x18
call rax
mov r10d, 0x22850906
mov r11d, 0x2a90911b
mov rsp, qword [r10 + rbp - 0x22850916]
movsx edx, r11b
mov rbp, qword [r10 + rbp - 0x2285090e]
mov qword [rbp + r10*2 - 0x450a120c], rax
movsx r8d, r10w
movsx eax, dx
mov rsi, rbp
and r8b, 0x9f
pop r8
pop r10
movzx ebx, r11b
lea r11, [rdx*8 + 0x28b36f28]
movzx ebp, bl
pop rbp
ror edx, 0xf3
or edx, r11d
mov ebx, dword [r11 + rbp - 0x28b37000]
lea r9, [rax*8 - 0x58cbb878]
mov ecx, 0x6693c586
call fcn.1802d673a
mov r11d, 0x3dbc6694
mov r11d, dword [r11 + rbp - 0x3dbc6694]
mov edi, 0xdf03088b
add rbp, 4
xor r11d, r8d
mov ebx, edi
call fcn.180311e9e
dec word [rsp + rcx*4 - 0x72bc003]
and rcx, rdi
mov word [r8 + rcx*2 - 0x300a000], bp
pop rbp
pop rbp
jge fcn.18030a981

Function at 0x18031388f
Capabilities:
Encode data using base64

Disassembly:
jmp 0x180316fb7
sar qword [rsp + rdi - 0x497ab46b], 0xd3
not ebx
call fcn.18031261b
movsxd rax, eax
add r10, rax
add dil, cl
mov r8, qword [r8 + rbx*4 - 0x3b4]
btc rdx, 0x2d
jae fcn.18030a981
xor ebx, esi
jmp 0x1802debd1
lea rsp, [rsp + 0x18]
mov qword [rbp + riz - 0x10], rsp
jmp 0x1802c8a59
sub rsp, rcx
call fcn.1802ce43e
push 0x16a63fac
mov ebx, 0x672a01b0
movzx edi, bx
mov rbx, qword [rdi + r8 - 0x1b0]
mov cx, word [r8 + rdi*4 - 0x6b8]
push rdi
xor dword [rsp + rdi*2 - 0x360], edi
adc dword [rsp + rdi*4 - 0x6c0], edi
lea r8, [r8 + rdi*8 - 0xd76]
mov word [rbx + rdi*8 - 0xd80], cx
mov ebx, dword [rdi + r11 - 0x1b0]
xadd qword [rsp + rdi - 0x1a8], rdi
xor dword [rsp + rdi*4 - 0x5a98fea8], edi
lea rdi, [rdi + rdi + 0x1c2e351b]
lea r11, [r11 + rdi - 0x497ab46f]
jns 0x18030021d

Function at 0x18031389e
Capabilities:
Encode data using base64

Disassembly:
dec r11d
mov qword [rsp + rdx], rdi
mov rcx, rsi
lea rsi, [rsi + rbx - 0x724a6ec2]
mov qword [r9 + rsi - 0x58e8e694], rcx
div ebx
sar rbx, 0x8a
sbb dword [rsp + r9 - 0x58e8e683], 0x1410dbb9
pop r9
pop rdi
pop rdi
jno fcn.180307268

Function at 0x1803144e1
Capabilities:
Encode data using base64

Disassembly:
mov rbx, qword [rsp + 0x20]
movzx r15d, r13b
movsx ecx, bpl
push rcx
mov rbp, qword [rsp + r15 - 0x2e]
pop r15
not qword [rsp + r15 - 0x1e]
call fcn.180303155
mov rsi, rbp
sub dil, byte [rsp + rbx*2 + 0x5ea42fd8]
mov r8, qword [rsp + rbx + 0x2f5217f5]
lea rax, [rbx*4 + 0x1731d12b]
call fcn.1802d8d2f
lea rcx, [rbp + rbp*4 - 0x297f3656]
add r8, 0xc
mov dword [rdx], eax
call fcn.18030a4f0
mov qword [rsp + rbx + 0x2f5217e5], rbx
mov qword [rsi + rbp - 0x601b], rax
call 0x1802f8d88
mov rsp, rsi
pop rax
mov r9d, 0xc22345ab
push r9
lea r8, [r9 + r9*4 - 0x10dcb0f9]
mov r10, qword [rsp + 8]
mov r12d, r8d
mov qword [rsp + 8], 0x4f3ba50e
xor byte [rsp + 3], r9b
push qword [rsp + 0x10]
popfq
push r8
pop r13
mov ebp, 0x82bc6421
mov r8, qword [rsp + 0x18]
jmp 0x1802f8d69

Function at 0x180315bd6
Capabilities:
Encode data using base64

Disassembly:
xor r9, 0x73ad11f
mov qword [rsp + r9 - 0x16adbfa2], rcx
bswap edi
mov qword [rsp + r9*2 - 0x2d5b7f44], rsi
not dl
shl rbx, cl
mul ax
xor dword [rsp + r9 - 0x16adbfa2], edi
shr ax, 0xe9
bswap eax
je 0x1802b02a8
Function at 0x180316e7a
Capabilities:
Encode data using base64

Disassembly:
push 0x74bd3227
jmp 0x180307c91