joyce8/EMBER2024-capa huggingface dataset:
Function at 0x140251990
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0xe8
mov rax, qword [0x1403531c0]
xor rax, rsp
mov qword [rsp + 0xd8], rax
mov r13, r9
mov r14, r8
mov qword [rsp + 0x40], rdx
mov qword [rsp + 0x20], rcx
mov rbx, rcx
mov bpl, 1
shr r8, 1
je 0x1402519dd
xor edx, edx
call fcn.1402f7260
mov rdx, qword [rsp + 0x40]
xor esi, esi
test r14, r14
je 0x140251b49
mov dword [rsp + 0x30], 0xd0a0920
movzx r12d, byte [rsp + 0x150]
nop dword [rax]
movzx r11d, byte [rdx + rsi]
lea ecx, [r11 - 0x41]
xor cl, r11b
movzx eax, r11b
xor al, 0x41
or cl, al
xor cl, r11b
mov r15d, 0x46
sub r15b, r11b
xor r15b, 0x46
movzx eax, r11b
xor al, 0x46
or r15b, al
xor r15b, 0x46
or r15b, cl
shr r15b, 7
dec r15b
lea ecx, [r11 - 0x61]
xor cl, r11b
movzx eax, r11b
xor al, 0x61
or cl, al
xor cl, r11b
mov edx, 0x66
sub dl, r11b
xor dl, 0x66
movzx eax, r11b
xor al, 0x66
or dl, al
xor dl, 0x66
or cl, dl
shr cl, 7
dec cl
lea edi, [r11 - 0x30]
movzx edx, dil
xor dl, r11b
movzx eax, r11b
xor al, 0x30
or dl, al
xor dl, r11b
mov r8d, 0x39
sub r8b, r11b
xor r8b, 0x39
movzx eax, r11b
xor al, 0x39
or r8b, al
xor r8b, 0x39
or dl, r8b
shr dl, 7
dec dl
xor al, al
lea r8, [rsp + 0x30]
nop dword [rax]
movzx r10d, byte [r8]
xor r10b, r11b
lea r9d, [r10 - 1]
not r10b
and r9b, r10b
or al, r9b
inc r8
lea r9, [rsp + 0x34]
cmp r8, r9
jne 0x140251ab0
shr al, 7
neg al
lea r9d, [r11 - 0x37]
not r9b
and r9b, r15b
lea r8d, [r11 - 0x57]
not r8b
xor r8b, r9b
and r8b, cl
not r8b
xor r8b, r9b
xor dil, r8b
and dil, dl
xor dil, r8b
movzx ecx, dil
xor cl, 0x80
and cl, al
xor cl, dil
cmp cl, 0x10
jb 0x140251b19
cmp cl, 0x80
jne 0x140251b85
test r12b, r12b
je 0x140251b85
jmp 0x140251b37
movzx eax, byte [rbx]
test bpl, bpl
je 0x140251b2d
shl cl, 4
or cl, al
mov byte [rbx], cl
xor bpl, bpl
jmp 0x140251b37
or al, cl
mov byte [rbx], al
mov bpl, 1
inc rbx
inc rsi
cmp rsi, r14
je 0x140251b49
mov rdx, qword [rsp + 0x40]
jmp 0x140251a00
mov qword [r13], r14
mov rax, rbx
sub rax, qword [rsp + 0x20]
test bpl, bpl
jne 0x140251b61
mov byte [rbx], bpl
dec qword [r13]
mov rcx, qword [rsp + 0xd8]
xor rcx, rsp
call fcn.1402d55d0
add rsp, 0xe8
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
movzx edx, r11b
lea rcx, [rsp + 0x98]
call fcn.140260c60
mov rbx, rax
lea rdx, str.hex_decode:_invalid_character_
lea rcx, [rsp + 0x40]
call fcn.140246530
movups xmm0, xmmword [rax]
movaps xmmword [rsp + 0x20], xmm0
mov r8, rbx
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0xb8]
call fcn.14024d190
nop
lea rdx, [rsp + 0x50]
mov rcx, rax
call fcn.140247060
movups xmm0, xmmword [rax]
movaps xmmword [rsp + 0x20], xmm0
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x60]
call fcn.14024f5c0
lea rdx, [0x140350fc0]
lea rcx, [rsp + 0x60]
call fcn.1402d6228
int3
Function at 0x1402574d0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r14
sub rsp, 0x20
mov rax, qword [rcx]
mov rdi, r9
mov rbp, r8
mov r14, rdx
mov rsi, rcx
call qword [rax + 0x30]
mov rdx, rbp
mov rcx, r14
mov rbx, rax
imul rbx, rdi
mov r8, rbx
call fcn.140249980
mov rax, qword [rsi]
mov r9, rdi
mov r8, r14
mov rdx, r14
mov rcx, rsi
call qword [rax + 0x48]
mov r8, rbx
mov rdx, rbp
mov rcx, r14
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
mov rdi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
jmp fcn.140249980

Function at 0x1402595e0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r14
sub rsp, 0x20
mov rsi, rdx
movzx r14d, r9b
sub r14b, r8b
mov rcx, rsi
movzx ebx, r14b
mov rdi, r9
mov edx, ebx
sub rdx, qword [rsi]
add rdx, qword [rsi + 8]
call fcn.140249200
mov rax, qword [rsi + 8]
mov rcx, qword [rsi]
mov rbp, rax
mov r11, rax
sub rbp, rcx
sub r11, rcx
sub rax, rcx
dec rbp
sub r11, rbx
sub rax, rdi
cmp rax, rbp
je 0x140259693
mov r10, rax
sub r10, r11
nop word [rax + rax]
mov r9, qword [rsi]
mov r8, r10
shr r8, 0x3f
mov rcx, rax
shr rcx, 0x3f
mov rdx, rax
xor r8b, cl
shr rdx, 0x3f
mov rcx, r11
inc r10
shr rcx, 0x3f
xor dl, cl
mov rcx, rax
or r8b, dl
shr rcx, 0x3f
xor r8b, cl
neg r8b
and byte [r9 + rax], r8b
inc rax
cmp rax, rbp
jne 0x140259650
mov rax, qword [rsi + 8]
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
mov rdi, qword [rsp + 0x48]
mov byte [rax - 1], r14b
add rsp, 0x20
pop r14
ret

Function at 0x1402596c0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r14
sub rsp, 0x20
mov r14, rdx
movzx eax, r9b
mov rdx, qword [rdx + 8]
sub al, r8b
movzx ebx, al
mov rcx, r14
mov rdi, r9
sub rdx, qword [r14]
add rdx, rbx
call fcn.140249200
mov rsi, qword [r14 + 8]
mov r11b, 1
mov rbp, rsi
sub rsi, qword [r14]
sub rbp, qword [r14]
sub rsi, rbx
mov r9, rbp
sub r9, rdi
cmp r9, rbp
je 0x14025977b
mov r10, r9
sub r10, rsi
mov rdx, qword [r14]
mov r8, r10
shr r8, 0x3f
mov rax, r9
shr rax, 0x3f
mov rcx, r9
xor r8b, al
shr rcx, 0x3f
mov rax, rsi
inc r10
shr rax, 0x3f
xor cl, al
mov rax, r9
or r8b, cl
shr rax, 0x3f
movzx ecx, byte [rdx + r9]
xor r8b, al
dec r8b
lea eax, [r11 + 1]
xor cl, r11b
xor al, r11b
and cl, r8b
and al, r8b
xor byte [rdx + r9], cl
xor r11b, al
inc r9
cmp r9, rbp
jne 0x140259720
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
mov rdi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret
Function at 0x1402597a0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push r14
sub rsp, 0x20
mov r14, rdx
movzx eax, r9b
sub al, r8b
mov rcx, r14
movzx ebx, al
mov rdi, r9
mov edx, ebx
sub rdx, qword [r14]
add rdx, qword [r14 + 8]
call fcn.140249200
mov rsi, qword [r14 + 8]
mov rbp, rsi
sub rsi, qword [r14]
sub rbp, qword [r14]
sub rsi, rbx
mov r11, rbp
sub r11, rdi
cmp r11, rbp
je 0x140259863
nop word [rax + rax]
mov r10, qword [r14]
mov rdx, r11
xor rdx, rsi
mov r9, rsi
sub r9, r11
mov rax, rsi
shr rax, 0x3f
shr r9, 0x3f
xor r9b, al
lea rcx, [rdx - 1]
shr rcx, 0x3f
mov rax, rdx
shr rax, 0x3f
not rdx
or r9b, al
shr rdx, 0x3f
and cl, dl
mov rax, rsi
shr rax, 0x3f
neg cl
xor r9b, al
movzx eax, byte [r10 + r11]
xor al, 0x80
dec r9b
and cl, al
xor cl, byte [r10 + r11]
and r9b, cl
mov byte [r10 + r11], r9b
inc r11
cmp r11, rbp
jne 0x140259800
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
mov rdi, qword [rsp + 0x48]
add rsp, 0x20
pop r14
ret

Function at 0x140259880
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
push r14
push r15
sub rsp, 0x20
mov r14, rdx
movzx r15d, r9b
sub r15b, r8b
mov rcx, r14
movzx ebx, r15b
mov rdi, r9
mov edx, ebx
sub rdx, qword [r14]
add rdx, qword [r14 + 8]
call fcn.140249200
mov rsi, qword [r14 + 8]
mov rbp, rsi
sub rsi, qword [r14]
sub rbp, qword [r14]
sub rsi, rbx
mov rax, rbp
sub rax, rdi
cmp rax, rbp
je 0x14025992e
mov r11, rax
sub r11, rsi
nop dword [rax + rax]
mov r10, qword [r14]
mov r9, r11
shr r9, 0x3f
mov rcx, rax
shr rcx, 0x3f
mov rdx, rax
xor r9b, cl
shr rdx, 0x3f
mov rcx, rsi
inc r11
shr rcx, 0x3f
xor dl, cl
mov rcx, rax
shr rcx, 0x3f
or r9b, dl
xor r9b, cl
movzx ecx, byte [r10 + rax]
xor cl, r15b
dec r9b
and r9b, cl
xor byte [r10 + rax], r9b
inc rax
cmp rax, rbp
jne 0x1402598e0
mov rbx, qword [rsp + 0x40]
mov rbp, qword [rsp + 0x48]
mov rsi, qword [rsp + 0x50]
add rsp, 0x20
pop r15
pop r14
pop rdi
ret

Function at 0x140259c10
Capabilities:
Encode data using xor

Disassembly:
push rbx
lea rax, [r8 - 3]
mov rbx, rdx
cmp rax, 0xfc
jbe 0x140259c26
mov rax, r8
pop rbx
ret
movzx eax, byte [rdx + r8 - 1]
mov r11, r8
sub r11, rax
mov qword [rsp + 0x10], rsi
mov r10, r11
lea rsi, [r8 - 1]
xor r10, r8
xor r9d, r9d
mov rcx, r10
or rcx, r8
xor rcx, r8
shr rcx, 0x3f
neg rcx
test rsi, rsi
je 0x140259cb3
mov qword [rsp + 0x18], rdi
lea rdi, [r11 + rdx]
nop dword [rax]
nop word [rax + rax]
lea rdx, [r9 + rbx]
mov rax, r9
mov r8, rdx
xor rax, r11
movzx edx, byte [rdx]
sub r8, rdi
xor r8, r9
dec rdx
or r8, rax
shr rdx, 0x3f
xor r8, r9
neg rdx
shr r8, 0x3f
inc r9
neg r8
or r8, rdx
not r8
or rcx, r8
cmp r9, rsi
jne 0x140259c70
mov rdi, qword [rsp + 0x18]
mov rsi, qword [rsp + 0x10]
and r10, rcx
xor r10, r11
mov rax, r10
pop rbx
ret
Function at 0x140259cd0
Capabilities:
Encode data using xor

Disassembly:
sub rsp, 8
lea rax, [r8 - 3]
mov r10, rdx
cmp rax, 0xfc
jbe 0x140259ceb
mov rax, r8
add rsp, 8
ret
movzx edx, byte [rdx + r8 - 1]
movzx eax, dl
mov qword [rsp + 0x10], rbx
mov qword [rsp], rdi
movzx edi, r8b
xor al, dil
movzx r11d, dil
sub r11b, dl
mov r9d, edi
movzx ecx, r11b
movzx ebx, r11b
xor cl, dil
or cl, al
lea eax, [rdx - 1]
xor cl, dil
shr al, 7
shr cl, 7
not dl
shr dl, 7
neg cl
and al, dl
neg al
or cl, al
sub r9, 1
je 0x140259d7d
nop word [rax + rax]
movzx eax, byte [r10 + r9]
mov r8, rbx
dec al
sub r8, r9
xor al, byte [r10 + r9 - 1]
shr r8, 0x3f
lea edx, [rax - 1]
not al
shr al, 7
shr dl, 7
and dl, al
mov rax, r9
shr rax, 0x3f
dec dl
or r8b, al
neg r8b
and dl, r8b
or cl, dl
sub r9, 1
jne 0x140259d40
mov rbx, qword [rsp + 0x10]
mov rax, rdi
mov rdi, qword [rsp]
movzx edx, r11b
xor rax, rdx
movzx edx, cl
and rax, rdx
movzx ecx, r11b
xor rax, rcx
add rsp, 8
ret

Function at 0x140259dc0
Capabilities:
Encode data using xor

Disassembly:
push rdi
mov r10, r8
mov rdi, rdx
cmp r8, 2
ja 0x140259dd3
mov rax, r8
pop rdi
ret
xor cl, cl
mov qword [rsp + 0x10], rbx
xor al, al
lea r11, [r8 - 1]
mov rbx, r10
nop dword [rax]
nop word [rax + rax]
movzx r9d, byte [rdi + rbx - 1]
movzx r8d, r9b
xor r8b, 0x80
lea edx, [r8 - 1]
not r8b
shr dl, 7
shr r8b, 7
and dl, r8b
neg dl
or al, dl
movzx edx, al
not dl
movzx r8d, dl
mov edx, r8d
and edx, 1
sub r11, rdx
lea edx, [r9 - 1]
shr dl, 7
not r9b
shr r9b, 7
and dl, r9b
dec dl
and dl, r8b
or cl, dl
sub rbx, 1
jne 0x140259df0
mov rbx, qword [rsp + 0x10]
not al
movzx eax, al
movzx edx, cl
mov rcx, r11
or rax, rdx
xor rcx, r10
dec rax
shr rax, 0x3f
dec rax
and rax, rcx
xor rax, r11
pop rdi
ret

Function at 0x140259e70
Capabilities:
Encode data using xor

Disassembly:
sub rsp, 8
lea rax, [r8 - 3]
cmp rax, 0xfc
jbe 0x140259e88
mov rax, r8
add rsp, 8
ret
mov qword [rsp + 0x18], rsi
mov r11, r8
mov qword [rsp], rdi
lea rsi, [r8 - 1]
movzx edi, byte [rdx + r8 - 1]
xor r10d, r10d
sub r11, rdi
mov r9, r11
xor r9, r8
mov rcx, r9
or rcx, r8
xor rcx, r8
shr rcx, 0x3f
neg rcx
test rsi, rsi
je 0x140259f13
mov qword [rsp + 0x10], rbx
lea rbx, [r11 + rdx]
nop dword [rax + rax]
mov rdx, r10
mov rax, r10
sub rdx, r11
xor rax, r11
mov r8, rdx
xor r8, r10
or r8, rax
movzx edx, byte [rdx + rbx]
xor r8, r10
xor rdx, rdi
shr r8, 0x3f
dec rdx
dec r8
shr rdx, 0x3f
inc r10
dec rdx
and r8, rdx
or rcx, r8
cmp r10, rsi
jne 0x140259ed0
mov rbx, qword [rsp + 0x10]
mov rdi, qword [rsp]
and r9, rcx
mov rsi, qword [rsp + 0x18]
xor r9, r11
mov rax, r9
add rsp, 8
ret
Function at 0x14025bf00
Capabilities:
Encode data using xor

Disassembly:
push rsi
push r14
push r15
sub rsp, 0x20
mov rax, qword [rcx]
mov r15, r8
mov rsi, rdx
mov r14, rcx
call qword [rax + 0x20]
test al, al
jne 0x14025bf25
mov rcx, r14
call fcn.140251df0
mov rax, qword [r14 + 0x10]
cmp qword [r14 + 8], rax
je 0x14025c086
mov rcx, qword [r14 + 0x38]
mov qword [rsp + 0x40], rbx
mov qword [rsp + 0x48], rbp
mov rbp, r15
mov qword [rsp + 0x50], rdi
mov rdi, qword [r14 + 0x50]
test rcx, rcx
je 0x14025bf8c
mov rdx, qword [r14 + 0x20]
mov rax, rdi
sub rax, rcx
mov rbx, r15
cmp rax, r15
cmovb rbx, rax
add rdx, rcx
mov r8, rbx
mov rcx, rsi
call fcn.14025c740
add qword [r14 + 0x38], rbx
sub rbp, rbx
add rsi, rbx
cmp qword [r14 + 0x38], rdi
jne 0x14025bf8c
mov rcx, r14
call fcn.14025c3f0
mov rbx, rbp
cmp rbp, rdi
jb 0x14025c052
nop dword [rax + rax]
mov r9, qword [r14 + 0x20]
xor ecx, ecx
test rdi, rdi
je 0x14025c038
cmp rdi, 0x10
jb 0x14025c00a
lea rdx, [rdi - 1]
lea rax, [r9 - 1]
add rdx, rsi
add rax, rdi
cmp rsi, rax
ja 0x14025bfcd
cmp rdx, r9
jae 0x14025c00a
mov rdx, rdi
and rdx, 0xfffffffffffffff0
mov r8, r9
mov rax, rsi
sub r8, rsi
nop dword [rax]
movdqu xmm0, xmmword [rax]
add rcx, 0x10
movdqu xmm1, xmmword [r8 + rax]
movdqu xmmword [r8 + rax], xmm0
lea rax, [rax + 0x10]
xorps xmm1, xmm0
movdqu xmmword [rax - 0x10], xmm1
cmp rcx, rdx
jne 0x14025bfe0
cmp rcx, rdi
je 0x14025c038
sub r9, rsi
lea rax, [rcx + rsi]
mov r8, rdi
sub r8, rcx
nop word [rax + rax]
movzx ecx, byte [rax]
movzx edx, byte [r9 + rax]
mov byte [r9 + rax], cl
xor byte [rax], dl
lea rax, [rax + 1]
sub r8, 1
jne 0x14025c020
sub rbp, rdi
mov rcx, r14
mov rbx, rbp
add rsi, rdi
call fcn.14025c3f0
cmp rbp, rdi
jae 0x14025bfa0
mov rdi, qword [rsp + 0x50]
test rbx, rbx
je 0x14025c06f
mov rdx, qword [r14 + 0x20]
mov r8, rbp
mov rcx, rsi
call fcn.14025c740
add qword [r14 + 0x38], rbx
mov rbp, qword [rsp + 0x48]
mov rax, r15
mov rbx, qword [rsp + 0x40]
add rsp, 0x20
pop r15
pop r14
pop rsi
ret
lea r8, str.C:_Users_Rosalyn_vcpkg_buildtrees_botan_src_3.5.0_2446fa6972.clean_src_lib_modes_cfb_cfb.cpp
lea rdx, str.process_msg
lea rcx, str.m_state.empty____false
call fcn.140251790
int3
Function at 0x14025c740
Capabilities:
Encode data using xor

Disassembly:
sub rsp, 8
xor r9d, r9d
mov r10, rdx
test r8, r8
je 0x14025c7e8
cmp r8, 0x10
jb 0x14025c7be
lea rdx, [rcx - 1]
lea rax, [r8 - 1]
add rdx, r8
add rax, r10
cmp rcx, rax
ja 0x14025c771
cmp rdx, r10
jae 0x14025c7be
mov rdx, r8
mov qword [rsp], rbx
and rdx, 0xfffffffffffffff0
mov r11, r10
mov rax, rcx
sub r11, rcx
nop word [rax + rax]
movdqu xmm0, xmmword [rax]
add r9, 0x10
movdqu xmm1, xmmword [r11 + rax]
movdqu xmmword [r11 + rax], xmm0
lea rax, [rax + 0x10]
xorps xmm1, xmm0
movdqu xmmword [rax - 0x10], xmm1
cmp r9, rdx
jne 0x14025c790
mov rbx, qword [rsp]
cmp r9, r8
je 0x14025c7e8
sub r10, rcx
lea rax, [r9 + rcx]
sub r8, r9
nop dword [rax + rax]
movzx ecx, byte [rax]
movzx edx, byte [r10 + rax]
mov byte [r10 + rax], cl
xor byte [rax], dl
lea rax, [rax + 1]
sub r8, 1
jne 0x14025c7d0
add rsp, 8
ret
Function at 0x14025f830
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
push rbx
sub rsp, 0x40
mov rbx, rdx
lea rdx, [rsp + 0x20]
call fcn.14025de40
mov r8, qword [rbx + 8]
mov rax, qword [rsp + 0x28]
mov r9, qword [rsp + 0x20]
sub rax, r9
cmp rax, r8
je 0x14025f85d
xor bl, bl
jmp 0x14025f8a4
mov rdx, qword [rbx]
mov byte [rsp + 0x58], 0
test r8, r8
je 0x14025f88d
sub rdx, r9
nop dword [rax]
movzx ecx, byte [r9 + rdx]
xor cl, byte [r9]
movzx eax, byte [rsp + 0x58]
or al, cl
mov byte [rsp + 0x58], al
lea r9, [r9 + 1]
sub r8, 1
jne 0x14025f870
movzx eax, byte [rsp + 0x58]
lea ebx, [rax - 1]
shr bl, 7
not al
shr al, 7
and bl, al
mov r9, qword [rsp + 0x20]
test r9, r9
je 0x14025f8c0
mov rdx, qword [rsp + 0x30]
sub rdx, r9
mov r8d, 1
mov rcx, r9
call fcn.1402456d0
nop
movzx eax, bl
add rsp, 0x40
pop rbx
ret
Function at 0x1402631f0
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r14
push r15
sub rsp, 0xe8
mov rax, qword [0x1403531c0]
xor rax, rsp
mov qword [rsp + 0xd0], rax
mov rax, qword [rcx]
mov r14, r9
mov rbp, r8
mov rsi, rdx
mov rdi, rcx
call qword [rax + 0x20]
test al, al
jne 0x140263230
mov rcx, rdi
call fcn.140251df0
mov rbx, qword [rdi + 0x48]
mov rcx, qword [rdi + 0x40]
mov rax, rbx
mov r15, qword [rdi + 0x58]
sub rax, rcx
sub rax, r15
cmp r14, rax
jb 0x140263429
mov rdx, r15
xor r15d, r15d
nop dword [rax]
nop dword [rax + rax]
sub rbx, rdx
mov qword [rsp + 0x50], rbp
sub rbx, rcx
mov qword [rsp + 0x60], rsi
mov qword [rsp + 0x58], rbx
lea r8, [rdx + rcx]
movaps xmm0, xmmword [rsp + 0x50]
mov r10, rbx
mov qword [rsp + 0x70], r8
mov rax, rsi
mov qword [rsp + 0x78], rbx
mov r9, rbp
mov qword [rsp + 0x68], rbx
mov rdx, rbx
movaps xmm1, xmmword [rsp + 0x60]
movdqa xmmword [rsp + 0x20], xmm0
movaps xmm0, xmmword [rsp + 0x70]
movdqa xmmword [rsp + 0x40], xmm0
movdqa xmmword [rsp + 0x30], xmm1
cmp rbx, 0x20
jb 0x1402633c6
nop
mov rdx, qword [rsp + 0x40]
mov r8, qword [rsp + 0x30]
mov r10, qword [rsp + 0x28]
add r10, 0xffffffffffffffe0
mov rax, qword [rdx + 8]
movups xmm1, xmmword [r8]
mov qword [rsp + 0x88], r10
movups xmm3, xmmword [r8 + 0x10]
movups xmmword [rsp + 0xb0], xmm1
xor qword [rsp + 0xb8], rax
mov rax, qword [rdx + 0x18]
movq rcx, xmm1
xor rcx, qword [rdx]
mov qword [rsp + 0xb0], rcx
movq rcx, xmm3
xor rcx, qword [rdx + 0x10]
movups xmm0, xmmword [rsp + 0xb0]
movups xmmword [rsp + 0xc0], xmm3
xor qword [rsp + 0xc8], rax
mov rax, qword [rsp + 0x20]
mov qword [rsp + 0xc0], rcx
mov rcx, qword [rsp + 0x38]
movups xmm1, xmmword [rsp + 0xc0]
add rcx, 0xffffffffffffffe0
lea r9, [rax + 0x20]
movups xmmword [rax], xmm0
mov qword [rsp + 0x98], rcx
mov rcx, qword [rsp + 0x48]
add rcx, 0xffffffffffffffe0
mov qword [rsp + 0x80], r9
movaps xmm0, xmmword [rsp + 0x80]
movdqa xmmword [rsp + 0x20], xmm0
mov qword [rsp + 0xa8], rcx
movups xmmword [rax + 0x10], xmm1
lea rax, [r8 + 0x20]
mov qword [rsp + 0x90], rax
lea r8, [rdx + 0x20]
movaps xmm0, xmmword [rsp + 0x90]
mov qword [rsp + 0xa0], r8
movdqa xmmword [rsp + 0x30], xmm0
movaps xmm0, xmmword [rsp + 0xa0]
movdqa xmmword [rsp + 0x40], xmm0
cmp r10, 0x20
jae 0x1402632c0
mov rdx, r10
test r10, r10
je 0x1402633e6
sub r8, rax
sub r9, rax
movzx ecx, byte [r8 + rax]
xor cl, byte [rax]
mov byte [r9 + rax], cl
lea rax, [rax + 1]
sub rdx, 1
jne 0x1402633d1
mov rcx, qword [rdi + 0x40]
mov rdx, qword [rdi + 0x48]
mov r9, qword [rdi + 8]
sub rdx, rcx
mov r8, qword [rdi + 0x28]
shr rdx, 6
call fcn.140262b60
sub r14, rbx
mov qword [rdi + 0x58], r15
mov rcx, qword [rdi + 0x40]
add rsi, rbx
add rbp, rbx
mov rdx, r15
mov rbx, qword [rdi + 0x48]
mov rax, rbx
sub rax, rcx
cmp r14, rax
jae 0x140263260
lea r8, [r15 + rcx]
mov r9, r14
mov rcx, rbp
mov rdx, rsi
call fcn.1402642f0
add qword [rdi + 0x58], r14
mov rcx, qword [rsp + 0xd0]
xor rcx, rsp
call fcn.1402d55d0
add rsp, 0xe8
pop r15
pop r14
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x1402642f0
Capabilities:
Encode data using xor

Disassembly:
sub rsp, 0x98
mov rax, qword [0x1403531c0]
xor rax, rsp
mov qword [rsp + 0x80], rax
mov qword [rsp + 0x10], rcx
mov r10, rcx
mov qword [rsp + 0x18], r9
mov rcx, r9
movaps xmm0, xmmword [rsp + 0x10]
mov qword [rsp], rdx
mov qword [rsp + 8], r9
movaps xmm1, xmmword [rsp]
mov qword [rsp + 0x20], r8
mov qword [rsp + 0x28], r9
movdqa xmmword [rsp + 0x30], xmm0
movaps xmm0, xmmword [rsp + 0x20]
movdqa xmmword [rsp + 0x10], xmm0
movdqa xmmword [rsp], xmm1
cmp r9, 0x20
jb 0x14026442f
nop word [rax + rax]
mov r8, qword [rsp + 0x10]
mov rdx, qword [rsp]
mov r9, qword [rsp + 0x38]
add r9, 0xffffffffffffffe0
mov rax, qword [r8 + 8]
movups xmm1, xmmword [rdx]
mov qword [rsp + 0x28], r9
movups xmm3, xmmword [rdx + 0x10]
add rdx, 0x20
movups xmmword [rsp + 0x60], xmm1
xor qword [rsp + 0x68], rax
mov rax, qword [r8 + 0x18]
movq rcx, xmm1
xor rcx, qword [r8]
mov qword [rsp + 0x60], rcx
movq rcx, xmm3
xor rcx, qword [r8 + 0x10]
add r8, 0x20
movups xmm0, xmmword [rsp + 0x60]
mov qword [rsp + 0x40], rdx
movups xmmword [rsp + 0x70], xmm3
xor qword [rsp + 0x78], rax
mov rax, qword [rsp + 0x30]
mov qword [rsp + 0x70], rcx
movups xmm1, xmmword [rsp + 0x70]
mov qword [rsp + 0x50], r8
movups xmmword [rax], xmm0
lea r10, [rax + 0x20]
movups xmmword [rax + 0x10], xmm1
mov rax, qword [rsp + 8]
add rax, 0xffffffffffffffe0
mov qword [rsp + 0x20], r10
movaps xmm0, xmmword [rsp + 0x20]
mov qword [rsp + 0x48], rax
mov rax, qword [rsp + 0x18]
add rax, 0xffffffffffffffe0
movdqa xmmword [rsp + 0x30], xmm0
movaps xmm0, xmmword [rsp + 0x40]
mov qword [rsp + 0x58], rax
movdqa xmmword [rsp], xmm0
movaps xmm0, xmmword [rsp + 0x50]
movdqa xmmword [rsp + 0x10], xmm0
cmp r9, 0x20
jae 0x140264360
mov rcx, r9
test r9, r9
je 0x140264455
sub r8, rdx
sub r10, rdx
nop word [rax + rax]
movzx eax, byte [r8 + rdx]
xor al, byte [rdx]
mov byte [r10 + rdx], al
lea rdx, [rdx + 1]
sub rcx, 1
jne 0x140264440
mov rcx, qword [rsp + 0x80]
xor rcx, rsp
call fcn.1402d55d0
add rsp, 0x98
ret
Function at 0x140264470
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rbp
push rsi
push rdi
push r14
push r15
sub rsp, 0xe8
mov rax, qword [0x1403531c0]
xor rax, rsp
mov qword [rsp + 0xd0], rax
mov rax, qword [rcx]
mov r15, r9
mov rbp, r8
mov rsi, rdx
mov rdi, rcx
call qword [rax + 0x20]
test al, al
jne 0x1402644b0
mov rcx, rdi
call fcn.140251df0
mov rbx, qword [rdi + 0x40]
mov rcx, qword [rdi + 0x38]
mov rax, rbx
mov r14, qword [rdi + 0x50]
sub rax, rcx
sub rax, r14
cmp r15, rax
jb 0x1402646b7
mov rdx, r14
xor r14d, r14d
nop dword [rax]
nop dword [rax + rax]
sub rbx, rdx
mov qword [rsp + 0x50], rbp
sub rbx, rcx
mov qword [rsp + 0x60], rsi
mov qword [rsp + 0x58], rbx
lea r8, [rdx + rcx]
movaps xmm0, xmmword [rsp + 0x50]
mov r10, rbx
mov qword [rsp + 0x70], r8
mov rax, rsi
mov qword [rsp + 0x78], rbx
mov r9, rbp
mov qword [rsp + 0x68], rbx
mov rdx, rbx
movaps xmm1, xmmword [rsp + 0x60]
movdqa xmmword [rsp + 0x20], xmm0
movaps xmm0, xmmword [rsp + 0x70]
movdqa xmmword [rsp + 0x40], xmm0
movdqa xmmword [rsp + 0x30], xmm1
cmp rbx, 0x20
jb 0x140264646
nop
mov rdx, qword [rsp + 0x40]
mov r8, qword [rsp + 0x30]
mov r10, qword [rsp + 0x28]
add r10, 0xffffffffffffffe0
mov rax, qword [rdx + 8]
movups xmm1, xmmword [r8]
mov qword [rsp + 0x88], r10
movups xmm3, xmmword [r8 + 0x10]
movups xmmword [rsp + 0xb0], xmm1
xor qword [rsp + 0xb8], rax
mov rax, qword [rdx + 0x18]
movq rcx, xmm1
xor rcx, qword [rdx]
mov qword [rsp + 0xb0], rcx
movq rcx, xmm3
xor rcx, qword [rdx + 0x10]
movups xmm0, xmmword [rsp + 0xb0]
movups xmmword [rsp + 0xc0], xmm3
xor qword [rsp + 0xc8], rax
mov rax, qword [rsp + 0x20]
mov qword [rsp + 0xc0], rcx
mov rcx, qword [rsp + 0x38]
movups xmm1, xmmword [rsp + 0xc0]
add rcx, 0xffffffffffffffe0
lea r9, [rax + 0x20]
movups xmmword [rax], xmm0
mov qword [rsp + 0x98], rcx
mov rcx, qword [rsp + 0x48]
add rcx, 0xffffffffffffffe0
mov qword [rsp + 0x80], r9
movaps xmm0, xmmword [rsp + 0x80]
movdqa xmmword [rsp + 0x20], xmm0
mov qword [rsp + 0xa8], rcx
movups xmmword [rax + 0x10], xmm1
lea rax, [r8 + 0x20]
mov qword [rsp + 0x90], rax
lea r8, [rdx + 0x20]
movaps xmm0, xmmword [rsp + 0x90]
mov qword [rsp + 0xa0], r8
movdqa xmmword [rsp + 0x30], xmm0
movaps xmm0, xmmword [rsp + 0xa0]
movdqa xmmword [rsp + 0x40], xmm0
cmp r10, 0x20
jae 0x140264540
mov rdx, r10
test r10, r10
je 0x140264666
sub r8, rax
sub r9, rax
movzx ecx, byte [r8 + rax]
xor cl, byte [rax]
mov byte [r9 + rax], cl
lea rax, [rax + 1]
sub rdx, 1
jne 0x140264651
mov rdx, qword [rdi + 0x20]
mov r8d, 0x14
mov rcx, qword [rdi + 0x38]
call fcn.140264b70
mov rax, qword [rdi + 0x20]
mov rdx, r14
inc dword [rax + 0x20]
mov eax, r14d
mov rcx, qword [rdi + 0x20]
cmp dword [rcx + 0x20], eax
sete al
sub r15, rbx
add dword [rcx + 0x24], eax
add rsi, rbx
mov qword [rdi + 0x50], r14
add rbp, rbx
mov rbx, qword [rdi + 0x40]
mov rcx, qword [rdi + 0x38]
mov rax, rbx
sub rax, rcx
cmp r15, rax
jae 0x1402644e0
lea r8, [r14 + rcx]
mov r9, r15
mov rcx, rbp
mov rdx, rsi
call fcn.1402642f0
add qword [rdi + 0x50], r15
mov rcx, qword [rsp + 0xd0]
xor rcx, rsp
call fcn.1402d55d0
add rsp, 0xe8
pop r15
pop r14
pop rdi
pop rsi
pop rbp
pop rbx
ret