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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297700], edx
jle 0x180155f64
lea rcx, [0x180297700]
call fcn.180199ce8
cmp dword [0x180297700], 0xffffffff
jne 0x180155f64
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180155f4e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180155ef2
mov rdx, r11
test rax, rax
je 0x180155f30
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 0x180155f10
cmp r9d, 0x7a1c884e
je 0x180155f3b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180155ee1
jmp 0x180155f4e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x180297654], eax
lea rcx, [0x180297700]
call fcn.180199c7c
movsxd rax, dword [0x180297654]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297644], edx
jle 0x180156064
lea rcx, [0x180297644]
call fcn.180199ce8
cmp dword [0x180297644], 0xffffffff
jne 0x180156064
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015604e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180155ff2
mov rdx, r11
test rax, rax
je 0x180156030
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 0x180156010
cmp r9d, 0x7a1c884e
je 0x18015603b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180155fe1
jmp 0x18015604e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x1802975f8], eax
lea rcx, [0x180297644]
call fcn.180199c7c
movsxd rax, dword [0x1802975f8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180156080
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802975f0], edx
jle 0x180156164
lea rcx, [0x1802975f0]
call fcn.180199ce8
cmp dword [0x1802975f0], 0xffffffff
jne 0x180156164
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015614e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801560f2
mov rdx, r11
test rax, rax
je 0x180156130
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 0x180156110
cmp r9d, 0x7a1c884e
je 0x18015613b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801560e1
jmp 0x18015614e
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x18029768c], eax
lea rcx, [0x1802975f0]
call fcn.180199c7c
movsxd rax, dword [0x18029768c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18029760c], edx
jle 0x180156264
lea rcx, [0x18029760c]
call fcn.180199ce8
cmp dword [0x18029760c], 0xffffffff
jne 0x180156264
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015624e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801561f2
mov rdx, r11
test rax, rax
je 0x180156230
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 0x180156210
cmp r9d, 0x7a1c884e
je 0x18015623b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801561e1
jmp 0x18015624e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x1802975fc], eax
lea rcx, [0x18029760c]
call fcn.180199c7c
movsxd rax, dword [0x1802975fc]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180156280
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297614], edx
jle 0x180156364
lea rcx, [0x180297614]
call fcn.180199ce8
cmp dword [0x180297614], 0xffffffff
jne 0x180156364
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015634e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801562f2
mov rdx, r11
test rax, rax
je 0x180156330
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 0x180156310
cmp r9d, 0x7a1c884e
je 0x18015633b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801562e1
jmp 0x18015634e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x1802976dc], eax
lea rcx, [0x180297614]
call fcn.180199c7c
movsxd rax, dword [0x1802976dc]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297694], edx
jle 0x180156464
lea rcx, [0x180297694]
call fcn.180199ce8
cmp dword [0x180297694], 0xffffffff
jne 0x180156464
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015644e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801563f2
mov rdx, r11
test rax, rax
je 0x180156430
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 0x180156410
cmp r9d, 0x7a1c884e
je 0x18015643b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801563e1
jmp 0x18015644e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x1802976bc], eax
lea rcx, [0x180297694]
call fcn.180199c7c
movsxd rax, dword [0x1802976bc]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180156480
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297638], edx
jle 0x180156564
lea rcx, [0x180297638]
call fcn.180199ce8
cmp dword [0x180297638], 0xffffffff
jne 0x180156564
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015654e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x1801564f2
mov rdx, r11
test rax, rax
je 0x180156530
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 0x180156510
cmp r9d, 0x7a1c884e
je 0x18015653b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801564e1
jmp 0x18015654e
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x180297674], eax
lea rcx, [0x180297638]
call fcn.180199c7c
movsxd rax, dword [0x180297674]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
mov qword [rsp + 8], rbx
push rdi
sub rsp, 0x20
mov rbx, rdx
mov rdi, rcx
mov r8d, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + r8*8]
mov r8d, dword [rcx + rax]
cmp dword [0x1802976f0], r8d
jle 0x180156674
lea rcx, [0x1802976f0]
call fcn.180199ce8
cmp dword [0x1802976f0], 0xffffffff
jne 0x180156674
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015665e
nop dword [rax + rax]
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156601
mov rdx, r11
test rax, rax
je 0x180156640
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 0x180156620
cmp r9d, 0x7a1c884e
je 0x18015664b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801565f0
jmp 0x18015665e
lea r8, str.m_hConstraintEntity
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 - 8]
mov dword [0x180297650], eax
lea rcx, [0x1802976f0]
call fcn.180199c7c
movsxd rax, dword [0x180297650]
mov qword [rax + rdi], rbx
mov rbx, qword [rsp + 0x30]
add rsp, 0x20
pop rdi
ret
Function at 0x180156690
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18029769c], edx
jle 0x180156771
lea rcx, [0x18029769c]
call fcn.180199ce8
cmp dword [0x18029769c], 0xffffffff
jne 0x180156771
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015675e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156702
mov rdx, r11
test rax, rax
je 0x180156740
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 0x180156720
cmp r9d, 0x7c5cc931
je 0x18015674b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801566f1
jmp 0x18015675e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x180297604], r11d
lea rcx, [0x18029769c]
call fcn.180199c7c
movsxd rax, dword [0x180297604]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297640], edx
jle 0x180156871
lea rcx, [0x180297640]
call fcn.180199ce8
cmp dword [0x180297640], 0xffffffff
jne 0x180156871
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015685e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156802
mov rdx, r11
test rax, rax
je 0x180156840
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 0x180156820
cmp r9d, 0x7c5cc931
je 0x18015684b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801567f1
jmp 0x18015685e
lea r8, str.m_bJumping
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x18029765c], r11d
lea rcx, [0x180297640]
call fcn.180199c7c
movsxd rax, dword [0x18029765c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180156890
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297668], edx
jle 0x180156971
lea rcx, [0x180297668]
call fcn.180199ce8
cmp dword [0x180297668], 0xffffffff
jne 0x180156971
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015695e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156902
mov rdx, r11
test rax, rax
je 0x180156940
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 0x180156920
cmp r9d, 0x7c5cc931
je 0x18015694b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801568f1
jmp 0x18015695e
lea r8, str.m_iAirDash
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802976b0], r11d
lea rcx, [0x180297668]
call fcn.180199c7c
movsxd rax, dword [0x1802976b0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297684], edx
jle 0x180156a71
lea rcx, [0x180297684]
call fcn.180199ce8
cmp dword [0x180297684], 0xffffffff
jne 0x180156a71
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180156a5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156a02
mov rdx, r11
test rax, rax
je 0x180156a40
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 0x180156a20
cmp r9d, 0x7c5cc931
je 0x180156a4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801569f1
jmp 0x180156a5e
lea r8, str.m_nAirDucked
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802976d8], r11d
lea rcx, [0x180297684]
call fcn.180199c7c
movsxd rax, dword [0x1802976d8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180156a90
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802976ac], edx
jle 0x180156b71
lea rcx, [0x1802976ac]
call fcn.180199ce8
cmp dword [0x1802976ac], 0xffffffff
jne 0x180156b71
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180156b5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156b02
mov rdx, r11
test rax, rax
je 0x180156b40
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 0x180156b20
cmp r9d, 0x7c5cc931
je 0x180156b4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180156af1
jmp 0x180156b5e
lea r8, str.m_flHypeMeter
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802976b8], r11d
lea rcx, [0x1802976ac]
call fcn.180199c7c
movsxd rax, dword [0x1802976b8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297664], edx
jle 0x180156c71
lea rcx, [0x180297664]
call fcn.180199ce8
cmp dword [0x180297664], 0xffffffff
jne 0x180156c71
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180156c5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156c02
mov rdx, r11
test rax, rax
je 0x180156c40
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 0x180156c20
cmp r9d, 0x7c5cc931
je 0x180156c4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180156bf1
jmp 0x180156c5e
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x180297688], r11d
lea rcx, [0x180297664]
call fcn.180199c7c
movsxd rax, dword [0x180297688]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180156c90
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18029763c], edx
jle 0x180156d71
lea rcx, [0x18029763c]
call fcn.180199ce8
cmp dword [0x18029763c], 0xffffffff
jne 0x180156d71
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180156d5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156d02
mov rdx, r11
test rax, rax
je 0x180156d40
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 0x180156d20
cmp r9d, 0x7c5cc931
je 0x180156d4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180156cf1
jmp 0x180156d5e
lea r8, str.m_flCurrentTauntMoveSpeed
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802976f8], r11d
lea rcx, [0x18029763c]
call fcn.180199c7c
movsxd rax, dword [0x1802976f8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297630], edx
jle 0x180156e71
lea rcx, [0x180297630]
call fcn.180199ce8
cmp dword [0x180297630], 0xffffffff
jne 0x180156e71
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180156e5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156e02
mov rdx, r11
test rax, rax
je 0x180156e40
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 0x180156e20
cmp r9d, 0x7c5cc931
je 0x180156e4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180156df1
jmp 0x180156e5e
lea r8, str.m_flVehicleReverseTime
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x18029764c], r11d
lea rcx, [0x180297630]
call fcn.180199c7c
movsxd rax, dword [0x18029764c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180156e90
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18029762c], edx
jle 0x180156f71
lea rcx, [0x18029762c]
call fcn.180199ce8
cmp dword [0x18029762c], 0xffffffff
jne 0x180156f71
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180156f5e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180156f02
mov rdx, r11
test rax, rax
je 0x180156f40
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 0x180156f20
cmp r9d, 0x7c5cc931
je 0x180156f4b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180156ef1
jmp 0x180156f5e
lea r8, str.m_iKartState
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
mov dword [0x1802975e0], r11d
lea rcx, [0x18029762c]
call fcn.180199c7c
movsxd rax, dword [0x1802975e0]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297620], edx
jle 0x180157074
lea rcx, [0x180297620]
call fcn.180199ce8
cmp dword [0x180297620], 0xffffffff
jne 0x180157074
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015705e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180157002
mov rdx, r11
test rax, rax
je 0x180157040
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 0x180157020
cmp r9d, 0x7c5cc931
je 0x18015704b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180156ff1
jmp 0x18015705e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 - 0x18]
mov dword [0x180297624], eax
lea rcx, [0x180297620]
call fcn.180199c7c
movsxd rax, dword [0x180297624]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180157090
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x1802975f4], edx
jle 0x180157174
lea rcx, [0x1802975f4]
call fcn.180199ce8
cmp dword [0x1802975f4], 0xffffffff
jne 0x180157174
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015715e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180157102
mov rdx, r11
test rax, rax
je 0x180157140
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 0x180157120
cmp r9d, 0x7c5cc931
je 0x18015714b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801570f1
jmp 0x18015715e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 - 3]
mov dword [0x18029767c], eax
lea rcx, [0x1802975f4]
call fcn.180199c7c
movsxd rax, dword [0x18029767c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18029475c]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x180297658], edx
jle 0x180157274
lea rcx, [0x180297658]
call fcn.180199ce8
cmp dword [0x180297658], 0xffffffff
jne 0x180157274
mov rcx, qword [0x180297128]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x18015725e
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180157202
mov rdx, r11
test rax, rax
je 0x180157240
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 0x180157220
cmp r9d, 0x7c5cc931
je 0x18015724b
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x1801571f1
jmp 0x18015725e
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.180199880
mov r11d, eax
lea eax, [r11 + 1]
mov dword [0x180297680], eax
lea rcx, [0x180297658]
call fcn.180199c7c
movsxd rax, dword [0x180297680]
add rax, rbx
add rsp, 0x20
pop rbx
ret