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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cee4], edx
jle 0x180131601
lea rcx, [0x18022cee4]
call fcn.18017f85c
cmp dword [0x18022cee4], 0xffffffff
jne 0x180131601
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801315ee
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180131592
mov rdx, r11
test rax, rax
je 0x1801315d0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801315b0
cmp r9d, 0x7a1c884e
je 0x1801315db
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180131581
jmp 0x1801315ee
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cebc], r11d
lea rcx, [0x18022cee4]
call fcn.18017f7f0
movsxd rax, dword [0x18022cebc]
cmp byte [rax + rbx], 1
seta al
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf00], edx
jle 0x180131704
lea rcx, [0x18022cf00]
call fcn.18017f85c
cmp dword [0x18022cf00], 0xffffffff
jne 0x180131704
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801316ee
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180131692
mov rdx, r11
test rax, rax
je 0x1801316d0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801316b0
cmp r9d, 0x7c5cc931
je 0x1801316db
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180131681
jmp 0x1801316ee
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 4]
mov dword [0x18022cec4], eax
lea rcx, [0x18022cf00]
call fcn.18017f7f0
movsxd rax, dword [0x18022cec4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180134af0
Capabilities:
Encode data using xor

Disassembly:
mov qword [rsp + 0x18], rbx
push rsi
push rdi
push r12
push r14
push r15
sub rsp, 0x20
mov qword [rsp + 0x50], rbp
mov r15, r9
lea rbp, [r8 - 1]
mov qword [rsp + 0x58], r13
sar rbp, 1
mov r14, r8
mov rsi, rdx
mov rdi, rcx
mov r12, rdx
mov r10, rdx
cmp rdx, rbp
jge 0x180134b82
nop dword [rax]
lea rbx, [r10 + r10]
lea rax, [rbx + 2]
lea rax, [rax + rax*2]
lea rdx, [rdi + rax*4]
lea r8, [rdx - 0xc]
lea rcx, [rsp + 0x70]
call fcn.1801345f0
movzx eax, al
lea rcx, [rsi + rsi*2]
xor rax, 1
lea r10, [rbx + 1]
add r10, rax
mov rsi, r10
lea rdx, [r10 + r10*2]
mov eax, dword [rdi + rdx*4]
mov dword [rdi + rcx*4], eax
mov eax, dword [rdi + rdx*4 + 4]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [rdi + rdx*4 + 8]
mov dword [rdi + rcx*4 + 8], eax
cmp r10, rbp
jl 0x180134b30
cmp r10, rbp
mov rbp, qword [rsp + 0x50]
jne 0x180134bb5
test r14b, 1
jne 0x180134bb5
lea rcx, [rsi + rsi*2]
lea rdx, [r14 + r14*2]
mov eax, dword [rdi + rdx*4 - 0xc]
lea rsi, [r14 - 1]
mov dword [rdi + rcx*4], eax
mov eax, dword [rdi + rdx*4 - 8]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [rdi + rdx*4 - 4]
mov dword [rdi + rcx*4 + 8], eax
mov rax, qword [rsp + 0x70]
mov r13, qword [rsp + 0x58]
mov qword [rsp + 0x70], rax
cmp r12, rsi
jge 0x180134c15
nop dword [rax]
lea rbx, [rsi - 1]
mov r8, r15
sar rbx, 1
lea rcx, [rsp + 0x70]
lea rax, [rbx + rbx*2]
lea r14, [rdi + rax*4]
mov rdx, r14
call fcn.1801345f0
test al, al
je 0x180134c15
mov eax, dword [r14]
lea rcx, [rsi + rsi*2]
mov dword [rdi + rcx*4], eax
mov rsi, rbx
mov eax, dword [r14 + 4]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [r14 + 8]
mov dword [rdi + rcx*4 + 8], eax
cmp r12, rbx
jl 0x180134bd0
mov eax, dword [r15]
lea rcx, [rsi + rsi*2]
mov rbx, qword [rsp + 0x60]
mov dword [rdi + rcx*4], eax
mov eax, dword [r15 + 4]
mov dword [rdi + rcx*4 + 4], eax
mov eax, dword [r15 + 8]
mov dword [rdi + rcx*4 + 8], eax
add rsp, 0x20
pop r15
pop r14
pop r12
pop rdi
pop rsi
ret
Function at 0x18013bce0
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 [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18022cf40], r8d
jle 0x18013bdd1
lea rcx, [0x18022cf40]
call fcn.18017f85c
cmp dword [0x18022cf40], 0xffffffff
jne 0x18013bdd1
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013bdbe
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013bd61
mov rdx, r11
test rax, rax
je 0x18013bda0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013bd80
cmp r9d, 0x3369e751
je 0x18013bdab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013bd50
jmp 0x18013bdbe
lea r8, str.m_iTeam
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf20], r11d
lea rcx, [0x18022cf40]
call fcn.18017f7f0
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x18022cf20]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x18013be00
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 [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18022cf18], r8d
jle 0x18013bef1
lea rcx, [0x18022cf18]
call fcn.18017f85c
cmp dword [0x18022cf18], 0xffffffff
jne 0x18013bef1
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013bede
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013be81
mov rdx, r11
test rax, rax
je 0x18013bec0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013bea0
cmp r9d, 0x3369e751
je 0x18013becb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013be70
jmp 0x18013bede
lea r8, str.m_bValid
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf24], r11d
lea rcx, [0x18022cf18]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf24]
add rax, rdi
movzx eax, byte [rbx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x18013bf10
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 0x18013bfd7
lea rdi, [rcx + 0x90]
mov r10, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013bf4b
mov r10, qword [rbx]
xor ecx, ecx
movabs r9, 0xcbf29ce484222325
test rdx, rdx
je 0x18013bf84
movabs r8, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [r10 + rcx]
xor r9, rax
imul r9, r8
inc rcx
cmp rcx, rdx
jb 0x18013bf70
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180092ff0
cmp qword [rax + 8], 0
je 0x18013bfd7
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180125c50
mov rax, qword [rax]
movsd xmm0, qword [rax + 0x30]
movsd qword [rsi], xmm0
mov eax, dword [rax + 0x38]
mov dword [rsi + 8], eax
mov rcx, rbx
call fcn.18008f640
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
mov rcx, rbx
call fcn.18008f640
xor al, al
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x18013c230
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 0x18013c4b2
add rcx, 0x50
lea r8, [rbp + 0x58]
lea rdx, [rsp + 0x30]
call fcn.180125ee0
mov rsi, qword [rax]
mov rax, qword [rsi + 0x18]
mov rcx, qword [rsi + 0x20]
cmp rax, rcx
je 0x18013c4b2
nop word [rax + rax]
mov r10, rax
cmp qword [rax + 0x18], 0xf
jbe 0x18013c29d
mov r10, qword [rax]
mov rdx, 0xffffffffffffffff
mov r11d, 0x811c9dc5
nop word [rax + rax]
inc rdx
cmp byte [r10 + rdx], 0
jne 0x18013c2b0
xor r9d, r9d
test rdx, rdx
je 0x18013c2fa
nop dword [rax]
nop word [rax + rax]
movsx r8d, byte [r10 + r9]
xor r8d, r11d
imul r11d, r8d, 0x1000193
inc r9
cmp r9, rdx
jb 0x18013c2d0
test r11d, r11d
jne 0x18013c2fa
add rax, 0x20
cmp rax, rcx
jne 0x18013c290
jmp 0x18013c4b2
mov rdi, rcx
lea rbx, [rax + 0x20]
cmp rbx, rcx
je 0x18013c325
nop word [rax + rax]
lea rcx, [rbx - 0x20]
mov rdx, rbx
call fcn.18008f1e0
add rbx, 0x20
cmp rbx, rdi
jne 0x18013c310
mov rcx, qword [rsi + 0x20]
sub rcx, 0x20
call fcn.18008f640
add qword [rsi + 0x20], 0xffffffffffffffe0
mov byte [r15 + 0x129], 1
cmp qword [r12 + 0x10], 0
je 0x18013c4b2
mov dword [rsp + 0x30], 0xffffffff
mov rdx, r14
lea rcx, [rbp - 0x58]
call fcn.18008f2b0
lea r8, [rsp + 0x30]
mov rdx, rax
mov rcx, r15
call fcn.18013bf10
test al, al
je 0x18013c4b2
lea rax, [rbp - 0x30]
mov qword [rsp + 0x70], rax
mov rdx, r14
lea rcx, [rbp - 0x30]
call fcn.18008f2b0
mov rbx, rax
lea rax, [rbp - 0x58]
mov qword [rbp - 0x38], rax
lea rax, str._b:02X:02X:02X:02X
mov qword [rsp + 0x40], rax
mov qword [rsp + 0x48], 0x19
movzx ecx, byte [rsp + 0x30]
mov dword [rbp - 0x68], ecx
movabs rax, 0x2000000000000000
mov qword [rsp + 0x78], rax
movzx eax, byte [rsp + 0x31]
mov dword [rbp - 0x64], eax
movabs rax, 0x2000000000000004
mov qword [rbp - 0x80], rax
movzx eax, byte [rsp + 0x32]
mov dword [rbp - 0x60], eax
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
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.1800ca850
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 rax, qword [str.Removed]
mov dword [rsp + 0x50], eax
movzx eax, word [0x1801fdbfc]
mov word [rsp + 0x54], ax
movzx eax, byte [0x1801fdbfe]
mov byte [rsp + 0x56], al
mov byte [rsp + 0x57], 0
mov rdx, r12
lea rcx, [rbp - 0x10]
call fcn.18008f2b0
nop
mov qword [rsp + 0x20], rbx
lea r9, [rbp - 0x58]
lea r8, [rsp + 0x50]
mov rdx, rax
call fcn.180130f40
nop
mov rcx, r14
call fcn.18008f640
nop
mov rcx, r12
call fcn.18008f640
add rsp, 0x110
pop r15
pop r14
pop r12
pop rdi
pop rsi
pop rbx
pop rbp
ret
Function at 0x18013c4e0
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 0x18013c516
mov rcx, r8
call fcn.18008f640
xor al, al
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
cmp qword [r8 + 0x18], 0xf
jbe 0x18013c520
mov r8, qword [r8]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
nop dword [rax]
inc rcx
cmp byte [r8 + rcx], 0
jne 0x18013c530
xor edx, edx
test rcx, rcx
je 0x18013c565
nop dword [rax]
nop word [rax + rax]
movsx eax, byte [r8 + rdx]
xor eax, edi
imul edi, eax, 0x1000193
inc rdx
cmp rdx, rcx
jb 0x18013c550
lea rbp, [r9 + 0x50]
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180125ee0
mov rcx, qword [rax]
mov r10, qword [rcx + 0x20]
mov rbx, qword [rcx + 0x18]
cmp rbx, r10
je 0x18013c5e6
nop dword [rax + rax]
mov r8, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013c59d
mov r8, qword [rbx]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop word [rax + rax]
inc rax
cmp byte [r8 + rax], 0
jne 0x18013c5b0
xor edx, edx
test rax, rax
je 0x18013c5d8
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013c5c1
cmp edi, r9d
je 0x18013c5e6
add rbx, 0x20
cmp rbx, r10
jne 0x18013c590
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180125ee0
mov rcx, qword [rax]
cmp rbx, qword [rcx + 0x20]
setne bl
mov rcx, rsi
call fcn.18008f640
movzx eax, bl
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
Function at 0x18013e830
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf4c], edx
jle 0x18013e911
lea rcx, [0x18022cf4c]
call fcn.18017f85c
cmp dword [0x18022cf4c], 0xffffffff
jne 0x18013e911
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013e8fe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013e8a2
mov rdx, r11
test rax, rax
je 0x18013e8e0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013e8c0
cmp r9d, 0x9dc483b8
je 0x18013e8eb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013e891
jmp 0x18013e8fe
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf50], r11d
lea rcx, [0x18022cf4c]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf50]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf58], edx
jle 0x18013ea14
lea rcx, [0x18022cf58]
call fcn.18017f85c
cmp dword [0x18022cf58], 0xffffffff
jne 0x18013ea14
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013e9fe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013e9a2
mov rdx, r11
test rax, rax
je 0x18013e9e0
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013e9c0
cmp r9d, 0x7c5cc931
je 0x18013e9eb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013e991
jmp 0x18013e9fe
lea r8, str.m_hItem
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
lea eax, [r11 - 0x58]
mov dword [0x18022cf54], eax
lea rcx, [0x18022cf58]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf54]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18013ead0
Capabilities:
Hash data using fnv

Disassembly:
mov qword [rsp + 0x18], rsi
mov qword [rsp + 8], rcx
push rdi
sub rsp, 0x70
movabs rax, 0xcbf29ce484222325
movzx r9d, r8b
xor r9, rax
mov rsi, rdx
movabs rdx, 0x100000001b3
mov rax, r8
imul r9, rdx
shr rax, 8
mov rdi, r8
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x10
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x18
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x20
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x28
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x30
imul r9, rdx
movzx ecx, al
mov rax, r8
xor r9, rcx
shr rax, 0x38
mov rcx, qword [0x18023b650]
imul r9, rdx
xor r9, rax
imul r9, rdx
mov rdx, qword [0x18023b638]
and rcx, r9
add rcx, rcx
mov rax, qword [rdx + rcx*8 + 8]
cmp rax, qword [0x18023b628]
je 0x18013ebb5
mov rcx, qword [rdx + rcx*8]
cmp r8, qword [rax + 0x10]
je 0x18013ebb7
cmp rax, rcx
je 0x18013ebb5
mov rax, qword [rax + 8]
cmp rdi, qword [rax + 0x10]
jne 0x18013eba4
jmp 0x18013ebb7
xor eax, eax
test rax, rax
je 0x18013ecb3
mov qword [rsp + 0x88], rbx
lea r8, [rsp + 0x80]
movaps xmmword [rsp + 0x60], xmm6
lea rdx, [rsp + 0x30]
movaps xmmword [rsp + 0x50], xmm7
lea rcx, [0x18023b620]
movaps xmmword [rsp + 0x40], xmm8
mov qword [rsp + 0x80], rdi
call fcn.180140540
mov rcx, qword [rax]
mov rax, qword [rdi]
movss xmm6, dword [rcx + 0x18]
movss xmm7, dword [rcx + 0x1c]
movss xmm8, dword [rcx + 0x20]
mov rcx, rdi
call qword [rax + 0x48]
mov rcx, rdi
mov rbx, rax
call fcn.1800a6980
movss xmm1, dword [rbx + 4]
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x30]
mov qword [rsp + 0x24], 0
mov dword [rsp + 0x20], 0
movss xmm0, dword [rax]
addss xmm0, dword [rbx]
addss xmm1, dword [rax + 4]
subss xmm6, xmm0
movss xmm0, dword [rbx + 8]
addss xmm0, dword [rax + 8]
subss xmm7, xmm1
movss dword [rsp + 0x30], xmm6
subss xmm8, xmm0
movss dword [rsp + 0x34], xmm7
movss dword [rsp + 0x38], xmm8
call fcn.1800baa30
movss xmm0, dword [rsp + 0x20]
mov rax, rsi
movaps xmm8, xmmword [rsp + 0x40]
movaps xmm7, xmmword [rsp + 0x50]
movaps xmm6, xmmword [rsp + 0x60]
mov rbx, qword [rsp + 0x88]
movss dword [rsi], xmm0
mov byte [rsi + 4], 1
mov rsi, qword [rsp + 0x90]
add rsp, 0x70
pop rdi
ret
mov byte [rsi + 4], 0
mov rax, rsi
mov rsi, qword [rsp + 0x90]
add rsp, 0x70
pop rdi
ret
Function at 0x180140860
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d008], edx
jle 0x180140941
lea rcx, [0x18022d008]
call fcn.18017f85c
cmp dword [0x18022d008], 0xffffffff
jne 0x180140941
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014092e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801408d2
mov rdx, r11
test rax, rax
je 0x180140910
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801408f0
cmp r9d, 0x7a1c884e
je 0x18014091b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801408c1
jmp 0x18014092e
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf94], r11d
lea rcx, [0x18022d008]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf94]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022d01c], edx
jle 0x180140a41
lea rcx, [0x18022d01c]
call fcn.18017f85c
cmp dword [0x18022d01c], 0xffffffff
jne 0x180140a41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140a2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801409d2
mov rdx, r11
test rax, rax
je 0x180140a10
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x1801409f0
cmp r9d, 0x7a1c884e
je 0x180140a1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801409c1
jmp 0x180140a2e
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d014], r11d
lea rcx, [0x18022d01c]
call fcn.18017f7f0
movsxd rax, dword [0x18022d014]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180140a60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cf98], edx
jle 0x180140b41
lea rcx, [0x18022cf98]
call fcn.18017f85c
cmp dword [0x18022cf98], 0xffffffff
jne 0x180140b41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140b2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140ad2
mov rdx, r11
test rax, rax
je 0x180140b10
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180140af0
cmp r9d, 0x7a1c884e
je 0x180140b1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140ac1
jmp 0x180140b2e
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022cf60], r11d
lea rcx, [0x18022cf98]
call fcn.18017f7f0
movsxd rax, dword [0x18022cf60]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022b1cc]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022cff0], edx
jle 0x180140c41
lea rcx, [0x18022cff0]
call fcn.18017f85c
cmp dword [0x18022cff0], 0xffffffff
jne 0x180140c41
mov rcx, qword [0x18022cad0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140c2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140bd2
mov rdx, r11
test rax, rax
je 0x180140c10
nop dword [rax]
nop word [rax + rax]
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180140bf0
cmp r9d, 0x7a1c884e
je 0x180140c1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140bc1
jmp 0x180140c2e
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.18017f3f0
mov r11d, eax
mov dword [0x18022d044], r11d
lea rcx, [0x18022cff0]
call fcn.18017f7f0
movsxd rax, dword [0x18022d044]
add rax, rbx
add rsp, 0x20
pop rbx
ret