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

Disassembly:
rol r11d, 0x82
setb sil
inc ecx
lea rsi, [rbx + r11*2 + 0x5038a124]
push rsi
push rbx
mov qword [rsp + rdi - 0x1b89], rbp
ror word [rsp + rdi*4 - 0x6e7f], 0x45
dec eax
xor dword [rsp + rdi*2 - 0x372a], ecx
neg eax
mov rbp, qword [rsp + rax*2 - 0x77fa6a36]
sbb al, 0x34
movsxd rcx, ecx
imul r11d
ror rdi, 0x20
adc r9, rcx
movzx esi, word [r10 + riz]
mov qword [rsp + 0x10], r11
push rbx
mov qword [rsp + 0x20], 0xffffffffe68ab697
add r10, 2
not qword [rsp + 0x20]
xadd qword [rsp + 0x15], r11
xor si, bp
sub r11b, 0x16
adc si, 0x4d2e
sar dil, 0xa1
lea rdi, [rdx + 0x3e3721a7]
neg si
xor di, dx
push r11
inc si
pop r11
and byte [rsp + 0x1b], dil
or rdi, 0xca28d92
neg si
add r11, rdi
sal eax, 0x49
jns 0x1401c3f0c

Function at 0x1401801f8
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + r11 - 0x7dbe6625], r8
movsx eax, byte [rsp + r8*8 - 0x1893e]
xor esi, 0xac8fd316
inc bx
ror esi, 1
inc byte [rsp + r8*2 - 0x624a]
shl qword [rsp + rax], 0x5e
cbw
inc esi
movsx ecx, word [rsp + r8*2 - 0x624c]
rol esi, 1
pop rdx
push r9
dec rdx
xor dword [rsp + r11 - 0x7dbe6625], esi
lea r11, [rax + rcx*4 + 0x6539b004]
pop r9
movsxd rsi, esi
push rbx
inc qword [rsp + r8 - 0x3128]
pop rcx
add rdi, rsi
lea r10, [r10 + r11 - 0x6539e12e]
lea rax, [rcx - 0x7bf9f7e6]
movzx edx, word [r11 + r10 - 0x6539e12c]
xor r8b, 2
lea rsi, [rcx + rax*2 + 0x638af29c]
xor dx, r9w
cdqe
xor dx, 0xa23b
not r11d
not r8d
ror dx, 1
not dx
dec rbx
push rbx
dec dx
call fcn.1400fb135

Function at 0x140180e5e
Capabilities:
Encode data using base64

Disassembly:
add rdi, r9
xadd sil, cl
mov qword [rsp + r8*2], rcx
pop r9
jae fcn.1400e339e
mov esi, dword [r8]
mov r11d, 0x1584b737
lea r8, [r11 + r8 - 0x1584b733]
call fcn.1400e2a26
Function at 0x1401837ce
Capabilities:
Encode data using base64

Disassembly:
movsxd r8, r8d
sub sil, 0xa1
add rdi, r8
add rax, qword [rbp + r10*2 - 0x18928]
call fcn.1401235e5
adc r11, 4
shr dl, 0xc3
mov esi, 0xa6073102
push rdx
mov dword [r11 + riz], ecx
call fcn.14013f8f2
mov ebx, 0x85ab310d
jmp 0x14019f5b6
mov qword [rsp + r10 - 0xc494], r11
push r10
or edx, dword [rsp + r10*2 - 0x18928]
xor dword [rsp + r10*2 - 0x18920], r8d
cdqe
imul ax
mov r11, qword [rsp + r10 - 0xc48c]
cdqe
jno 0x140168ec5
mov rax, qword [rsi + riz]
movsx edi, bx
mov edx, edi
imul edx, ebx
lea rsi, [rsi + rdi*4 - 0xc42c]
lea r10, [rdi + r10 - 0x310f]
movzx r8d, bl
movzx ecx, word [rdi + r10 - 0x310d]
xor cx, r9w
xor r8b, r8b
adc cx, 0x72b4
and r8d, 0xbbe1b37
rol cx, 1
not cx
push rdi
neg cx
xor r9w, cx
dec rdx
xadd qword [rsp + rdi*4 - 0xc434], rbx
bt bx, 0x10
lea rcx, [rsp + rcx + 8]
mov qword [rcx + rbx*4 - 0xc434], rax
inc byte [rsp + rbx*2 - 0x6215]
lea r10, [r10 + rbx*2 - 0x621e]
sar bl, 0xe2
lea rcx, [r8 + rdi*4 + 0x60204f2f]
movzx r11d, r8b
adc r8d, dword [r10 + rbx - 0x3103]
pop rdx
xchg bx, di
ror di, 0x4a
xor r8d, r9d
movsx eax, dl
shr r11b, cl
adc al, bl
not r8d
bswap r8d
rol r8d, 2
add cl, dil
sbb r11, r11
neg rbx
bswap r8d
xor ebx, ebx
sar dil, 0xc5
push r9
rol cx, 0x21
lea r9, [r11 + rbx*4 - 0x1be70ade]
xor dword [rsp + rbx], r8d
pop r9
or edx, 0x171fe23c
adc ebx, 0x342e5a9e
xadd rcx, rdx
movsxd r8, r8d
call fcn.1400cc019

Function at 0x1401837fd
Capabilities:
Encode data using base64

Disassembly:
ror r10d, cl
bswap rcx
neg r10d
push rdi
add di, 0xa980
rol r10d, 1
imul al
mov qword [rsp + rsi*2 + 0x20], r11
idiv ax
mov ebx, 0x559c6c95
mul rdi
xor dword [rsp + rsi*2 + 0x20], r10d
mov r11, qword [rsp + rsi + 0x20]
imul edi
pop rbx
movsxd r10, r10d
adc r9, r10
add al, bl
rol dl, 1
pop rcx
pop rsi
pop rsi
pop rbx
jae fcn.1400e29ec
Function at 0x14018ba99
Capabilities:
Encode data using base64

Disassembly:
mov rbp, qword [rsp + r11 - 0x29089fff]
shr qword [rsp + r11 - 0x2908a007], cl
movsxd rbx, ebx
neg r11w
add r9, rbx
movsx esi, word [rsp + rcx*8 - 0x77]
mov di, word [r8 + r11*2 - 0x5210bfe2]
mov cx, word [r8 + r11*2 - 0x5210bfe0]
lea r8, [r8 + r11*2 - 0x5210bfe0]
neg word [rsp + r11*2 - 0x5210bfd5]
or sil, 0xa7
mov qword [rsp + r11 - 0x29085fe1], 0x1e150284
not di
not cx
lea rbx, [rdx + rsi + 0x79b18b24]
mov word [rsp + r11*2 - 0x5210bfd7], r11w
jge 0x1401c16dc
and di, cx
pop rsi
add rsi, 0xffffffffffeb85c1
jmp rsi
mov esi, 0xa10a8a
movzx ecx, sil
mov edx, 0xa3b39d29
mov dx, word [rbp + rsi*2 - 0x1421514]
mov r8d, esi
movzx r10d, cx
sub ecx, 0x248d4480
lea rbp, [rbp + rsi*4 - 0x2842a26]
jge 0x1400914bc
ror esi, cl
movzx eax, word [rdi + r10 - 0x8a]
lea rdi, [rdi + r8 - 0xa10a88]
jb 0x1401fab7d
mov eax, 0x2485dc03
movsx edx, ax
and dx, dx
lea r10, [r10 + rax - 0x2485dc07]
js 0x1401d64d7
mov edx, dword [r10 + rax*2 - 0x490bb806]
lea rcx, [rax + 0x6a3dd9af]
shr rax, cl
xor edx, r9d
push rcx
dec edx
movsx r11d, cx
rol edx, 3
sub word [rsp + rax*2 + 4], cx
btr ax, r11w
pop r8
bswap edx
call fcn.1402383b7

Function at 0x14018ed40
Capabilities:
Encode data using base64

Disassembly:
xchg byte [rsp + rbp - 0x2dbfb57d], dl
xor r8b, sil
sar rdx, 0xf3
mov qword [rsp + rax - 0xe1c152f], rcx
lea rsi, [rsp + rsi + 0x20]
idiv word [rsp + rbp - 0x2dbfb596]
and word [rsp + rax*4 - 0x387000af], r11w
sal word [rsp + rbp - 0x2dbfb57d], cl
movzx r11w, byte [rsi + rbp*2 - 0x5b7f6b32]
div cl
movsx esi, bpl
call fcn.140234083
mov r11d, dword [r10]
add r10, 4
xor r11d, ebp
mov edx, 0x631d4b03
sub r11d, 0x578c8808
movsx ebx, dx
sub edx, edx
xor r11d, 0xfaa3de1b
inc r11d
xor r11d, 0x84aba69e
sal dx, 0x4d
lea rsi, [rdx + rdx*8 - 0x58df59e2]
push rbp
xor dword [rsp + rsi + 0x58df59e2], r11d
lea rcx, [rbx + rsi + 0x74aa3ea5]
call fcn.14022ed95
Function at 0x14018fc3b
Capabilities:
Encode data using base64

Disassembly:
lea rbp, [rax + 0x59074421]
mov ebp, dword [r10 + rax*8 - 0xd8]
movzx ecx, dx
lea rdi, [rdx + 0x7a2bc10]
xor ebp, r9d
mov r8d, eax
sub ebp, 0xcb117c99
xchg cx, dx
neg edi
cdqe
xor ebp, 0x28361f2e
sar dl, 0xa2
bswap ebp
xor r8b, 0x24
xor rcx, r8
rol ebp, 2
sal dl, cl
mul r8b
bt r8w, dx
sbb ebp, 0xfd31280e
xadd rdx, r8
shr edi, cl
xor ebp, 0xcd0ca2af
lea rdi, [rax*2 + 0x7e8134ba]
push r9
sal r8d, 0x43
call fcn.1401b8533
div dil
lea edx, [rdx + rdi*2 - 0x244b4d75]
xadd si, bx
sar ax, 0x8e
push r11
xor dword [rsp + rax - 1], edx
mov r11d, 0xfa91ad32
inc ax
pop r11
cmovne esi, r10d
movsxd rdx, edx
sar si, 0x8b
shr dil, 0x65
lea rcx, [rbx*8 - 0x534266df]
adc r9, rdx
mov dx, word [r8 + rax*4 - 8]
mov si, word [rax + r8]
add r10, 0x5e089c29
not dil
call fcn.140157299
dec dx
add rbp, rcx
mov r11, qword [rsi + rdi*2]
btc dx, r8w
lea rsi, [rsi + r8 - 0x38]
lea r10, [r8 + r10 - 0x42]
mov eax, edi
sbb di, di
movzx edx, word [r10 + rdi*4]
xor dx, r9w
add rdi, 0x23df6b9
rol bl, 0xc4
adc dx, 0x72b4
cwde
add ebx, ebx
rol dx, 1
not dx
call fcn.140094fe4
call fcn.1400d12ae
mov edx, 0xa88e991b
sub r10, 4
movzx eax, dl
jmp 0x140138983
bswap ecx
rol ecx, 2
bswap ecx
mov qword [rsp + rdi*4], r9
imul ebx, r8d
xor dword [rsp + rdi*2], ecx
lea rdx, [r11 + rdi*4 - 0x7bd4dbdf]
lea rbx, [rbx + rdx*2 + 0x2c86c084]
inc r8
pop r9
movsxd rcx, ecx
jge 0x140183651
Function at 0x14019134b
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
adc rdi, rcx
add rbx, rbx
js 0x1400f722a
mov qword [rsp + rbp - 0x52b93ba6], rbp
mov rdx, qword [rbp + r10 - 0x52b93ba6]
call fcn.1401a5bb4
mov edx, 0xb104531
mov rax, qword [rbp + rdx*8 - 0x58822988]
lea rsi, [rdx + rdx*8 + 0x61b6ea2c]
mov r8d, edx
mov rsi, qword ss:[rax + rdx*2 - 0x16208a62]
shr dx, 0x63
mov qword [rbp + rdx - 0xb1008a6], rsi
mov ebx, edx
btr ebx, edx
lea r10, [rdx + r10 - 0xb1008aa]
mov r11d, dword [r10 + rdx*2 - 0x1620114c]
and rbx, 0x5c964593
xor r11d, r9d
bt edx, ebx
bt rdx, 0xb4
neg r11d
lea rax, [r8 + rbx*4 + 0xe0d26bb]
mov ecx, eax
btr bx, ax
rol r11d, 1
not bx
xadd ax, dx
bswap r11d
adc r8b, dl
xchg ecx, edx
not ecx
neg r11d
neg rdx
push r9
movzx r9d, dl
xor dword [rsp + rdx*2 + 0x72badbe8], r11d
pop r9
bt bx, r8w
adc dl, bl
call fcn.1401cf354

Function at 0x140194719
Capabilities:
Encode data using base64

Disassembly:
bt rax, 0x12
mov r9, qword [rsp + r8 - 0x3b82fe24]
movsxd rbx, ebx
mov qword [rsp + r8*2 - 0x7705fc58], rdi
neg rdx
add rbp, rbx
movzx ebx, r11b
sub rcx, r8
mov qword [rsp + rax*4 + 4], 0xffffffffec15f23a
lea r10, [r10 + rcx*2 + 0x7705fbf8]
neg dword [rsp + r8 - 0x3b82fe22]
adc r8w, 0xfd1b
shl qword [rsp + rcx + 0x3b82fe05], 0x1a
mov rdi, qword [r8 + r10 - 0x3b82fb48]
xor rdi, r9
xor dl, r11b
rol rdi, 1
neg rdi
sub dl, byte [rsp + r8*2 - 0x7705f687]
dec eax
or ax, 0xa0d
inc rdi
xchg r8, rax
lea r11, [r8 + rdx*2 + 0x3534b88b]
rol word [rsp + r8 - 0xa02], 0x85
ror rdi, 4
cwde
or r8d, r11d
xor r9, rdi
lea r11, [rax*4 + 0x5b190517]
lea rsi, [rsi + rdx + 0x347dca66]
mov qword [rsi + rcx + 0x3b82fe00], rdi
pop rdi
pop rdi
jmp fcn.140158ba3

Function at 0x1401970fb
Capabilities:
Encode data using base64

Disassembly:
and ax, r10w
and rdx, rcx
shl rax, 0x11
sal di, 0xcc
mov qword [r11 + rbx*4], rdx
dec eax
push rdi
mov qword [rsp + rbx*2], r8
ret
mov qword [rsp + rsi*2 - 0x581c0000], r10
cdq
mov r10d, edx
xor dword [rsp + rsi - 0x2c0e0000], r9d
xor r11b, al
bts rcx, r11
jae 0x14010079b
pop r10
lea rax, [rcx*4 - 0x704fa4ef]
lea r11, [r11 + rcx*8 - 0x1650dfef]
not si
movsxd r9, r9d
bswap eax
jb 0x1401afa28
not r9d
or dx, r8w
neg r8b
lea rsi, [rdx - 0x3148b571]
neg r9d
btc r8, 8
not r9d
mov r10d, 0x25aed1af
btr edx, ecx
lea r9d, [r9 + rdx*2 + 0x2089d316]
sar r8d, 0xc9
adc cx, r10w
not cx
push r11
mov r11d, r10d
xor dword [rsp + rcx - 0x489a33cc], r9d
call fcn.14011cbdb
and rsi, rdx
adc rdi, r9
xor rcx, rsi
sar ax, 0xc4
xchg rcx, rbx
mov rax, qword [rbp + rsi*2]
neg rsi
lea r11, [rcx*2 + 0x4488898d]
sub bl, 0xab
mov ecx, dword ss:[rax + rsi*2]
lea rbp, [rbp + rsi*4 + 4]
add ebx, 0x45ba5991
lea rax, [rdx*4 - 0x1f78117f]
mov dword [rbp + rsi*8], ecx
add rsi, rdi
jmp rsi

Function at 0x140198972
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rsi - 0x36aa58fa], 0x19b1940b
xor edx, r9d
neg sil
not si
adc bl, 1
not edx
ror edx, 1
neg edx
mov eax, ebx
movzx r11d, bx
ror edx, 2
push rbx
mov qword [rsp + rsi*2 - 0x6d554fea], r9
shr word [rsp + rsi*2 - 0x6d554ff2], 0xae
pop rcx
xor dword [rsp + rsi - 0x36aaa7f9], edx
pop r9
mov r8d, 0x38a00239
add rcx, rcx
jns 0x1400a5e83
Function at 0x1401a2d11
Capabilities:
Encode data using base64

Disassembly:
sets dil
movsx esi, dx
lea r9, [rdi + r9 + 0x20efb504]
xor ebx, ebp
dec ebx
dec rdx
btr di, 0
neg ebx
shl esi, 0x6f
adc ebx, 0x82163ab1
movzx ecx, di
neg ebx
inc rsi
push rbp
shl rdi, 0xf5
xor dword [rsp + rdi*8], ebx
xor rdi, 0xffffffff96b90121
pop rbp
mov eax, 0x2c9de292
rol dil, 0x86
jbe 0x14017cdd2
movsxd rbx, ebx
idiv si
mul esi
mov r10d, ecx
adc r8, rbx
jmp fcn.14007c713
sar word [rsp + rdi - 0x297], 0xa
mov r8d, dword [rsp + rdi - 0x296]
xor dl, 0x1c
jmp 0x140165d3a
mov r11d, r8d
xor dword [rsp + rsi*2 - 0x80001f6], edx
mov r11, qword [rsp + rsi - 0x40000f7]
movzx r10d, si
movsxd rdx, edx
rol cl, 0x26
pop r9
add rdi, rdx
movzx r9d, si
inc r10b
pop r8
jp fcn.1400e339e
movsxd rdi, edi
and al, 0x1a
rol ecx, 0xda
rol si, 0xc8
adc rbx, rdi
bts dx, ax
lea r10, [r10 + rdx*8 - 0x7fffffc9]
lea r8, [rbp + rcx - 0x1f7add5f]
add cl, r8b
movzx edi, byte [r10 + rdx - 0xffffff9]
bt r8w, bp
adc cx, r8w
xor dil, r9b
xor dil, 0xb0
add al, sil
cdqe
sbb dil, 0x21
dec al
not dil
neg dil
or cl, r8b
neg rax
sbb dx, dx
sbb dil, 0x17
cbw
bts esi, r8d
xor r9b, dil
bswap esi
lea r8, [rcx + rdx*8 + 0x72a5181e]
xor rsi, 0x2501af9a
adc rdi, rsp
lea rbp, [rsi*2 - 0x7a65a174]
mov r8w, word [rdi + rdx*4 - 0x3ffffffc]
lea r11, [rdx + r11 - 0x10000001]
mov word [r11 + rdx*2 - 0x1ffffffe], r8w
lea rdi, [rdx + rsi*4 - 0x7253097f]
neg rdi
not si
jp fcn.14009521e
lea rdi, [rdi*4 - 0x20f0caec]
lea r11, [r11 + rdi*2 + 0x41df681c]
mov dword [r11 + rdi + 0x20efb410], ebx
mov ebx, dword [r9 + rdi*2 + 0x41df6820]
jge 0x140099bcf

Function at 0x1401a4ad1
Capabilities:
Encode data using base64

Disassembly:
lea rbp, [rbp + rsi - 0x55d773]
shld bx, r9w, cl
mov word [rbp + rsi - 0x55d777], bx
shr ax, 0xc2
call fcn.1401aa7a2
rol dl, 1
lea r10, [r8 + rsi - 0x3b687460]
mov qword [rsp + rax - 0x110cfff9], rax
mov qword [rsp + rax*4 - 0x44340004], r10
sub dl, al
xchg byte [rsp + r10*2 - 0x575fad53], r8b
add qword [rsp + rax - 0x110cfff9], 0xffffffffd0098129
sbb word [rsp + rax*2 - 0x2219fffc], 0x6d1a
not dl
sbb dl, 0x94
movzx ecx, sil
bswap r8
shl rax, 0x77
xor r11b, dl
or r10d, r10d
xadd sil, r8b
lea rdx, [rsp + rdx + 0x10]
jne 0x1400a347d
jbe 0x1401fee39
mov word [rdx + r10 - 0x2bafd6af], r9w
lea rdx, [rcx + rax*4 - 0x28d760f6]
mov qword [rsp + r10*2 - 0x575fad5e], rbx
ret 8
Function at 0x1401a5d26
Capabilities:
Encode data using base64

Disassembly:
ror cx, 0xe7
adc dl, dil
ror rbx, 0x5e
adc ebx, 0xdb923b31
rol dl, cl
sar r11w, 0x4d
adc dl, 0x88
rol dl, cl
btr edi, r11d
xor r9b, dl
lea rbx, [rcx + rbx*2 + 0x2b91fcb1]
sub di, 0x1f84
add rdx, rsp
or bl, r11b
movzx bx, byte [rdi + rdx - 0xe07c]
or r11w, di
lea rsi, [rdi + rsi - 0xe07e]
dec dil
xchg di, r8w
mov word [rsi + rdi*2], bx
rol eax, cl
or r8, r8
jle fcn.140158ba3
mov r10d, 0x17ad182a
and r10d, r10d
sub r10b, 0xb8
mov r8d, dword [rbp + r10*4 - 0x5eb461c8]
push r10
lea rdx, [r10*4 - 0xa542ef5]
mov cl, byte [r10 + rbp - 0x17ad186e]
lea rbp, [rbp + r10*4 - 0x5eb461c6]
sbb dword [rsp + rdx - 0x546032d3], 0x32a4f1b8
shr r8d, cl
movzx eax, dx
jmp 0x1400d5093
mov r9d, 0xb79e1f14
mov dword [rbp + r10*2 - 0x2f5a30e4], r8d
jmp 0x14013fbfa
ror dil, 0xa1
or dl, byte [r10 + rdi*2]
xor dl, r9b
jmp 0x1400c4557
mov edx, dword [rbx + r10 - 0x17ad1872]
pop rcx
call fcn.1400bc876
mov r10d, dword [r9]
mov ebx, 0xed1e3328
jmp 0x14018b205
add r9, 4
movzx ecx, bl
movsx edx, cl
xor r10d, ebp
rol bx, 0x8e
rol r10d, 1
not r10d
lea rcx, [rdx + 0x723bb0a9]
lea rdi, [rbx - 0x357d34fb]
dec r10d
ror r10d, 2
mov eax, 0x9c1b19a3
call fcn.1401e8107
lea eax, [rax + rdi*4 - 0x41b3b6b6]
neg eax
inc ebx
pop rcx
bswap eax
rol bx, 0x42
shr dx, 0xe7
rol edx, 0x48
xor eax, 0x1538bc3e
bswap r11
xchg rbx, rdx
dec eax
xor rdi, r11
adc edi, ebx
je 0x1401db910
push r9
movsx r9d, r11b
js 0x140111dde
xor edi, edi
xor dword [rsp + rdi], eax
sar dl, 0x86
movsx r8d, dl
pop r9
bswap r8
xadd r11w, dx
xadd dl, dil
movsxd rax, eax
dec r11b
shr dil, 0x21
adc rbp, rax
movsx eax, dx
movzx ecx, bl
lea r10, [rdi + r10 - 1]
and r11d, ecx
jne 0x140134439
bts ax, 0x15
xor bp, bx

Function at 0x1401a7366
Capabilities:
Encode data using base64

Disassembly:
dec bp
neg eax
lea rbx, [rdx + rdx*8 - 0x1961f16b]
xadd sil, bpl
not ebp
bswap eax
add cx, bp
sal bl, 0x42
shr dx, 0x64
push r8
lea r8, [rsi + 0xa87a3a]
xor dword [rsp + rbp - 0x161cacfd], eax
neg bpl
pop r8
bts si, bx
adc rcx, rcx
jbe 0x1400f4c41
movsxd rax, eax
setge cl
adc rdi, rax
neg ebp
btc r11, r11
jae fcn.14021d268
bswap rax
shl si, 0x4f
sal r11d, 0x27
not bp
xor rax, 0x218a20bf
mov ecx, esi
mov qword [rsp + rdx*2 - 0x677d848], rbp
pop rsi
xor r8, rax
btr esi, esi
lea r10, [rdx + r10 - 0x33bec2c]
shr si, 0x2d
sar cl, 0x24
or dl, dh
mov qword [r10 + rdx - 0x33becec], rax
lea r9, [rdx + r9 - 0x33becf0]
sbb esi, ecx
mov eax, dword [r9 + rdx*4 - 0xcefb3b0]
lea rcx, [rbx + rcx*8 - 0x24fdcac7]
xor eax, r8d
add rbx, rbp
lea eax, [rdx + rax + 0x5ed24718]
rol eax, 1
sub r11b, cl
jbe 0x140077178
Function at 0x1401a73d6
Capabilities:
Encode data using base64

Disassembly:
sal byte [rsp + r11 + 0x2384915a], 0xc5
adc ax, 0x9205
or qword [rsp + r11 + 0x23849155], r11
ror word [rsp + r11 + 0x23849155], 0xce
mov qword [rsp + r11 + 0x23849145], 0xffffffffd4962d26
ror ax, 1
pop rdi
call fcn.140211110
xor ecx, 0x3c8de6a2
not dx
cqo
add edi, eax
bswap ecx
neg r10w
xor ecx, 0xf3a6ab31
cdq
neg ecx
mov ebx, edi
bts rsi, 0xe
adc esi, esi
bswap ecx
sbb rbx, 0xffffffff941b40a5
sub rdi, 0x3624e133
idiv rdi
xor ecx, 0x6a35ee0d
inc bl
jns 0x1401c2abf
not r10b
push rbp
bswap eax
div rdi
shl eax, 0x85
xor dword [rsp + rdi + 0x1c1718f1], ecx
dec rdi
jnp 0x140094b00
Function at 0x1401a97d5
Capabilities:
Encode data using base64

Disassembly:
shr r9w, cl
imul word [rsp + rax + 8]
xor dword [rsp + rax - 0xe466], ebx
ror qword [rsp + rax*8 - 0x723a8], cl
mov r10, qword [rsp + rax*2 - 0x1c8dc]
btr si, 0x9f
movsxd rbx, ebx
dec r11w
adc rdi, rbx
bts esi, edx
add ecx, edx
mov qword [rsp + rax - 0xe466], 0xffffffffe087d887
mov qword [rsp + rax - 0xe476], rdi
ret 0x10
sbb esi, ebx
rol edi, cl
inc rbx
btr esi, eax
jb 0x14017a553
not r10d
push rbp
push rdx
movzx esi, cl
and edi, edi
xor dword [rsp + rax - 0x197ffff8], r10d
mov rbp, qword [rsp + rax - 0x197ffff8]
cqo
mov qword [rsp + rax*2 - 0x32fffff8], rdi
movsxd r10, r10d
mul di
pop rax
adc r8, r10
and dword [rsp + rdx*8 + 3], 0x812beb21
sub eax, 0x8220da1b
dec rsi
xor rdi, qword [r11 + rdx*4]
inc dword [rsp + rdx*2 + 1]
mov rax, qword ss:[rdi + rdx]
movsx edi, bx
sar ebx, cl
xchg word [rsp + rdx + 3], bx
mov qword [r11 + rdx*2], rax
mov qword [rsp + rdx], r8
ret
push rbp
xor dword [rsp + rbx - 2], edi
add sil, r11b
shr rcx, cl
pop rbp
movsxd rdi, edi
dec rsi
add r9, rdi
mov r8d, dword [r8 + rbx - 2]
dec si
jle fcn.140199adb
div dword [rsp + r9 - 0x180684a5]
sub ebx, 0x930178bb
sar rdx, 0xc3
lea r11, [r9*4 - 0x3bc9c0d2]
jb 0x140224c14
lea rbp, [r10*8 + 0x77203b15]
neg r10w
pop rbp
cbw
movsxd rsi, esi
xchg bl, cl
neg rax
sal cl, 0xc7
adc r8, rsi
mov esi, dword [rcx + r11]
call fcn.14022db53
mov edi, dword [r10]
mov ecx, 0x9a31c301
movzx ebx, cl
lea rsi, [rcx + rcx*8 + 0x28b2ec2d]
lea r10, [r10 + rbx + 3]
or si, si
xor edi, ebp
rol cl, cl
neg edi
sub edi, 0xd1bad1bf
ror edi, cl
movzx eax, bx
bswap edi
inc esi
xor edi, 0x3a2accaa
dec cx
rol edi, 2
sar rsi, cl
movzx r11d, cl
lea rsi, [rsi*4 - 0x1547caf4]
lea edi, [rdi + rbx - 0x40b7b5b0]
jno 0x14010909a
rol ebx, 1
shr rsi, cl
sbb dl, sil
inc ebx
neg edx
mov qword [rsp + rax - 2], 0x5316d0b8
mov qword [rsp + rax + 0xe], r10
jnp 0x1400c2adb
movzx r8d, dl
lea r10, [r10 + rax - 0x230dbd07]
not r8
and ax, bx
btr bx, ax
mov r8d, dword [r10 + rbx*2 - 0x461b7a06]
sub bx, word [rsp + rbx - 0x230dbcff]
sbb byte [rsp + rax - 0x230dbd00], 0x9f
movzx ecx, dl
xor r8d, r9d
ror dword [rsp + rax - 0x230dbd03], 0x48
dec r8d
call fcn.14013252b
mov ecx, 0xab34f523
mov rax, qword [rbp + riz]
mov r10d, dword ss:[rax + riz]
add rbp, 4
movzx r9d, cx
movzx esi, cl
mov dword [r9 + rbp - 0xf523], r10d
mov r8d, ecx
mov r10d, dword [r9 + rdi - 0xf523]
btc esi, esi
lea rdi, [rdi + r9*2 - 0x1ea42]
btc r8, rsi
movzx eax, r9w
xor r10d, r11d
lea rdx, [r9 + rsi*2 + 0x3ab7a992]
shl si, 0xee
bswap r10d
not r10d
xchg r9w, ax
cdq
or ax, 0xe4a2
neg r10d
idiv al
cdq
dec cx
inc r10d
rol r10d, 1
rol r8b, 0x66
lea rax, [rcx + 0x7eb449b5]
dec r10d
xadd ax, r8w
sbb r9b, 0xbb
xadd r8d, r9d
ror r10d, 1
div ecx
xor sil, dl
push r11
xor r8d, 0x2ca6179e
ror ecx, cl
xor dword [rsp + rsi - 0xc09f], r10d
sar ax, 0x86
sar r8w, cl
pop r11
inc edx
btr r9, 0xbc
cdqe
movsxd r10, r10d
inc r8
cmovle ax, si
bts r8d, esi
add rbx, r10
xor rax, rbx
jmp rax
Function at 0x1401ae934
Capabilities:
Authenticate hmac
Encode data using base64

Disassembly:
mov esi, edx
mov ax, word [rbp + riz]
movsx r11d, si
mov ebx, r11d
mov cx, word [rbp + riz + 2]
mov qword [rsp], rbx
movzx r9d, bl
and rsi, qword [rsp + r9 - 0xb8]
lea rbp, [rbp + r9*8 - 0x5be]
pop rbx
bt esi, 0x1a
and ax, cx
shr r9, 0x1a
not ax
shl r9, 0x4f
xadd r11, rdx
seta r9b
mov word [rbp + r9 - 1], ax
mov r11d, dword [r9 + r8 - 1]
sete r9b
sal esi, 0x65
lea r8, [rsi + r8 - 0x47fef6fc]
jp 0x14021680e

Function at 0x1401b4306
Capabilities:
Encode data using base64

Disassembly:
sal sil, cl
add rsi, rdi
jmp rsi
mov qword [r10 + rcx*2 + 0x201d9b00], rsi
pop rsi
pop rax
pop rax
pop rax
jae fcn.14021d268
mov esi, 0x82168484
sub r10, 4
mov eax, 0xe9ad3d03
mov r8d, esi
mov ebx, dword [r10 + riz]
shl sil, 0xa3
movzx edx, sil
xor ebx, r9d
mov ecx, r8d
mov r11d, 0xb328fbb
sub ebx, 0x97ba6235
mul r11d
inc r11
neg ebx
not eax
sub ebx, 0x84931024
rol ebx, 1
lea rsi, [rsi + rax*4 + 0x1b9c191e]
mul dl
neg ebx
shr dl, cl
add r11, 0x5b94893f
push r9
xor dword [rsp + rdx*4 - 0x28e26028], ebx
cqo
dec dl
sub r11w, cx
pop r9
setle cl
sbb rdx, rsi
and ax, r8w
movsxd rbx, ebx
adc rdi, rbx
or r8, 0xffffffffd9162ba8
mov rbx, qword [rax + rbp - 0x7dc98400]
adc dl, cl
not ecx
neg rax
movzx r8w, byte [rax + rbx + 0x7dc98400]
mov ebx, 0xa600a134
dec r11w
lea rbp, [rax + rbp + 0x7dc98406]
sar rsi, 0xa4
setp cl
mov word [rsi + rbp], r8w
jp 0x1400861b1

Function at 0x1401b624d
Capabilities:
Encode data using base64

Disassembly:
not di
adc di, ax
rol di, 1
xor rsi, qword [rsp + rdx - 0x391b95ff]
call fcn.1400fea12
mov eax, 0x4a205132
shr eax, 0xff
lea r10, [r10 + rax*2 - 4]
cdqe
lea r8, [rax + rax - 0x1fedd6c8]
mov ebx, dword [r10 + rax]
xor ebx, r9d
lea rdi, [r8*4 - 0x32c6e0f7]
movzx ecx, al
mul rdi
not ebx
xor ebx, 0xaa90da91
jmp 0x140097790
mov qword [rsp + rax - 0x391b9600], rbx
lea rsi, [rdx + rdx*2 - 0x6a65dfe4]
lea rbp, [rdx + rbp - 0x391b95fe]
rol byte [rsp + rdx - 0x391b9600], 0x42
xor di, r11w
neg qword [rsp + rdx - 0x391b9600]
mul qword [rsp + rax - 0x391b9600]
sbb di, ax
shr qword [rsp + rsi - 0x40ece21c], 0xb1
jne 0x14011e987
mov eax, 0xc12e063f
bt rax, rax
mov edx, eax
mov rcx, qword [rbp + riz]
sbb dl, ah
movzx r9d, al
mov r9w, word ss:[rcx + r9*2 - 0x7e]
movsx r10d, ax
movsx r8d, r10b
movsx esi, dx
lea rbp, [rbp + r10 - 0x639]
not edx
and ax, si
dec r10b
mov word [r10 + rbp - 0x63e], r9w
xadd al, r8b
movzx ecx, ax
adc rsi, 0x13204125
mov r8d, dword [rbx + r10*2 - 0xc7c]
lea rbx, [rbx + rdx - 0x3ed1f9c2]
xor r8d, r11d
cdqe
not r10b
neg r8d
neg sil
rol r10d, 0x83
dec r8d
lea rax, [rdx*8 + 0x7d85baab]
not r8d
and rsi, rax
sar dx, 0x61
lea r10, [rax + rdx*4 + 0x720fb381]
neg r8d
jmp 0x140151b4c

Function at 0x1401b6399
Capabilities:
Encode data using base64
Parse pe header

Disassembly:
rol esi, 0x5d
bswap ecx
mov qword [rsp + rdx - 0x2411], rdx
shl rsi, 0xc7
cwde
mov qword [rsp + rax - 0x2410], rbp
mul dil
movzx r11d, sil
xor dword [rsp + rax - 0x110], ecx
jmp 0x140144320

Function at 0x1401b7124
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + 0x10], r11
call fcn.1401d0781
Function at 0x1401b7488
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + rsi - 0x236d], r9
mov qword [rsp + rsi - 0x2375], rbx
xor dword [rsp + rsi - 0x236d], ecx
mov r9, qword [rsp + rsi*2 - 0x46e2]
movsxd rcx, ecx
xadd r11, rsi
or r8, 0x23980483
mov qword [rsp + rdx*4 + 8], rax
adc rdi, rcx
btc eax, r11d
not r8
ror r8d, 0x69
mov ebx, dword [rbp + rbx*2 - 0xea]
movzx ecx, word [rsp + rax - 0x414abd9c]
mov cl, byte [rbp + rax - 0x414abda1]
neg dx
push rdx
sar r8b, 0xa5
lea rbp, [rax + rbp - 0x414abda3]
xor r8w, dx
shl ebx, cl
mov dword [rbp + rdx], ebx
inc rdx
call fcn.1401c89d1

Function at 0x1401b8fe9
Capabilities:
Encode data using base64

Disassembly:
add rbx, rdx
push r8
call fcn.140089bf5
mov edi, 0xb9859585
mov rsp, rbp
lea r15, [rdi + rdi - 0x5775abe8]
call fcn.1401a93f4
inc r11b
mov dx, word [rbp + rdx*2 - 0xb910]
xor ax, r11w
lea rbp, [rbp + rax - 0x59ca]
call fcn.1400f065f
lea r8, [r8 + rsi - 0x5da842a5]
or eax, eax
inc sil
imul si, si
xor ebx, r10d
rol al, 0xe6
inc rsi
adc ecx, 0xf636df26
bswap ebx
push rax
dec ebx
ror ebx, 2
movzx r9d, sil
shr cl, 1
call fcn.1401db567
movsx r10d, si
mov edx, dword [rdi + rsi*2 - 0x145a3e3c]
rol r10d, 0x82
mov qword [rsp + rsi - 0xa2d1f1e], 0x698ea88d
lea rdi, [rdi + rsi*4 - 0x28b47c74]
movsx eax, word [rsp + rsi - 0xa2d1f1b]
xadd qword [rsp + rsi*2 - 0x145a3e3c], rax
xor edx, r11d
movsx r9d, byte [rsp + rsi*2 - 0x145a3e3c]
movsx r8d, r10b
bswap edx
lea edx, [rdx + rsi + 0x6d67eaf1]
ror r10d, 0xa7
sar r9b, 0x42
inc word [rsp + rsi - 0xa2d1f1e]
ror edx, 2
push r9
add sil, r9b
neg edx
inc sil
add qword [rsp + rsi - 0xa2d1f14], r9
mov qword [rsp + rsi - 0xa2d1f14], r11
pop r8
sar r8, 0x8c
xor dword [rsp + rsi - 0xa2d1f1c], edx
lea r10, [rax + r9*4 + 0x50b9c316]
mov ecx, r8d
pop r11
sar r8w, 9
sal r9b, 0x41
and r9, r8
movsxd rdx, edx
sub rsi, 0x71897f19
jb 0x14009cd98
mov esi, 0x5da842a9
movsx ecx, sil
mov ebx, dword [rsi + r8 - 0x5da842a9]
or cl, sil
movsx eax, si
jp 0x140192d86
imul r9w, r10w
mov qword [rsp + rdx*2], rbx
ret 8

Function at 0x1401bb736
Capabilities:
Encode data using base64

Disassembly:
xor r11d, r10d
mov esi, 0xc92f08b6
call fcn.14017455a
bswap ecx
sar word [rsp + r11 - 0x9b], 0xc1
shl r8b, 0xe2
sbb ecx, edi
imul dword [rsp + r11 - 0x9a]
sbb r8w, word [rsp + r11*2 - 0x13a]
xor byte [rsp + r11 - 0x98], dl
xor ecx, 0xdbbdae8f
mov qword [rsp + r11*2 - 0x13a], r9
add dx, 0x57b1
xor dword [rsp + r11*2 - 0x13a], ecx
lea r9, [rax + rdx*4 + 0x5e11821c]
pop r9
lea rdx, [rdi + 0x2fbfb8b8]
movsxd rcx, ecx
bt dx, dx
sal dl, 0x23
xor ax, di
adc rbp, rcx
jmp fcn.140158ba3