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

Disassembly:
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x48
movaps xmmword [rsp + 0x30], xmm6
test r8, r8
je 0x1400b6226
mov rsi, rcx
test rcx, rcx
je 0x1400b6226
mov rbx, rdx
test rdx, rdx
je 0x1400b6226
mov r14d, r9d
test r9d, r9d
jle 0x1400b6226
mov rdi, r8
mov r8d, dword [rbx + 0x138]
mov rdx, qword [rbx + 0x130]
mov qword [rsp + 0x20], 0x20
mov rcx, rsi
mov r9d, r14d
call fcn.1401cf2b0
test rax, rax
je 0x1400b623c
mov r15, rax
mov rdx, qword [rbx + 0x130]
mov rcx, rsi
call fcn.1401cf120
mov qword [rbx + 0x130], r15
or byte [rbx + 0x12d], 2
movsxd rbp, dword [rbx + 0x138]
shl rbp, 5
add rbp, r15
lea r15, str.png_set_unknown_chunks_now_expects_a_valid_location
xorps xmm6, xmm6
lea r12, str.unknown_chunk:_out_of_memory
jmp 0x1400b6173
movups xmmword [rbp + 8], xmm6
add rbp, 0x20
inc dword [rbx + 0x138]
lea eax, [r14 - 1]
add rdi, 0x20
cmp r14d, 1
mov r14d, eax
jle 0x1400b6226
movzx eax, byte [rdi + 4]
mov byte [rbp + 4], al
mov eax, dword [rdi]
mov dword [rbp], eax
mov byte [rbp + 4], 0
movzx eax, byte [rdi + 0x18]
and eax, 0xb
jne 0x1400b61c0
test byte [rsi + 0x165], 0x80
jne 0x1400b6266
mov rcx, rsi
mov rdx, r15
call fcn.1400b4b20
mov eax, dword [rsi + 0x164]
and eax, 0xb
je 0x1400b6266
nop word cs:[rax + rax]
mov ecx, eax
mov edx, eax
neg edx
and edx, eax
mov eax, edx
xor eax, ecx
cmp ecx, edx
jne 0x1400b61c0
mov byte [rbp + 0x18], cl
mov rdx, qword [rdi + 0x10]
test rdx, rdx
je 0x1400b6150
mov rcx, rsi
call fcn.1401cf220
mov qword [rbp + 8], rax
test rax, rax
je 0x1400b6210
mov rdx, qword [rdi + 8]
mov r13, qword [rdi + 0x10]
mov rcx, rax
mov r8, r13
call fcn.140562340
mov qword [rbp + 0x10], r13
jmp 0x1400b6154
mov rcx, rsi
mov rdx, r12
mov r8d, 1
call fcn.1400b4dd0
jmp 0x1400b615e
movaps xmm6, xmmword [rsp + 0x30]
add rsp, 0x48
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
ret
lea rdx, str.too_many_unknown_chunks
mov rcx, rsi
mov r8d, 1
movaps xmm6, xmmword [rsp + 0x30]
add rsp, 0x48
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
jmp fcn.1400b4dd0
lea rdx, str.invalid_location_in_png_set_unknown_chunks
mov rcx, rsi
call fcn.1400b41d0
int3
Function at 0x14013be20
Capabilities:
Resolve function by parsing pe exports

Disassembly:
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x28
mov rbx, r9
mov rdi, rdx
mov rsi, rcx
mov r14, qword [rsp + 0xb8]
movzx ebp, byte [rsp + 0xa0]
mov r15d, dword [rsp + 0xb0]
movzx r12d, byte [rsp + 0x98]
mov r13d, dword [rsp + 0x90]
mov eax, dword [rsp + 0xa8]
mov dword [rcx + 8], 1
lea rcx, method.icu::StringEnumeration.virtual_0
mov qword [rsi], rcx
mov qword [rsi + 0x10], 0
mov dword [rsi + 0x18], eax
lea rcx, [rsi + 0x1c]
mov rdx, r8
call fcn.1401b0470
mov qword [rsi + 0x34], rbx
mov dword [rsi + 0x3c], r13d
mov byte [rsi + 0x40], r12b
mov dword [rsi + 0x44], r15d
call fcn.1401a63e0
mov dword [rsi + 0x48], eax
mov qword [rsi + 0x88], 0
mov rax, qword [rdi + 0x38]
test rax, rax
je 0x14013befc
cmp rax, rdi
je 0x14013becb
mov qword [rsi + 0x88], rax
jmp 0x14013bef4
lea rdx, [rsi + 0x50]
mov rax, qword [rdi]
mov rcx, rdi
call qword [rax + 8]
mov qword [rsi + 0x88], rax
mov rcx, qword [rdi + 0x38]
test rcx, rcx
je 0x14013befc
cmp rcx, rdi
setne dl
mov rax, qword [rcx]
call qword [rax + 0x20]
mov qword [rdi + 0x38], 0
mov word [rsi + 0x90], 0
mov byte [rsi + 0x92], 0
mov byte [rsi + 0x93], bpl
mov dword [rsi + 0x94], 0
lea rcx, [rsi + 0x98]
mov qword [rsi + 0x98], 0
mov qword [rsi + 0xa8], 0
mov qword [rsi + 0xb0], 0xf
mov byte [rsi + 0x98], 0
mov r9, qword [r14]
mov rdi, qword [r14 + 8]
cmp rdi, 0xf
jbe 0x14013bf63
mov rdx, rdi
call fcn.1400a7100
jmp 0x14013bf7d
mov qword [rsi + 0xa8], rdi
mov rdx, r9
mov r8, rdi
call fcn.140562340
mov byte [rsi + rdi + 0x98], 0
mov qword [rsi + 0xb8], 0xffffffffffffffff
mov rax, rsi
add rsp, 0x28
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
ret
Function at 0x140146fd0
Capabilities:
Hash data using murmur3

Disassembly:
push r15
push r14
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x28
mov rbx, r8
mov rsi, rdx
mov rdi, rcx
mov al, 1
xchg byte [rcx], al
test al, 1
je 0x140146ff5
mov rcx, rdi
call fcn.140258470
mov eax, dword [rbx]
mov ecx, eax
shr ecx, 0x10
xor ecx, eax
imul ecx, ecx, 0x85ebca6b
mov edx, ecx
shr edx, 0xd
xor edx, ecx
imul ecx, edx, 0xc2b2ae35
mov edx, ecx
shr edx, 0x10
xor edx, ecx
mov ecx, 1
cmovne ecx, edx
mov edx, dword [rdi + 0x1c]
test edx, edx
jle 0x140147127
lea r8d, [rdx - 1]
and r8d, ecx
mov r9, qword [rdi + 0x20]
xor r10d, r10d
mov r11d, edx
jmp 0x140147059
test r8d, r8d
mov r14d, edx
cmovg r14d, r10d
add r8d, r14d
dec r8d
dec r11d
je 0x140147127
movsxd r14, r8d
lea r14, [r14 + r14*2]
shl r14, 4
mov ebp, dword [r9 + r14]
test ebp, ebp
je 0x140147127
cmp ecx, ebp
jne 0x140147040
cmp eax, dword [r9 + r14 + 8]
jne 0x140147040
add r14, r9
add r14, 8
cmp dword [r14 + 0x20], 0
jle 0x140147127
xor r15d, r15d
mov rax, qword [r14 + 0x18]
mov rcx, qword [rax + r15*8]
add rcx, 0x40
mov rdx, rbx
call fcn.14025b590
test al, al
jne 0x1401470b6
inc r15
movsxd rax, dword [r14 + 0x20]
cmp r15, rax
jl 0x140147090
jmp 0x140147127
test r15d, r15d
js 0x140147127
mov rax, qword [r14 + 0x18]
mov rax, qword [rax + r15*8]
test rax, rax
je 0x140147127
lock inc dword [rax + 8]
mov qword [rsi], rax
cmp rax, qword [rdi + 8]
je 0x14014712e
lea rcx, [rdi + 8]
mov rdx, qword [rax + 0x10]
mov r8, qword [rax + 0x18]
lea r9, [rdx + 0x18]
test rdx, rdx
cmove r9, rcx
mov qword [r9], r8
test r8, r8
cmove r8, rdi
mov qword [r8 + 0x10], rdx
xorps xmm0, xmm0
movups xmmword [rax + 0x10], xmm0
mov rcx, qword [rdi + 8]
mov qword [rax + 0x18], rcx
mov rcx, qword [rdi + 8]
test rcx, rcx
je 0x140147116
mov qword [rcx + 0x10], rax
mov qword [rdi + 8], rax
cmp qword [rdi + 0x10], 0
jne 0x14014712e
mov qword [rdi + 0x10], rax
jmp 0x14014712e
mov qword [rsi], 0
mov byte [rdi], 0
mov rax, rsi
add rsp, 0x28
pop rbx
pop rbp
pop rdi
pop rsi
pop r14
pop r15
ret
Function at 0x1401474e0
Capabilities:
Hash data using murmur3

Disassembly:
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x38
mov r14, rdx
mov r15, rcx
mov rax, qword [0x1406a7e00]
xor rax, rsp
mov qword [rsp + 0x30], rax
mov eax, dword [rdx + 0x40]
mov dword [rsp + 0x2c], eax
mov ecx, eax
shr ecx, 0x10
xor ecx, eax
imul ecx, ecx, 0x85ebca6b
mov edx, ecx
shr edx, 0xd
xor edx, ecx
imul ecx, edx, 0xc2b2ae35
mov edx, ecx
shr edx, 0x10
xor edx, ecx
mov ecx, 1
cmovne ecx, edx
mov edx, dword [r15 + 0x1c]
test edx, edx
jle 0x1401476e1
lea rbx, [r14 + 0x40]
lea rsi, [r15 + 0x18]
lea r8d, [rdx - 1]
and r8d, ecx
mov r9, qword [r15 + 0x20]
xor r10d, r10d
mov r11d, edx
jmp 0x140147578
test r8d, r8d
mov edi, edx
cmovg edi, r10d
add r8d, edi
dec r8d
dec r11d
je 0x1401476e1
movsxd rdi, r8d
lea rdi, [rdi + rdi*2]
shl rdi, 4
mov ebp, dword [r9 + rdi]
test ebp, ebp
je 0x1401476e1
cmp ecx, ebp
jne 0x140147560
cmp eax, dword [r9 + rdi + 8]
jne 0x140147560
lea r12, [r9 + rdi]
add r12, 8
cmp dword [r12 + 0x20], 0
jle 0x1401475f1
xor edi, edi
xor r13d, r13d
nop
mov rax, qword [r12 + 0x18]
mov rcx, qword [rax + r13*8]
add rcx, 0x40
mov rdx, rbx
call fcn.14025b590
test al, al
jne 0x1401475d8
inc r13
movsxd rax, dword [r12 + 0x20]
cmp r13, rax
jl 0x1401475b0
jmp 0x1401475f3
test r13d, r13d
js 0x1401475f1
mov rax, qword [r12 + 0x18]
mov rdi, qword [rax + r13*8]
test rdi, rdi
je 0x1401475f1
lock inc dword [rdi + 8]
jmp 0x1401475f3
xor edi, edi
cmp rdi, r14
jne 0x1401476cd
movsxd rax, dword [r14 + 0x38]
sub qword [r15 + 0x30], rax
lea rax, [r15 + 8]
mov rcx, qword [r14 + 0x10]
mov rdx, qword [r14 + 0x18]
lea r8, [rcx + 0x18]
test rcx, rcx
cmove r8, rax
mov qword [r8], rdx
test rdx, rdx
cmove rdx, r15
mov qword [rdx + 0x10], rcx
xorps xmm0, xmm0
movups xmmword [r14 + 0x10], xmm0
mov r14d, dword [r12 + 0x20]
mov ebp, 0xffffffff
test r14d, r14d
jle 0x14014767e
xor r15d, r15d
nop word cs:[rax + rax]
mov rax, qword [r12 + 0x18]
mov rcx, qword [rax + r15*8]
add rcx, 0x40
mov rdx, rbx
call fcn.14025b590
mov r14d, dword [r12 + 0x20]
test al, al
jne 0x14014767b
movsxd rax, r14d
inc r15
cmp r15, rax
jl 0x140147650
jmp 0x14014767e
mov ebp, r15d
dec r14d
mov dword [r12 + 0x20], r14d
mov rax, qword [r12 + 0x18]
movsxd rbx, ebp
mov rcx, qword [rax + rbx*8]
test rcx, rcx
je 0x1401476a3
lock dec dword [rcx + 8]
jne 0x1401476a3
mov rax, qword [rcx]
call qword [rax + 8]
cmp r14d, ebp
je 0x1401476b8
mov rax, qword [r12 + 0x18]
movsxd rcx, r14d
mov rcx, qword [rax + rcx*8]
mov qword [rax + rbx*8], rcx
cmp dword [r12 + 0x20], 0
jne 0x1401476cd
lea rdx, [rsp + 0x2c]
mov rcx, rsi
call fcn.140147ab0
test rdi, rdi
je 0x1401476e1
lock dec dword [rdi + 8]
jne 0x1401476e1
mov rax, qword [rdi]
mov rcx, rdi
call qword [rax + 8]
mov rcx, qword [rsp + 0x30]
xor rcx, rsp
call fcn.1405602f0
nop
add rsp, 0x38
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
ret
Function at 0x1401478b0
Capabilities:
Hash data using murmur3

Disassembly:
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x58
movaps xmmword [rsp + 0x40], xmm6
mov rsi, rcx
mov rax, qword [0x1406a7e00]
xor rax, rsp
mov qword [rsp + 0x38], rax
mov qword [rsp + 0x28], 0
lea rbx, [rcx + 0x40]
movabs rax, 0x100000000
mov qword [rsp + 0x30], rax
lea rdi, [rcx + 0x50]
mov eax, 0xffffffff
lock xadd dword [rcx + 0x50], eax
test eax, eax
jg 0x14014790d
mov rcx, rdi
call fcn.140025d00
lea rdx, [rsp + 0x28]
mov rcx, rbx
call fcn.14002a780
mov edx, 1
mov eax, 1
lock xadd dword [rdi], eax
test eax, eax
jns 0x14014793b
neg eax
test eax, eax
cmovle edx, eax
mov rcx, rdi
call fcn.140025c70
movsxd rax, dword [rsp + 0x30]
test rax, rax
je 0x140147a74
mov rdi, qword [rsp + 0x28]
lea r14, [rdi + rax*8]
lea rbx, [rsi + 0x18]
lea r15, [rsi + 8]
mov ebp, 1
xor r12d, r12d
xorps xmm6, xmm6
jmp 0x14014798d
mov rcx, rbx
mov rdx, rdi
call fcn.140147ab0
nop word cs:[rax + rax]
add rdi, 8
cmp rdi, r14
je 0x140147a74
mov eax, dword [rdi]
mov ecx, eax
shr ecx, 0x10
xor ecx, eax
imul ecx, ecx, 0x85ebca6b
mov edx, ecx
shr edx, 0xd
xor edx, ecx
imul edx, edx, 0xc2b2ae35
mov ecx, edx
shr ecx, 0x10
xor ecx, edx
cmove ecx, ebp
mov edx, dword [rsi + 0x1c]
test edx, edx
jle 0x140147980
lea r8d, [rdx - 1]
and r8d, ecx
mov r9, qword [rsi + 0x20]
mov r10d, edx
jmp 0x1401479e5
test r8d, r8d
mov r11d, edx
cmovg r11d, r12d
add r8d, r11d
dec r8d
dec r10d
je 0x140147980
movsxd r11, r8d
lea r11, [r11 + r11*2]
shl r11, 4
mov r13d, dword [r9 + r11]
test r13d, r13d
je 0x140147980
cmp ecx, r13d
jne 0x1401479d0
cmp eax, dword [r9 + r11 + 8]
jne 0x1401479d0
lea rcx, [r9 + r11]
add rcx, 8
movsxd rax, dword [rcx + 0x20]
test rax, rax
je 0x140147967
mov rcx, qword [rcx + 0x18]
shl rax, 3
xor edx, edx
nop word cs:[rax + rax]
mov r8, qword [rcx + rdx]
movsxd r8, dword [r8 + 0x38]
sub qword [rsi + 0x30], r8
mov r8, qword [rcx + rdx]
mov r9, qword [r8 + 0x10]
mov r10, qword [r8 + 0x18]
lea r11, [r9 + 0x18]
test r9, r9
cmove r11, r15
mov qword [r11], r10
test r10, r10
cmove r10, rsi
mov qword [r10 + 0x10], r9
movups xmmword [r8 + 0x10], xmm6
add rdx, 8
cmp rax, rdx
jne 0x140147a30
jmp 0x140147967
test byte [rsp + 0x34], 1
je 0x140147a85
mov rcx, qword [rsp + 0x28]
call fcn.14000b650
mov rcx, qword [rsp + 0x38]
xor rcx, rsp
call fcn.1405602f0
movaps xmm6, xmmword [rsp + 0x40]
add rsp, 0x58
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
ret
Function at 0x140147ab0
Capabilities:
Hash data using murmur3

Disassembly:
push rsi
push rdi
sub rsp, 0x28
mov rsi, rcx
mov eax, dword [rdx]
mov ecx, eax
shr ecx, 0x10
xor ecx, eax
imul ecx, ecx, 0x85ebca6b
mov edx, ecx
shr edx, 0xd
xor edx, ecx
imul ecx, edx, 0xc2b2ae35
mov edx, ecx
shr edx, 0x10
xor edx, ecx
mov ecx, 1
cmovne ecx, edx
mov r8d, dword [rsi + 4]
test r8d, r8d
jle 0x140147b53
lea edx, [r8 - 1]
and edx, ecx
mov r9, qword [rsi + 8]
xor r10d, r10d
mov r11d, r8d
jmp 0x140147b12
test edx, edx
mov edi, r8d
cmovg edi, r10d
add edx, edi
dec edx
dec r11d
je 0x140147b53
movsxd rdi, edx
lea rdi, [rdi + rdi*2]
shl rdi, 4
cmp ecx, dword [r9 + rdi]
jne 0x140147b00
cmp eax, dword [r9 + rdi + 8]
jne 0x140147b00
mov rcx, rsi
call fcn.140147b60
mov eax, dword [rsi]
mov edx, dword [rsi + 4]
shl eax, 2
cmp eax, edx
jg 0x140147b53
cmp edx, 5
jl 0x140147b53
shr edx, 1
mov rcx, rsi
add rsp, 0x28
pop rdi
pop rsi
jmp fcn.140147cb0
nop
add rsp, 0x28
pop rdi
pop rsi
ret

Function at 0x140147fc0
Capabilities:
Hash data using murmur3

Disassembly:
push r15
push r14
push r13
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x28
mov rsi, rdx
mov eax, dword [rdx]
mov edx, eax
shr edx, 0x10
xor edx, eax
imul edx, edx, 0x85ebca6b
mov r8d, edx
shr r8d, 0xd
xor r8d, edx
imul edx, r8d, 0xc2b2ae35
mov r8d, edx
shr r8d, 0x10
xor r8d, edx
mov ebp, 1
cmovne ebp, r8d
mov rbx, rcx
mov ecx, dword [rcx + 4]
xor edi, edi
test ecx, ecx
jle 0x140148148
lea edx, [rcx - 1]
and edx, ebp
mov r14, qword [rbx + 8]
mov r8d, ecx
jmp 0x140148047
test edx, edx
mov r9d, ecx
cmovg r9d, edi
add edx, r9d
dec edx
dec r8d
je 0x140148148
movsxd r9, edx
lea r12, [r9 + r9*2]
shl r12, 4
lea r15, [r14 + r12]
mov r9d, dword [r14 + r12]
test r9d, r9d
je 0x1401480af
cmp ebp, r9d
jne 0x140148030
cmp eax, dword [r14 + r12 + 8]
jne 0x140148030
lea rbx, [r14 + r12]
add rbx, 0x20
movsxd rax, dword [r14 + r12 + 0x28]
test rax, rax
je 0x1401480f5
mov rdi, qword [rbx]
lea r13, [rdi + rax*8]
jmp 0x140148099
add rdi, 8
cmp rdi, r13
jae 0x1401480f5
mov rcx, qword [rdi]
test rcx, rcx
je 0x140148090
lock dec dword [rcx + 8]
jne 0x140148090
mov rax, qword [rcx]
call qword [rax + 8]
jmp 0x140148090
lea rdi, [r14 + r12]
add rdi, 8
mov dword [r14 + r12 + 8], eax
mov eax, dword [rsi + 8]
mov dword [r14 + r12 + 0x10], eax
lea rax, [r14 + r12 + 0x18]
lea rcx, [r14 + r12 + 0x20]
mov qword [r14 + r12 + 0x20], rax
movabs rax, 0x200000000
mov qword [r14 + r12 + 0x28], rax
add rsi, 0x18
mov rdx, rsi
call fcn.140147ee0
mov dword [r15], ebp
inc dword [rbx]
jmp 0x140148148
lea rdi, [r14 + r12]
add rdi, 8
test byte [r14 + r12 + 0x2c], 1
je 0x14014810d
mov rcx, qword [rbx]
call fcn.14000b650
mov dword [r15], 0
mov eax, dword [rsi]
mov dword [rdi], eax
mov eax, dword [rsi + 8]
mov dword [r14 + r12 + 0x10], eax
lea rax, [r14 + r12 + 0x18]
mov qword [rbx], rax
mov dword [rdi + 0x24], 2
mov dword [rdi + 0x20], 0
add rsi, 0x18
mov rcx, rbx
mov rdx, rsi
call fcn.140147ee0
mov dword [r15], ebp
mov rax, rdi
add rsp, 0x28
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r13
pop r14
pop r15
ret
Function at 0x14017da60
Capabilities:
Resolve function by parsing pe exports

Disassembly:
push r15
push r14
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x88
mov rsi, rcx
mov rax, qword [0x1406a7e00]
xor rax, rsp
mov qword [rsp + 0x80], rax
cmp dword [rcx + 0x50], 0
jle 0x14017dc8c
mov ebp, r8d
test dl, dl
je 0x14017db7c
movzx eax, byte [rsi + 0x54]
movss xmm0, dword [rsi]
movss xmm1, dword [rsi + 4]
lea rcx, [rsi + 0x24]
lea r9, [rsi + 0x3c]
lea r8, [rsi + 0x2c]
lea rbx, [rsi + 0x68]
lea rdi, [rsi + 0x78]
mov byte [rsp + 0x40], bpl
mov byte [rsp + 0x38], al
movss dword [rsp + 0x30], xmm1
movss dword [rsp + 0x28], xmm0
mov qword [rsp + 0x20], rcx
mov rcx, rdi
mov rdx, rbx
call qword [rsi + 0x60]
mov rcx, rdi
call fcn.14008d370
cmp byte [rsi + 0x55], 0
je 0x14017dbfa
mov rcx, rbx
call fcn.14008be10
mov r14, rax
mov rcx, rdi
call fcn.14008be10
movsd xmm1, qword [rax]
movsd xmm0, qword [rax + 8]
ucomiss xmm0, xmm1
jbe 0x14017dc2e
movaps xmm2, xmm1
cmpnltps xmm2, xmm0
pextrw eax, xmm2, 2
test al, 1
jne 0x14017dc2e
movsd xmm3, qword [r14]
movsd xmm2, qword [r14 + 8]
movaps xmm4, xmm3
cmpltps xmm4, xmm2
unpcklps xmm4, xmm4
movmskpd eax, xmm4
test al, 1
je 0x14017dc2e
movlhps xmm2, xmm1
movlhps xmm0, xmm3
cmpleps xmm0, xmm2
pslld xmm0, 0x1f
movmskps ecx, xmm0
cmp cl, 0xf
jne 0x14017dc2e
shr al, 1
je 0x14017dc2e
mov rcx, rbx
mov rdx, rdi
call fcn.14008b190
jmp 0x14017dc2e
lea rbx, [rsi + 0x68]
lea r14, [rsp + 0x48]
mov rcx, rbx
mov rdx, r14
call fcn.14008c520
xor r15d, r15d
test bpl, bpl
mov eax, 0
cmovne rax, rbx
lea r8, [rsi + 0x1c]
lea rdx, [rsi + 0x3c]
lea rdi, [rsi + 0x78]
mov qword [rsp + 0x20], rax
mov rcx, rdi
mov r9, r14
call qword [rsi + 0x58]
mov rcx, rdi
mov rdx, rbx
call fcn.14008fa50
mov rax, qword [rsi + 0x58]
cmp byte [rsi + 0x54], 0
cmovne r15, rbx
lea r9, [rsi + 0x44]
movsd xmm0, qword [rsi + 0x14]
xorps xmm0, xmmword [0x140599730]
movlps qword [rsp + 0x50], xmm0
lea rdx, [rsi + 0x34]
mov qword [rsp + 0x20], r15
lea r8, [rsp + 0x50]
mov rcx, rdi
call rax
jmp 0x14017dc26
lea rdx, [rsp + 0x48]
mov rcx, rbx
call fcn.14008c520
movss xmm1, dword [rsp + 0x48]
movss xmm2, dword [rsp + 0x4c]
mov rcx, rdi
call fcn.14008c620
mov rcx, rdi
mov rdx, rbx
call fcn.14008fa50
mov rcx, rdi
call fcn.14008d370
lea rdi, [rsi + 0x88]
mov rcx, rdi
call fcn.14008bdb0
test al, al
jne 0x14017dc8c
lea rbx, [rsi + 0x78]
movss xmm0, dword [0x1406908dc]
movaps xmmword [rsp + 0x50], xmm0
movaps xmmword [rsp + 0x60], xmm0
movabs rax, 0x103f800000
mov qword [rsp + 0x70], rax
lea r14, [rsp + 0x50]
mov rcx, r14
call fcn.14001ffc0
mov rcx, rbx
mov rdx, rdi
mov r8, r14
xor r9d, r9d
call fcn.14008f410
mov rcx, rdi
call fcn.14008bd30
lea rcx, [rsi + 0x68]
call fcn.14008bd30
mov dword [rsi + 0x50], 0xffffffff
lea rcx, [rsi + 0x78]
call fcn.14008c460
mov dword [rsi + 0x4c], eax
mov rcx, qword [rsp + 0x80]
xor rcx, rsp
call fcn.1405602f0
nop
add rsp, 0x88
pop rbx
pop rbp
pop rdi
pop rsi
pop r14
pop r15
ret
Function at 0x1401b1940
Capabilities:
Hash data using murmur3

Disassembly:
push rsi
push rdi
push rbx
sub rsp, 0x20
mov esi, edx
mov rdi, rcx
mov eax, dword [rcx]
mov ecx, dword [rcx + 4]
shl eax, 2
lea edx, [rcx + rcx*2]
cmp eax, edx
jl 0x1401b1973
lea eax, [rcx + rcx]
test ecx, ecx
mov edx, 4
cmovg edx, eax
mov rcx, rdi
call fcn.1401b1a20
mov ecx, dword [rdi + 4]
mov eax, esi
shr eax, 0x10
xor eax, esi
imul eax, eax, 0x85ebca6b
mov edx, eax
shr edx, 0xd
xor edx, eax
imul eax, edx, 0xc2b2ae35
mov r8d, eax
shr r8d, 0x10
xor r8d, eax
mov edx, 1
cmovne edx, r8d
xor eax, eax
test ecx, ecx
jle 0x1401b1a11
lea r9d, [rcx - 1]
and r9d, edx
mov r8, qword [rdi + 8]
mov r10d, ecx
jmp 0x1401b19d5
test r9d, r9d
mov r11d, ecx
cmovg r11d, eax
add r9d, r11d
dec r9d
dec r10d
je 0x1401b1a11
movsxd r11, r9d
mov ebx, dword [r8 + r11*8]
test ebx, ebx
je 0x1401b19fe
cmp edx, ebx
jne 0x1401b19c0
cmp dword [r8 + r11*8 + 4], esi
jne 0x1401b19c0
lea rax, [r8 + r11*8]
add rax, 4
mov dword [r8 + r11*8 + 4], esi
mov dword [r8 + r11*8], edx
jmp 0x1401b1a11
lea rax, [r8 + r11*8]
add rax, 4
mov dword [r8 + r11*8 + 4], esi
mov dword [r8 + r11*8], edx
inc dword [rdi]
add rsp, 0x20
pop rbx
pop rdi
pop rsi
ret
Function at 0x1401b1a20
Capabilities:
Hash data using murmur3

Disassembly:
push r15
push r14
push r12
push rsi
push rdi
push rbp
push rbx
sub rsp, 0x20
mov rdi, rcx
mov ebx, dword [rcx + 4]
mov dword [rcx], 0
mov dword [rcx + 4], edx
mov rsi, qword [rcx + 8]
test edx, edx
je 0x1401b1a92
movsxd r15, edx
lea r14, [r15*8]
mov rcx, r14
add rcx, 8
mov rax, 0xffffffffffffffff
cmovb rcx, rax
test edx, edx
cmovs rcx, rax
call fcn.14056080c
mov qword [rax], r15
add rax, 8
xor ecx, ecx
nop word cs:[rax + rax]
mov dword [rax + rcx], 0
add rcx, 8
cmp r14, rcx
jne 0x1401b1a80
jmp 0x1401b1a94
xor eax, eax
mov qword [rdi + 8], rax
test ebx, ebx
jle 0x1401b1b6b
xor eax, eax
mov ecx, 1
xor edx, edx
jmp 0x1401b1acc
mov dword [r11 + r15*8 + 4], r8d
mov dword [r11 + r15*8], r9d
inc dword [rdi]
nop word cs:[rax + rax]
inc rdx
cmp rdx, rbx
je 0x1401b1b6b
cmp dword [rsi + rdx*8], 0
je 0x1401b1ac0
mov r8d, dword [rsi + rdx*8 + 4]
mov r9d, r8d
shr r9d, 0x10
xor r9d, r8d
imul r9d, r9d, 0x85ebca6b
mov r10d, r9d
shr r10d, 0xd
xor r10d, r9d
imul r10d, r10d, 0xc2b2ae35
mov r9d, r10d
shr r9d, 0x10
xor r9d, r10d
cmove r9d, ecx
mov r10d, dword [rdi + 4]
test r10d, r10d
jle 0x1401b1ac0
lea r14d, [r10 - 1]
and r14d, r9d
mov r11, qword [rdi + 8]
mov ebp, r10d
jmp 0x1401b1b34
test r14d, r14d
mov r15d, r10d
cmovg r15d, eax
add r14d, r15d
dec r14d
dec ebp
je 0x1401b1ac0
movsxd r15, r14d
mov r12d, dword [r11 + r15*8]
test r12d, r12d
je 0x1401b1aab
cmp r9d, r12d
jne 0x1401b1b20
cmp r8d, dword [r11 + r15*8 + 4]
jne 0x1401b1b20
mov dword [r11 + r15*8], 0
mov r8d, dword [rsi + rdx*8 + 4]
mov dword [r11 + r15*8 + 4], r8d
mov dword [r11 + r15*8], r9d
jmp 0x1401b1ac0
test rsi, rsi
je 0x1401b1bbb
mov rax, qword [rsi - 8]
add rsi, 0xfffffffffffffff8
test rax, rax
je 0x1401b1ba5
shl rax, 3
jmp 0x1401b1b96
add rax, 0xfffffffffffffff8
je 0x1401b1ba5
cmp dword [rsi + rax], 0
je 0x1401b1b90
mov dword [rsi + rax], 0
jmp 0x1401b1b90
mov rcx, rsi
add rsp, 0x20
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r14
pop r15
jmp fcn.140560310
nop
add rsp, 0x20
pop rbx
pop rbp
pop rdi
pop rsi
pop r12
pop r14
pop r15
ret
Function at 0x1401bd000
Capabilities:
Inspect section memory permissions

Disassembly:
push rsi
push rdi
push rbx
sub rsp, 0x20
mov rsi, rcx
movzx eax, byte [rcx + 0x14]
shl eax, 4
movzx ecx, byte [rcx + 0x15]
shl ecx, 2
or ecx, eax
movzx r8d, byte [rsi + 0x16]
or r8d, ecx
movss xmm0, dword [rsi + 8]
movss xmm1, dword [rsi + 0xc]
cvttss2si ecx, xmm0
cvttps2dq xmm2, xmm0
cvtdq2ps xmm2, xmm2
mov eax, ecx
shl eax, 0x10
or eax, r8d
or eax, 0x80000000
ucomiss xmm2, xmm0
cmovne eax, r8d
cmovp eax, r8d
cmp ecx, 0x100
cmovae eax, r8d
mov ecx, eax
or ecx, 0x40000000
ucomiss xmm1, dword [0x1406908dc]
cmovne eax, ecx
cmovp eax, ecx
mov ecx, eax
or ecx, 0x20000000
xorps xmm0, xmm0
ucomiss xmm0, dword [rsi + 0x10]
cmovne eax, ecx
cmovp eax, ecx
mov ebx, eax
or ebx, 0x10000000
cmp qword [rsi], 0
mov rdi, rdx
cmove ebx, eax
mov rax, qword [rdx]
mov rcx, rdx
mov edx, ebx
call qword [rax + 0x30]
test ebx, ebx
js 0x1401bd0b2
movss xmm1, dword [rsi + 8]
mov rax, qword [rdi]
mov rcx, rdi
call qword [rax + 0x20]
test ebx, 0x40000000
jne 0x1401bd0d2
test ebx, 0x20000000
jne 0x1401bd0e8
test ebx, 0x10000000
jne 0x1401bd0fe
add rsp, 0x20
pop rbx
pop rdi
pop rsi
ret
movss xmm1, dword [rsi + 0xc]
mov rax, qword [rdi]
mov rcx, rdi
call qword [rax + 0x20]
test ebx, 0x20000000
je 0x1401bd0c2
movss xmm1, dword [rsi + 0x10]
mov rax, qword [rdi]
mov rcx, rdi
call qword [rax + 0x20]
test ebx, 0x10000000
je 0x1401bd0ca
mov rdx, qword [rsi]
mov rax, qword [rdi]
mov rax, qword [rax + 0xd8]
mov rcx, rdi
add rsp, 0x20
pop rbx
pop rdi
pop rsi
jmp rax