joyce8/EMBER2024-capa huggingface dataset:
Function at 0x1400d79b0
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
push r15
sub rsp, 0x40
mov r10, qword [0x140423cc8]
mov r15, rcx
test r10, r10
jne 0x1400d7ab5
mov rax, qword gs:[0x60]
mov qword [rsp + 0x50], rbx
mov qword [rsp + 0x58], rsi
mov qword [rsp + 0x60], rdi
mov rax, qword [rax + 0x18]
mov qword [rsp + 0x68], r14
mov rax, qword [rax + 0x10]
nop
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1400d7a7a
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1400d7a7a
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x34506f52
lea rcx, [r14 + r11*4]
mov r8d, dword [rcx + rbx]
add r8, rbx
movzx r9d, byte [r8]
inc r8
test r9b, r9b
je 0x1400d7a75
movsx ecx, r9b
lea r8, [r8 + 1]
sub r9b, 0x41
mov edx, ecx
or edx, 0x20
cmp r9b, 0x19
movzx r9d, byte [r8 - 1]
cmova edx, ecx
xor edx, r10d
imul r10d, edx, 0x1000193
test r9b, r9b
jne 0x1400d7a40
cmp r10d, 0xcb8fbad4
je 0x1400d7a82
test r11d, r11d
jne 0x1400d7a20
mov rax, qword [rax]
jmp 0x1400d79f0
mov ecx, dword [rsi + 0x24]
mov r14, qword [rsp + 0x68]
add rcx, rbx
mov rdi, qword [rsp + 0x60]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x58]
add rcx, rbx
mov r10d, dword [rcx + rdx*4]
add r10, rbx
mov rbx, qword [rsp + 0x50]
mov qword [0x140423cc8], r10
cvttss2si edx, dword [r15 + 0x10]
mov rcx, qword [r15]
mov dword [rsp + 0x30], 8
cvttss2si eax, dword [r15 + 0x14]
cvttss2si r9d, dword [r15 + 0xc]
mov dword [rsp + 0x28], eax
mov dword [rsp + 0x20], edx
xor edx, edx
cvttss2si r8d, dword [r15 + 8]
call r10
test eax, eax
setne al
add rsp, 0x40
pop r15
ret
Function at 0x1401c5ff0
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 0x20], rbx
push rbp
push rsi
push rdi
push r14
push r15
sub rsp, 0x30
mov rax, qword [0x1403e9140]
xor rax, rsp
mov qword [rsp + 0x28], rax
mov rbp, rdx
mov r15, rcx
mov qword [rsp + 0x20], rdx
cmp qword [rdx + 0x10], 0
jne 0x1401c6028
xor eax, eax
jmp 0x1401c611f
add rcx, 0x7f8
movss xmm2, dword [r8 + 0xc]
movss xmm1, dword [r8 + 8]
movss xmm0, dword [r8 + 4]
mov eax, dword [r8]
mov dword [rcx], eax
movss dword [rcx + 4], xmm0
movss dword [rcx + 8], xmm1
movss dword [rcx + 0xc], xmm2
call fcn.1400bd800
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop dword [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1401c60f9
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1401c60f9
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
lea rcx, [r14 + r11*4]
mov r8d, dword [rcx + rbx]
add r8, rbx
mov r10d, 0x173196ea
movzx r9d, byte [r8]
inc r8
test r9b, r9b
je 0x1401c60f4
movsx ecx, r9b
sub r9b, 0x41
mov edx, ecx
or edx, 0x20
cmp r9b, 0x19
cmova edx, ecx
xor edx, r10d
imul r10d, edx, 0x1000193
movzx r9d, byte [r8]
lea r8, [r8 + 1]
test r9b, r9b
jne 0x1401c60c0
cmp r10d, 0x52d8f5a4
je 0x1401c6101
test r11d, r11d
jne 0x1401c60a0
mov rax, qword [rax]
jmp 0x1401c6070
mov edx, dword [rsi + 0x1c]
add rdx, rbx
mov eax, dword [rsi + 0x24]
add rax, rbx
movzx eax, word [rax + r11*2]
mov edx, dword [rdx + rax*4]
add rdx, rbx
call rdx
add eax, 0x1c84
mov dword [r15 + 0xd0c], eax
mov byte [r15 + 0xd10], 1
mov rcx, rbp
call fcn.140091b10
mov rcx, qword [rsp + 0x28]
xor rcx, rsp
call fcn.140362750
mov rbx, qword [rsp + 0x78]
add rsp, 0x30
pop r15
pop r14
pop rdi
pop rsi
pop rbp
ret
Function at 0x1401e9270
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

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 rbp, rcx
mov r15, qword [rcx + 0x18]
test r15, r15
je 0x1401e9360
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop dword [rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1401e933c
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1401e933c
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
mov r10d, 0x5612dd99
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1401e9337
nop
movsx edx, r9b
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
movzx r9d, byte [rcx]
lea rcx, [rcx + 1]
test r9b, r9b
jne 0x1401e9300
cmp r10d, 0xdbf93a19
je 0x1401e9344
test r11d, r11d
jne 0x1401e92e0
mov rax, qword [rax]
jmp 0x1401e92b0
mov edx, dword [rsi + 0x1c]
add rdx, rbx
mov eax, dword [rsi + 0x24]
add rax, rbx
movzx eax, word [rax + r11*2]
mov edx, dword [rdx + rax*4]
add rdx, rbx
mov rcx, r15
call rdx
lea rcx, [rbp + 0x50]
call fcn.140092d70
nop
mov edx, 0x78
mov rcx, rbp
call fcn.140362770
mov rax, rbp
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 0x1402b3180
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 0x1402b31e1
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 0x1402b31a0
mov ecx, dword [r9]
jmp 0x1402b32cb
cmp ecx, 0x4e0
jb 0x1402b32cb
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 0x1402b3200
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 0x1402b3250
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 0x1402b7370
Capabilities:
Encode data using xor
Hash data with crc32

Disassembly:
lea r11, [0x1403c5b00]
mov r9, rdx
not ecx
cmp r8, 4
jb 0x1402b73e9
mov r10, r8
shr r10, 2
imul rax, r10, 0xfffffffffffffffc
add r8, rax
movzx edx, byte [r9]
mov eax, ecx
xor rdx, rax
shr ecx, 8
movzx eax, dl
movzx edx, byte [r9 + 1]
xor ecx, dword [r11 + rax*4]
mov eax, ecx
shr ecx, 8
xor rdx, rax
movzx eax, dl
movzx edx, byte [r9 + 2]
xor ecx, dword [r11 + rax*4]
mov eax, ecx
shr ecx, 8
xor rdx, rax
movzx eax, dl
movzx edx, byte [r9 + 3]
add r9, 4
xor ecx, dword [r11 + rax*4]
mov eax, ecx
shr ecx, 8
xor rdx, rax
movzx eax, dl
xor ecx, dword [r11 + rax*4]
sub r10, 1
jne 0x1402b7390
test r8, r8
je 0x1402b740d
nop
movzx edx, byte [r9]
lea r9, [r9 + 1]
mov eax, ecx
shr ecx, 8
xor rdx, rax
movzx eax, dl
xor ecx, dword [r11 + rax*4]
sub r8, 1
jne 0x1402b73f0
not ecx
mov eax, ecx
ret
Function at 0x1402babe0
Capabilities:
Write file on windows

Disassembly:
mov rax, r9
mov r10, r8
mov r9, rcx
mov r8, rax
mov rcx, r10
mov edx, 1
jmp fcn.14036ad7c
Function at 0x1402fb360
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fb41d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fb41d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x62d3dd2d
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fb418
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fb3e0
cmp r10d, 0x6017547f
je 0x1402fb425
test r11d, r11d
jne 0x1402fb3c0
mov rax, qword [rax]
jmp 0x1402fb390
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret

Function at 0x1402fb460
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fb51d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fb51d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0xfffb3d
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fb518
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fb4e0
cmp r10d, 0x65bc8471
je 0x1402fb525
test r11d, r11d
jne 0x1402fb4c0
mov rax, qword [rax]
jmp 0x1402fb490
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret
Function at 0x1402fb560
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fb61d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fb61d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x845e8e93
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fb618
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fb5e0
cmp r10d, 0x331152a7
je 0x1402fb625
test r11d, r11d
jne 0x1402fb5c0
mov rax, qword [rax]
jmp 0x1402fb590
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret

Function at 0x1402fb660
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fb71d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fb71d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x5098c3c2
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fb718
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fb6e0
cmp r10d, 0x6242e7c8
je 0x1402fb725
test r11d, r11d
jne 0x1402fb6c0
mov rax, qword [rax]
jmp 0x1402fb690
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret
Function at 0x1402fba90
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fbb4d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fbb4d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x88ec5066
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fbb48
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fbb10
cmp r10d, 0xfd0495e0
je 0x1402fbb55
test r11d, r11d
jne 0x1402fbaf0
mov rax, qword [rax]
jmp 0x1402fbac0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret

Function at 0x1402fbb90
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fbc4d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fbc4d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x37fea6c2
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fbc48
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fbc10
cmp r10d, 0xb5c29469
je 0x1402fbc55
test r11d, r11d
jne 0x1402fbbf0
mov rax, qword [rax]
jmp 0x1402fbbc0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret
Function at 0x1402fbc90
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fbd4d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fbd4d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x38fea855
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fbd48
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fbd10
cmp r10d, 0xc3a3345b
je 0x1402fbd55
test r11d, r11d
jne 0x1402fbcf0
mov rax, qword [rax]
jmp 0x1402fbcc0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret

Function at 0x1402fbd90
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fbe4d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fbe4d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0xb9c675f0
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fbe48
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fbe10
cmp r10d, 0x62edb24f
je 0x1402fbe55
test r11d, r11d
jne 0x1402fbdf0
mov rax, qword [rax]
jmp 0x1402fbdc0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret
Function at 0x1402fbe90
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fbf4d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fbf4d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0xbac67783
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fbf48
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fbf10
cmp r10d, 0xf93fb07c
je 0x1402fbf55
test r11d, r11d
jne 0x1402fbef0
mov rax, qword [rax]
jmp 0x1402fbec0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret

Function at 0x1402fbf90
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fc04d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fc04d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0xac50e4ff
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fc048
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fc010
cmp r10d, 0x980ad9e9
je 0x1402fc055
test r11d, r11d
jne 0x1402fbff0
mov rax, qword [rax]
jmp 0x1402fbfc0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret
Function at 0x1402fc090
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fc14d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fc14d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x76718134
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fc148
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fc110
cmp r10d, 0xa8c82ba6
je 0x1402fc155
test r11d, r11d
jne 0x1402fc0f0
mov rax, qword [rax]
jmp 0x1402fc0c0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret

Function at 0x1402fc190
Capabilities:
Access peb ldr_data
Encode data using xor
Hash data using fnv
Resolve function by parsing pe exports

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x10], rsi
mov qword [rsp + 0x18], rdi
mov qword [rsp + 0x20], r14
mov rax, qword gs:[0x60]
mov rax, qword [rax + 0x18]
mov rax, qword [rax + 0x10]
nop word [rax + rax]
mov rbx, qword [rax + 0x30]
movsxd rcx, dword [rbx + 0x3c]
mov esi, dword [rcx + rbx + 0x88]
add rsi, rbx
cmp rsi, rbx
je 0x1402fc24d
mov r11d, dword [rsi + 0x18]
test r11d, r11d
je 0x1402fc24d
mov r14d, dword [rsi + 0x20]
nop dword [rax]
nop dword [rax + rax]
dec r11d
mov r10d, 0x6a6072a1
lea rcx, [r14 + r11*4]
mov ecx, dword [rcx + rbx]
add rcx, rbx
movzx r9d, byte [rcx]
inc rcx
test r9b, r9b
je 0x1402fc248
nop
movsx edx, r9b
lea rcx, [rcx + 1]
sub r9b, 0x41
mov r8d, edx
or r8d, 0x20
cmp r9b, 0x19
movzx r9d, byte [rcx - 1]
cmova r8d, edx
xor r8d, r10d
imul r10d, r8d, 0x1000193
test r9b, r9b
jne 0x1402fc210
cmp r10d, 0xb6eb8541
je 0x1402fc255
test r11d, r11d
jne 0x1402fc1f0
mov rax, qword [rax]
jmp 0x1402fc1c0
mov ecx, dword [rsi + 0x24]
mov rdi, qword [rsp + 0x18]
add rcx, rbx
mov r14, qword [rsp + 0x20]
movzx edx, word [rcx + r11*2]
mov ecx, dword [rsi + 0x1c]
mov rsi, qword [rsp + 0x10]
add rcx, rbx
mov eax, dword [rcx + rdx*4]
add rax, rbx
mov rbx, qword [rsp + 8]
ret