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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fa8], edx
jle 0x180143de4
lea rcx, [0x180230fa8]
call fcn.18018237c
cmp dword [0x180230fa8], 0xffffffff
jne 0x180143de4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143dce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143d72
mov rdx, r11
test rax, rax
je 0x180143db0
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 0x180143d90
cmp r9d, 0x7a1c884e
je 0x180143dbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143d61
jmp 0x180143dce
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x180231070], eax
lea rcx, [0x180230fa8]
call fcn.180182310
movsxd rax, dword [0x180231070]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231028], edx
jle 0x180143ee4
lea rcx, [0x180231028]
call fcn.18018237c
cmp dword [0x180231028], 0xffffffff
jne 0x180143ee4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143ece
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143e72
mov rdx, r11
test rax, rax
je 0x180143eb0
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 0x180143e90
cmp r9d, 0x7a1c884e
je 0x180143ebb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143e61
jmp 0x180143ece
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x180231050], eax
lea rcx, [0x180231028]
call fcn.180182310
movsxd rax, dword [0x180231050]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180143f00
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fd0], edx
jle 0x180143fe4
lea rcx, [0x180230fd0]
call fcn.18018237c
cmp dword [0x180230fd0], 0xffffffff
jne 0x180143fe4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180143fce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180143f72
mov rdx, r11
test rax, rax
je 0x180143fb0
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 0x180143f90
cmp r9d, 0x7a1c884e
je 0x180143fbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180143f61
jmp 0x180143fce
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x180231008], eax
lea rcx, [0x180230fd0]
call fcn.180182310
movsxd rax, dword [0x180231008]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231030], edx
jle 0x1801440e1
lea rcx, [0x180231030]
call fcn.18018237c
cmp dword [0x180231030], 0xffffffff
jne 0x1801440e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801440ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144072
mov rdx, r11
test rax, rax
je 0x1801440b0
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 0x180144090
cmp r9d, 0x7c5cc931
je 0x1801440bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144061
jmp 0x1801440ce
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230fa4], r11d
lea rcx, [0x180231030]
call fcn.180182310
movsxd rax, dword [0x180230fa4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144100
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fd8], edx
jle 0x1801441e1
lea rcx, [0x180230fd8]
call fcn.18018237c
cmp dword [0x180230fd8], 0xffffffff
jne 0x1801441e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801441ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144172
mov rdx, r11
test rax, rax
je 0x1801441b0
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 0x180144190
cmp r9d, 0x7c5cc931
je 0x1801441bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144161
jmp 0x1801441ce
lea r8, str.m_bJumping
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230ff0], r11d
lea rcx, [0x180230fd8]
call fcn.180182310
movsxd rax, dword [0x180230ff0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230ffc], edx
jle 0x1801442e1
lea rcx, [0x180230ffc]
call fcn.18018237c
cmp dword [0x180230ffc], 0xffffffff
jne 0x1801442e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801442ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144272
mov rdx, r11
test rax, rax
je 0x1801442b0
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 0x180144290
cmp r9d, 0x7c5cc931
je 0x1801442bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144261
jmp 0x1801442ce
lea r8, str.m_iAirDash
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180231044], r11d
lea rcx, [0x180230ffc]
call fcn.180182310
movsxd rax, dword [0x180231044]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144300
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231018], edx
jle 0x1801443e1
lea rcx, [0x180231018]
call fcn.18018237c
cmp dword [0x180231018], 0xffffffff
jne 0x1801443e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801443ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144372
mov rdx, r11
test rax, rax
je 0x1801443b0
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 0x180144390
cmp r9d, 0x7c5cc931
je 0x1801443bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144361
jmp 0x1801443ce
lea r8, str.m_nAirDucked
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x18023106c], r11d
lea rcx, [0x180231018]
call fcn.180182310
movsxd rax, dword [0x18023106c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180231040], edx
jle 0x1801444e1
lea rcx, [0x180231040]
call fcn.18018237c
cmp dword [0x180231040], 0xffffffff
jne 0x1801444e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801444ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144472
mov rdx, r11
test rax, rax
je 0x1801444b0
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 0x180144490
cmp r9d, 0x7c5cc931
je 0x1801444bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144461
jmp 0x1801444ce
lea r8, str.m_flHypeMeter
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x18023104c], r11d
lea rcx, [0x180231040]
call fcn.180182310
movsxd rax, dword [0x18023104c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144500
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230ff8], edx
jle 0x1801445e1
lea rcx, [0x180230ff8]
call fcn.18018237c
cmp dword [0x180230ff8], 0xffffffff
jne 0x1801445e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801445ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144572
mov rdx, r11
test rax, rax
je 0x1801445b0
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 0x180144590
cmp r9d, 0x7c5cc931
je 0x1801445bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144561
jmp 0x1801445ce
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x18023101c], r11d
lea rcx, [0x180230ff8]
call fcn.180182310
movsxd rax, dword [0x18023101c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fd4], edx
jle 0x1801446e1
lea rcx, [0x180230fd4]
call fcn.18018237c
cmp dword [0x180230fd4], 0xffffffff
jne 0x1801446e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801446ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144672
mov rdx, r11
test rax, rax
je 0x1801446b0
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 0x180144690
cmp r9d, 0x7c5cc931
je 0x1801446bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144661
jmp 0x1801446ce
lea r8, str.m_flCurrentTauntMoveSpeed
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180231088], r11d
lea rcx, [0x180230fd4]
call fcn.180182310
movsxd rax, dword [0x180231088]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144700
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fc8], edx
jle 0x1801447e1
lea rcx, [0x180230fc8]
call fcn.18018237c
cmp dword [0x180230fc8], 0xffffffff
jne 0x1801447e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801447ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144772
mov rdx, r11
test rax, rax
je 0x1801447b0
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 0x180144790
cmp r9d, 0x7c5cc931
je 0x1801447bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144761
jmp 0x1801447ce
lea r8, str.m_flVehicleReverseTime
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230fe4], r11d
lea rcx, [0x180230fc8]
call fcn.180182310
movsxd rax, dword [0x180230fe4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fc4], edx
jle 0x1801448e1
lea rcx, [0x180230fc4]
call fcn.18018237c
cmp dword [0x180230fc4], 0xffffffff
jne 0x1801448e1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801448ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144872
mov rdx, r11
test rax, rax
je 0x1801448b0
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 0x180144890
cmp r9d, 0x7c5cc931
je 0x1801448bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144861
jmp 0x1801448ce
lea r8, str.m_iKartState
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x180230f78], r11d
lea rcx, [0x180230fc4]
call fcn.180182310
movsxd rax, dword [0x180230f78]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144900
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fbc], edx
jle 0x1801449e4
lea rcx, [0x180230fbc]
call fcn.18018237c
cmp dword [0x180230fbc], 0xffffffff
jne 0x1801449e4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801449ce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144972
mov rdx, r11
test rax, rax
je 0x1801449b0
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 0x180144990
cmp r9d, 0x7c5cc931
je 0x1801449bb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144961
jmp 0x1801449ce
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 0x18]
mov dword [0x180230fb8], eax
lea rcx, [0x180230fbc]
call fcn.180182310
movsxd rax, dword [0x180230fb8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230f8c], edx
jle 0x180144ae4
lea rcx, [0x180230f8c]
call fcn.18018237c
cmp dword [0x180230f8c], 0xffffffff
jne 0x180144ae4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144ace
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144a72
mov rdx, r11
test rax, rax
je 0x180144ab0
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 0x180144a90
cmp r9d, 0x7c5cc931
je 0x180144abb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144a61
jmp 0x180144ace
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 - 3]
mov dword [0x180231014], eax
lea rcx, [0x180230f8c]
call fcn.180182310
movsxd rax, dword [0x180231014]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180144b00
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180230fe8], edx
jle 0x180144be4
lea rcx, [0x180230fe8]
call fcn.18018237c
cmp dword [0x180230fe8], 0xffffffff
jne 0x180144be4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144bce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144b72
mov rdx, r11
test rax, rax
je 0x180144bb0
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 0x180144b90
cmp r9d, 0x7c5cc931
je 0x180144bbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144b61
jmp 0x180144bce
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 + 1]
mov dword [0x180231010], eax
lea rcx, [0x180230fe8]
call fcn.180182310
movsxd rax, dword [0x180231010]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18023103c], edx
jle 0x180144ce4
lea rcx, [0x18023103c]
call fcn.18018237c
cmp dword [0x18023103c], 0xffffffff
jne 0x180144ce4
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180144cce
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180144c72
mov rdx, r11
test rax, rax
je 0x180144cb0
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 0x180144c90
cmp r9d, 0x7c5cc931
je 0x180144cbb
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180144c61
jmp 0x180144cce
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
lea eax, [r11 + 4]
mov dword [0x180230fa0], eax
lea rcx, [0x18023103c]
call fcn.180182310
movsxd rax, dword [0x180230fa0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18014aaf0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802310c8], edx
jle 0x18014abd1
lea rcx, [0x1802310c8]
call fcn.18018237c
cmp dword [0x1802310c8], 0xffffffff
jne 0x18014abd1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014abbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ab62
mov rdx, r11
test rax, rax
je 0x18014aba0
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 0x18014ab80
cmp r9d, 0x14cce891
je 0x18014abab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014ab51
jmp 0x18014abbe
lea r8, str.m_hLauncher
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x1802310bc], r11d
lea rcx, [0x1802310c8]
call fcn.180182310
movsxd rax, dword [0x1802310bc]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802310b0], edx
jle 0x18014acd1
lea rcx, [0x1802310b0]
call fcn.18018237c
cmp dword [0x1802310b0], 0xffffffff
jne 0x18014acd1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014acbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ac62
mov rdx, r11
test rax, rax
je 0x18014aca0
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 0x18014ac80
cmp r9d, 0xd134a6b7
je 0x18014acab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014ac51
jmp 0x18014acbe
lea r8, str.m_hOwner
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x1802310c4], r11d
lea rcx, [0x1802310b0]
call fcn.180182310
movsxd rax, dword [0x1802310c4]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x18014acf0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802310b8], edx
jle 0x18014add1
lea rcx, [0x1802310b8]
call fcn.18018237c
cmp dword [0x1802310b8], 0xffffffff
jne 0x18014add1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014adbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ad62
mov rdx, r11
test rax, rax
je 0x18014ada0
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 0x18014ad80
cmp r9d, 0xc262c48c
je 0x18014adab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014ad51
jmp 0x18014adbe
lea r8, str.m_hBuilder
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x1802310b4], r11d
lea rcx, [0x1802310b8]
call fcn.180182310
movsxd rax, dword [0x1802310b4]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022f1ec]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802310c0], edx
jle 0x18014aed1
lea rcx, [0x1802310c0]
call fcn.18018237c
cmp dword [0x1802310c0], 0xffffffff
jne 0x18014aed1
mov rcx, qword [0x180230ae0]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18014aebe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x18014ae62
mov rdx, r11
test rax, rax
je 0x18014aea0
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 0x18014ae80
cmp r9d, 0x8d97f7e7
je 0x18014aeab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x18014ae51
jmp 0x18014aebe
lea r8, str.m_hPlayer
mov rdx, qword [r10 + 0x18]
call fcn.180181f10
mov r11d, eax
mov dword [0x1802310ac], r11d
lea rcx, [0x1802310c0]
call fcn.180182310
movsxd rax, dword [0x1802310ac]
add rax, rbx
add rsp, 0x20
pop rbx
ret