joyce8/EMBER2024-capa huggingface dataset:
Function at 0x1801c5800
Capabilities:
Hash data using murmur3

Disassembly:
xor eax, eax
mov r8d, dword [rdx + 8]
test r8d, r8d
jle 0x1801c583e
mov r9d, eax
lea r9, [rdx + r9*8 + 0x10]
mov r9, qword [r9]
mov r10, r9
test r10, r10
jne 0x1801c5823
xor r10d, r10d
jmp 0x1801c5827
mov r10d, dword [r9 + 0x14]
mov r9d, ecx
rol r9d, 0xd
add r9d, ecx
mov ecx, r9d
xor ecx, r10d
inc eax
cmp r8d, eax
jg 0x1801c580b
mov eax, ecx
rol eax, 0xf
add eax, ecx
ret

Function at 0x1801c8700
Capabilities:
Hash data using murmur3

Disassembly:
push rdi
push rsi
sub rsp, 0x28
mov esi, ecx
mov edi, edx
call fcn.1800010db
mov eax, dword [rax]
add eax, 0x165667b1
add eax, 8
imul edx, esi, 0xc2b2ae3d
add edx, eax
rol edx, 0x11
imul eax, edx, 0x27d4eb2f
imul edx, edi, 0xc2b2ae3d
add edx, eax
rol edx, 0x11
imul eax, edx, 0x27d4eb2f
mov edx, eax
shr edx, 0xf
xor eax, edx
imul eax, eax, 0x85ebca77
mov edx, eax
shr edx, 0xd
xor eax, edx
imul eax, eax, 0xc2b2ae3d
mov edx, eax
shr edx, 0x10
xor eax, edx
add rsp, 0x28
pop rsi
pop rdi
ret

Function at 0x1801c8770
Capabilities:
Hash data using murmur3

Disassembly:
push rdi
push rsi
push rbx
sub rsp, 0x20
mov esi, ecx
mov edi, edx
mov ebx, r8d
call fcn.1800010db
mov eax, dword [rax]
add eax, 0x165667b1
add eax, 0xc
imul edx, esi, 0xc2b2ae3d
add edx, eax
rol edx, 0x11
imul eax, edx, 0x27d4eb2f
imul edx, edi, 0xc2b2ae3d
add edx, eax
rol edx, 0x11
imul eax, edx, 0x27d4eb2f
imul edx, ebx, 0xc2b2ae3d
add edx, eax
rol edx, 0x11
imul eax, edx, 0x27d4eb2f
mov edx, eax
shr edx, 0xf
xor eax, edx
imul eax, eax, 0x85ebca77
mov edx, eax
shr edx, 0xd
xor eax, edx
imul eax, eax, 0xc2b2ae3d
mov edx, eax
shr edx, 0x10
xor eax, edx
add rsp, 0x20
pop rbx
pop rsi
pop rdi
ret

Function at 0x1801cc750
Capabilities:
Encode data using xor
Hash data using murmur3

Disassembly:
push rdi
push rsi
push rbp
push rbx
sub rsp, 0x28
mov rsi, r8
mov edi, edx
xor ebx, ebx
mov ebp, dword [rsi + 8]
test ebp, ebp
jle 0x1801cc784
mov ecx, ebx
mov rcx, qword [rsi + rcx*8 + 0x10]
mov rax, qword [rcx]
call qword [rax + 0x28]
mov edx, edi
rol edx, 0xd
add edx, edi
mov edi, eax
xor edi, edx
inc ebx
cmp ebp, ebx
jg 0x1801cc766
mov eax, edi
rol eax, 0xf
add eax, edi
add rsp, 0x28
pop rbx
pop rbp
pop rsi
pop rdi
ret

Function at 0x1801cc7a0
Capabilities:
Encode data using xor
Hash data using murmur3

Disassembly:
push rdi
push rsi
push rbp
push rbx
sub rsp, 0x28
mov rsi, r8
mov edi, edx
xor ebx, ebx
mov ebp, dword [rsi + 8]
test ebp, ebp
jle 0x1801cc7d4
mov ecx, ebx
mov rcx, qword [rsi + rcx*8 + 0x10]
mov rax, qword [rcx]
call qword [rax + 0x28]
mov edx, edi
rol edx, 0xd
add edx, edi
mov edi, eax
xor edi, edx
inc ebx
cmp ebp, ebx
jg 0x1801cc7b6
mov eax, edi
rol eax, 0xf
add eax, edi
add rsp, 0x28
pop rbx
pop rbp
pop rsi
pop rdi
ret
Function at 0x1400042f0
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 8], rbx
mov r11d, r8d
mov r10, rdx
not r11d
mov r9, rcx
mov eax, r11d
test rdx, rdx
je 0x14000434d
lea rbx, [0x14015ed90]
movzx r8d, byte [r9]
lea r9, [r9 + 1]
dec r10
cmp r8b, 0x23
jne 0x140004334
cmp r10, 2
jb 0x140004334
cmp byte [r9], r8b
jne 0x140004334
cmp byte [r9 + 1], r8b
cmove eax, r11d
movzx edx, al
xor rdx, r8
shr eax, 8
xor eax, dword [rbx + rdx*4]
test r10, r10
jne 0x140004310
not eax
mov rbx, qword [rsp + 8]
ret
movzx r8d, byte [rcx]
inc r9
test r8b, r8b
je 0x14000438f
lea rbx, [0x14015ed90]
cmp r8b, 0x23
jne 0x140004373
cmp byte [r9], r8b
jne 0x140004373
cmp byte [r9 + 1], r8b
cmove eax, r11d
movzx edx, al
movzx ecx, r8b
movzx r8d, byte [r9]
xor rdx, rcx
shr eax, 8
inc r9
xor eax, dword [rbx + rdx*4]
test r8b, r8b
jne 0x140004360
mov rbx, qword [rsp + 8]
not eax
ret
Function at 0x140007660
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 0x18], rbx
push rdi
sub rsp, 0x20
mov r11, rcx
lea rdi, [0x14015ed90]
movsxd rcx, dword [rcx + 0xf0]
mov r10d, edx
shr r10d, 0x18
mov r8d, edx
shr r8d, 8
mov r9d, edx
mov rax, qword [r11 + 0xf8]
shr r9d, 0x10
mov ebx, dword [rax + rcx*4 - 4]
not ebx
movzx eax, dl
movzx ecx, bl
xor rcx, rax
shr ebx, 8
movzx eax, r8b
xor ebx, dword [rdi + rcx*4]
movzx ecx, bl
xor rcx, rax
shr ebx, 8
movzx eax, r9b
xor ebx, dword [rdi + rcx*4]
movzx ecx, bl
xor rcx, rax
shr ebx, 8
xor ebx, dword [rdi + rcx*4]
movzx ecx, bl
xor rcx, r10
shr ebx, 8
xor ebx, dword [rdi + rcx*4]
mov rcx, qword [r11]
not ebx
cmp dword [rcx + 0x3f38], ebx
jne 0x1400076f4
movsxd r8, edx
mov ecx, ebx
mov edx, 4
call fcn.14001a1f0
mov eax, ebx
mov rbx, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret

Function at 0x140007710
Capabilities:
Hash data with crc32

Disassembly:
sub rsp, 0x18
movss xmm0, dword [rcx + 0x110]
lea r10, [0x14015ed90]
mov rax, qword [rcx + 0xf8]
movss xmm1, dword [rcx + 0x114]
movss xmm2, dword [rdx]
movss xmm4, dword [rdx + 8]
subss xmm2, xmm0
movss xmm3, dword [rdx + 4]
subss xmm4, xmm0
movss xmm0, dword [rdx + 0xc]
subss xmm3, xmm1
movsxd rcx, dword [rcx + 0xf0]
subss xmm0, xmm1
movd r8d, xmm2
movss dword [rsp], xmm2
mov r9d, dword [rax + rcx*4 - 4]
movzx eax, byte [rsp]
not r9d
movzx ecx, r9b
xor rcx, rax
shr r9d, 8
mov eax, r8d
movss dword [rsp + 4], xmm3
shr eax, 8
movzx edx, al
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
movzx ecx, r9b
xor rdx, rcx
shr r9d, 8
shr eax, 0x10
movss dword [rsp + 8], xmm4
movss dword [rsp + 0xc], xmm0
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
movzx eax, byte [rsp + 4]
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
mov edx, r8d
shr rdx, 0x18
xor rdx, rcx
movd r8d, xmm3
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
xor rcx, rax
shr r9d, 8
mov eax, r8d
shr eax, 8
movzx edx, al
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
movzx ecx, r9b
xor rdx, rcx
shr r9d, 8
shr eax, 0x10
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
movzx eax, byte [rsp + 8]
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
mov edx, r8d
shr rdx, 0x18
xor rdx, rcx
movd r8d, xmm4
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
xor rcx, rax
shr r9d, 8
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
shr eax, 8
movzx edx, al
movzx ecx, r9b
xor rdx, rcx
shr r9d, 8
mov eax, r8d
shr eax, 0x10
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
movzx eax, byte [rsp + 0xc]
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
mov edx, r8d
shr rdx, 0x18
xor rdx, rcx
movd r8d, xmm0
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
xor rcx, rax
shr r9d, 8
mov eax, r8d
shr eax, 8
movzx edx, al
mov eax, r8d
xor r9d, dword [r10 + rcx*4]
movzx ecx, r9b
xor rdx, rcx
shr r9d, 8
shr eax, 0x10
shr r8, 0x18
xor r9d, dword [r10 + rdx*4]
movzx ecx, r9b
shr r9d, 8
movzx edx, al
xor rdx, rcx
xor r9d, dword [r10 + rdx*4]
movzx edx, r9b
shr r9d, 8
xor r8, rdx
xor r9d, dword [r10 + r8*4]
not r9d
mov eax, r9d
add rsp, 0x18
ret
Function at 0x140013e90
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x40
mov rax, qword [0x1401c10c0]
xor rax, rsp
mov qword [rsp + 0x30], rax
mov rbx, qword [0x14028a660]
mov edi, ecx
cmp byte [rbx + 0x4a7d], 0
jne 0x140013ef1
cmp byte [rbx + 0x4a7e], 0
jne 0x140013ef1
movsx r9d, word [rbx + 0x5b8a]
lea r8, str.Tooltip__02d
mov edx, 0x10
lea rcx, [rsp + 0x20]
call fcn.140004150
test dil, 1
je 0x14001401f
jmp 0x140013f7c
movss xmm1, dword [rbx + 0x38bc]
lea r8, str.Tooltip__02d
movsx r9d, word [rbx + 0x5b8a]
lea rcx, [rsp + 0x20]
movaps xmm0, xmm1
xor eax, eax
mulss xmm0, dword [0x1401a3ab4]
mov edx, 0x10
mulss xmm1, dword [0x1401a3a98]
addss xmm0, dword [rbx + 0xe08]
addss xmm1, dword [rbx + 0xe0c]
mov qword [rbx + 0x47e0], rax
mov dword [rbx + 0x47cc], 1
movss dword [rbx + 0x47d8], xmm0
movss dword [rbx + 0x47dc], xmm1
movss xmm0, dword [rbx + 0x3924]
mulss xmm0, dword [0x1401a3a14]
or dword [rbx + 0x47c8], 0x41
movss dword [rbx + 0x4828], xmm0
call fcn.140004150
movzx r9d, byte [rsp + 0x20]
lea r8, [rsp + 0x21]
mov r10d, 0xffffffff
mov ecx, r10d
test r9b, r9b
je 0x140013fd0
lea r11, [0x14015ed90]
nop dword [rax]
cmp r9b, 0x23
jne 0x140013fb3
cmp byte [r8], r9b
jne 0x140013fb3
cmp byte [r8 + 1], r9b
cmove ecx, r10d
movzx edx, cl
movzx eax, r9b
movzx r9d, byte [r8]
xor rdx, rax
shr ecx, 8
inc r8
xor ecx, dword [r11 + rdx*4]
test r9b, r9b
jne 0x140013fa0
not ecx
call fcn.14000b610
test rax, rax
je 0x14001401f
cmp byte [rax + 0xb6], 0
je 0x14001401f
mov byte [rax + 0xbb], 1
lea r8, str.Tooltip__02d
mov byte [rax + 0xbd], 1
lea rcx, [rsp + 0x20]
mov byte [rax + 0xd8], 1
mov edx, 0x10
inc word [rbx + 0x5b8a]
movsx r9d, word [rbx + 0x5b8a]
call fcn.140004150
xor edx, edx
lea rcx, [rsp + 0x20]
mov r8d, 0x20c0347
call fcn.14000dd10
mov al, 1
mov rcx, qword [rsp + 0x30]
xor rcx, rsp
call fcn.14012c680
mov rbx, qword [rsp + 0x50]
add rsp, 0x40
pop rdi
ret
Function at 0x140018f80
Capabilities:
Hash data with crc32

Disassembly:
sub rsp, 8
movzx r9d, byte [rcx]
lea r8, [rcx + 1]
mov r10, qword [0x14028a660]
mov r11d, 0xffffffff
mov eax, r11d
test r9b, r9b
je 0x140018fe3
mov qword [rsp], rbx
lea rbx, [0x14015ed90]
nop dword [rax]
cmp r9b, 0x23
jne 0x140018fc3
cmp byte [r8], r9b
jne 0x140018fc3
cmp byte [r8 + 1], r9b
cmove eax, r11d
movzx edx, al
movzx ecx, r9b
movzx r9d, byte [r8]
xor rdx, rcx
shr eax, 8
inc r8
xor eax, dword [rbx + rdx*4]
test r9b, r9b
jne 0x140018fb0
mov rbx, qword [rsp]
movsxd rcx, dword [r10 + 0x5be8]
xor r8d, r8d
not eax
test ecx, ecx
jle 0x140019017
mov r10, qword [r10 + 0x5bf0]
mov r9, rcx
mov edx, r8d
lea rcx, [r10 + 8]
cmp dword [rcx], eax
je 0x14001901e
inc r8d
inc rdx
add rcx, 0x48
cmp rdx, r9
jl 0x140019004
xor eax, eax
add rsp, 8
ret
movsxd rax, r8d
lea rcx, [rax + rax*8]
lea rax, [r10 + rcx*8]
add rsp, 8
ret
Function at 0x1400338a0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
mov qword [rsp + 8], rbx
push rdi
mov eax, 0x13d0
call fcn.14012d420
sub rsp, rax
mov rax, qword [0x1401c10c0]
xor rax, rsp
mov qword [rsp + 0x13c0], rax
call qword [0x140133750]
mov edi, 1
mov dword [rsp + 0x13b4], 0xffffffff
mov dword [rsp + 0x34], eax
mov edx, edi
mov ecx, eax
shr ecx, 0x1e
xor ecx, eax
imul eax, ecx, 0x6c078965
add eax, edx
mov dword [rsp + rdx*4 + 0x34], eax
inc rdx
cmp rdx, 0x270
jb 0x1400338e1
lea rcx, [rsp + 0x30]
mov dword [rsp + 0x30], 0x270
call fcn.140036da0
mov ecx, eax
imul rbx, rcx, 0x385
cmp ebx, 0x132
ja 0x14003393e
lea rcx, [rsp + 0x30]
call fcn.140036da0
mov ecx, eax
imul rbx, rcx, 0x385
cmp ebx, 0x133
jb 0x140033923
shr rbx, 0x20
lea rcx, [rsp + 0x20]
sub rbx, 0x7fffff9c
call fcn.1400337c0
xor rbx, 0xffffffff80000000
mov rax, qword [rsp + 0x20]
mov qword [rsp + 0x20], rax
je 0x1400339a1
imul rdx, rbx, 0xf4240
movabs r9, 0x7fffffffffffffff
mov rcx, r9
sub rcx, rdx
cmp rax, rcx
je 0x14003399c
mov r8d, 0xff
cmovl edi, r8d
test dil, dil
jns 0x14003399c
lea rcx, [rdx + rax]
mov qword [rsp + 0x20], rcx
jmp 0x1400339a1
mov qword [rsp + 0x20], r9
lea rcx, [rsp + 0x20]
call fcn.140036cc0
mov rcx, qword [rsp + 0x13c0]
xor rcx, rsp
call fcn.14012c680
mov rbx, qword [rsp + 0x13e0]
add rsp, 0x13d0
pop rdi
ret
Function at 0x1400363e0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
mov dword [rcx + 0x1384], 0xffffffff
lea r9, [rcx + 8]
mov dword [rcx + 4], edx
mov r8d, 1
nop word [rax + rax]
mov eax, edx
lea r9, [r9 + 4]
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, r8d
inc r8
mov dword [r9 - 4], edx
cmp r8, 0x270
jb 0x140036400
mov dword [rcx], 0x270
mov rax, rcx
ret

Function at 0x140036da0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
sub rsp, 8
mov r9, rcx
mov r10d, 0x270
mov ecx, dword [rcx]
cmp ecx, r10d
jne 0x140036e01
lea r8, [r9 + 8]
nop dword [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 0x140036dc0
mov ecx, dword [r9]
jmp 0x140036eeb
cmp ecx, 0x4e0
jb 0x140036eeb
lea r10, [r9 + 0x9c4]
mov qword [rsp], rbx
mov r11d, dword [r10]
mov ebx, 0xe3
mov eax, r11d
mov r8, r10
mov r11d, dword [r10 + 4]
add r10, 4
mov edx, r11d
xor edx, eax
btr edx, 0x1f
xor edx, eax
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
shr edx, 1
and ecx, 0x9908b0df
xor ecx, dword [r8 + 0x634]
xor ecx, edx
mov dword [r8 - 0x9c0], ecx
sub rbx, 1
jne 0x140036e20
lea r10, [r9 + 0xd50]
mov ebx, 0x18c
mov r11d, dword [r10]
nop
mov eax, r11d
mov r8, r10
mov r11d, dword [r10 + 4]
mov edx, eax
xor edx, r11d
add r10, 4
btr edx, 0x1f
xor edx, eax
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
shr edx, 1
and ecx, 0x9908b0df
xor ecx, dword [r8 - 0xd4c]
xor ecx, edx
mov dword [r8 - 0x9c0], ecx
sub rbx, 1
jne 0x140036e70
mov eax, dword [r9 + 0x1380]
mov edx, eax
xor edx, dword [r9 + 4]
mov rbx, qword [rsp]
btr edx, 0x1f
xor edx, eax
mov eax, edx
and al, 1
neg al
sbb ecx, ecx
shr edx, 1
and ecx, 0x9908b0df
xor ecx, dword [r9 + 0x634]
xor ecx, edx
mov dword [r9 + 0x9c0], ecx
xor ecx, ecx
mov dword [r9], ecx
mov eax, ecx
mov edx, dword [r9 + rax*4 + 4]
lea eax, [rcx + 1]
mov dword [r9], eax
mov ecx, edx
mov eax, dword [r9 + 0x1384]
shr ecx, 0xb
and eax, ecx
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 eax, edx
shr eax, 0x12
xor eax, edx
add rsp, 8
ret
Function at 0x14003b2d0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
mov qword [rsp + 0x18], rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
push r15
sub rsp, 0x40
mov r15, rdx
mov rsi, rcx
mov qword [rsp + 0x30], rcx
xor ebp, ebp
mov dword [rsp + 0x24], ebp
mov rax, qword gs:[0x58]
mov rdi, qword [rax]
mov r14d, 0x13b8
mov eax, dword [r14 + rdi]
mov r13d, 0x30
test al, 1
jne 0x14003b368
or eax, 1
mov dword [r14 + rdi], eax
mov ebx, r13d
add rbx, rdi
call qword [0x140133750]
mov edx, eax
mov dword [rbx + 0x1384], 0xffffffff
mov dword [rbx + 4], eax
mov ecx, 1
lea r8, [rbx + 8]
mov eax, edx
shr eax, 0x1e
xor eax, edx
imul edx, eax, 0x6c078965
add edx, ecx
mov dword [r8], edx
inc rcx
lea r8, [r8 + 4]
cmp rcx, 0x270
jb 0x14003b340
mov dword [rbx], 0x270
mov eax, dword [r14 + rdi]
mov ebx, 0x18
test al, 2
jne 0x14003b389
or eax, 2
mov dword [r14 + rdi], eax
mov qword [rbx + rdi], rbp
mov qword [rbx + rdi + 8], 0xf
xorps xmm0, xmm0
movups xmmword [rsi], xmm0
mov qword [rsi + 0x10], rbp
mov qword [rsi + 0x18], 0xf
mov byte [rsi], 0
mov dword [rsp + 0x24], 1
cmp r15, 0xf
jbe 0x14003b3bb
mov rdx, r15
mov rcx, rsi
call fcn.140051f80
mov qword [rsi + 0x10], rbp
lea r12, [rdi + rbx]
mov ebx, r13d
add rbx, rdi
lea r13, str.0123456789ABCDEF
movzx edi, byte [rsp + 0x20]
dec r15
mov qword [rsp + 0x28], rbx
mov rbp, qword [r12]
mov rdx, qword [r12 + 8]
sub rdx, rbp
cmp rdx, 0xffffffffffffffff
jne 0x14003b409
mov rcx, rbx
call fcn.140036da0
mov r14d, eax
shl r14, 0x20
mov rcx, rbx
call fcn.140036da0
mov eax, eax
or r14, rax
jmp 0x14003b419
inc rdx
lea rcx, [rsp + 0x28]
call fcn.14005b460
mov r14, rax
lea rax, [r14 + rbp]
movzx r9d, byte [rax + r13]
mov rcx, qword [rsi + 0x10]
mov rdx, qword [rsi + 0x18]
cmp rcx, rdx
jae 0x14003b44e
lea rax, [rcx + 1]
mov qword [rsi + 0x10], rax
mov rax, rsi
cmp rdx, 0xf
jbe 0x14003b443
mov rax, qword [rsi]
mov byte [rax + rcx], r9b
mov byte [rax + rcx + 1], 0
jmp 0x14003b45f
movzx r8d, dil
mov edx, 1
mov rcx, rsi
call fcn.140054760
test r15, r15
jne 0x14003b3d1
mov rax, rsi
mov rbx, qword [rsp + 0x90]
add rsp, 0x40
pop r15
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
ret
Function at 0x14003b7b0
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
sub rsp, 0x20
mov ebx, edx
mov esi, ecx
mov ecx, 0x10
mov rax, qword gs:[0x58]
mov rax, qword [rax]
lea rbp, [0x14028b0f0]
mov eax, dword [rcx + rax]
cmp dword [0x14028b0ec], eax
jle 0x14003b857
lea rcx, [0x14028b0ec]
call fcn.14012c748
cmp dword [0x14028b0ec], 0xffffffff
jne 0x14003b857
call qword [0x140133750]
mov dword [0x14028c474], 0xffffffff
mov dword [0x14028b0f4], eax
mov r8d, 1
nop dword [rax]
mov edx, eax
shr edx, 0x1e
xor edx, eax
imul eax, edx, 0x6c078965
add eax, r8d
mov dword [rbp + r8*4 + 4], eax
inc r8
cmp r8, 0x270
jb 0x14003b820
mov dword [0x14028b0f0], 0x270
lea rcx, [0x14028b0ec]
call fcn.14012c6dc
btc esi, 0x1f
btc ebx, 0x1f
sub ebx, esi
mov rcx, rbp
cmp ebx, 0xffffffff
jne 0x14003b872
call fcn.140036da0
mov ecx, eax
jmp 0x14003b8a9
inc ebx
call fcn.140036da0
mov edi, ebx
mov ecx, eax
imul rcx, rdi
cmp ecx, ebx
jae 0x14003b8a5
mov eax, ebx
neg eax
xor edx, edx
div ebx
mov ebx, edx
cmp ecx, edx
jae 0x14003b8a5
mov rcx, rbp
call fcn.140036da0
mov ecx, eax
imul rcx, rdi
cmp ecx, ebx
jb 0x14003b893
shr rcx, 0x20
lea eax, [rcx + rsi]
xor eax, 0x80000000
mov rbx, qword [rsp + 0x30]
mov rbp, qword [rsp + 0x38]
mov rsi, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret
Function at 0x140040aa0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
mov qword [rsp + 0x10], rbx
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x20], rdi
push rbp
lea rbp, [rsp - 0x1330]
mov eax, 0x1430
call fcn.14012d420
sub rsp, rax
mov rax, qword [0x1401c10c0]
xor rax, rsp
mov qword [rbp + 0x1320], rax
mov rdi, rcx
mov qword [rsp + 0x68], rcx
xor esi, esi
call qword [0x140133750]
mov edx, eax
mov dword [rbp + 0x12f4], 0xffffffff
mov dword [rsp + 0x74], eax
mov ecx, 1
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 + 0x74], edx
inc rcx
cmp rcx, 0x270
jb 0x140040b00
mov dword [rsp + 0x70], 0x270
mov rbx, rsi
nop word [rax + rax]
lea rcx, [rsp + 0x70]
call fcn.140036da0
and eax, 0xf0000000
lea rcx, [rsp + 0x70]
cmp eax, 0xa0000000
jae 0x140040b58
call fcn.140036da0
shr eax, 0x1c
add eax, 0x30
jmp 0x140040b63
call fcn.140036da0
shr eax, 0x1c
add eax, 0x37
mov word [rbp + rbx*2 + 0x1300], ax
inc rbx
cmp rbx, 8
jl 0x140040b30
mov word [rbp + 0x1310], si
xorps xmm0, xmm0
movups xmmword [rsp + 0x48], xmm0
xorps xmm1, xmm1
movdqu xmmword [rsp + 0x58], xmm1
mov r8d, 4
lea rdx, [rbp + 0x1308]
lea rcx, [rsp + 0x48]
call fcn.1400413f0
nop
xorps xmm0, xmm0
movups xmmword [rsp + 0x28], xmm0
xorps xmm1, xmm1
movdqu xmmword [rsp + 0x38], xmm1
mov r8d, 4
lea rdx, [rbp + 0x1300]
lea rcx, [rsp + 0x28]
call fcn.1400413f0
nop
mov r8d, 1
lea rdx, [0x1401a1680]
lea rcx, [rsp + 0x28]
call fcn.14004c830
movups xmm0, xmmword [rax]
movups xmmword [rbp + 0x1300], xmm0
movups xmm1, xmmword [rax + 0x10]
movups xmmword [rbp + 0x1310], xmm1
mov qword [rax + 0x10], rsi
mov qword [rax + 0x18], 7
mov word [rax], si
lea r9, [rsp + 0x48]
lea r8, [rbp + 0x1300]
mov rcx, rdi
call fcn.1400561c0
nop
mov rdx, qword [rbp + 0x1318]
cmp rdx, 7
jbe 0x140040c67
lea rdx, [rdx*2 + 2]
mov rcx, qword [rbp + 0x1300]
mov rax, rcx
cmp rdx, 0x1000
jb 0x140040c61
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x140040c61
call qword [0x140133ce8]
int3
call fcn.14012cdb4
nop
mov rdx, qword [rsp + 0x40]
cmp rdx, 7
jbe 0x140040cac
lea rdx, [rdx*2 + 2]
mov rcx, qword [rsp + 0x28]
mov rax, rcx
cmp rdx, 0x1000
jb 0x140040ca7
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x140040ca7
call qword [0x140133ce8]
int3
call fcn.14012cdb4
movdqa xmm0, xmmword [0x1401a3be0]
movdqu xmmword [rsp + 0x38], xmm0
mov word [rsp + 0x28], si
mov rdx, qword [rsp + 0x60]
cmp rdx, 7
jbe 0x140040d04
lea rdx, [rdx*2 + 2]
mov rcx, qword [rsp + 0x48]
mov rax, rcx
cmp rdx, 0x1000
jb 0x140040cff
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x140040cff
call qword [0x140133ce8]
int3
call fcn.14012cdb4
mov rax, rdi
mov rcx, qword [rbp + 0x1320]
xor rcx, rsp
call fcn.14012c680
lea r11, [rsp + 0x1430]
mov rbx, qword [r11 + 0x18]
mov rsi, qword [r11 + 0x20]
mov rdi, qword [r11 + 0x28]
mov rsp, r11
pop rbp
ret
Function at 0x1400c7900
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rsi
push rdi
sub rsp, 0x50
mov r10, r8
mov rbx, rdx
mov rdi, rcx
mov qword [rsp + 0x28], rcx
xor esi, esi
cmp byte [r8 + 7], sil
je 0x1400c7934
mov eax, esi
lea ecx, [rax + 0x2a]
xor byte [r8 + rax], cl
inc rax
cmp rax, 6
jb 0x1400c7920
mov byte [r8 + 7], sil
add r8, 6
lea r9, [rsp + 0x20]
mov rdx, r10
lea rcx, [rsp + 0x30]
call fcn.140056e80
nop
mov r9, qword [rbx + 0x10]
cmp qword [rbx + 0x18], 0xf
jbe 0x1400c7959
mov rbx, qword [rbx]
mov r8, rbx
xor edx, edx
lea rcx, [rsp + 0x30]
call fcn.140056d60
xorps xmm0, xmm0
movups xmmword [rdi], xmm0
mov qword [rdi + 0x10], rsi
mov qword [rdi + 0x18], rsi
movups xmm0, xmmword [rax]
movups xmmword [rdi], xmm0
movups xmm1, xmmword [rax + 0x10]
movups xmmword [rdi + 0x10], xmm1
mov qword [rax + 0x10], rsi
mov qword [rax + 0x18], 0xf
mov byte [rax], 0
mov rdx, qword [rsp + 0x48]
cmp rdx, 0xf
jbe 0x1400c79d3
inc rdx
mov rcx, qword [rsp + 0x30]
mov rax, rcx
cmp rdx, 0x1000
jb 0x1400c79ce
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x1400c79ce
call qword [0x140133ce8]
int3
call fcn.14012cdb4
mov rax, rdi
add rsp, 0x50
pop rdi
pop rsi
pop rbx
ret

Function at 0x1400c79e0
Capabilities:
Encode data using xor

Disassembly:
push rbx
push rsi
push rdi
sub rsp, 0x50
mov r10, r8
mov rbx, rdx
mov rdi, rcx
mov qword [rsp + 0x28], rcx
xor esi, esi
cmp byte [r8 + 9], sil
je 0x1400c7a14
mov eax, esi
lea ecx, [rax + 0x2a]
xor byte [r8 + rax], cl
inc rax
cmp rax, 8
jb 0x1400c7a00
mov byte [r8 + 9], sil
add r8, 8
lea r9, [rsp + 0x20]
mov rdx, r10
lea rcx, [rsp + 0x30]
call fcn.140056e80
nop
mov r9, qword [rbx + 0x10]
cmp qword [rbx + 0x18], 0xf
jbe 0x1400c7a39
mov rbx, qword [rbx]
mov r8, rbx
xor edx, edx
lea rcx, [rsp + 0x30]
call fcn.140056d60
xorps xmm0, xmm0
movups xmmword [rdi], xmm0
mov qword [rdi + 0x10], rsi
mov qword [rdi + 0x18], rsi
movups xmm0, xmmword [rax]
movups xmmword [rdi], xmm0
movups xmm1, xmmword [rax + 0x10]
movups xmmword [rdi + 0x10], xmm1
mov qword [rax + 0x10], rsi
mov qword [rax + 0x18], 0xf
mov byte [rax], 0
mov rdx, qword [rsp + 0x48]
cmp rdx, 0xf
jbe 0x1400c7ab3
inc rdx
mov rcx, qword [rsp + 0x30]
mov rax, rcx
cmp rdx, 0x1000
jb 0x1400c7aae
add rdx, 0x27
mov rcx, qword [rcx - 8]
sub rax, rcx
add rax, 0xfffffffffffffff8
cmp rax, 0x1f
jbe 0x1400c7aae
call qword [0x140133ce8]
int3
call fcn.14012cdb4
mov rax, rdi
add rsp, 0x50
pop rdi
pop rsi
pop rbx
ret