joyce8/EMBER2024-capa huggingface dataset:
Function at 0x140038190
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov rbx, rdx
mov edx, 4
mov rax, qword gs:[0x58]
mov rcx, qword [rax]
mov eax, dword [rdx + rcx]
cmp dword [0x140047c18], eax
jle 0x140038411
lea rcx, [0x140047c18]
call fcn.140040288
cmp dword [0x140047c18], 0xffffffff
jne 0x140038411
xor eax, eax
mov qword [0x140047c91], rax
mov word [0x140047c99], ax
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov edx, eax
mov dword [rsp + 0x13a4], 0xffffffff
mov dword [rsp + 0x24], eax
mov ecx, 1
mov r9d, 0x270
nop
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [rsp + rcx*4 + 0x24], edx
inc rcx
cmp rcx, r9
jb 0x140038220
mov dword [rsp + 0x20], r9d
lea rax, [rsp + 0x28]
nop word [rax + rax]
mov r8d, dword [rax - 4]
xor r8d, dword [rax]
btr r8d, 0x1f
xor r8d, dword [rax - 4]
mov ecx, r8d
and cl, 1
neg cl
sbb edx, edx
and edx, 0x9908b0df
xor edx, dword [rax + 0x630]
shr r8d, 1
xor edx, r8d
mov dword [rax + 0x9bc], edx
lea rax, [rax + 4]
sub r9, 1
jne 0x140038250
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
lea eax, [rcx - 0x80000000]
mov edx, 0x80000000
lea r8d, [rcx + rdx]
cmp ecx, edx
cmovae r8d, eax
mov dword [0x140047c8c], 5
movzx ecx, byte [0x140047c90]
test cl, cl
jne 0x1400382f5
add r8d, 5
mov cl, 1
test cl, cl
je 0x1400382fb
sub r8d, 5
xor cl, cl
movzx eax, r8b
xor al, 0x70
mov byte [0x140047c91], al
test cl, cl
jne 0x14003830f
add r8d, 5
add r8d, 0xfffffffb
lea ecx, [r8 + 1]
mov eax, 1
cdq
idiv ecx
add dl, r8b
xor dl, 0x61
mov byte [0x140047c92], dl
lea ecx, [r8 + 1]
mov eax, 2
cdq
idiv ecx
add dl, r8b
xor dl, 0x75
mov byte [0x140047c93], dl
lea ecx, [r8 + 1]
mov eax, 3
cdq
idiv ecx
add dl, r8b
xor dl, 0x73
mov byte [0x140047c94], dl
lea ecx, [r8 + 1]
mov eax, 4
cdq
idiv ecx
add dl, r8b
xor dl, 0x65
mov byte [0x140047c95], dl
lea ecx, [r8 + 1]
mov eax, 5
cdq
idiv ecx
add dl, r8b
xor dl, 0x3e
mov byte [0x140047c96], dl
lea ecx, [r8 + 1]
mov eax, 6
cdq
idiv ecx
add dl, r8b
xor dl, 0x4e
mov byte [0x140047c97], dl
lea ecx, [r8 + 1]
mov eax, 7
cdq
idiv ecx
add dl, r8b
xor dl, 0x55
mov byte [0x140047c98], dl
mov r9d, r8d
lea ecx, [r8 + 1]
mov eax, 8
cdq
idiv ecx
add dl, r8b
xor dl, 0x4c
mov byte [0x140047c99], dl
lea r10d, [r9 + 5]
mov byte [0x140047c90], 0
lea r8d, [r10 - 4]
mov eax, 9
cdq
idiv r8d
add dl, r9b
mov byte [0x140047c9a], dl
mov dword [0x140047c88], r10d
mov byte [0x140047c90], 1
lea rcx, [0x140047c18]
call fcn.14004021c
movups xmm0, xmmword [0x140047c88]
movups xmmword [rbx], xmm0
mov ecx, dword [0x140047c98]
mov dword [rbx + 0x10], ecx
mov rax, rbx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
add rsp, 0x13c0
pop rbx
ret
Function at 0x140039080
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
mov qword [rsp + 0x18], rbx
push rbp
push rsi
push rdi
lea rbp, [rsp - 0x1310]
mov eax, 0x1410
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rbp + 0x1300], rax
mov rsi, rdx
mov rdi, rcx
mov dword [rsp + 0x20], 0
movups xmm0, xmmword [str.ABCDEFGHIJKLMNOPQRSTUVWXYZ]
movups xmmword [rbp + 0x12e0], xmm0
movsd xmm0, qword [0x140042728]
movsd qword [rbp + 0x12f0], xmm0
movzx eax, word [0x140042730]
mov word [rbp + 0x12f8], ax
movzx eax, byte [0x140042732]
mov byte [rbp + 0x12fa], al
xorps xmm0, xmm0
movups xmmword [rsp + 0x28], xmm0
mov qword [rsp + 0x38], 0
mov qword [rsp + 0x40], 0xf
mov byte [rsp + 0x28], 0
mov ebx, 1
mov dword [rsp + 0x20], ebx
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov dword [rbp + 0x12d4], 0xffffffff
mov dword [rsp + 0x54], eax
mov ecx, eax
shr ecx, 0x1e
xor ecx, eax
imul eax, ecx, 0x6c078965
add eax, ebx
mov dword [rsp + rbx*4 + 0x54], eax
inc rbx
cmp rbx, 0x270
jb 0x140039131
mov dword [rsp + 0x50], 0x270
mov ebx, 0xa
nop dword [rax]
lea rcx, [rsp + 0x50]
call fcn.14003fc50
mov ecx, eax
imul rax, rcx, 0x1b
cmp eax, 0x15
ja 0x14003918a
lea rcx, [rsp + 0x50]
call fcn.14003fc50
mov ecx, eax
imul rax, rcx, 0x1b
cmp eax, 0x16
jb 0x140039175
shr rax, 0x20
movsxd rcx, eax
movzx r9d, byte [rbp + rcx + 0x12e0]
mov rcx, qword [rsp + 0x38]
mov rdx, qword [rsp + 0x40]
cmp rcx, rdx
jae 0x1400391cc
lea rax, [rcx + 1]
mov qword [rsp + 0x38], rax
lea rax, [rsp + 0x28]
cmp rdx, 0xf
cmova rax, qword [rsp + 0x28]
mov byte [rax + rcx], r9b
mov byte [rax + rcx + 1], 0
jmp 0x1400391d6
lea rcx, [rsp + 0x28]
call fcn.14003f1d0
sub rbx, 1
jne 0x140039160
lea rdx, [rsp + 0x28]
cmp qword [rsp + 0x40], 0xf
cmova rdx, qword [rsp + 0x28]
mov r8, rsi
mov rcx, rdi
call fcn.140033520
lea rax, [rsp + 0x28]
cmp qword [rsp + 0x40], 0xf
cmova rax, qword [rsp + 0x28]
mov qword [rsp + 0x38], rbx
mov byte [rax], bl
mov rdx, qword [rsp + 0x40]
cmp rdx, 0xf
jbe 0x140039250
inc rdx
mov rcx, qword [rsp + 0x28]
mov rax, rcx
cmp rdx, 0x1000
jb 0x14003924b
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x14003924b
call qword [sym.imp.api_ms_win_crt_runtime_l1_1_0.dll__invalid_parameter_noinfo_noreturn]
int3
call fcn.140040584
mov rcx, qword [rbp + 0x1300]
xor rcx, rsp
call fcn.1400401c0
mov rbx, qword [rsp + 0x1440]
add rsp, 0x1410
pop rdi
pop rsi
pop rbp
ret
Function at 0x140039340
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rbp
mov qword [rsp + 0x18], rsi
push rdi
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov edi, edx
mov ebx, ecx
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov dword [rsp + 0x13a4], 0xffffffff
mov r9d, 1
mov dword [rsp + 0x24], eax
mov r10d, 0x270
mov r8d, eax
shr r8d, 0x1e
xor r8d, eax
imul eax, r8d, 0x6c078965
add eax, r9d
mov dword [rsp + r9*4 + 0x24], eax
inc r9
cmp r9, r10
jb 0x140039394
lea eax, [rbx - 0x80000000]
mov dword [rsp + 0x20], r10d
mov ebp, 0x80000000
cmp ebx, ebp
lea esi, [rbx + rbp]
cmovae esi, eax
lea ebx, [rdi + rbp]
cmp edi, ebp
lea eax, [rdi - 0x80000000]
cmovae ebx, eax
sub ebx, esi
cmp ebx, 0xffffffff
jne 0x140039460
lea r8, [rsp + 0x28]
nop word [rax + rax]
mov edx, dword [r8 - 4]
xor edx, dword [r8]
lea r8, [r8 + 4]
btr edx, 0x1f
xor edx, dword [r8 - 8]
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
shr edx, 1
and ecx, 0x9908b0df
xor ecx, dword [r8 + 0x62c]
xor ecx, edx
mov dword [r8 + 0x9b8], ecx
sub r10, 1
jne 0x1400393f0
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
jmp 0x14003949e
lea rcx, [rsp + 0x20]
inc ebx
call fcn.14003fc50
mov ecx, eax
mov edi, ebx
imul rcx, rdi
cmp ecx, ebx
jae 0x14003949a
mov eax, ebx
xor edx, edx
neg eax
div ebx
mov ebx, edx
cmp ecx, edx
jae 0x14003949a
lea rcx, [rsp + 0x20]
call fcn.14003fc50
mov ecx, eax
imul rcx, rdi
cmp ecx, ebx
jb 0x140039486
shr rcx, 0x20
lea edx, [rsi + rcx]
cmp edx, ebp
lea ecx, [rdx - 0x80000000]
lea eax, [rdx + rbp]
cmovae eax, ecx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
lea r11, [rsp + 0x13c0]
mov rbx, qword [r11 + 0x10]
mov rbp, qword [r11 + 0x18]
mov rsi, qword [r11 + 0x20]
mov rsp, r11
pop rdi
ret
Function at 0x140039df0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov rbx, rdx
mov edx, 4
mov rax, qword gs:[0x58]
mov rcx, qword [rax]
mov eax, dword [rdx + rcx]
cmp dword [0x140047d4c], eax
jle 0x140039ff9
lea rcx, [0x140047d4c]
call fcn.140040288
cmp dword [0x140047d4c], 0xffffffff
jne 0x140039ff9
xor eax, eax
mov dword [0x140047d99], eax
mov byte [0x140047d9d], al
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov edx, eax
mov dword [rsp + 0x13a4], 0xffffffff
mov dword [rsp + 0x24], eax
mov ecx, 1
mov r9d, 0x270
nop dword [rax]
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [rsp + rcx*4 + 0x24], edx
inc rcx
cmp rcx, r9
jb 0x140039e80
mov dword [rsp + 0x20], r9d
lea rax, [rsp + 0x28]
nop word [rax + rax]
mov r8d, dword [rax - 4]
xor r8d, dword [rax]
btr r8d, 0x1f
xor r8d, dword [rax - 4]
mov ecx, r8d
and cl, 1
neg cl
sbb edx, edx
and edx, 0x9908b0df
xor edx, dword [rax + 0x630]
shr r8d, 1
xor edx, r8d
mov dword [rax + 0x9bc], edx
lea rax, [rax + 4]
sub r9, 1
jne 0x140039eb0
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
lea eax, [rcx - 0x80000000]
mov edx, 0x80000000
lea r8d, [rcx + rdx]
cmp ecx, edx
cmovae r8d, eax
mov dword [0x140047d94], 5
movzx ecx, byte [0x140047d98]
test cl, cl
jne 0x140039f55
add r8d, 5
mov cl, 1
test cl, cl
je 0x140039f5b
sub r8d, 5
xor cl, cl
movzx eax, r8b
xor al, 0x54
mov byte [0x140047d99], al
test cl, cl
jne 0x140039f6f
add r8d, 5
add r8d, 0xfffffffb
lea ecx, [r8 + 1]
mov eax, 1
cdq
idiv ecx
add dl, r8b
xor dl, 0x45
mov byte [0x140047d9a], dl
lea ecx, [r8 + 1]
mov eax, 2
cdq
idiv ecx
add dl, r8b
xor dl, 0x4d
mov byte [0x140047d9b], dl
mov r9d, r8d
lea ecx, [r8 + 1]
mov eax, 3
cdq
idiv ecx
add dl, r8b
xor dl, 0x50
mov byte [0x140047d9c], dl
lea r10d, [r9 + 5]
mov byte [0x140047d98], 0
lea r8d, [r10 - 4]
mov eax, 4
cdq
idiv r8d
add dl, r9b
mov byte [0x140047d9d], dl
mov dword [0x140047d90], r10d
mov byte [0x140047d98], 1
lea rcx, [0x140047d4c]
call fcn.14004021c
movups xmm0, xmmword [0x140047d90]
movups xmmword [rbx], xmm0
mov rax, rbx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
add rsp, 0x13c0
pop rbx
ret
Function at 0x14003a020
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov rbx, rdx
mov edx, 4
mov rax, qword gs:[0x58]
mov rcx, qword [rax]
mov eax, dword [rdx + rcx]
cmp dword [0x140047c4c], eax
jle 0x14003a1da
lea rcx, [0x140047c4c]
call fcn.140040288
cmp dword [0x140047c4c], 0xffffffff
jne 0x14003a1da
xor eax, eax
mov word [0x140047cc9], ax
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov edx, eax
mov dword [rsp + 0x13a4], 0xffffffff
mov dword [rsp + 0x24], eax
mov ecx, 1
mov r9d, 0x270
nop dword [rax + rax]
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [rsp + rcx*4 + 0x24], edx
inc rcx
cmp rcx, r9
jb 0x14003a0b0
mov dword [rsp + 0x20], r9d
lea r8, [rsp + 0x28]
nop word [rax + rax]
mov edx, dword [r8 - 4]
xor edx, dword [r8]
btr edx, 0x1f
xor edx, dword [r8 - 4]
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
and ecx, 0x9908b0df
xor ecx, dword [r8 + 0x630]
shr edx, 1
xor ecx, edx
mov dword [r8 + 0x9bc], ecx
lea r8, [r8 + 4]
sub r9, 1
jne 0x14003a0e0
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
lea eax, [rcx - 0x80000000]
mov edx, 0x80000000
lea r10d, [rcx + rdx]
cmp ecx, edx
cmovae r10d, eax
mov dword [0x140047cc4], 5
movzx ecx, byte [0x140047cc8]
test cl, cl
jne 0x14003a182
add r10d, 5
mov cl, 1
test cl, cl
je 0x14003a188
sub r10d, 5
xor cl, cl
movzx eax, r10b
xor al, 0x2d
mov byte [0x140047cc9], al
test cl, cl
jne 0x14003a19c
add r10d, 5
mov r9d, r10d
sub r10d, 5
mov byte [0x140047cc8], 0
lea r8d, [r9 - 4]
mov eax, 1
cdq
idiv r8d
add dl, r10b
mov byte [0x140047cca], dl
mov dword [0x140047cc0], r9d
mov byte [0x140047cc8], 1
lea rcx, [0x140047c4c]
call fcn.14004021c
movsd xmm0, qword [0x140047cc0]
movsd qword [rbx], xmm0
mov ecx, dword [0x140047cc8]
mov dword [rbx + 8], ecx
mov rax, rbx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
add rsp, 0x13c0
pop rbx
ret
Function at 0x14003a210
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov rbx, rdx
mov edx, 4
mov rax, qword gs:[0x58]
mov rcx, qword [rax]
mov eax, dword [rdx + rcx]
cmp dword [0x140047d40], eax
jle 0x14003a3ca
lea rcx, [0x140047d40]
call fcn.140040288
cmp dword [0x140047d40], 0xffffffff
jne 0x14003a3ca
xor eax, eax
mov word [0x140047ee1], ax
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov edx, eax
mov dword [rsp + 0x13a4], 0xffffffff
mov dword [rsp + 0x24], eax
mov ecx, 1
mov r9d, 0x270
nop dword [rax + rax]
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [rsp + rcx*4 + 0x24], edx
inc rcx
cmp rcx, r9
jb 0x14003a2a0
mov dword [rsp + 0x20], r9d
lea r8, [rsp + 0x28]
nop word [rax + rax]
mov edx, dword [r8 - 4]
xor edx, dword [r8]
btr edx, 0x1f
xor edx, dword [r8 - 4]
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
and ecx, 0x9908b0df
xor ecx, dword [r8 + 0x630]
shr edx, 1
xor ecx, edx
mov dword [r8 + 0x9bc], ecx
lea r8, [r8 + 4]
sub r9, 1
jne 0x14003a2d0
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
lea eax, [rcx - 0x80000000]
mov edx, 0x80000000
lea r10d, [rcx + rdx]
cmp ecx, edx
cmovae r10d, eax
mov dword [0x140047edc], 5
movzx ecx, byte [0x140047ee0]
test cl, cl
jne 0x14003a372
add r10d, 5
mov cl, 1
test cl, cl
je 0x14003a378
sub r10d, 5
xor cl, cl
movzx eax, r10b
xor al, 0x5c
mov byte [0x140047ee1], al
test cl, cl
jne 0x14003a38c
add r10d, 5
mov r9d, r10d
sub r10d, 5
mov byte [0x140047ee0], 0
lea r8d, [r9 - 4]
mov eax, 1
cdq
idiv r8d
add dl, r10b
mov byte [0x140047ee2], dl
mov dword [0x140047ed8], r9d
mov byte [0x140047ee0], 1
lea rcx, [0x140047d40]
call fcn.14004021c
movsd xmm0, qword [0x140047ed8]
movsd qword [rbx], xmm0
mov ecx, dword [0x140047ee0]
mov dword [rbx + 8], ecx
mov rax, rbx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
add rsp, 0x13c0
pop rbx
ret
Function at 0x14003c290
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov rbx, rdx
mov edx, 4
mov rax, qword gs:[0x58]
mov rcx, qword [rax]
mov eax, dword [rdx + rcx]
cmp dword [0x140047e94], eax
jle 0x14003c44a
lea rcx, [0x140047e94]
call fcn.140040288
cmp dword [0x140047e94], 0xffffffff
jne 0x14003c44a
xor eax, eax
mov word [0x140047c59], ax
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov edx, eax
mov dword [rsp + 0x13a4], 0xffffffff
mov dword [rsp + 0x24], eax
mov ecx, 1
mov r9d, 0x270
nop dword [rax + rax]
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [rsp + rcx*4 + 0x24], edx
inc rcx
cmp rcx, r9
jb 0x14003c320
mov dword [rsp + 0x20], r9d
lea r8, [rsp + 0x28]
nop word [rax + rax]
mov edx, dword [r8 - 4]
xor edx, dword [r8]
btr edx, 0x1f
xor edx, dword [r8 - 4]
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
and ecx, 0x9908b0df
xor ecx, dword [r8 + 0x630]
shr edx, 1
xor ecx, edx
mov dword [r8 + 0x9bc], ecx
lea r8, [r8 + 4]
sub r9, 1
jne 0x14003c350
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
lea eax, [rcx - 0x80000000]
mov edx, 0x80000000
lea r10d, [rcx + rdx]
cmp ecx, edx
cmovae r10d, eax
mov dword [0x140047c54], 5
movzx ecx, byte [0x140047c58]
test cl, cl
jne 0x14003c3f2
add r10d, 5
mov cl, 1
test cl, cl
je 0x14003c3f8
sub r10d, 5
xor cl, cl
movzx eax, r10b
xor al, 0x22
mov byte [0x140047c59], al
test cl, cl
jne 0x14003c40c
add r10d, 5
mov r9d, r10d
sub r10d, 5
mov byte [0x140047c58], 0
lea r8d, [r9 - 4]
mov eax, 1
cdq
idiv r8d
add dl, r10b
mov byte [0x140047c5a], dl
mov dword [0x140047c50], r9d
mov byte [0x140047c58], 1
lea rcx, [0x140047e94]
call fcn.14004021c
movsd xmm0, qword [0x140047c50]
movsd qword [rbx], xmm0
mov ecx, dword [0x140047c58]
mov dword [rbx + 8], ecx
mov rax, rbx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
add rsp, 0x13c0
pop rbx
ret
Function at 0x14003c790
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov rbx, rdx
mov edx, 4
mov rax, qword gs:[0x58]
mov rcx, qword [rax]
mov eax, dword [rdx + rcx]
cmp dword [0x140047f20], eax
jle 0x14003c94a
lea rcx, [0x140047f20]
call fcn.140040288
cmp dword [0x140047f20], 0xffffffff
jne 0x14003c94a
xor eax, eax
mov word [0x140047eb9], ax
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov edx, eax
mov dword [rsp + 0x13a4], 0xffffffff
mov dword [rsp + 0x24], eax
mov ecx, 1
mov r9d, 0x270
nop dword [rax + rax]
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [rsp + rcx*4 + 0x24], edx
inc rcx
cmp rcx, r9
jb 0x14003c820
mov dword [rsp + 0x20], r9d
lea r8, [rsp + 0x28]
nop word [rax + rax]
mov edx, dword [r8 - 4]
xor edx, dword [r8]
btr edx, 0x1f
xor edx, dword [r8 - 4]
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
and ecx, 0x9908b0df
xor ecx, dword [r8 + 0x630]
shr edx, 1
xor ecx, edx
mov dword [r8 + 0x9bc], ecx
lea r8, [r8 + 4]
sub r9, 1
jne 0x14003c850
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
lea eax, [rcx - 0x80000000]
mov edx, 0x80000000
lea r10d, [rcx + rdx]
cmp ecx, edx
cmovae r10d, eax
mov dword [0x140047eb4], 5
movzx ecx, byte [0x140047eb8]
test cl, cl
jne 0x14003c8f2
add r10d, 5
mov cl, 1
test cl, cl
je 0x14003c8f8
sub r10d, 5
xor cl, cl
movzx eax, r10b
xor al, 0x22
mov byte [0x140047eb9], al
test cl, cl
jne 0x14003c90c
add r10d, 5
mov r9d, r10d
sub r10d, 5
mov byte [0x140047eb8], 0
lea r8d, [r9 - 4]
mov eax, 1
cdq
idiv r8d
add dl, r10b
mov byte [0x140047eba], dl
mov dword [0x140047eb0], r9d
mov byte [0x140047eb8], 1
lea rcx, [0x140047f20]
call fcn.14004021c
movsd xmm0, qword [0x140047eb0]
movsd qword [rbx], xmm0
mov ecx, dword [0x140047eb8]
mov dword [rbx + 8], ecx
mov rax, rbx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
add rsp, 0x13c0
pop rbx
ret
Function at 0x14003c980
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push rbx
mov eax, 0x13c0
call fcn.140041130
sub rsp, rax
mov rax, qword [0x140047040]
xor rax, rsp
mov qword [rsp + 0x13b0], rax
mov rbx, rdx
mov edx, 4
mov rax, qword gs:[0x58]
mov rcx, qword [rax]
mov eax, dword [rdx + rcx]
cmp dword [0x140047d44], eax
jle 0x14003cb89
lea rcx, [0x140047d44]
call fcn.140040288
cmp dword [0x140047d44], 0xffffffff
jne 0x14003cb89
xor eax, eax
mov dword [0x140047cf1], eax
mov byte [0x140047cf5], al
call qword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov edx, eax
mov dword [rsp + 0x13a4], 0xffffffff
mov dword [rsp + 0x24], eax
mov ecx, 1
mov r9d, 0x270
nop dword [rax]
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [rsp + rcx*4 + 0x24], edx
inc rcx
cmp rcx, r9
jb 0x14003ca10
mov dword [rsp + 0x20], r9d
lea rax, [rsp + 0x28]
nop word [rax + rax]
mov r8d, dword [rax - 4]
xor r8d, dword [rax]
btr r8d, 0x1f
xor r8d, dword [rax - 4]
mov ecx, r8d
and cl, 1
neg cl
sbb edx, edx
and edx, 0x9908b0df
xor edx, dword [rax + 0x630]
shr r8d, 1
xor edx, r8d
mov dword [rax + 0x9bc], edx
lea rax, [rax + 4]
sub r9, 1
jne 0x14003ca40
mov eax, dword [rsp + 0x20]
mov edx, dword [rsp + rax*4 + 0x24]
mov eax, edx
shr eax, 0xb
and eax, dword [rsp + 0x13a4]
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov ecx, edx
shr ecx, 0x12
xor ecx, edx
lea eax, [rcx - 0x80000000]
mov edx, 0x80000000
lea r8d, [rcx + rdx]
cmp ecx, edx
cmovae r8d, eax
mov dword [0x140047cec], 5
movzx ecx, byte [0x140047cf0]
test cl, cl
jne 0x14003cae5
add r8d, 5
mov cl, 1
test cl, cl
je 0x14003caeb
sub r8d, 5
xor cl, cl
movzx eax, r8b
xor al, 0x2e
mov byte [0x140047cf1], al
test cl, cl
jne 0x14003caff
add r8d, 5
add r8d, 0xfffffffb
lea ecx, [r8 + 1]
mov eax, 1
cdq
idiv ecx
add dl, r8b
xor dl, 0x73
mov byte [0x140047cf2], dl
lea ecx, [r8 + 1]
mov eax, 2
cdq
idiv ecx
add dl, r8b
xor dl, 0x79
mov byte [0x140047cf3], dl
mov r9d, r8d
lea ecx, [r8 + 1]
mov eax, 3
cdq
idiv ecx
add dl, r8b
xor dl, 0x73
mov byte [0x140047cf4], dl
lea r10d, [r9 + 5]
mov byte [0x140047cf0], 0
lea r8d, [r10 - 4]
mov eax, 4
cdq
idiv r8d
add dl, r9b
mov byte [0x140047cf5], dl
mov dword [0x140047ce8], r10d
mov byte [0x140047cf0], 1
lea rcx, [0x140047d44]
call fcn.14004021c
movups xmm0, xmmword [0x140047ce8]
movups xmmword [rbx], xmm0
mov rax, rbx
mov rcx, qword [rsp + 0x13b0]
xor rcx, rsp
call fcn.1400401c0
add rsp, 0x13c0
pop rbx
ret