joyce8/EMBER2024-capa huggingface dataset:
Function at 0xb5db4b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
call fcn.0167d5a9
mov rdx, r9
jmp 0x168d33b
mov qword [r9], rbx
push 0xfffffffff3a10d88
jmp 0xb584c1
push 0xffffffffee046c30
push 0xffffffffe935310f
sub r9, 2
not word [rsp + 9]
mov word [r9], dx
lea rsp, [rsp + 0x10]
jmp fcn.0166c840

Function at 0xb5e0a9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
jmp 0xb68adc
push 0x3e2992bd
mov dword [r9], esi
push 0x2336fa1e
lea rsp, [rsp + 0x18]
jmp fcn.01685cbe

Function at 0xb5e31a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x4214cf95
lea rsp, [rsp + 0x20]
jmp fcn.0166c840

Function at 0xb5f2e8
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 8]
jmp 0x168eed8

Function at 0xb5f35c
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [r9], dx
push 0xffffffffb3a2f799
push 0xffffffffc51a8616
lea rsp, [rsp + 0x38]
jmp fcn.0166c840

Function at 0xb614a6
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x28]
jmp fcn.01685cbe

Function at 0xb62a81
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 8]
jmp 0x168eed8
jmp 0xb5e78f

Function at 0xb63d5a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
jmp 0xb59741
cmpsd dword [rsi], dword [rdi]
mov ah, 0xb
pop qword [rdx]
mov r9d, dword [r9]
jmp 0xb600db
lea rsp, [rsp + 0x28]
jne fcn.01685cbe
in al, dx
je 0xb63ddc
mov esp, 0x8b2f8747
je 0xb63cf3
mov esp, 0x17f74f54
cmpsd dword [rsi], dword [rdi]
adc al, 0x88
xchg esp, eax
sub al, 0x87
jae 0xb63df3
out dx, eax
and al, 0xf8
and al, 0xf4
out 0x43, eax
mov bh, 0x6f
sub ch, 0x34
fmul qword [rbx + 0x3a]
add dword [rdi - 0x13], esp
invalid
in eax, dx
adc eax, 0xe44ef6f5
movabs eax, dword [0x9f6263b6003a4bdc]
mov edi, 0x66013afd
stosb byte [rdi], al
pop rsi
js 0xb63d78
xor r8, qword [r11 - 0x6d172921]
adc al, 0xb
xor eax, 0xa6b86b7c
xchg ebp, eax
imul eax, dword [rsi + 0x4cff785d], 0x7bea224d
iretd

Function at 0xb672bd
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0xffffffffe6b49a30
jmp 0x167b17a

Function at 0xb67790
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
call fcn.00b5f5cd
lea rsp, [rsp + 0x18]
jmp fcn.01685cbe

Function at 0xb68999
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov qword [rsp + 8], 0x4bbb30bb
sub r9, 4
mov dword [r9], edi
lea rsp, [rsp + 0x30]
jmp fcn.0166c840

Function at 0xb6954a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 8]
call rax
mov r11d, 0xdd3d9682
lea r10, [r11 + r11*4 + 0x23b2530a]
bswap r10d
mov rsp, qword [rbp + riz - 0x10]
call fcn.00b52c0f

Function at 0xb6b8a1
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
jmp 0x16764d7
lea rsp, [rsp + 0x28]
jmp fcn.0166c840
Function at 0xb6ea80
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov qword [rsp + 0x30], rbp
mov ebp, 0xe5ab4638
xor dword [rsp + 0x30], edi
btc ebp, ebp
add bp, bp
xchg dword [rsp + 0x28], ebp
mov rbp, qword [rsp + 0x30]
dec byte [rsp + 0x12]
jns 0xb6b736
sbb r9, 8
push 0x3885cf89
mov qword [r9], rdi
lea rsp, [rsp + 0x40]
jmp fcn.0166c840
not word [rsp + 0x35]
jmp 0x1697890
jne 0xb67fa4
ror edi, 3
sal dword [rsp + 9], 0x6c
js 0x166fee6
invalid

Function at 0xb6f58b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov qword [rsp + 8], 0x73bf2f18
lea rsp, [rsp + 0x10]
jmp fcn.01685cbe

Function at 0xb70161
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
not byte [rsp + 0xb]
lea rsp, [rsp + 0x20]
jmp fcn.01685cbe

Function at 0x1667ea2
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov dword [r9], ebx
push 0x3290f722
lea rsp, [rsp + 0x30]
jmp fcn.01685cbe

Function at 0x1669bc4
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 8]
jne 0x1670cd0
jmp 0xb55cbe
mov edx, 0x17a2018f
mov rdx, rax
jmp 0x1699bce
jmp 0xb54713
jmp 0x1667664
jmp 0x16972ec
stosb byte [rdi], al
invalid
call int.00b7013c
js 0x1697293
invalid
jmp 0x168eed8

Function at 0x166acd9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
jmp 0x166d330
mov dword [r9], ebx
jmp 0x16734e0
lea rsp, [rsp + 0x20]
jmp fcn.0166c840

Function at 0x166d338
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
sar bl, 0x44
mov qword [rsp], rbx
xor sil, bpl
xchg dword [rsp + 3], ebx
btc rbx, rbx
sbb sil, 0x24
xadd bl, bh
rol dword [rsp + 1], 0x16
xchg dword [rsp + 4], ebx
ror sil, 1
dec bx
and byte [rsp + rbx - 0xbcabbf], 0xb8
shl word [rsp + rbx - 0xbcabbb], 0x89
dec sil
ror dword [rsp + rbx - 0xbcabbf], 0x63
xchg byte [rsp + rbx*4 - 0x2f2aefc], bl
sal bx, 0x87
not sil
xchg byte [rsp + rbx - 0xbc9ffb], bl
xor sil, 0x17
jmp 0x16975be
sub ebx, dword [rsp + rbx*4 - 0x2f281dc]
xor bpl, sil
shl dword [rsp + rbx*2 - 0x17940ec], 0x5d
lea rsi, [rsp + rsi + 8]
cmovns ebx, dword [rsp + rbx - 0xbca078]
sal rbx, 0x81
and rbx, qword [rsp + rbx*4 - 0x2df8]
mov rbx, qword [rsi + rbx - 0x13e]
call fcn.0168c1a9
push rdx
jbe 0x169762e
sbb ebp, 0x61
cwde
invalid
invalid

Function at 0x166d677
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
adc r9, 5
push 0x3f3c7c08
mov word [r9], di
jmp 0x16836f4

Function at 0x166d720
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x253dcb03
jmp 0x1696bc1
lea rsp, [rsp + 0x20]
jmp 0x168eed8

Function at 0x166de37
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0xffffffffd29ede33
lea rsp, [rsp + 0x18]
jmp fcn.0166c840

Function at 0x1670a96
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
ror dword [rsp + 0xd], 0xe7
xor bp, bx
shl dword [rsp + 0x11], 0x13
shl byte [rsp + 0x11], 0x67
jae 0x167a62e
lea rbx, [rsp + rbx + 0x38]
call fcn.016834b0
invalid
Function at 0x16712f8
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x5e11ff26
mov dword ss:[r8], edi
not word [rsp + 0x15]
mov qword [rsp + 8], 0x5ea90b0e
not word [rsp + 0xb]
lea rsp, [rsp + 0x18]
jmp fcn.01685cbe

Function at 0x1675726
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0xffffffff9eaab13a
jmp 0x1695445
lea rsp, [rsp + 0x58]
jmp fcn.0166c840

Function at 0x167656b
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0xfffffffffbaaaf9f
lea rsp, [rsp + 0x18]
jmp fcn.01685cbe

Function at 0x1676d27
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [r9], si
jmp 0x169eebf
push 0xffffffffd6004a0b
lea rsp, [rsp + 0x18]
jmp fcn.01685cbe

Function at 0x16791a5
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
movabs r13, 0x1e0cb4133583f934
mov r13, qword [rsp + 8]
mov qword [rsp + 8], 0xffffffffebfb5bac
lea rsp, [rsp + 8]
call fcn.0169b840
call fcn.0166bdcc
lea rsp, [rsp + 0x30]
jmp fcn.01685cbe

Function at 0x167b139
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
call fcn.0167074c
mov edi, 0x8460b403
push rsp
invalid
push r15
movabs r15, 0xcc24060af7bd1dbc
not r9d
mov qword [rsp + 0x20], 0x7e705aac
mov r15, qword [rsp + r9*2 - 0x79e7bba6]
xor r9d, r9d
shr r9b, 0xc
sets r9b
lea r9, [r9*2 + 0xaa0f61c]
mov r9, qword [rsp + r9 - 0xaa0f604]
jns 0x166ace8
xor bpl, bl
shl qword [rsp + 0x10], 0xdc
push 0xffffffffba9ea9bb
jp 0x167e532
fdiv qword [rdi + rbp*4 + 0x77]
mov bh, 0x6f
nop
xchg esp, eax
adc byte [rdi], cl
inc edi
invalid
lea rsp, [rsp + 0x28]
jmp fcn.0166c840
sbb r9, 2
mov byte [rsp + 0xb], 0xb6
push 0x2404a41c
not byte [rsp + 9]
mov word [r9], bx
jmp 0x167d86c

Function at 0x167b5cf
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
call fcn.00b63d5a
mov eax, 0xef2806a5
mov rax, qword [r9 + riz]
mov bl, byte [r9 + 8]
push 0xffffffffc4ad721b
add r9, 0xa
mov byte ss:[rax], bl
jmp 0x1693de7
lea rsp, [rsp + 8]
jmp fcn.01685cbe

Function at 0x167ce23
Capabilities:
Encode data using base64

Disassembly:
call fcn.01675c99
movzx r11d, r9w

Function at 0x167d5a9
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x28]
jmp fcn.0166c840

Function at 0x1682140
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
or byte [rsp + 0x1b], 0x31
call fcn.00b55878
call fcn.016712f8
jmp 0x167a65a
mov dword [r9], esi
not dword [rsp + 3]
push 0xffffffffeb3b5faf
push 0x35183e99
lea rsp, [rsp + 0x18]
jmp fcn.01685cbe
mov r9d, dword [rsi + r9*4]
push 0xffffffffb60ce50b
rol word [rsp + 6], 0xea
not word [rsp + 0x16]
shr ecx, 8
push 0x3ead3097
add byte [rsp + 0x1c], 0x28
jg 0x1687d87
jmp 0x1681e9d
xor ecx, r9d
mov qword [rsp + 0x10], 0x3212490e
inc rdx
jmp 0xb55d25
Function at 0x1686eec
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
call fcn.0166acd9
js 0x1686e8f
test al, 0x18
stosd dword [rdi], eax
invalid

Function at 0x168857f
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
not word [rsp + 0x41]
sbb r9, 1
push 0xffffffffd883b096
call fcn.0167c9f9
adc dil, 0xb2
mov qword [rsp + 8], 0x6f2e0d0d
ror dil, 1
push 0x39309c9c
push 0x6339c632
push 0x1a0889f
xor bpl, dil
neg byte [rsp + 0xa]
js 0xb5c3c0

Function at 0x16885ab
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push qword [rsp + 0x18]
popfq
jmp 0x1686e7e
call fcn.01705226
mov qword [rsp + 8], 0xffffffffd31cc0a9
sal word [rsp + 0xe], 0xcd
rep movsb byte [rdi], byte [rsi]
push 0xffffffffdc21ef38
jne 0x1669079
je fcn.00b5316d
push 0x1a0caca7
adc dil, 0x21
add word [rsp + 0x1c], 0x7505
rol dil, 1
sal dword [rsp + 0x2a], 0x32
neg dil
shr qword [rsp + 0x18], 0xf6
xor bpl, dil
push 0xffffffffe21e7a1c
mov qword [rsp + 0x10], 0x73ba640d
or dword [rsp + 7], 0xdda2d110
sbb r9, 8
push 0x200d824
mov byte [rsp + 0xd], 0x11
push 0xffffffff8f844e29
mov qword [r9], rdi
call fcn.01675726
lea r8, [rsi + rsi*2 - 0x6dd98bfd]
movzx r8d, word [r11 + rsi - 0x4f1a668f]
sal rsi, 0x5a
adc r11, 2
xor r8w, bp
not si
xor esi, 0x310b5183
sbb r8w, 0x92
rol si, 0xc1
and si, si
rol r8w, 1
inc r8w
and sil, sil
jns 0x1685be0
shl si, 0xa6
not r8w
dec sil
bswap esi
inc sil
xor bp, r8w
bts rsi, 0xa9
and si, si
dec rsi
adc r8, rsp
bt rsi, 0x2b
and esi, esi
neg rsi
mov rsi, qword [r8 + rsi*2 + 0x7e7c161a]
push 0xfffffffff9102c21
sbb r9, 7
mov qword [r9], rsi
call fcn.0166de37

Function at 0x16886b4
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rbx, [rsp + rbx + 0x30]
mov qword [rsp + 8], 0x79138b8f
mov word [rbx], ax
lea rsp, [rsp + 0x30]
jmp fcn.01685cbe

Function at 0x168ee29
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
xor bp, di
inc word [rsp + 0x2a]
lea rdi, [rsp + rdi + 0x30]
mov qword [rsp], 0x551eeb2c
jl 0x168f750
mov byte [rdi], sil
jp 0xb62dcd
jne 0x167ee86
mov ebx, 0x49b1c128
add bl, bl
not bl
movzx ebx, word [rbx + r11 - 0x49b1c1af]
jg 0x16747e7

Function at 0x168fb86
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov qword [r9 + 8], rax
lea rsp, [rsp + 0x20]
jmp fcn.01685cbe

Function at 0x169403a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
sub sil, sil
mov r9d, 0x711d7c85
lea rsi, [0x0167a7a8]
push 0x19319719
mov qword [rcx], rdx
call fcn.01671c38
xor ecx, ecx
test r8, r8
jmp 0x1696bcb
jmp 0x167da59
lea rsp, [rsp + 0x10]
je 0xb5b334
mov esi, 0x4f07f62a
push r9
jmp 0xb5ab3d

Function at 0x1695454
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov qword [r9], rdx
not word [rsp + 0x1c]
call fcn.00b6b8a1
mov dword [r9], ebx
push 0xffffffff9ca0ea8f
jmp 0x169b38d
ror dword [rsp + 0xb], 0x47
sbb r9, 8
push 0xffffffffaf8da98c
not word [rsp + 0x1d]
jmp 0xb5b1ac
xor bpl, dl
not word [rsp + 8]
jmp 0x168f73f
lea rsp, [rsp + 0x28]
jmp fcn.0166c840
Function at 0x1698c91
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 8]
jmp 0x16970ad
lea rsp, [rsp + 0x10]
jne 0x169e0b1
mov r9d, 0xaca80ca9
mov r9, rax
push 0x3d81b52c
not word [rsp]
jmp 0x1680349
mov eax, 0xe9228e15
and ax, 0xf28a
mov rax, qword [rbp + rbx*8 + 0x20]
call fcn.0169709e

Function at 0x1699b3d
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x28]
jmp fcn.01685cbe

Function at 0x169c1cf
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x18]
jmp fcn.01685cbe
call fcn.00b55014
push 0x3412c2a3
mov word [r9], cx
jmp 0x1682d56

Function at 0x169c354
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x10]
jmp fcn.01685cbe
mov word [r9], ax
jmp 0x168c4f7
jmp 0x169b7d4

Function at 0x169c8ab
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x48]
jmp fcn.0166c840
push 0x7b08621e
push 0x32051db8
mov word [r9], bx
jmp 0x168e8b0

Function at 0x169d9cb
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov word [r9], cx
lea rsp, [rsp + 0x28]
jmp fcn.01685cbe

Function at 0x169dac7
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
ror bl, 1
sal dword [rsp + 1], 0x21
ror word [rsp], 0xcc
inc bl
ror bl, 1
jmp 0x168a1d9
mov r10d, 0x922681bc
pop r10
not ecx
call fcn.00b56636
push 0x6e0928bb
add r11, 1
shl dword [rsp + 1], 0x14
shr dword [rsp], 0xf
shr byte [rsp], 0xa6
xor bl, bpl
sal dword [rsp], 0x31
jp 0xb6acce
jrcxz 0xb6b826
movabs al, byte [0xe007cbdb737c8840]
xor al, ch
push 0xffffffffc72b874b
sar byte [rax - 0x68], 0x70
imul edx, dword [rbx - 0xb9f944d], 0xffffffd0
imul r14d, edi, 0xffffffeb
pop rbx
push 0xffffffffffffffb3
push rsi
cmp al, byte [r8]
mov dh, 0x4a
push 0x7237fda3
out dx, al
jbe 0xb6b7dd
std
invalid
enter 0xffffffffffffdc68, 0xffffffffffffffff
cmp eax, 0xbfedeac8
invalid
mov ebp, 0xf91590f5
push rsp
invalid
mov eax, 0x2b1d1b8a
rol rax, 0xfa
shr rax, 0x3e
or al, byte [rax + rbx]
xor eax, ecx
jmp fcn.00b665ea
jmp 0xb6b779
neg bl
call fcn.00b672bd
call fcn.0169d9d9
jmp 0x168f182
jmp 0x16815fe
lea rsp, [rsp + 0x30]
jne 0xb6bda0
jmp 0x1680628

Function at 0x16a0531
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x10]
jmp fcn.01685cbe
jmp 0x168c501

Function at 0x16a0c81
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0xffffffffc4baf892
lea rsp, [rsp + 0x68]
jmp fcn.0166c840

Function at 0x16a0c90
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x40]
jmp fcn.0166c840

Function at 0x170461a
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
push 0x5f2d31b3
lea rsp, [rsp + 0x28]
jmp fcn.01685cbe

Function at 0x1705226
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
mov r9w, word [r9]
lea rsp, [rsp + 0x10]
jmp fcn.0166c840
Function at 0x1705faf
Capabilities:
Encode data using base64
Encrypt data using speck

Disassembly:
lea rsp, [rsp + 0x10]
jmp fcn.0166c840
jmp 0xb54237
sub r9, 8
mov qword [r9], rbx
jmp 0xb64809
Function at 0x140003440
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 0x14000349d
lea rbx, [0x140066e00]
movzx r8d, byte [r9]
lea r9, [r9 + 1]
dec r10
cmp r8b, 0x23
jne 0x140003484
cmp r10, 2
jb 0x140003484
cmp byte [r9], r8b
jne 0x140003484
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 0x140003460
not eax
mov rbx, qword [rsp + 8]
ret
movzx r8d, byte [rcx]
inc r9
test r8b, r8b
je 0x1400034df
lea rbx, [0x140066e00]
cmp r8b, 0x23
jne 0x1400034c3
cmp byte [r9], r8b
jne 0x1400034c3
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 0x1400034b0
mov rbx, qword [rsp + 8]
not eax
ret

Function at 0x140003620
Capabilities:
Read file on windows

Disassembly:
mov qword [rsp + 0x18], rbx
push r14
sub rsp, 0x20
mov r14, r8
test r8, r8
je 0x14000363a
mov qword [r8], 0
lea rdx, [0x140066960]
call fcn.1400034f0
mov rbx, rax
test rax, rax
jne 0x14000365a
mov rbx, qword [rsp + 0x40]
add rsp, 0x20
pop r14
ret
mov qword [rsp + 0x30], rsi
mov rcx, rbx
mov qword [rsp + 0x38], rdi
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_ftell]
mov esi, eax
cmp eax, 0xffffffff
je 0x140003733
xor edx, edx
mov r8d, 2
mov rcx, rbx
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fseek]
test eax, eax
jne 0x140003733
mov rcx, rbx
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_ftell]
movsxd rdi, eax
cmp edi, 0xffffffff
je 0x140003733
xor r8d, r8d
mov edx, esi
mov rcx, rbx
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fseek]
test eax, eax
jne 0x140003733
cmp rdi, 0xffffffffffffffff
je 0x140003733
mov rax, qword [0x140076fb0]
test rax, rax
je 0x1400036d0
inc dword [rax + 0xf4]
mov rcx, rdi
call qword [sym.imp.api_ms_win_crt_heap_l1_1_0.dll_malloc]
mov rsi, rax
test rax, rax
je 0x140003733
mov r9, rbx
mov r8, rdi
mov edx, 1
mov rcx, rax
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fread]
mov rcx, rbx
cmp rax, rdi
je 0x140003720
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fclose]
mov rax, qword [0x140076fb0]
test rax, rax
je 0x140003715
dec dword [rax + 0xf4]
mov rcx, rsi
call qword [sym.imp.api_ms_win_crt_heap_l1_1_0.dll_free]
jmp 0x14000373c
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fclose]
test r14, r14
je 0x14000372e
mov qword [r14], rdi
mov rax, rsi
jmp 0x14000373e
mov rcx, rbx
call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll_fclose]
xor eax, eax
mov rsi, qword [rsp + 0x30]
mov rdi, qword [rsp + 0x38]
mov rbx, qword [rsp + 0x40]
add rsp, 0x20
pop r14
ret
Function at 0x140006e50
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 0x18], rbx
push rdi
sub rsp, 0x20
mov r11, rcx
lea rdi, [0x140066e00]
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 + 0x3f40], ebx
jne 0x140006ee4
movsxd r8, edx
mov ecx, ebx
mov edx, 4
call fcn.14001bc70
mov eax, ebx
mov rbx, qword [rsp + 0x40]
add rsp, 0x20
pop rdi
ret

Function at 0x140006f00
Capabilities:
Hash data with crc32

Disassembly:
sub rsp, 0x18
movss xmm0, dword [rcx + 0x110]
lea r10, [0x140066e00]
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 0x140014e40
Capabilities:
Hash data with crc32

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x40
mov rax, qword [0x140076040]
xor rax, rsp
mov qword [rsp + 0x30], rax
mov rbx, qword [0x140076fb0]
mov edi, ecx
cmp byte [rbx + 0x4a7d], 0
jne 0x140014ea1
cmp byte [rbx + 0x4a7e], 0
jne 0x140014ea1
movsx r9d, word [rbx + 0x5ba2]
lea r8, str.Tooltip__02d
mov edx, 0x10
lea rcx, [rsp + 0x20]
call fcn.1400032a0
test dil, 1
je 0x140014fcf
jmp 0x140014f2c
movss xmm1, dword [rbx + 0x389c]
lea r8, str.Tooltip__02d
movsx r9d, word [rbx + 0x5ba2]
lea rcx, [rsp + 0x20]
movaps xmm0, xmm1
xor eax, eax
mulss xmm0, dword [0x14006c6f0]
mov edx, 0x10
mulss xmm1, dword [0x14006c6cc]
addss xmm0, dword [rbx + 0xe08]
addss xmm1, dword [rbx + 0xe0c]
mov qword [rbx + 0x47e8], rax
mov dword [rbx + 0x47d4], 1
movss dword [rbx + 0x47e0], xmm0
movss dword [rbx + 0x47e4], xmm1
movss xmm0, dword [rbx + 0x3904]
mulss xmm0, dword [0x14006c5cc]
or dword [rbx + 0x47d0], 0x41
movss dword [rbx + 0x4830], xmm0
call fcn.1400032a0
movzx r9d, byte [rsp + 0x20]
lea r8, [rsp + 0x21]
mov r10d, 0xffffffff
mov ecx, r10d
test r9b, r9b
je 0x140014f80
lea r11, [0x140066e00]
nop dword [rax]
cmp r9b, 0x23
jne 0x140014f63
cmp byte [r8], r9b
jne 0x140014f63
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 0x140014f50
not ecx
call fcn.14000b860
test rax, rax
je 0x140014fcf
cmp byte [rax + 0xb6], 0
je 0x140014fcf
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 + 0x5ba2]
movsx r9d, word [rbx + 0x5ba2]
call fcn.1400032a0
xor edx, edx
lea rcx, [rsp + 0x20]
mov r8d, 0x20c0347
call fcn.14000e030
mov al, 1
mov rcx, qword [rsp + 0x30]
xor rcx, rsp
call fcn.140062260
mov rbx, qword [rsp + 0x50]
add rsp, 0x40
pop rdi
ret