joyce8/EMBER2024-capa huggingface dataset:
Function at 0x180141200
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 0x180141292
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.180140d00
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 0x180141240
cmp r10, rbp
mov rbp, qword [rsp + 0x50]
jne 0x1801412c5
test r14b, 1
jne 0x1801412c5
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 0x180141325
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.180140d00
test al, al
je 0x180141325
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 0x1801412e0
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 0x180148160
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 [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x180244324], r8d
jle 0x180148251
lea rcx, [0x180244324]
call fcn.1801905cc
cmp dword [0x180244324], 0xffffffff
jne 0x180148251
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014823e
nop word [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801481e1
mov rdx, r11
test rax, rax
je 0x180148220
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 0x180148200
cmp r9d, 0x3369e751
je 0x18014822b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801481d0
jmp 0x18014823e
lea r8, str.m_iTeam
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x180244304], r11d
lea rcx, [0x180244324]
call fcn.180190560
lea eax, [rbx*4]
cdqe
movsxd rdx, dword [0x180244304]
add rax, rdi
mov eax, dword [rdx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret

Function at 0x180148280
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 [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x1802442fc], r8d
jle 0x180148371
lea rcx, [0x1802442fc]
call fcn.1801905cc
cmp dword [0x1802442fc], 0xffffffff
jne 0x180148371
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014835e
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180148301
mov rdx, r11
test rax, rax
je 0x180148340
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 0x180148320
cmp r9d, 0x3369e751
je 0x18014834b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801482f0
jmp 0x18014835e
lea r8, str.m_bValid
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x180244308], r11d
lea rcx, [0x1802442fc]
call fcn.180190560
movsxd rax, dword [0x180244308]
add rax, rdi
movzx eax, byte [rbx + rax]
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x1801483c0
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 0x180148487
lea rdi, [rcx + 0x90]
mov r10, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x1801483fb
mov r10, qword [rbx]
xor ecx, ecx
movabs r9, 0xcbf29ce484222325
test rdx, rdx
je 0x180148434
movabs r8, 0x100000001b3
nop word [rax + rax]
movzx eax, byte [r10 + rcx]
xor r9, rax
imul r9, r8
inc rcx
cmp rcx, rdx
jb 0x180148420
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.18009c890
cmp qword [rax + 8], 0
je 0x180148487
mov r8, rbx
lea rdx, [rsp + 0x20]
mov rcx, rdi
call fcn.1801325a0
mov rax, qword [rax]
vmovsd xmm0, qword [rax + 0x30]
vmovsd qword [rsi], xmm0
mov eax, dword [rax + 0x38]
mov dword [rsi + 8], eax
mov rcx, rbx
call fcn.180098e30
mov al, 1
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
mov rcx, rbx
call fcn.180098e30
xor al, al
mov rbx, qword [rsp + 0x40]
mov rsi, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
ret
Function at 0x1801486e0
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 0x180148964
add rcx, 0x50
lea r8, [rbp + 0x58]
lea rdx, [rsp + 0x30]
call fcn.180132830
mov rsi, qword [rax]
mov rax, qword [rsi + 0x18]
mov rcx, qword [rsi + 0x20]
cmp rax, rcx
je 0x180148964
nop word [rax + rax]
mov r10, rax
cmp qword [rax + 0x18], 0xf
jbe 0x18014874d
mov r10, qword [rax]
mov rdx, 0xffffffffffffffff
mov r11d, 0x811c9dc5
nop word [rax + rax]
inc rdx
cmp byte [r10 + rdx], 0
jne 0x180148760
xor r9d, r9d
test rdx, rdx
je 0x1801487aa
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 0x180148780
test r11d, r11d
jne 0x1801487aa
add rax, 0x20
cmp rax, rcx
jne 0x180148740
jmp 0x180148964
mov rdi, rcx
lea rbx, [rax + 0x20]
cmp rbx, rcx
je 0x1801487d5
nop word [rax + rax]
lea rcx, [rbx - 0x20]
mov rdx, rbx
call fcn.1800989d0
add rbx, 0x20
cmp rbx, rdi
jne 0x1801487c0
mov rcx, qword [rsi + 0x20]
sub rcx, 0x20
call fcn.180098e30
add qword [rsi + 0x20], 0xffffffffffffffe0
mov byte [r15 + 0x129], 1
cmp qword [r12 + 0x10], 0
je 0x180148964
mov dword [rsp + 0x30], 0xffffffff
mov rdx, r14
lea rcx, [rbp - 0x58]
call fcn.180098aa0
lea r8, [rsp + 0x30]
mov rdx, rax
mov rcx, r15
call fcn.1801483c0
test al, al
je 0x180148964
lea rax, [rbp - 0x30]
mov qword [rsp + 0x70], rax
mov rdx, r14
lea rcx, [rbp - 0x30]
call fcn.180098aa0
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
vmovups xmm0, xmmword [rsp + 0x30]
vmovdqa xmmword [rsp + 0x30], xmm0
vmovups xmm1, xmmword [rsp + 0x40]
vmovdqa xmmword [rsp + 0x40], xmm1
lea r8, [rsp + 0x30]
lea rdx, [rsp + 0x40]
lea rcx, [rbp - 0x58]
call fcn.1800b12c0
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 [0x180212304]
mov word [rsp + 0x54], ax
movzx eax, byte [0x180212306]
mov byte [rsp + 0x56], al
mov byte [rsp + 0x57], 0
mov rdx, r12
lea rcx, [rbp - 0x10]
call fcn.180098aa0
nop
mov qword [rsp + 0x20], rbx
lea r9, [rbp - 0x58]
lea r8, [rsp + 0x50]
mov rdx, rax
call fcn.18013d6b0
nop
mov rcx, r14
call fcn.180098e30
nop
mov rcx, r12
call fcn.180098e30
add rsp, 0x110
pop r15
pop r14
pop r12
pop rdi
pop rsi
pop rbx
pop rbp
ret
Function at 0x180148990
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 0x1801489c6
mov rcx, r8
call fcn.180098e30
xor al, al
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
cmp qword [r8 + 0x18], 0xf
jbe 0x1801489d0
mov r8, qword [r8]
mov edi, 0x811c9dc5
mov rcx, 0xffffffffffffffff
nop dword [rax]
inc rcx
cmp byte [r8 + rcx], 0
jne 0x1801489e0
xor edx, edx
test rcx, rcx
je 0x180148a15
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 0x180148a00
lea rbp, [r9 + 0x50]
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180132830
mov rcx, qword [rax]
mov r10, qword [rcx + 0x20]
mov rbx, qword [rcx + 0x18]
cmp rbx, r10
je 0x180148a96
nop dword [rax + rax]
mov r8, rbx
cmp qword [rbx + 0x18], 0xf
jbe 0x180148a4d
mov r8, qword [rbx]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
nop word [rax + rax]
inc rax
cmp byte [r8 + rax], 0
jne 0x180148a60
xor edx, edx
test rax, rax
je 0x180148a88
movsx ecx, byte [r8 + rdx]
xor ecx, r9d
imul r9d, ecx, 0x1000193
inc rdx
cmp rdx, rax
jb 0x180148a71
cmp edi, r9d
je 0x180148a96
add rbx, 0x20
cmp rbx, r10
jne 0x180148a40
lea r8, [rsp + 0x58]
lea rdx, [rsp + 0x20]
mov rcx, rbp
call fcn.180132830
mov rcx, qword [rax]
cmp rbx, qword [rcx + 0x20]
setne bl
mov rcx, rsi
call fcn.180098e30
movzx eax, bl
mov rbx, qword [rsp + 0x50]
add rsp, 0x30
pop rdi
pop rsi
pop rbp
ret
Function at 0x18014ad60
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180244330], edx
jle 0x18014ae41
lea rcx, [0x180244330]
call fcn.1801905cc
cmp dword [0x180244330], 0xffffffff
jne 0x18014ae41
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014ae2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014add2
mov rdx, r11
test rax, rax
je 0x18014ae10
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 0x18014adf0
cmp r9d, 0x9dc483b8
je 0x18014ae1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014adc1
jmp 0x18014ae2e
lea r8, str.m_hOwnerEntity
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x180244334], r11d
lea rcx, [0x180244330]
call fcn.180190560
movsxd rax, dword [0x180244334]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18024433c], edx
jle 0x18014af44
lea rcx, [0x18024433c]
call fcn.1801905cc
cmp dword [0x18024433c], 0xffffffff
jne 0x18014af44
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014af2e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014aed2
mov rdx, r11
test rax, rax
je 0x18014af10
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 0x18014aef0
cmp r9d, 0x7c5cc931
je 0x18014af1b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014aec1
jmp 0x18014af2e
lea r8, str.m_hItem
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
lea eax, [r11 - 0x58]
mov dword [0x180244338], eax
lea rcx, [0x18024433c]
call fcn.180190560
movsxd rax, dword [0x180244338]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18014af60
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 [0x180253820]
imul r9, rdx
xor r9, rax
imul r9, rdx
mov rdx, qword [0x180253808]
and rcx, r9
add rcx, rcx
mov rax, qword [rdx + rcx*8 + 8]
cmp rax, qword [0x1802537f8]
je 0x18014b045
mov rcx, qword [rdx + rcx*8]
cmp r8, qword [rax + 0x10]
je 0x18014b047
cmp rax, rcx
je 0x18014b045
mov rax, qword [rax + 8]
cmp rdi, qword [rax + 0x10]
jne 0x18014b034
jmp 0x18014b047
xor eax, eax
test rax, rax
je 0x18014b149
mov qword [rsp + 0x88], rbx
lea r8, [rsp + 0x80]
vmovaps xmmword [rsp + 0x60], xmm6
vmovaps xmmword [rsp + 0x50], xmm7
lea rdx, [rsp + 0x30]
mov qword [rsp + 0x80], rdi
lea rcx, [0x1802537f0]
vmovaps xmmword [rsp + 0x40], xmm8
call fcn.18014ccb0
mov rcx, qword [rax]
mov rax, qword [rdi]
vmovss xmm6, dword [rcx + 0x18]
vmovss xmm7, dword [rcx + 0x1c]
vmovss xmm8, dword [rcx + 0x20]
mov rcx, rdi
call qword [rax + 0x48]
mov rcx, rdi
mov rbx, rax
call fcn.1800be0e0
lea rdx, [rsp + 0x20]
lea rcx, [rsp + 0x30]
vmovss xmm0, dword [rax]
vaddss xmm1, xmm0, dword [rbx]
vmovss xmm0, dword [rbx + 4]
vsubss xmm2, xmm6, xmm1
vaddss xmm1, xmm0, dword [rax + 4]
vmovss xmm0, dword [rbx + 8]
vmovss dword [rsp + 0x30], xmm2
vsubss xmm2, xmm7, xmm1
vaddss xmm1, xmm0, dword [rax + 8]
vxorps xmm0, xmm0, xmm0
vmovss dword [rsp + 0x34], xmm2
vsubss xmm2, xmm8, xmm1
vmovss dword [rsp + 0x38], xmm2
vmovss dword [rsp + 0x28], xmm0
vmovss dword [rsp + 0x24], xmm0
vmovss dword [rsp + 0x20], xmm0
call fcn.1800d1e90
vmovss xmm0, dword [rsp + 0x20]
vmovaps xmm8, xmmword [rsp + 0x40]
vmovaps xmm7, xmmword [rsp + 0x50]
vmovaps xmm6, xmmword [rsp + 0x60]
mov rbx, qword [rsp + 0x88]
mov rax, rsi
vmovss 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 0x18014cfc0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802443ec], edx
jle 0x18014d0a1
lea rcx, [0x1802443ec]
call fcn.1801905cc
cmp dword [0x1802443ec], 0xffffffff
jne 0x18014d0a1
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014d08e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014d032
mov rdx, r11
test rax, rax
je 0x18014d070
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 0x18014d050
cmp r9d, 0x7a1c884e
je 0x18014d07b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014d021
jmp 0x18014d08e
lea r8, str.m_bDucked
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x180244378], r11d
lea rcx, [0x1802443ec]
call fcn.180190560
movsxd rax, dword [0x180244378]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180244400], edx
jle 0x18014d1a1
lea rcx, [0x180244400]
call fcn.1801905cc
cmp dword [0x180244400], 0xffffffff
jne 0x18014d1a1
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014d18e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014d132
mov rdx, r11
test rax, rax
je 0x18014d170
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 0x18014d150
cmp r9d, 0x7a1c884e
je 0x18014d17b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014d121
jmp 0x18014d18e
lea r8, str.m_bDucking
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x1802443f8], r11d
lea rcx, [0x180244400]
call fcn.180190560
movsxd rax, dword [0x1802443f8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18014d1c0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18024437c], edx
jle 0x18014d2a1
lea rcx, [0x18024437c]
call fcn.1801905cc
cmp dword [0x18024437c], 0xffffffff
jne 0x18014d2a1
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014d28e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014d232
mov rdx, r11
test rax, rax
je 0x18014d270
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 0x18014d250
cmp r9d, 0x7a1c884e
je 0x18014d27b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014d221
jmp 0x18014d28e
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x180244344], r11d
lea rcx, [0x18024437c]
call fcn.180190560
movsxd rax, dword [0x180244344]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802443d4], edx
jle 0x18014d3a1
lea rcx, [0x1802443d4]
call fcn.1801905cc
cmp dword [0x1802443d4], 0xffffffff
jne 0x18014d3a1
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014d38e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014d332
mov rdx, r11
test rax, rax
je 0x18014d370
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 0x18014d350
cmp r9d, 0x7a1c884e
je 0x18014d37b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014d321
jmp 0x18014d38e
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x180244428], r11d
lea rcx, [0x1802443d4]
call fcn.180190560
movsxd rax, dword [0x180244428]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18014d3c0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180244424], edx
jle 0x18014d4a1
lea rcx, [0x180244424]
call fcn.1801905cc
cmp dword [0x180244424], 0xffffffff
jne 0x18014d4a1
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014d48e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014d432
mov rdx, r11
test rax, rax
je 0x18014d470
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 0x18014d450
cmp r9d, 0x7a1c884e
je 0x18014d47b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014d421
jmp 0x18014d48e
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x1802443c8], r11d
lea rcx, [0x180244424]
call fcn.180190560
movsxd rax, dword [0x1802443c8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18024256c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18024434c], edx
jle 0x18014d5a1
lea rcx, [0x18024434c]
call fcn.1801905cc
cmp dword [0x18024434c], 0xffffffff
jne 0x18014d5a1
mov rcx, qword [0x180243e98]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014d58e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014d532
mov rdx, r11
test rax, rax
je 0x18014d570
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 0x18014d550
cmp r9d, 0x7a1c884e
je 0x18014d57b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014d521
jmp 0x18014d58e
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180190160
mov r11d, eax
mov dword [0x180244388], r11d
lea rcx, [0x18024434c]
call fcn.180190560
movsxd rax, dword [0x180244388]
add rax, rbx
add rsp, 0x20
pop rbx
ret