joyce8/EMBER2024-capa huggingface dataset:
Function at 0x180bcc058
Capabilities:
Decompress data using aplib

Disassembly:
call fcn.180bcc1df
push r10
mov r10, rsp
push r10
mov rsi, qword [r10 + 0x10]
mov rdi, qword [r10 + 0x20]
cld
mov dl, 0x80
mov al, byte [rsi]
inc rsi
mov byte [rdi], al
inc rdi
mov ebx, 2
add dl, dl
jne 0x180bcc089
mov dl, byte [rsi]
inc rsi
adc dl, dl
jae 0x180bcc06f
add dl, dl
jne 0x180bcc096
mov dl, byte [rsi]
inc rsi
adc dl, dl
jae 0x180bcc0f6
xor eax, eax
add dl, dl
jne 0x180bcc0a5
mov dl, byte [rsi]
inc rsi
adc dl, dl
jae 0x180bcc1ad
add dl, dl
jne 0x180bcc0b6
mov dl, byte [rsi]
inc rsi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x180bcc0c3
mov dl, byte [rsi]
inc rsi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x180bcc0d0
mov dl, byte [rsi]
inc rsi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x180bcc0dd
mov dl, byte [rsi]
inc rsi
adc dl, dl
adc eax, eax
je 0x180bcc0ea
push rdi
mov eax, eax
sub rdi, rax
mov al, byte [rdi]
pop rdi
mov byte [rdi], al
inc rdi
mov ebx, 2
jmp 0x180bcc07e
mov eax, 1
add dl, dl
jne 0x180bcc106
mov dl, byte [rsi]
inc rsi
adc dl, dl
adc eax, eax
add dl, dl
jne 0x180bcc113
mov dl, byte [rsi]
inc rsi
adc dl, dl
jb 0x180bcc0fb
sub eax, ebx
mov ebx, 1
jne 0x180bcc14c
mov ecx, 1
add dl, dl
jne 0x180bcc12e
mov dl, byte [rsi]
inc rsi
adc dl, dl
adc ecx, ecx
add dl, dl
jne 0x180bcc13b
mov dl, byte [rsi]
inc rsi
adc dl, dl
jb 0x180bcc123
push rsi
mov rsi, rdi
sub rsi, rbp
rep movsb byte [rdi], byte [rsi]
pop rsi
jmp 0x180bcc07e
dec eax
shl eax, 8
mov al, byte [rsi]
inc rsi
mov ebp, eax
mov ecx, 1
add dl, dl
jne 0x180bcc168
mov dl, byte [rsi]
inc rsi
adc dl, dl
adc ecx, ecx
add dl, dl
jne 0x180bcc175
mov dl, byte [rsi]
inc rsi
adc dl, dl
jb 0x180bcc15d
cmp eax, 0x7d00
jae 0x180bcc19b
cmp eax, 0x500
jb 0x180bcc196
inc ecx
push rsi
mov rsi, rdi
sub rsi, rax
rep movsb byte [rdi], byte [rsi]
pop rsi
jmp 0x180bcc07e
cmp eax, 0x7f
ja 0x180bcc19e
add ecx, 2
push rsi
mov rsi, rdi
sub rsi, rax
rep movsb byte [rdi], byte [rsi]
pop rsi
jmp 0x180bcc07e
mov al, byte [rsi]
inc rsi
xor ecx, ecx
shr al, 1
je 0x180bcc1d2
adc ecx, 2
mov ebp, eax
push rsi
mov rsi, rdi
sub rsi, rax
rep movsb byte [rdi], byte [rsi]
pop rsi
mov ebx, 1
jmp 0x180bcc07e
pop r10
sub rdi, qword [r10 + 0x20]
mov eax, edi
pop r10
ret 0x20
Function at 0x141be9cb8
Capabilities:
Encode data using add xor sub operations
Encode data using xor

Disassembly:
push qword [rsp + 0x18]
popfq
lea rsp, [rsp + 0x20]
call fcn.141f57511
invalid

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

Disassembly:
mov qword [rsp + r9 - 0x510821a5], r10
mov qword [rdx + rdi - 0x634e9dec], rbx
shr dl, 0x25
imul r10w, r10w
or r9, 0xffffffffae072d2f
lea r11, [r11 + r9 + 0xf0d24d]
mov r8d, dword [r11 + r9*2 + 0x1e1a4a2]
xor r8d, esi
ror r9b, 0x61
lea rax, [rdx*4 + 0x130657bf]
jno 0x141f9108f
inc r8d
jmp 0x141f757b7

Function at 0x141e695e3
Capabilities:
Encode data using base64

Disassembly:
mov qword [rsp + r9 + 0x10], rsi
movsx esi, r9b
or rbx, qword [rsp + r9 + 8]
jl 0x141f092da
sub rdi, 4
mov r8d, 0x178fe639
mov eax, dword [rdi + r8 - 0x178fe639]
xor eax, r10d
lea eax, [rax + r8 - 0x703bbfde]
movzx ecx, r8w
ror cl, 0x66
jb 0x14206324d
call fcn.14207c879
mov eax, 0xa2b51c83
movsx ebx, ax
mov ebp, ebx
mov rax, qword [r11 + rbx - 0x1c83]
lea rcx, [rbp*4 - 0x60e1a54e]
movzx r8d, bpl
mov si, word ss:[rax + rbx - 0x1c83]
sub bpl, cl
lea r11, [rbx + r11 - 0x1c7d]
movzx eax, r8w
bswap rax
mov word [rbx + r11 - 0x1c83], si
mov esi, ecx
mov ebp, dword [rdi + rbx*4 - 0x720c]
bt bx, si
dec rax
lea rdx, [rsi*8 - 0x3dd67947]
lea rdi, [rdi + rbx*2 - 0x3902]
jae 0x141f257c9
shl dword [rsp + rbx*8 + 2], 0xee
mov r11, qword [rbx + r9]
call fcn.142022c5b
jmp 0x142019deb
xor ebp, r9d
neg ebp
call fcn.141e73675
mov ebx, 0x223f51b1
mov eax, dword [rdi + rbx*2 - 0x447ea362]
push rbx
call fcn.141eee5e5
xor dword [rsp + rbx*4 + 0x1478b94], edx
ror word [rsp + rbx*2 + 0xa3c5d0], 0xcd
jb 0x141e85583
sub r9w, 0x2aa9
xchg dword [rsp + rbx*8], ecx
not r9w
and dword [rsp + rbx], ebx
inc r9w
sar rax, cl
dec dword [rsp + rbx]
xor bp, r9w
jmp 0x14205b49c
sub dx, ax
js 0x141ec352f
mov edx, 0xcc01e41e
lea r9, [rdx*2 + 0x4964f87]
mov bp, word [r10]
mov cl, byte [r10 + 2]
movsx edi, dl
sub edi, edx
call fcn.142039098
movsx edx, cx
lea r9, [rsp + r9 + 8]
jmp 0x141e8d59d
not eax
lea rbp, [r8*8 - 0x6643f261]
dec eax
mov edx, r8d
ror eax, 1
not eax
push rdx
mov qword [rsp + r8*2 - 0x2f1fcc72], r10
xor dword [rsp + r8*2 - 0x2f1fcc72], eax
pop r10
movzx ebx, dl
or r8, r8
and dx, dx
movsxd rax, eax
sub r8, 0x2921869d
sub r8d, 0xc3b31122
dec cl
adc r11, rax
lea rax, [r8 + rbx*8 - 0x1aca0242]
xchg edx, ecx
lea rsi, [rax + rbp + 0x3b1e338d]
mov esi, dword [r9 + rcx - 0x178fe639]
call fcn.141ec4bfd

Function at 0x141e6aad9
Capabilities:
Encrypt data using rc4 ksa

Disassembly:
movzx r8d, byte [rbx + rcx*4 - 0x58]
call fcn.142033bc9
mov r9d, dword [r11]
mov edi, 0x598bfa1c
lea r11, [r11 + rdi - 0x598bfa18]
call fcn.141f9a625
Function at 0x141e73a85
Capabilities:
Hash data using murmur3

Disassembly:
movsxd rax, eax
bts ecx, 0
mov qword [rsp + rsi*2 - 0x4008], rbp
dec r11d
adc r9, rax
mov rdx, qword [rdi + rsi*2 - 0x4010]
and qword [rsp + rsi - 0x2002], r11
lea rdi, [rdi + rsi - 0x2000]
sar rcx, cl
movzx esi, byte [r8 + rsi*8 - 0x10040]
add qword [rsp + rbp*2 - 0xe80f], r11
ror bp, 0x84
lea r8, [r8 + rbp*2 - 0x12e7f]
sbb rbp, rbp
xor sil, r10b
push rbp
and r11w, 0xafbb
sbb qword [rsp + rbp*4 + 0xe], rbp
neg sil
call fcn.141f5a4b0
bt ebp, 0x15
neg ecx
jmp 0x141ed9fa2
lea rsp, [rsp + 8]
call rax
mov rsp, qword [rbp + riz - 0x10]
mov r11d, 0xd8a26e3b
movzx r8d, r11w
movzx r10d, r11b
mov rbp, qword [r8 + rbp - 0x6e43]
mov ebx, r8d
and ebx, ebx
mov qword [rbp + r8*2 - 0xdc76], rax
mov rdi, rbp
pop rsi
movsx r9d, r8w
inc rbx
pop rbp
pop r11
movsx eax, r10b
lea r11, [r8 + r11 - 0x6e3f]
movzx ecx, r10b
mov r10d, dword [r11 + r8*4 - 0x1b8ec]
lea rdx, [rbx - 0x797e3600]
call fcn.141e7918b
jnp 0x141e56235
call fcn.1420790f7
sar ax, 0x25
rol r11d, 1
sub dl, 0x91
neg r11d
rol dx, 0x8e
ror bp, 0xe5
push r10
imul bx, ax
xor dword [rsp + rdx - 0x49ed9db], r11d
push rbp
mov r10, qword [rsp + rdx*2 - 0x93db3ae]
movsxd r11, r11d
call fcn.141f38ff4
ror ecx, 1
and edx, 0x452bca04
movzx edi, dl
mov qword [rsp + rdx - 0x452b8804], rsi
xchg dil, dl
xor dword [rsp + rdx - 0x452b8804], ecx
pop rsi
movsxd rcx, ecx
xor dil, bpl
adc rbx, rcx
btr bp, 0x87
mov dil, byte [r11 + rdi - 0xa4]
imul ebp, ebp
sbb rbp, 0xffffffffd329b415
lea r11, [r11 + rbp - 0x78740fe9]
imul edx, ebp
ror edx, 0x8f
xor dil, sil
btr ebp, edx
xor dil, 0xa9
dec dil
shl rbp, 0x30
neg dil
add rdx, 0xffffffff83211e07
rol bp, 0x44
not dil
setbe dl
sbb dx, 0x8da3
ror dil, 1
sal dl, 0xa7
and dx, dx
jns 0x141f4e6c2
btr bp, bx
bswap rbp
mov rbp, r10
mov ebx, edi
call fcn.14204e89b
mov r8d, dword [rdi]
mov r10d, 0x1008818f
mov r10d, dword [r10 + rdi - 0x1008818b]
mov ecx, 0xd50ad688
lea rbx, [rcx + rcx*4 - 0x2a443653]
mov cl, byte [rdi + 8]
add rdi, 6
jmp 0x141ed5757
inc dil
inc rbp
lea rdx, [rdx + rbp*4 - 0x217458ef]
ror dil, 1
lea rbp, [rbp*8 - 0x1f563463]
neg dl
inc dil
push rbp
shl qword [rsp], 0xc3
xor sil, dil
jmp 0x14200f50f
sub bpl, bpl
add dl, dl
mov qword [rsp], r11
sub rdx, rdx
lea rdx, [rbp + 0x453b4ab8]
push rbx
lea rbx, [rdx + rbp - 0x35f4baf7]
and rdx, rbp
push rsi
jns 0x141f10a4a

Function at 0x141e760e4
Capabilities:
Encode data using xor

Disassembly:
lea rsi, [0x141ea0748]
lea rsp, [rsp + 8]
movzx ebx, byte [rcx]
xor ebx, edx
push 0xffffffffcf353eb6
and ebx, 0xff
mov ebx, dword [rsi + rbx*4]
shr edx, 8
xor edx, ebx
inc rcx
xor edx, 0xb42d8605
shr qword [rsp], 2
dec r10
lea rsp, [rsp + 8]
jne 0x141e760f0
mov ecx, 0x96afb890
pop rsi
Function at 0x141e76a41
Capabilities:
Encode data using base64
Hash data using murmur3

Disassembly:
mov edx, dword [rdi]
add rdi, 4
mov qword [rsp], 0xffffffffdd026219
xor edx, r9d
bswap edx
xor edx, 0x4391a835
dec word [rsp + 3]
not edx
js 0x141eb44a7
push 0x5d8e67a5
inc edx
call fcn.141f79d6b
mov r10d, 0xa11521c
lea r11, [r11 + r10*2 - 0x1422a43c]
call fcn.141ef21b4
mov edi, 0x8bb32f2c
push rdi
mov ecx, dword [r11]
rol byte [rsp + 2], 0xc2
adc r11, 4
pop rax
movsx edx, dil
xor ecx, esi
movzx r8d, dx
not ecx
neg rdx
inc ecx
mov r9d, edx
push rdx
neg ecx
lea rbp, [rdx*8 - 0x7bf4d073]
pop rax
lea ecx, [rcx + rax*2 - 0x2e950139]
xadd dl, dil
rol ecx, 1
call fcn.1420652b6
lea rsp, [rsp + 0x18]
jne 0x141f005cd
mov r10d, 0xd2152e14
not r11d
movsx esi, r10b
mov dword [rbp + rsi*8 - 0xa0], r11d
inc si
bswap r10
movzx eax, sil
jmp r9
mov r10d, 0xca977cb7
call fcn.14205fa58
bt ebx, 0x3b
add r11, rcx
shl r8, 2
cdq
or rbp, 0xffffffffe8b668ad
mov r9d, dword [r9 + rsi*2]
bswap r8d
jl fcn.142036f60
mov esi, 0xa68512a6
mov r11d, esi
sub r10, 4
mov r11d, dword [r10]
mov eax, esi
xor r11d, ebp
or eax, eax
movzx ecx, sil
movsx edi, cx
ror r11d, 3
dec r11d
xchg edi, ecx
movsx r8d, di
neg r11d
bts rax, 0x25
bts rax, rsi
lea rdx, [rsi + rdi*8 + 0x248dfe8b]
dec r11d
rol r11d, 2
push rbp
xor dword [rsp + rcx*2 - 0x14c], r11d
bswap rdi
call fcn.141e7668c

Function at 0x141e7adb4
Capabilities:
Execute anti-debugging instructions

Disassembly:
bt rdx, rdi
jmp r10
rol edx, 0x61
xor ecx, ebp
lea rdi, [r9*4 - 0x7f9847f]
not ecx
neg ecx
mov qword [rsp + r9 + 0x62464143], rdx
inc ecx
xor ecx, 0xf81ef417
add word [rsp + r9 + 0x62464148], dx
mov qword [rsp + r9 + 0x62464143], rbp
dec rdx
xor r9b, 0x10
lea rsi, [r9*4 - 0x3ed2c9ef]
xor dword [rsp + r9 + 0x62464153], ecx
movsx ebp, si
pop rbp
btr esi, 0x33
movsxd rcx, ecx
rol dl, 0x82
xadd rdi, rsi
adc r10, rcx
or edi, edi
js 0x141e5e16d
Function at 0x141e7df97
Capabilities:
Hash data using murmur3

Disassembly:
mov eax, esi
lea rdi, [rsi + rdi - 0x52c1241e]
lea rdx, [rax*8 - 0x2050f65f]
bswap eax
jns 0x141ee509d
bswap ebp
xor esi, 0xe1006931
lea rax, [r10*2 + 0x59be8838]
dec dx
lea esi, [rsi + rcx*2 - 0x65e69a46]
sete byte [rsp + rcx - 0x7c921ef2]
rol esi, 1
sar word [rsp + r11 - 0x1eed], 0x83
jb 0x141f5eac3
jmp 0x141edf5ac
mov rax, qword [rdi]
mov esi, 0x13935aa5
movsx r11d, sil
movsx ecx, sil
mov r11, qword ss:[rax + rsi*4 - 0x4e4d6a94]
mov qword [rsi + rdi - 0x13935aa5], r11
mov esi, dword [r10 + rsi*2 - 0x2726b54a]
mov eax, ecx
push rcx
pop rbx
add r10, 4
xor esi, ebp
xor ax, cx
rol esi, 1
neg esi
call fcn.141eb7425
mov esi, 0x4a960921
or sil, sil
mov bp, word [rdi + rsi - 0x4a960921]
mov cl, byte [rsi + rdi - 0x4a96091f]
shl esi, 0x25
jb 0x141e6ba48
shr bp, cl
lea rcx, [rax + rsi*4 - 0xc6f047f]
mov word [rsi + rdi - 0x52c12420], bp
mov edx, dword [r8 + rax*2 - 0x404982a4]
xadd cl, ah
movzx ebx, ax
bswap rax
lea r8, [r8 + rsi - 0x52c1241c]
xor edx, r10d
call fcn.14206e258
lea esi, [rsi + rcx*2 - 0x6f277d6]
lea rdx, [r11*4 + 0x36aef7b6]
mov qword [rsp + rdx*2 - 0x6d5ee734], r8
lea r8, [r10 + 0x5e00f5bc]
pop r10
xor dword [rsp + rcx - 0x7c921efa], esi
imul ecx
pop r8
cdq
ror dl, 0x41
ror cl, 5
movsxd rsi, esi
push rcx
add r9, rsi
mov r10d, 0x1ab24eb5
or rcx, 0x5095fa83
neg r11
pop r11
jle fcn.141f6db95

Function at 0x141e7e442
Capabilities:
Authenticate hmac
Encode data using base64
Hash data using murmur3

Disassembly:
mov rsp, qword [rbp + rdx*2 - 0x7506e37e]
shr dx, 0xa3
jb 0x141ed59f4

Function at 0x141e7e59d
Capabilities:
Hash data using murmur3

Disassembly:
xor edx, esi
lea rbp, [rax + rdi*2 + 0x48b1ec03]
mov qword [rsp + rdi - 0x34], rax
lea edx, [rdx + rbp + 0x7c674f0e]
lea rcx, [r8*4 + 0x210752b5]
call fcn.141efb6d6

Function at 0x141e7ee93
Capabilities:
Hash data using murmur3

Disassembly:
cmp ebx, 2
push 0xfffffffff68b2b28
lea rsp, [rsp + 0x10]
jne 0x141fe5307
mov rdx, rax
push 0x1093a22
lea rsp, [rsp + 8]
jmp 0x142048bc7

Function at 0x141e864f2
Capabilities:
Authenticate hmac
Encode data using base64
Hash data using murmur3

Disassembly:
mov r8, qword [rsp + rdx - 0x68c906a1]
mov qword [rsp + rdx - 0x68c906a9], 0xffffffffea3914a3
movsxd r11, r11d
sar dword [rsp + rdx - 0x68c906a8], 0xfe
jb 0x142055623
shld dx, ax, cl
lea r11, [rsi + rsi*8 + 0x618be9a9]
mov qword [rsp + r10 - 0x36f956d9], r10
mov word [rbp + r10 - 0x36f956d9], dx
mov qword [rsp + r10 - 0x36f956d9], r9
ret
xor dword [rsp + rdx - 0x68c906a8], edx
adc r9, r11
lea rax, [rbx*2 - 0x3b65535b]
movzx r10d, byte [rsp + rdx - 0x68c906a6]
mov dx, word [rdx + rbp - 0x68c906a9]
xadd byte [rsp + r10*8 - 0x1b0], r10b
mov ax, word [rbp + r10 - 0xa1]
pop r10
bts r10d, r10d
mov cl, byte [rbp + r10 - 0x36f956d5]
lea rbp, [rbp + r10*2 - 0x6df2adae]
movzx esi, bl
jb 0x141f7a1cd
Function at 0x141e88ed5
Capabilities:
Execute anti-debugging instructions

Disassembly:
ror edx, 1
mov qword [rsp + rax - 0x4f29ffd5], rbp
push rax
rol dword [rsp + rax - 0x4f29ffda], 7
mov qword [rsp + rax - 0x4f29ffd5], 0xffffffff8420da07
xor dword [rsp + rax - 0x4f29ffcd], edx
dec dword [rsp + rax - 0x4f29ffdd]
rol qword [rsp + rax - 0x4f29ffdb], cl
mov rbp, qword [rsp + rax - 0x4f29ffcd]
movsxd rdx, edx
adc r10, rdx
mov ax, word [rax + r11 - 0x4f29ffdd]
mov r9w, word [r11 + 2]
xor dil, byte [rsp + 5]
mov cl, byte [r11 + 4]
adc r11, 4
shrd ax, r9w, cl
call fcn.141efd347
btc bx, dx
push r8
jb 0x1420799af

Function at 0x141e8ab73
Capabilities:
Execute anti-debugging instructions

Disassembly:
xor esi, 0x1e221808
or dx, r10w
mov eax, dword [rcx + rdx*2 - 0x1ffee]
lea rcx, [r10*2 - 0x78d47a5c]
lea rbp, [rbp + rdx*2 - 0x1fff2]
jb 0x141effa06
push rbx
mov qword [rsp + rdx - 0xffdf], 0xffffffffe1b09eba
mov dword [rbp + rdx*2 - 0x1ffee], eax
rol dx, cl
dec si
lea rdi, [rdi + rdx - 0xfe03]
mov edx, dword [rdi + rdx - 0xfdff]
sbb word [rsp + 0x18], si
inc sil
xor edx, r8d
sub edx, 0xf997bc87
mov eax, 0x7532a19a
call fcn.141ee1c3f
lea r9, [r9 + r8 - 0x7dba5ef2]
shrd rsi, rax, cl
add edx, 0xad038107
mov qword [r9 + rdx - 0x230b445], rsi
lea r10, [rdx + r10 - 0x230b449]
call fcn.141f44c4a
movsx ebp, r9b
rol bpl, 0xc1
rol edx, 2
movsx edi, r9w
lea edx, [rdx + rdi*2 - 0x583facbf]
movsx eax, r9w
mov r8d, eax
ror edx, 1
neg edx
inc edx
push rsi
or r9b, r8b
seta r9b
xor dword [rsp + rbp - 0x3c], edx
pop rsi
lea rcx, [r8 + rdi*2 + 0x6d104f2a]
inc ecx
movsxd rdx, edx
add rbx, rdx
movsx edx, r8b
mov rdi, qword [rbp + r10 - 0x3c]
jmp 0x141faa6d3
rol rbp, 2
movzx ebx, bpl
lea r11, [rbx + rbp + 0x729557ad]
lea r8, [r8 + rbp*4 - 0x1e8]
movzx edx, r11w
lea rdx, [rdx*4 + 0x2688d519]
mov ecx, 0x3693c42d
xor rax, r10
call fcn.141efa0e8
mov rdx, qword [rbp + r10 - 0x34]
call fcn.141f9b22a
mov ebp, 0x42bdf78e
rdtsc
movzx r9d, bpl
lea r10, [rbp + r10 - 0x42bdf796]
mov dword [r10 + rbp - 0x42bdf78a], eax
mov dword [r10 + rbp - 0x42bdf78e], edx
mov ecx, dword [rbp + r11 - 0x42bdf78e]
and rbp, r9
lea r11, [r11 + rbp*2 - 0x118]
mov edi, ebp
call fcn.141fcd61b

Function at 0x141e942cd
Capabilities:
Execute anti-debugging instructions

Disassembly:
lea rsp, [rsp + 0x10]
jne 0x14207c430
jmp 0x141e8aac6

Function at 0x141e9733f
Capabilities:
Hash data using murmur3

Disassembly:
movsxd rcx, ecx
sar r9w, 0x2b
jp 0x141fc819a
sub r11, 4
call fcn.14206c409

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

Disassembly:
mov qword [rsp + rax*8 - 0x2dbf0], r9
mov qword [rsp + rax - 0x5b70], rbp
xor ax, r11w
mov qword [rsp + rax - 0x5b6c], r9
jae 0x14207d76a
xor dword [rsp + rax*4 - 0x16dc0], ecx
mov rbp, qword [rsp + rax - 0x5b64]
or eax, edx
movsxd rcx, ecx
cdq
adc r8, rcx
and r11w, dx
mov qword [rsp + rax - 0xfff7], r8
ret 0x10
Function at 0x141eab813
Capabilities:
Hash data using murmur3

Disassembly:
btr r8w, 0x84
bswap eax
mov qword [rsp + rsi - 0x619], rdx
jae 0x141fcda82
inc eax
dec byte [rsp + rsi - 0x618]
inc dl
cmovp si, r8w
rol eax, 1
bswap eax
pop rbx
dec eax
inc r8d
dec esi
push r9
not rdx
bswap ebp
xor dword [rsp + rbx - 0x6584], eax
rol bp, 0x81
call fcn.142011845
mov ebp, dword [r11]
mov edx, 0xf083c7b8
add r11, 4
lea r8, [rdx*4 - 0x7f5b1ed2]
call fcn.142048000
mov rcx, qword [rsp + rbx - 0x231fb375]
mov r8, qword [rsp + rbx - 0x231fb36d]
mov qword [rsp + rbx*2 - 0x463f676a], rbx
mov rbx, qword [rsp + rbx*2 - 0x463f672a]
call fcn.141e8a3dc

Function at 0x141eb7379
Capabilities:
Hash data using murmur3

Disassembly:
mov qword [rsp + rdx*2 - 0x9e50], 0x35be4e32
jmp 0x141ecb20b

Function at 0x141eb86d1
Capabilities:
Hash data using murmur3

Disassembly:
xor edi, esi
and edi, 0xff
mov edi, dword [r8 + rdi*4]
shr esi, 8
xor esi, edi
push 0xffffffff81abd996
inc rbp
xor esi, 0x85151095
call fcn.141ffef2c
pop rcx
movsxd r11, r11d
add rbx, r11
add byte [rsp + rdx*8], 0x27
adc rax, 0xffffffff8a038b3a
js 0x141edda35

Function at 0x141eb8ac5
Capabilities:
Hash data using murmur3

Disassembly:
rol dx, 1
mov qword [rsp + rbx*4 - 0x4004], rsi
bswap rax
cdqe
sub dx, 0xbeb8
call fcn.141fb0388
sub rdi, 4
call fcn.141f9d8ce

Function at 0x141ebab55
Capabilities:
Hash data using murmur3

Disassembly:
rol r11d, cl
mov qword [rsp + rdx - 0xf2], r10
xor dword [rsp + rdx - 0xf2], r11d
mov r10, qword [rsp + rcx*2 - 0x3a]
bts ax, 0xbf
movsxd r11, r11d
adc r9, r11
call fcn.141fb4f19
sar bl, 0x67
jb fcn.141f6db95
xor ecx, ebp
not byte [rsp + 1]
bswap ecx
inc ecx
bswap ecx
rol ecx, 1
neg ecx
mov qword [rsp], rbp
xor dword [rsp], ecx
mov ebp, 0xce299498
call fcn.141f8652a

Function at 0x141ebc348
Capabilities:
Hash data using murmur3

Disassembly:
not ecx
rol ecx, 2
bswap ecx
sal byte [rsp + r10 - 0x6a038ec5], 0xa6
shr dword [rsp + rax - 0xbc], 0x8f
not ecx
dec di
call fcn.141efa701
sub rdi, 4
mov r10d, 0xfc128d28
neg r10
mov r10d, dword [rdi]
jle 0x142069cc1
Function at 0x141ebe343
Capabilities:
Hash data using murmur3

Disassembly:
mov r9d, eax
shr bl, 1
mov rax, rdi
lea rdi, [r10 + rdi - 0x10007]
mov qword [rsp + r10 - 0xffff], r10
jbe 0x141f31ff7
shl qword [rsp + r10*4 - 0x3fffc], 0xa9
mov qword [r10 + rdi - 0xffff], rax
lea rax, [rbx + r9 + 0x42a18aa7]
mul r10d
inc bl
pop r8
jno fcn.141f9adc4
mov edi, 0x6d28fa95
lea r10, [r10 + rdi - 0x6d28fa99]
mov r8d, edi
mov r11d, dword [r10 + rdi - 0x6d28fa95]
movsx eax, di
xor r11d, ebp
movzx esi, al
neg r11d
dec rdi
jns 0x141f19f32
xor r9w, 0xe84
lea rdi, [r9 + rcx + 0x512c359b]
mov qword [rsp + r10 - 0x5396], rbp
setp r10b
call fcn.141fdfdf4
rol r11d, 3
lea r11d, [r11 + rdi + 0x288e1712]
shl r8d, 0x7a
jbe 0x141f6b873
adc rdi, rsi
bswap r11d
lea rcx, [r8*4 - 0x4bde10d5]
not edi
neg si
lea r11d, [r11 + rsi*2 - 0x138c09f4]
xor r11d, 0xebae9a24
ror r11d, 1
movzx edx, al
dec sil
not r11d
cwde
neg r11d
bt rsi, 0xbf
shl r8d, cl
call fcn.141f7496a
rol r11d, 1
not r11d
mov edx, eax
mov qword [rsp + rdi - 0x48f326bf], 0xffffffffe61e8b93
mov qword [rsp + rax*2 + 8], rbp
xor dword [rsp + rdi - 0x48f326bf], r11d
xor sil, r8b
jne 0x141f270ca
add r11, r8
dec qword [rsp]
sub rdi, 2
movzx r8d, word [rdi]
xor r8w, r10w
and word [rsp + 5], bp
btr rbx, 0x95
adc byte [rsp + 5], 0xa4
rol r8w, 1
movsx ecx, bpl
shl esi, cl
xor r8w, 0xbf3d
call fcn.141f0158e
mov esi, dword [r11]
mov edx, 0x713f95ae
movzx r9d, dx
mov r9d, dword [r11 + rdx - 0x713f95aa]
movzx r8d, dl
push rdx
bswap r8d
mov cl, byte [r11 + rdx - 0x713f95a6]
bts r8, rdx
inc dl
call fcn.1420006cd
xor dword [rsp + rbx*4 - 0x720], esi
div bl
pop r10
lea rbp, [rdx + 0x9338638]
call fcn.141fd5b21
inc si
cwde
lea r9, [r9 + rsi - 0x1ff3]
shl dl, cl
lea rdi, [r11 + rsi*8 + 0x352dbb18]
mov word [r9 + rsi - 0x1ff5], dx
mov qword [rsp + rsi - 0x1ff5], rbx
ret 8
inc ax
mov rbp, qword [rsp + rax + 7]
push rdi
cdqe
pop rdx
movsxd r11, r11d
btr rdx, rax
add rbx, r11
lea rcx, [r8*2 - 0x266b90ed]
dec qword [rsp + rax*2 - 2]
sar qword [rsp + rsi*2 - 0x148], cl
adc qword [rsp + rax*8 - 8], rbx
ret 8

Function at 0x141ec2f98
Capabilities:
Hash data using murmur3

Disassembly:
dec si
sar ax, 0xa9
call fcn.141e9d6dc
mov esi, 0x19b5ef37
lea r8, [rsi + rsi*8 - 0x3f630fec]
push r8
mov r9d, dword [r11 + rsi*2 - 0x336bde6e]
add dword [rsp + rsi - 0x19b5ef36], esi
lea rax, [r8 - 0x2dd0286c]
mov eax, dword [r11 + rsi*2 - 0x336bde6a]
mov edx, dword [rsp + rsi*2 - 0x336bde6c]
push rdx
mov cl, byte [r11 + rsi*2 - 0x336bde66]
xor r8b, 0x89
neg dword [rsp + rsi - 0x19b5ef33]
shl r8w, 0x85
lea r11, [rsi + r11 - 0x19b5ef31]
shl qword [rsp + rsi - 0x19b5ef2f], 0x7e
xchg word [rsp + rsi - 0x19b5ef35], r8w
movzx edi, sil
shrd r9d, eax, cl
jmp 0x141e6aaac

Function at 0x141ec619d
Capabilities:
Hash data using murmur3

Disassembly:
not eax
movsx r8d, si
neg eax
movsx edx, cl
btr r8w, dx
mov qword [rsp + rcx + 0x2046d9f7], r9
lea rbx, [rcx + r8 + 0x14be2d8a]
or bl, 0xb6
movzx ebp, si
xor dword [rsp + rcx + 0x2046d9f7], eax
pop r9
push rbp
movsxd rax, eax
bt r8w, cx
adc r10, rax
neg rbp
mov rbp, qword [r11 + rcx*2 + 0x408db3ee]
mov rax, qword [r11 + rcx*2 + 0x408db3f6]
mov cl, byte [r11 + rcx + 0x2046da07]
and rbx, 0x591fad94
jnp 0x141ee17ba
Function at 0x141ecfa42
Capabilities:
Execute anti-debugging instructions

Disassembly:
neg esi
mov qword [rsp + rdi*2 - 0x5167ea04], 0xffffffff910a4f28
lea esi, [r8 + rsi - 0x5f57c135]
imul r8d, eax
xchg r11d, eax
bswap esi
jo 0x142021599

Function at 0x141ed5538
Capabilities:
Hash data using murmur3

Disassembly:
mov qword [rsp + r11 - 0x540fbbb0], rcx
ror cl, 0x66
not eax
mov qword [rsp + rcx + 0x2054ffd6], r10
xor dword [rsp + r11 - 0x540fbba0], eax
movzx r10d, cx
bts rcx, rcx
pop rdx

Function at 0x141ed5c06
Capabilities:
Hash data using murmur3

Disassembly:
lea rsp, [rsp + 8]
jne 0x14206c436
push 0x7b84f9bf
mov r9, rax
call fcn.141e5ce7e

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

Disassembly:
mov qword [rsp + rax*2], 0x497b581
neg cx
sub r10, rsi
xor si, 0x1427
rol cx, 1
sub word [rsp + rax*4 + 0xc], 0xaaa5
xchg byte [rsp + rax*2 + 7], r9b
adc cx, ax
xor bp, cx
lea rcx, [rsp + rcx + 0x10]
mov r10, qword [rcx + rax*4]
rol edx, 0x55
shr byte [rsp + rdi - 0x3fff], 0x26

Function at 0x141eef729
Capabilities:
Hash data using murmur3

Disassembly:
mov qword [rsp + rbx - 0x5e15f62a], rbp
mov ebp, r9d
sub eax, ebx
xor dword [rsp + rbx - 0x5e15f62a], ecx
sar bpl, 0x47
pop rbp
xchg sil, r11b
lea rdi, [rdi + rbx - 0x5e15f62e]
mov dword [rdi + rbx - 0x5e15f62a], ecx
mov ebx, dword [r10 + rbx - 0x5e15f62a]
adc r10, 4
xor ebx, ebp
movsx edx, r11w
dec ebx
btc r9w, r11w
call fcn.141fdd925
lea rax, [rax + rax*4 - 0x26591afa]
mov esi, eax
lea rsi, [0x14202ab50]

Function at 0x141eeffcb
Capabilities:
Execute anti-debugging instructions

Disassembly:
movzx eax, r10w
inc al
bswap r9d
xor r9d, 0x96b2141c
sar ax, 0x8c
mov ecx, 0xff281fa5
neg r9d
mov qword [rsp + rax - 4], 0x25318028
inc sil
bts eax, esi
lea r9d, [r9 + rsi*2 + 0x10c468c5]
mov qword [rsp + rsi - 0x61a4b026], rbp
xor dword [rsp + rax - 0x44], r9d
pop rbp
movsxd r9, r9d
sal rsi, cl

Function at 0x141f0012e
Capabilities:
Hash data using murmur3

Disassembly:
shl bp, cl
movsxd rbx, ebx
call fcn.142013460
mov rbp, r10
sub r10, 8
mov edx, 0xae3cf52a
xor dl, dh
mov qword [r10], rbp
mov edi, dword [r11]
movsx ebp, dx
not dx
adc r11, 4
movsx eax, bp
xor edi, esi
jmp 0x141eea7ca