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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235050], edx
jle 0x180145081
lea rcx, [0x180235050]
call fcn.180184dbc
cmp dword [0x180235050], 0xffffffff
jne 0x180145081
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014506e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145012
mov rdx, r11
test rax, rax
je 0x180145050
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 0x180145030
cmp r9d, 0x7a1c884e
je 0x18014505b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145001
jmp 0x18014506e
lea r8, str.m_bInDuckJump
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x18023501c], r11d
lea rcx, [0x180235050]
call fcn.180184d50
movsxd rax, dword [0x18023501c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350ac], edx
jle 0x180145181
lea rcx, [0x1802350ac]
call fcn.180184dbc
cmp dword [0x1802350ac], 0xffffffff
jne 0x180145181
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014516e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145112
mov rdx, r11
test rax, rax
je 0x180145150
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 0x180145130
cmp r9d, 0x7a1c884e
je 0x18014515b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145101
jmp 0x18014516e
lea r8, str.m_flDucktime
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x180235100], r11d
lea rcx, [0x1802350ac]
call fcn.180184d50
movsxd rax, dword [0x180235100]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801451a0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350fc], edx
jle 0x180145281
lea rcx, [0x1802350fc]
call fcn.180184dbc
cmp dword [0x1802350fc], 0xffffffff
jne 0x180145281
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014526e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145212
mov rdx, r11
test rax, rax
je 0x180145250
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 0x180145230
cmp r9d, 0x7a1c884e
je 0x18014525b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145201
jmp 0x18014526e
lea r8, str.m_flDuckJumpTime
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x1802350a0], r11d
lea rcx, [0x1802350fc]
call fcn.180184d50
movsxd rax, dword [0x1802350a0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235024], edx
jle 0x180145381
lea rcx, [0x180235024]
call fcn.180184dbc
cmp dword [0x180235024], 0xffffffff
jne 0x180145381
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014536e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145312
mov rdx, r11
test rax, rax
je 0x180145350
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 0x180145330
cmp r9d, 0x7a1c884e
je 0x18014535b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145301
jmp 0x18014536e
lea r8, str.m_flFallVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x180235060], r11d
lea rcx, [0x180235024]
call fcn.180184d50
movsxd rax, dword [0x180235060]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801453a0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023506c], edx
jle 0x180145481
lea rcx, [0x18023506c]
call fcn.180184dbc
cmp dword [0x18023506c], 0xffffffff
jne 0x180145481
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014546e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145412
mov rdx, r11
test rax, rax
je 0x180145450
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 0x180145430
cmp r9d, 0x7a1c884e
je 0x18014545b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145401
jmp 0x18014546e
lea r8, str.m_vecPunchAngle
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x1802350f4], r11d
lea rcx, [0x18023506c]
call fcn.180184d50
movsxd rax, dword [0x1802350f4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235108], edx
jle 0x180145581
lea rcx, [0x180235108]
call fcn.180184dbc
cmp dword [0x180235108], 0xffffffff
jne 0x180145581
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014556e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145512
mov rdx, r11
test rax, rax
je 0x180145550
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 0x180145530
cmp r9d, 0x7a1c884e
je 0x18014555b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145501
jmp 0x18014556e
lea r8, str.m_vecPunchAngleVel
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x180235038], r11d
lea rcx, [0x180235108]
call fcn.180184d50
movsxd rax, dword [0x180235038]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801455a0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235104], edx
jle 0x180145681
lea rcx, [0x180235104]
call fcn.180184dbc
cmp dword [0x180235104], 0xffffffff
jne 0x180145681
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014566e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145612
mov rdx, r11
test rax, rax
je 0x180145650
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 0x180145630
cmp r9d, 0x7a1c884e
je 0x18014565b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145601
jmp 0x18014566e
lea r8, str.m_vecBaseVelocity
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x1802350d4], r11d
lea rcx, [0x180235104]
call fcn.180184d50
movsxd rax, dword [0x1802350d4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235124], edx
jle 0x180145784
lea rcx, [0x180235124]
call fcn.180184dbc
cmp dword [0x180235124], 0xffffffff
jne 0x180145784
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014576e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145712
mov rdx, r11
test rax, rax
je 0x180145750
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 0x180145730
cmp r9d, 0x7a1c884e
je 0x18014575b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145701
jmp 0x18014576e
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 - 0xc]
mov dword [0x180235080], eax
lea rcx, [0x180235124]
call fcn.180184d50
movsxd rax, dword [0x180235080]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801457a0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235130], edx
jle 0x180145884
lea rcx, [0x180235130]
call fcn.180184dbc
cmp dword [0x180235130], 0xffffffff
jne 0x180145884
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014586e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145812
mov rdx, r11
test rax, rax
je 0x180145850
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 0x180145830
cmp r9d, 0x7a1c884e
je 0x18014585b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145801
jmp 0x18014586e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x180235090], eax
lea rcx, [0x180235130]
call fcn.180184d50
movsxd rax, dword [0x180235090]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023507c], edx
jle 0x180145984
lea rcx, [0x18023507c]
call fcn.180184dbc
cmp dword [0x18023507c], 0xffffffff
jne 0x180145984
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014596e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145912
mov rdx, r11
test rax, rax
je 0x180145950
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 0x180145930
cmp r9d, 0x7a1c884e
je 0x18014595b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145901
jmp 0x18014596e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x180235030], eax
lea rcx, [0x18023507c]
call fcn.180184d50
movsxd rax, dword [0x180235030]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801459a0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235028], edx
jle 0x180145a84
lea rcx, [0x180235028]
call fcn.180184dbc
cmp dword [0x180235028], 0xffffffff
jne 0x180145a84
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145a6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145a12
mov rdx, r11
test rax, rax
je 0x180145a50
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 0x180145a30
cmp r9d, 0x7a1c884e
je 0x180145a5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145a01
jmp 0x180145a6e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x1802350c0], eax
lea rcx, [0x180235028]
call fcn.180184d50
movsxd rax, dword [0x1802350c0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023503c], edx
jle 0x180145b84
lea rcx, [0x18023503c]
call fcn.180184dbc
cmp dword [0x18023503c], 0xffffffff
jne 0x180145b84
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145b6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145b12
mov rdx, r11
test rax, rax
je 0x180145b50
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 0x180145b30
cmp r9d, 0x7a1c884e
je 0x180145b5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145b01
jmp 0x180145b6e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x180235034], eax
lea rcx, [0x18023503c]
call fcn.180184d50
movsxd rax, dword [0x180235034]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180145ba0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235048], edx
jle 0x180145c84
lea rcx, [0x180235048]
call fcn.180184dbc
cmp dword [0x180235048], 0xffffffff
jne 0x180145c84
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145c6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145c12
mov rdx, r11
test rax, rax
je 0x180145c50
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 0x180145c30
cmp r9d, 0x7a1c884e
je 0x180145c5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145c01
jmp 0x180145c6e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x180235110], eax
lea rcx, [0x180235048]
call fcn.180184d50
movsxd rax, dword [0x180235110]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350c8], edx
jle 0x180145d84
lea rcx, [0x1802350c8]
call fcn.180184dbc
cmp dword [0x1802350c8], 0xffffffff
jne 0x180145d84
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145d6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145d12
mov rdx, r11
test rax, rax
je 0x180145d50
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 0x180145d30
cmp r9d, 0x7a1c884e
je 0x180145d5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145d01
jmp 0x180145d6e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x1802350f0], eax
lea rcx, [0x1802350c8]
call fcn.180184d50
movsxd rax, dword [0x1802350f0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180145da0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235070], edx
jle 0x180145e84
lea rcx, [0x180235070]
call fcn.180184dbc
cmp dword [0x180235070], 0xffffffff
jne 0x180145e84
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145e6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145e12
mov rdx, r11
test rax, rax
je 0x180145e50
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 0x180145e30
cmp r9d, 0x7a1c884e
je 0x180145e5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145e01
jmp 0x180145e6e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x1802350a8], eax
lea rcx, [0x180235070]
call fcn.180184d50
movsxd rax, dword [0x1802350a8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350cc], edx
jle 0x180145f81
lea rcx, [0x1802350cc]
call fcn.180184dbc
cmp dword [0x1802350cc], 0xffffffff
jne 0x180145f81
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180145f6e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180145f12
mov rdx, r11
test rax, rax
je 0x180145f50
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 0x180145f30
cmp r9d, 0x7c5cc931
je 0x180145f5b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180145f01
jmp 0x180145f6e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x180235040], r11d
lea rcx, [0x1802350cc]
call fcn.180184d50
movsxd rax, dword [0x180235040]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180145fa0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180235078], edx
jle 0x180146081
lea rcx, [0x180235078]
call fcn.180184dbc
cmp dword [0x180235078], 0xffffffff
jne 0x180146081
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014606e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180146012
mov rdx, r11
test rax, rax
je 0x180146050
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 0x180146030
cmp r9d, 0x7c5cc931
je 0x18014605b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180146001
jmp 0x18014606e
lea r8, str.m_bJumping
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x180235094], r11d
lea rcx, [0x180235078]
call fcn.180184d50
movsxd rax, dword [0x180235094]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023509c], edx
jle 0x180146181
lea rcx, [0x18023509c]
call fcn.180184dbc
cmp dword [0x18023509c], 0xffffffff
jne 0x180146181
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014616e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180146112
mov rdx, r11
test rax, rax
je 0x180146150
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 0x180146130
cmp r9d, 0x7c5cc931
je 0x18014615b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180146101
jmp 0x18014616e
lea r8, str.m_iAirDash
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x1802350e4], r11d
lea rcx, [0x18023509c]
call fcn.180184d50
movsxd rax, dword [0x1802350e4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801461a0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350b8], edx
jle 0x180146281
lea rcx, [0x1802350b8]
call fcn.180184dbc
cmp dword [0x1802350b8], 0xffffffff
jne 0x180146281
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014626e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180146212
mov rdx, r11
test rax, rax
je 0x180146250
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 0x180146230
cmp r9d, 0x7c5cc931
je 0x18014625b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180146201
jmp 0x18014626e
lea r8, str.m_nAirDucked
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x18023510c], r11d
lea rcx, [0x1802350b8]
call fcn.180184d50
movsxd rax, dword [0x18023510c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18023327c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802350e0], edx
jle 0x180146381
lea rcx, [0x1802350e0]
call fcn.180184dbc
cmp dword [0x1802350e0], 0xffffffff
jne 0x180146381
mov rcx, qword [0x180234b78]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014636e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180146312
mov rdx, r11
test rax, rax
je 0x180146350
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 0x180146330
cmp r9d, 0x7c5cc931
je 0x18014635b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180146301
jmp 0x18014636e
lea r8, str.m_flHypeMeter
mov rdx, qword [r10 + 0x18]
call fcn.180184950
mov r11d, eax
mov dword [0x1802350ec], r11d
lea rcx, [0x1802350e0]
call fcn.180184d50
movsxd rax, dword [0x1802350ec]
add rax, rbx
add rsp, 0x20
pop rbx
ret