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

Disassembly:
mov qword [rsp + 0x18], r8
push rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
sub rsp, 0x20
mov r14, rcx
mov qword [rsp + 0x68], r15
lea rcx, [r8 - 1]
mov r13, r9
mov rbp, rcx
mov qword [rsp + 0x60], rcx
sar rbp, 1
mov rax, r8
mov rsi, rdx
mov r12, rdx
mov r15, rdx
cmp rdx, rbp
jge 0x18012d458
nop
lea rbx, [r15 + r15]
lea rdx, [rbx + 2]
lea rdx, [rdx + rdx*2]
shl rdx, 4
add rdx, r14
lea r8, [rdx - 0x30]
call fcn.18012bbd0
movzx r15d, al
xor r15, 1
inc r15
add r15, rbx
lea rbx, [rsi + rsi*2]
shl rbx, 4
add rbx, r14
mov rcx, rbx
lea rdi, [r15 + r15*2]
shl rdi, 4
add rdi, r14
mov rdx, rdi
call fcn.180090680
movsd xmm0, qword [rdi + 0x20]
mov rsi, r15
movsd qword [rbx + 0x20], xmm0
mov eax, dword [rdi + 0x28]
mov dword [rbx + 0x28], eax
cmp r15, rbp
jl 0x18012d3f0
mov rax, qword [rsp + 0x70]
cmp r15, rbp
mov r15, qword [rsp + 0x68]
jne 0x18012d4a1
test al, 1
jne 0x18012d4a1
lea rdi, [rax + rax*2]
shl rdi, 4
lea rbx, [rsi + rsi*2]
shl rbx, 4
lea rdx, [r14 - 0x30]
add rbx, r14
add rdx, rdi
mov rcx, rbx
call fcn.180090680
movsd xmm0, qword [rdi + r14 - 0x10]
mov rsi, qword [rsp + 0x60]
movsd qword [rbx + 0x20], xmm0
mov eax, dword [rdi + r14 - 8]
mov dword [rbx + 0x28], eax
cmp r12, rsi
jge 0x18012d4ff
nop word [rax + rax]
lea rbx, [rsi - 1]
mov r8, r13
sar rbx, 1
lea rbp, [rbx + rbx*2]
shl rbp, 4
add rbp, r14
mov rdx, rbp
call fcn.18012bbd0
test al, al
je 0x18012d4ff
lea rdi, [rsi + rsi*2]
mov rdx, rbp
shl rdi, 4
add rdi, r14
mov rcx, rdi
call fcn.180090680
movsd xmm0, qword [rbp + 0x20]
mov rsi, rbx
movsd qword [rdi + 0x20], xmm0
mov eax, dword [rbp + 0x28]
mov dword [rdi + 0x28], eax
cmp r12, rbx
jl 0x18012d4b0
lea rbx, [rsi + rsi*2]
mov rdx, r13
shl rbx, 4
add rbx, r14
mov rcx, rbx
call fcn.180090680
movsd xmm0, qword [r13 + 0x20]
movsd qword [rbx + 0x20], xmm0
mov eax, dword [r13 + 0x28]
mov dword [rbx + 0x28], eax
add rsp, 0x20
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x18012d6f0
Capabilities:
Encode data using xor
Encrypt data using rc4 prga

Disassembly:
mov qword [rsp + 0x18], r8
push rbx
push rbp
push rsi
push rdi
push r12
push r13
push r14
sub rsp, 0x20
mov r14, rcx
mov qword [rsp + 0x68], r15
lea rcx, [r8 - 1]
mov r13, r9
mov rbp, rcx
mov qword [rsp + 0x60], rcx
sar rbp, 1
mov rax, r8
mov rsi, rdx
mov r12, rdx
mov r15, rdx
cmp rdx, rbp
jge 0x18012d7a4
nop
lea rbx, [r15 + r15]
lea rdx, [rbx + 2]
lea rdx, [rdx + rdx*4]
shl rdx, 4
add rdx, r14
lea r8, [rdx - 0x50]
call fcn.18012cb50
movzx r15d, al
xor r15, 1
inc r15
add r15, rbx
lea rbx, [rsi + rsi*4]
shl rbx, 4
add rbx, r14
mov rcx, rbx
lea rdi, [r15 + r15*4]
shl rdi, 4
add rdi, r14
mov rdx, rdi
call fcn.180090680
mov rax, qword [rdi + 0x20]
lea rdx, [rdi + 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180090680
movzx eax, byte [rdi + 0x48]
mov rsi, r15
mov byte [rbx + 0x48], al
cmp r15, rbp
jl 0x18012d730
mov rax, qword [rsp + 0x70]
cmp r15, rbp
mov r15, qword [rsp + 0x68]
jne 0x18012d7f5
test al, 1
jne 0x18012d7f5
lea rdi, [rax + rax*4]
shl rdi, 4
lea rbx, [rsi + rsi*4]
add rdi, r14
shl rbx, 4
add rbx, r14
mov rcx, rbx
lea rdx, [rdi - 0x50]
call fcn.180090680
mov rax, qword [rdi - 0x30]
lea rdx, [rdi - 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180090680
movzx eax, byte [rdi - 8]
mov rsi, qword [rsp + 0x60]
mov byte [rbx + 0x48], al
cmp r12, rsi
jge 0x18012d85b
nop word [rax + rax]
lea rbx, [rsi - 1]
mov r8, r13
sar rbx, 1
lea rbp, [rbx + rbx*4]
shl rbp, 4
add rbp, r14
mov rdx, rbp
call fcn.18012cb50
test al, al
je 0x18012d85b
lea rdi, [rsi + rsi*4]
mov rdx, rbp
shl rdi, 4
add rdi, r14
mov rcx, rdi
call fcn.180090680
mov rax, qword [rbp + 0x20]
lea rdx, [rbp + 0x28]
lea rcx, [rdi + 0x28]
mov qword [rdi + 0x20], rax
call fcn.180090680
movzx eax, byte [rbp + 0x48]
mov rsi, rbx
mov byte [rdi + 0x48], al
cmp r12, rbx
jl 0x18012d800
lea rbx, [rsi + rsi*4]
mov rdx, r13
shl rbx, 4
add rbx, r14
mov rcx, rbx
call fcn.180090680
mov rax, qword [r13 + 0x20]
lea rdx, [r13 + 0x28]
lea rcx, [rbx + 0x28]
mov qword [rbx + 0x20], rax
call fcn.180090680
movzx eax, byte [r13 + 0x48]
mov byte [rbx + 0x48], al
add rsp, 0x20
pop r14
pop r13
pop r12
pop rdi
pop rsi
pop rbp
pop rbx
ret
Function at 0x180130b20
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229e1c], edx
jle 0x180130bff
lea rcx, [0x180229e1c]
call fcn.18017dd34
cmp dword [0x180229e1c], 0xffffffff
jne 0x180130bff
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180130bec
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180130b92
mov rdx, r11
test rax, rax
je 0x180130bd0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180130bb0
cmp r9d, 0x7a1c884e
je 0x180130bd9
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x180130b7f
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229df4], r11d
lea rcx, [0x180229e1c]
call fcn.18017dcd4
movsxd rax, dword [0x180229df4]
cmp byte [rax + rbx], 1
seta al
add rsp, 0x20
pop rbx
ret

Function at 0x180130c20
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229e38], edx
jle 0x180130d02
lea rcx, [0x180229e38]
call fcn.18017dd34
cmp dword [0x180229e38], 0xffffffff
jne 0x180130d02
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180130cec
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180130c92
mov rdx, r11
test rax, rax
je 0x180130cd0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180130cb0
cmp r9d, 0x7c5cc931
je 0x180130cd9
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x180130c7f
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
lea eax, [r11 - 4]
mov dword [0x180229dfc], eax
lea rcx, [0x180229e38]
call fcn.18017dcd4
movsxd rax, dword [0x180229dfc]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013ac80
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
mov ebx, edx
mov rdi, rcx
mov r8d, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180229e94], r8d
jle 0x18013ad60
lea rcx, [0x180229e94]
call fcn.18017dd34
cmp dword [0x180229e94], 0xffffffff
jne 0x18013ad60
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013ad4d
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop dword [rax + rax]
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013ad00
mov rdx, r11
test rax, rax
je 0x18013ad31
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013ad11
cmp r9d, 0x3369e751
je 0x18013ad3a
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013ace8
lea r8, str.m_iTeam
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229e74], r11d
lea rcx, [0x180229e94]
call fcn.18017dcd4
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x180229e74]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x18013ad90
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
movsxd rbx, edx
mov rdi, rcx
mov r8d, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180229e6c], r8d
jle 0x18013ae70
lea rcx, [0x180229e6c]
call fcn.18017dd34
cmp dword [0x180229e6c], 0xffffffff
jne 0x18013ae70
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013ae5d
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop dword [rax]
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013ae10
mov rdx, r11
test rax, rax
je 0x18013ae41
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013ae21
cmp r9d, 0x3369e751
je 0x18013ae4a
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013adf9
lea r8, str.m_bValid
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229e78], r11d
lea rcx, [0x180229e6c]
call fcn.18017dcd4
movsxd rax, dword [0x180229e78]
add rax, rdi
movzx eax, byte [rbx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x18013ae90
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x18], rsi
mov qword [rsp + 0x10], rdx
push rdi
sub rsp, 0x30
mov rsi, r8
mov rbx, rdx
mov rdx, qword [rdx + 0x10]
test rdx, rdx
je 0x18013af57
lea rdi, [rcx + 0x90]
mov r10, rbx
cmp qword [rbx + 0x18], 0x10
jb 0x18013aecb
mov r10, qword [rbx]
xor ecx, ecx
movabs r9, 0xcbf29ce484222325
test rdx, rdx
je 0x18013af04
movabs r8, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [rcx + r10]
xor r9, rax
imul r9, r8
inc rcx
cmp rcx, rdx
jb 0x18013aef0
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.1800945f0
cmp qword [rax + 8], 0
je 0x18013af57
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180125a70
mov rcx, qword [rax]
movsd xmm0, qword [rcx + 0x30]
movsd qword [rsi], xmm0
mov eax, dword [rcx + 0x38]
mov dword [rsi + 8], eax
mov rcx, rbx
call fcn.180090ae0
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
mov rcx, rbx
call fcn.180090ae0
xor al, al
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x18013b1b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 0x18], r8
mov dword [rsp + 0x10], edx
push rbp
push rbx
push rsi
push rdi
push r12
push r14
push r15
lea rbp, [rsp - 0x10]
sub rsp, 0x110
mov r14, r8
mov r15, rcx
mov r12, qword [rbp + 0x70]
test edx, edx
je 0x18013b431
add rcx, 0x50
lea r8, [rbp + 0x58]
lea rdx, [rsp + 0x30]
call fcn.180125d00
mov rsi, qword [rax]
mov rax, qword [rsi + 0x18]
mov r11, qword [rsi + 0x20]
cmp rax, r11
je 0x18013b431
nop word [rax + rax]
mov r9, rax
cmp qword [rax + 0x18], 0x10
jb 0x18013b21d
mov r9, qword [rax]
mov rcx, 0xffffffffffffffff
mov r10d, 0x811c9dc5
nop word [rax + rax]
inc rcx
cmp byte [r9 + rcx], 0
jne 0x18013b230
xor r8d, r8d
test rcx, rcx
je 0x18013b27a
nop dword [rax]
nop word [rax + rax]
movsx edx, byte [r8 + r9]
xor edx, r10d
imul r10d, edx, 0x1000193
inc r8
cmp r8, rcx
jb 0x18013b250
test r10d, r10d
jne 0x18013b27a
add rax, 0x20
cmp rax, r11
jne 0x18013b210
jmp 0x18013b431
mov rdi, r11
lea rbx, [rax + 0x20]
cmp rbx, r11
je 0x18013b2a5
nop word [rax + rax]
lea rcx, [rbx - 0x20]
mov rdx, rbx
call fcn.180090680
add rbx, 0x20
cmp rbx, rdi
jne 0x18013b290
mov rcx, qword [rsi + 0x20]
sub rcx, 0x20
call fcn.180090ae0
add qword [rsi + 0x20], 0xffffffffffffffe0
mov byte [r15 + 0x129], 1
cmp qword [r12 + 0x10], 0
je 0x18013b431
mov dword [rsp + 0x30], 0xffffffff
mov rdx, r14
lea rcx, [rbp - 0x58]
call fcn.180090750
lea r8, [rsp + 0x30]
mov rdx, rax
mov rcx, r15
call fcn.18013ae90
test al, al
je 0x18013b431
lea rax, [rbp - 0x30]
mov qword [rsp + 0x70], rax
mov rdx, r14
lea rcx, [rbp - 0x30]
call fcn.180090750
mov rbx, rax
lea rax, [rbp - 0x58]
mov qword [rbp - 0x38], rax
movzx ecx, byte [rsp + 0x30]
mov dword [rbp - 0x68], ecx
movabs rax, 0x2000000000000000
mov qword [rsp + 0x78], rax
movzx ecx, byte [rsp + 0x31]
mov dword [rbp - 0x64], ecx
movabs rax, 0x2000000000000004
mov qword [rbp - 0x80], rax
movzx ecx, byte [rsp + 0x32]
mov dword [rbp - 0x60], ecx
movabs rax, 0x2000000000000008
mov qword [rbp - 0x78], rax
movzx eax, byte [rsp + 0x33]
mov dword [rbp - 0x5c], eax
movabs rax, 0x200000000000000c
mov qword [rbp - 0x70], rax
mov qword [rsp + 0x30], 4
lea rax, [rsp + 0x78]
mov qword [rsp + 0x38], rax
lea rax, str._b:02X:02X:02X:02X
mov qword [rsp + 0x40], rax
mov qword [rsp + 0x48], 0x19
movaps xmm0, xmmword [rsp + 0x30]
movdqa xmmword [rsp + 0x30], xmm0
movaps xmm1, xmmword [rsp + 0x40]
movdqa xmmword [rsp + 0x40], xmm1
lea r8, [rsp + 0x30]
lea rdx, [rsp + 0x40]
lea rcx, [rbp - 0x58]
call fcn.1800cb390
nop
lea rax, [rsp + 0x50]
mov qword [rsp + 0x40], rax
mov qword [rsp + 0x58], 0
mov qword [rsp + 0x60], 7
mov qword [rsp + 0x68], 0xf
mov eax, dword [str.Removed]
mov dword [rsp + 0x50], eax
movzx eax, word [0x1801fa7ec]
mov word [rsp + 0x54], ax
movzx eax, byte [0x1801fa7ee]
mov byte [rsp + 0x56], al
mov byte [rsp + 0x57], 0
mov rdx, r12
lea rcx, [rbp - 0x10]
call fcn.180090750
nop
mov qword [rsp + 0x20], rbx
lea r9, [rbp - 0x58]
lea r8, [rsp + 0x50]
mov rdx, rax
call fcn.180130560
nop
mov rcx, r14
call fcn.180090ae0
nop
mov rcx, r12
call fcn.180090ae0
add rsp, 0x110
pop r15
pop r14
pop r12
pop rdi
pop rsi
pop rbx
pop rbp
ret
Function at 0x18013b460
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
mov qword [rsp + 8], rbx
mov qword [rsp + 0x18], r8
mov dword [rsp + 0x10], edx
push rbp
push rsi
push rdi
sub rsp, 0x30
mov rsi, r8
mov r9, rcx
test edx, edx
jne 0x18013b496
mov rcx, r8
call fcn.180090ae0
xor al, al
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
cmp qword [r8 + 0x18], 0x10
jb 0x18013b4a0
mov r8, qword [r8]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
nop dword [rax]
inc rcx
cmp byte [r8 + rcx], 0
jne 0x18013b4b0
xor edx, edx
test rcx, rcx
je 0x18013b4e5
nop dword [rax]
nop word [rax + rax]
movsx eax, byte [rdx + r8]
xor eax, edi
imul edi, eax, 0x1000193
inc rdx
cmp rdx, rcx
jb 0x18013b4d0
lea rbp, [r9 + 0x50]
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180125d00
mov rcx, qword [rax]
mov r10, qword [rcx + 0x20]
mov rbx, qword [rcx + 0x18]
cmp rbx, r10
je 0x18013b566
nop dword [rax + rax]
mov r8, rbx
cmp qword [rbx + 0x18], 0x10
jb 0x18013b51d
mov r8, qword [rbx]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop word [rax + rax]
inc rax
cmp byte [r8 + rax], 0
jne 0x18013b530
xor edx, edx
test rax, rax
je 0x18013b558
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013b541
cmp edi, r9d
je 0x18013b566
add rbx, 0x20
cmp rbx, r10
jne 0x18013b510
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180125d00
mov rcx, qword [rax]
cmp rbx, qword [rcx + 0x20]
setne bl
mov rcx, rsi
call fcn.180090ae0
movzx eax, bl
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
Function at 0x18013d750
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229ea0], edx
jle 0x18013d82f
lea rcx, [0x180229ea0]
call fcn.18017dd34
cmp dword [0x180229ea0], 0xffffffff
jne 0x18013d82f
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013d81c
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013d7c2
mov rdx, r11
test rax, rax
je 0x18013d800
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013d7e0
cmp r9d, 0x9dc483b8
je 0x18013d809
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013d7af
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229ea4], r11d
lea rcx, [0x180229ea0]
call fcn.18017dcd4
movsxd rax, dword [0x180229ea4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x18013d840
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229eac], edx
jle 0x18013d922
lea rcx, [0x180229eac]
call fcn.18017dd34
cmp dword [0x180229eac], 0xffffffff
jne 0x18013d922
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013d90c
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013d8b2
mov rdx, r11
test rax, rax
je 0x18013d8f0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013d8d0
cmp r9d, 0x7c5cc931
je 0x18013d8f9
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013d89f
lea r8, str.m_hItem
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
lea eax, [r11 - 0x58]
mov dword [0x180229ea8], eax
lea rcx, [0x180229eac]
call fcn.18017dcd4
movsxd rax, dword [0x180229ea8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013efd0
Capabilities:
Hash data using fnv

Disassembly:
movzx r8d, byte [rdx]
mov r9, rcx
movabs rcx, 0x100000001b3
movabs rax, 0xcbf29ce484222325
xor r8, rax
mov r10, rdx
movzx eax, byte [rdx + 1]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 2]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 3]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 4]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 5]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 6]
imul r8, rcx
xor r8, rax
movzx eax, byte [rdx + 7]
mov rdx, qword [r9 + 0x30]
imul r8, rcx
xor r8, rax
imul r8, rcx
and rdx, r8
shl rdx, 4
add rdx, qword [r9 + 0x18]
mov rax, qword [rdx + 8]
cmp rax, qword [r9 + 8]
je 0x18013f07d
mov rcx, qword [r10]
mov rdx, qword [rdx]
cmp rcx, qword [rax + 0x10]
je 0x18013f07f
cmp rax, rdx
je 0x18013f07d
mov rax, qword [rax + 8]
cmp rcx, qword [rax + 0x10]
jne 0x18013f067
test rax, rax
setne al
ret
xor eax, eax
test rax, rax
setne al
ret
Function at 0x18013f3e0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229f5c], edx
jle 0x18013f4bf
lea rcx, [0x180229f5c]
call fcn.18017dd34
cmp dword [0x180229f5c], 0xffffffff
jne 0x18013f4bf
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013f4ac
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013f452
mov rdx, r11
test rax, rax
je 0x18013f490
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013f470
cmp r9d, 0x7a1c884e
je 0x18013f499
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013f43f
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229eec], r11d
lea rcx, [0x180229f5c]
call fcn.18017dcd4
movsxd rax, dword [0x180229eec]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x18013f4d0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229f74], edx
jle 0x18013f5af
lea rcx, [0x180229f74]
call fcn.18017dd34
cmp dword [0x180229f74], 0xffffffff
jne 0x18013f5af
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013f59c
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013f542
mov rdx, r11
test rax, rax
je 0x18013f580
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013f560
cmp r9d, 0x7a1c884e
je 0x18013f589
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013f52f
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229f6c], r11d
lea rcx, [0x180229f74]
call fcn.18017dcd4
movsxd rax, dword [0x180229f6c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013f5c0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229ee8], edx
jle 0x18013f69f
lea rcx, [0x180229ee8]
call fcn.18017dd34
cmp dword [0x180229ee8], 0xffffffff
jne 0x18013f69f
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013f68c
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013f632
mov rdx, r11
test rax, rax
je 0x18013f670
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013f650
cmp r9d, 0x7a1c884e
je 0x18013f679
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013f61f
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229eb4], r11d
lea rcx, [0x180229ee8]
call fcn.18017dcd4
movsxd rax, dword [0x180229eb4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

Function at 0x18013f6b0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022812c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180229f48], edx
jle 0x18013f78f
lea rcx, [0x180229f48]
call fcn.18017dd34
cmp dword [0x180229f48], 0xffffffff
jne 0x18013f78f
mov rcx, qword [0x180229a08]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013f77c
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013f722
mov rdx, r11
test rax, rax
je 0x18013f760
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [rdx + r8]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013f740
cmp r9d, 0x7a1c884e
je 0x18013f769
mov r10, qword [r10 + 0x20]
test r10, r10
jmp 0x18013f70f
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.18017d7d0
mov r11d, eax
mov dword [0x180229f9c], r11d
lea rcx, [0x180229f48]
call fcn.18017dcd4
movsxd rax, dword [0x180229f9c]
add rax, rbx
add rsp, 0x20
pop rbx
ret