joyce8/EMBER2024-capa huggingface dataset:
Function at 0x18013be90
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 [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18022bed4], r8d
jle 0x18013bf81
lea rcx, [0x18022bed4]
call fcn.18017f7fc
cmp dword [0x18022bed4], 0xffffffff
jne 0x18013bf81
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013bf6e
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013bf11
mov rdx, r11
test rax, rax
je 0x18013bf50
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 0x18013bf30
cmp r9d, 0x3369e751
je 0x18013bf5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013bf00
jmp 0x18013bf6e
lea r8, str.m_iTeam
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022beb4], r11d
lea rcx, [0x18022bed4]
call fcn.18017f790
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x18022beb4]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x18013bfb0
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 [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x18022beac], r8d
jle 0x18013c0a1
lea rcx, [0x18022beac]
call fcn.18017f7fc
cmp dword [0x18022beac], 0xffffffff
jne 0x18013c0a1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013c08e
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013c031
mov rdx, r11
test rax, rax
je 0x18013c070
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 0x18013c050
cmp r9d, 0x3369e751
je 0x18013c07b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013c020
jmp 0x18013c08e
lea r8, str.m_bValid
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022beb8], r11d
lea rcx, [0x18022beac]
call fcn.18017f790
movsxd rax, dword [0x18022beb8]
add rax, rdi
movzx eax, byte [rbx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x18013c0c0
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 0x18013c187
lea rdi, [rcx + 0x90]
mov r10, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013c0fb
mov r10, qword [rbx]
xor ecx, ecx
movabs r9, 0xcbf29ce484222325
test rdx, rdx
je 0x18013c134
movabs r8, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [r10 + rcx]
xor r9, rax
imul r9, r8
inc rcx
cmp rcx, rdx
jb 0x18013c120
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180093740
cmp qword [rax + 8], 0
je 0x18013c187
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.180126630
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.18008fd00
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
mov rcx, rbx
call fcn.18008fd00
xor al, al
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x18013c3e0
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 0x18013c662
add rcx, 0x50
lea r8, [rbp + 0x58]
lea rdx, [rsp + 0x30]
call fcn.1801268c0
mov rsi, qword [rax]
mov rax, qword [rsi + 0x18]
mov r11, qword [rsi + 0x20]
cmp rax, r11
je 0x18013c662
nop word [rax + rax]
mov r9, rax
cmp qword [rax + 0x18], 0xf
jbe 0x18013c44d
mov r9, qword [rax]
mov rcx, 0xffffffffffffffff
mov r10d, 0x811c9dc5
nop word [rax + rax]
inc rcx
cmp byte [r9 + rcx], 0
jne 0x18013c460
xor r8d, r8d
test rcx, rcx
je 0x18013c4aa
nop dword [rax]
nop word [rax + rax]
movsx edx, byte [r9 + r8]
xor edx, r10d
imul r10d, edx, 0x1000193
inc r8
cmp r8, rcx
jb 0x18013c480
test r10d, r10d
jne 0x18013c4aa
add rax, 0x20
cmp rax, r11
jne 0x18013c440
jmp 0x18013c662
mov rdi, r11
lea rbx, [rax + 0x20]
cmp rbx, r11
je 0x18013c4d5
nop word [rax + rax]
lea rcx, [rbx - 0x20]
mov rdx, rbx
call fcn.18008f8a0
add rbx, 0x20
cmp rbx, rdi
jne 0x18013c4c0
mov rcx, qword [rsi + 0x20]
sub rcx, 0x20
call fcn.18008fd00
add qword [rsi + 0x20], 0xffffffffffffffe0
mov byte [r15 + 0x129], 1
cmp qword [r12 + 0x10], 0
je 0x18013c662
mov dword [rsp + 0x30], 0xffffffff
mov rdx, r14
lea rcx, [rbp - 0x58]
call fcn.18008f970
lea r8, [rsp + 0x30]
mov rdx, rax
mov rcx, r15
call fcn.18013c0c0
test al, al
je 0x18013c662
lea rax, [rbp - 0x30]
mov qword [rsp + 0x70], rax
mov rdx, r14
lea rcx, [rbp - 0x30]
call fcn.18008f970
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.1800cad30
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 [0x1801fca44]
mov word [rsp + 0x54], ax
movzx eax, byte [0x1801fca46]
mov byte [rsp + 0x56], al
mov byte [rsp + 0x57], 0
mov rdx, r12
lea rcx, [rbp - 0x10]
call fcn.18008f970
nop
mov qword [rsp + 0x20], rbx
lea r9, [rbp - 0x58]
lea r8, [rsp + 0x50]
mov rdx, rax
call fcn.180131740
nop
mov rcx, r14
call fcn.18008fd00
nop
mov rcx, r12
call fcn.18008fd00
add rsp, 0x110
pop r15
pop r14
pop r12
pop rdi
pop rsi
pop rbx
pop rbp
ret
Function at 0x18013c690
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 0x18013c6c6
mov rcx, r8
call fcn.18008fd00
xor al, al
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
cmp qword [r8 + 0x18], 0xf
jbe 0x18013c6d0
mov r8, qword [r8]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
nop dword [rax]
inc rcx
cmp byte [r8 + rcx], 0
jne 0x18013c6e0
xor edx, edx
test rcx, rcx
je 0x18013c715
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 0x18013c700
lea rbp, [r9 + 0x50]
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.1801268c0
mov rcx, qword [rax]
mov r10, qword [rcx + 0x20]
mov rbx, qword [rcx + 0x18]
cmp rbx, r10
je 0x18013c796
nop dword [rax + rax]
mov r8, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x18013c74d
mov r8, qword [rbx]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop word [rax + rax]
inc rax
cmp byte [r8 + rax], 0
jne 0x18013c760
xor edx, edx
test rax, rax
je 0x18013c788
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x18013c771
cmp edi, r9d
je 0x18013c796
add rbx, 0x20
cmp rbx, r10
jne 0x18013c740
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.1801268c0
mov rcx, qword [rax]
cmp rbx, qword [rcx + 0x20]
setne bl
mov rcx, rsi
call fcn.18008fd00
movzx eax, bl
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
Function at 0x18013ea00
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bee0], edx
jle 0x18013eae1
lea rcx, [0x18022bee0]
call fcn.18017f7fc
cmp dword [0x18022bee0], 0xffffffff
jne 0x18013eae1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013eace
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013ea72
mov rdx, r11
test rax, rax
je 0x18013eab0
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 0x18013ea90
cmp r9d, 0x9dc483b8
je 0x18013eabb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013ea61
jmp 0x18013eace
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bee4], r11d
lea rcx, [0x18022bee0]
call fcn.18017f790
movsxd rax, dword [0x18022bee4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022beec], edx
jle 0x18013ebe4
lea rcx, [0x18022beec]
call fcn.18017f7fc
cmp dword [0x18022beec], 0xffffffff
jne 0x18013ebe4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18013ebce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18013eb72
mov rdx, r11
test rax, rax
je 0x18013ebb0
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 0x18013eb90
cmp r9d, 0x7c5cc931
je 0x18013ebbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18013eb61
jmp 0x18013ebce
lea r8, str.m_hItem
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 - 0x58]
mov dword [0x18022bee8], eax
lea rcx, [0x18022beec]
call fcn.18017f790
movsxd rax, dword [0x18022bee8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180140290
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 0x18014033d
mov rcx, qword [r10]
mov rdx, qword [rdx]
cmp rcx, qword [rax + 0x10]
je 0x18014033f
cmp rax, rdx
je 0x18014033d
mov rax, qword [rax + 8]
cmp rcx, qword [rax + 0x10]
jne 0x180140327
test rax, rax
setne al
ret
xor eax, eax
test rax, rax
setne al
ret
Function at 0x1801406f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfa0], edx
jle 0x1801407d1
lea rcx, [0x18022bfa0]
call fcn.18017f7fc
cmp dword [0x18022bfa0], 0xffffffff
jne 0x1801407d1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801407be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140762
mov rdx, r11
test rax, rax
je 0x1801407a0
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 0x180140780
cmp r9d, 0x7a1c884e
je 0x1801407ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140751
jmp 0x1801407be
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf28], r11d
lea rcx, [0x18022bfa0]
call fcn.18017f790
movsxd rax, dword [0x18022bf28]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfb4], edx
jle 0x1801408d1
lea rcx, [0x18022bfb4]
call fcn.18017f7fc
cmp dword [0x18022bfb4], 0xffffffff
jne 0x1801408d1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801408be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140862
mov rdx, r11
test rax, rax
je 0x1801408a0
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 0x180140880
cmp r9d, 0x7a1c884e
je 0x1801408ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140851
jmp 0x1801408be
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bfac], r11d
lea rcx, [0x18022bfb4]
call fcn.18017f790
movsxd rax, dword [0x18022bfac]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801408f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf2c], edx
jle 0x1801409d1
lea rcx, [0x18022bf2c]
call fcn.18017f7fc
cmp dword [0x18022bf2c], 0xffffffff
jne 0x1801409d1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801409be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140962
mov rdx, r11
test rax, rax
je 0x1801409a0
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 0x180140980
cmp r9d, 0x7a1c884e
je 0x1801409ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140951
jmp 0x1801409be
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bef4], r11d
lea rcx, [0x18022bf2c]
call fcn.18017f790
movsxd rax, dword [0x18022bef4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf88], edx
jle 0x180140ad1
lea rcx, [0x18022bf88]
call fcn.18017f7fc
cmp dword [0x18022bf88], 0xffffffff
jne 0x180140ad1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140abe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140a62
mov rdx, r11
test rax, rax
je 0x180140aa0
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 0x180140a80
cmp r9d, 0x7a1c884e
je 0x180140aab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140a51
jmp 0x180140abe
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bfdc], r11d
lea rcx, [0x18022bf88]
call fcn.18017f790
movsxd rax, dword [0x18022bfdc]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180140af0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfd8], edx
jle 0x180140bd1
lea rcx, [0x18022bfd8]
call fcn.18017f7fc
cmp dword [0x18022bfd8], 0xffffffff
jne 0x180140bd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140bbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140b62
mov rdx, r11
test rax, rax
je 0x180140ba0
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 0x180140b80
cmp r9d, 0x7a1c884e
je 0x180140bab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140b51
jmp 0x180140bbe
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf7c], r11d
lea rcx, [0x18022bfd8]
call fcn.18017f790
movsxd rax, dword [0x18022bf7c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022befc], edx
jle 0x180140cd1
lea rcx, [0x18022befc]
call fcn.18017f7fc
cmp dword [0x18022befc], 0xffffffff
jne 0x180140cd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140cbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140c62
mov rdx, r11
test rax, rax
je 0x180140ca0
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 0x180140c80
cmp r9d, 0x7a1c884e
je 0x180140cab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140c51
jmp 0x180140cbe
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf38], r11d
lea rcx, [0x18022befc]
call fcn.18017f790
movsxd rax, dword [0x18022bf38]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180140cf0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf44], edx
jle 0x180140dd1
lea rcx, [0x18022bf44]
call fcn.18017f7fc
cmp dword [0x18022bf44], 0xffffffff
jne 0x180140dd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140dbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140d62
mov rdx, r11
test rax, rax
je 0x180140da0
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 0x180140d80
cmp r9d, 0x7a1c884e
je 0x180140dab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140d51
jmp 0x180140dbe
lea r8, str.m_vecPunchAngle
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bfd0], r11d
lea rcx, [0x18022bf44]
call fcn.18017f790
movsxd rax, dword [0x18022bfd0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfe4], edx
jle 0x180140ed1
lea rcx, [0x18022bfe4]
call fcn.18017f7fc
cmp dword [0x18022bfe4], 0xffffffff
jne 0x180140ed1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140ebe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140e62
mov rdx, r11
test rax, rax
je 0x180140ea0
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 0x180140e80
cmp r9d, 0x7a1c884e
je 0x180140eab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140e51
jmp 0x180140ebe
lea r8, str.m_vecPunchAngleVel
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf10], r11d
lea rcx, [0x18022bfe4]
call fcn.18017f790
movsxd rax, dword [0x18022bf10]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180140ef0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfe0], edx
jle 0x180140fd1
lea rcx, [0x18022bfe0]
call fcn.18017f7fc
cmp dword [0x18022bfe0], 0xffffffff
jne 0x180140fd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180140fbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180140f62
mov rdx, r11
test rax, rax
je 0x180140fa0
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 0x180140f80
cmp r9d, 0x7a1c884e
je 0x180140fab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180140f51
jmp 0x180140fbe
lea r8, str.m_vecBaseVelocity
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bfb0], r11d
lea rcx, [0x18022bfe0]
call fcn.18017f790
movsxd rax, dword [0x18022bfb0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bffc], edx
jle 0x1801410d4
lea rcx, [0x18022bffc]
call fcn.18017f7fc
cmp dword [0x18022bffc], 0xffffffff
jne 0x1801410d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801410be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141062
mov rdx, r11
test rax, rax
je 0x1801410a0
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 0x180141080
cmp r9d, 0x7a1c884e
je 0x1801410ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141051
jmp 0x1801410be
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 - 0xc]
mov dword [0x18022bf5c], eax
lea rcx, [0x18022bffc]
call fcn.18017f790
movsxd rax, dword [0x18022bf5c]
add rax, rbx
add rsp, 0x20
pop rbx
ret