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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022c008], edx
jle 0x1801411d4
lea rcx, [0x18022c008]
call fcn.18017f7fc
cmp dword [0x18022c008], 0xffffffff
jne 0x1801411d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801411be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141162
mov rdx, r11
test rax, rax
je 0x1801411a0
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 0x180141180
cmp r9d, 0x7a1c884e
je 0x1801411ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141151
jmp 0x1801411be
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 - 0x3c]
mov dword [0x18022bf6c], eax
lea rcx, [0x18022c008]
call fcn.18017f790
movsxd rax, dword [0x18022bf6c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf50], edx
jle 0x1801412d4
lea rcx, [0x18022bf50]
call fcn.18017f7fc
cmp dword [0x18022bf50], 0xffffffff
jne 0x1801412d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801412be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141262
mov rdx, r11
test rax, rax
je 0x1801412a0
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 0x180141280
cmp r9d, 0x7a1c884e
je 0x1801412ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141251
jmp 0x1801412be
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 - 0x2c]
mov dword [0x18022bf08], eax
lea rcx, [0x18022bf50]
call fcn.18017f790
movsxd rax, dword [0x18022bf08]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801412f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf00], edx
jle 0x1801413d4
lea rcx, [0x18022bf00]
call fcn.18017f7fc
cmp dword [0x18022bf00], 0xffffffff
jne 0x1801413d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801413be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141362
mov rdx, r11
test rax, rax
je 0x1801413a0
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 0x180141380
cmp r9d, 0x7a1c884e
je 0x1801413ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141351
jmp 0x1801413be
lea r8, str.m_fOnTarget
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 - 0x24]
mov dword [0x18022bf9c], eax
lea rcx, [0x18022bf00]
call fcn.18017f790
movsxd rax, dword [0x18022bf9c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf14], edx
jle 0x1801414d4
lea rcx, [0x18022bf14]
call fcn.18017f7fc
cmp dword [0x18022bf14], 0xffffffff
jne 0x1801414d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801414be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141462
mov rdx, r11
test rax, rax
je 0x1801414a0
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 0x180141480
cmp r9d, 0x7a1c884e
je 0x1801414ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141451
jmp 0x1801414be
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 + 0x48]
mov dword [0x18022bf0c], eax
lea rcx, [0x18022bf14]
call fcn.18017f790
movsxd rax, dword [0x18022bf0c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801414f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf24], edx
jle 0x1801415d4
lea rcx, [0x18022bf24]
call fcn.18017f7fc
cmp dword [0x18022bf24], 0xffffffff
jne 0x1801415d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801415be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141562
mov rdx, r11
test rax, rax
je 0x1801415a0
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 0x180141580
cmp r9d, 0x7a1c884e
je 0x1801415ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141551
jmp 0x1801415be
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 + 0x4c]
mov dword [0x18022bfec], eax
lea rcx, [0x18022bf24]
call fcn.18017f790
movsxd rax, dword [0x18022bfec]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfa4], edx
jle 0x1801416d4
lea rcx, [0x18022bfa4]
call fcn.18017f7fc
cmp dword [0x18022bfa4], 0xffffffff
jne 0x1801416d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801416be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141662
mov rdx, r11
test rax, rax
je 0x1801416a0
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 0x180141680
cmp r9d, 0x7a1c884e
je 0x1801416ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141651
jmp 0x1801416be
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 + 0x50]
mov dword [0x18022bfcc], eax
lea rcx, [0x18022bfa4]
call fcn.18017f790
movsxd rax, dword [0x18022bfcc]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801416f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf48], edx
jle 0x1801417d4
lea rcx, [0x18022bf48]
call fcn.18017f7fc
cmp dword [0x18022bf48], 0xffffffff
jne 0x1801417d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801417be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141762
mov rdx, r11
test rax, rax
je 0x1801417a0
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 0x180141780
cmp r9d, 0x7a1c884e
je 0x1801417ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141751
jmp 0x1801417be
lea r8, str.m_hLastWeapon
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 + 0x54]
mov dword [0x18022bf84], eax
lea rcx, [0x18022bf48]
call fcn.18017f790
movsxd rax, dword [0x18022bf84]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfa8], edx
jle 0x1801418d1
lea rcx, [0x18022bfa8]
call fcn.18017f7fc
cmp dword [0x18022bfa8], 0xffffffff
jne 0x1801418d1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801418be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141862
mov rdx, r11
test rax, rax
je 0x1801418a0
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 0x180141880
cmp r9d, 0x7c5cc931
je 0x1801418ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141851
jmp 0x1801418be
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf1c], r11d
lea rcx, [0x18022bfa8]
call fcn.18017f790
movsxd rax, dword [0x18022bf1c]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801418f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf54], edx
jle 0x1801419d1
lea rcx, [0x18022bf54]
call fcn.18017f7fc
cmp dword [0x18022bf54], 0xffffffff
jne 0x1801419d1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801419be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141962
mov rdx, r11
test rax, rax
je 0x1801419a0
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 0x180141980
cmp r9d, 0x7c5cc931
je 0x1801419ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141951
jmp 0x1801419be
lea r8, str.m_bJumping
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf70], r11d
lea rcx, [0x18022bf54]
call fcn.18017f790
movsxd rax, dword [0x18022bf70]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf78], edx
jle 0x180141ad1
lea rcx, [0x18022bf78]
call fcn.18017f7fc
cmp dword [0x18022bf78], 0xffffffff
jne 0x180141ad1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141abe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141a62
mov rdx, r11
test rax, rax
je 0x180141aa0
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 0x180141a80
cmp r9d, 0x7c5cc931
je 0x180141aab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141a51
jmp 0x180141abe
lea r8, str.m_iAirDash
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bfc0], r11d
lea rcx, [0x18022bf78]
call fcn.18017f790
movsxd rax, dword [0x18022bfc0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141af0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf94], edx
jle 0x180141bd1
lea rcx, [0x18022bf94]
call fcn.18017f7fc
cmp dword [0x18022bf94], 0xffffffff
jne 0x180141bd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141bbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141b62
mov rdx, r11
test rax, rax
je 0x180141ba0
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 0x180141b80
cmp r9d, 0x7c5cc931
je 0x180141bab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141b51
jmp 0x180141bbe
lea r8, str.m_nAirDucked
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bfe8], r11d
lea rcx, [0x18022bf94]
call fcn.18017f790
movsxd rax, dword [0x18022bfe8]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfbc], edx
jle 0x180141cd1
lea rcx, [0x18022bfbc]
call fcn.18017f7fc
cmp dword [0x18022bfbc], 0xffffffff
jne 0x180141cd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141cbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141c62
mov rdx, r11
test rax, rax
je 0x180141ca0
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 0x180141c80
cmp r9d, 0x7c5cc931
je 0x180141cab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141c51
jmp 0x180141cbe
lea r8, str.m_flHypeMeter
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bfc8], r11d
lea rcx, [0x18022bfbc]
call fcn.18017f790
movsxd rax, dword [0x18022bfc8]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141cf0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf74], edx
jle 0x180141dd1
lea rcx, [0x18022bf74]
call fcn.18017f7fc
cmp dword [0x18022bf74], 0xffffffff
jne 0x180141dd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141dbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141d62
mov rdx, r11
test rax, rax
je 0x180141da0
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 0x180141d80
cmp r9d, 0x7c5cc931
je 0x180141dab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141d51
jmp 0x180141dbe
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf98], r11d
lea rcx, [0x18022bf74]
call fcn.18017f790
movsxd rax, dword [0x18022bf98]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf4c], edx
jle 0x180141ed1
lea rcx, [0x18022bf4c]
call fcn.18017f7fc
cmp dword [0x18022bf4c], 0xffffffff
jne 0x180141ed1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141ebe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141e62
mov rdx, r11
test rax, rax
je 0x180141ea0
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 0x180141e80
cmp r9d, 0x7c5cc931
je 0x180141eab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141e51
jmp 0x180141ebe
lea r8, str.m_flCurrentTauntMoveSpeed
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022c000], r11d
lea rcx, [0x18022bf4c]
call fcn.18017f790
movsxd rax, dword [0x18022c000]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x180141ef0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf40], edx
jle 0x180141fd1
lea rcx, [0x18022bf40]
call fcn.18017f7fc
cmp dword [0x18022bf40], 0xffffffff
jne 0x180141fd1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x180141fbe
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180141f62
mov rdx, r11
test rax, rax
je 0x180141fa0
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 0x180141f80
cmp r9d, 0x7c5cc931
je 0x180141fab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180141f51
jmp 0x180141fbe
lea r8, str.m_flVehicleReverseTime
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bf60], r11d
lea rcx, [0x18022bf40]
call fcn.18017f790
movsxd rax, dword [0x18022bf60]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf3c], edx
jle 0x1801420d1
lea rcx, [0x18022bf3c]
call fcn.18017f7fc
cmp dword [0x18022bf3c], 0xffffffff
jne 0x1801420d1
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801420be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180142062
mov rdx, r11
test rax, rax
je 0x1801420a0
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 0x180142080
cmp r9d, 0x7c5cc931
je 0x1801420ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180142051
jmp 0x1801420be
lea r8, str.m_iKartState
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
mov dword [0x18022bef0], r11d
lea rcx, [0x18022bf3c]
call fcn.18017f790
movsxd rax, dword [0x18022bef0]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801420f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf30], edx
jle 0x1801421d4
lea rcx, [0x18022bf30]
call fcn.18017f7fc
cmp dword [0x18022bf30], 0xffffffff
jne 0x1801421d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801421be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180142162
mov rdx, r11
test rax, rax
je 0x1801421a0
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 0x180142180
cmp r9d, 0x7c5cc931
je 0x1801421ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180142151
jmp 0x1801421be
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 - 0x18]
mov dword [0x18022bf34], eax
lea rcx, [0x18022bf30]
call fcn.18017f790
movsxd rax, dword [0x18022bf34]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf04], edx
jle 0x1801422d4
lea rcx, [0x18022bf04]
call fcn.18017f7fc
cmp dword [0x18022bf04], 0xffffffff
jne 0x1801422d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801422be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180142262
mov rdx, r11
test rax, rax
je 0x1801422a0
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 0x180142280
cmp r9d, 0x7c5cc931
je 0x1801422ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180142251
jmp 0x1801422be
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 - 3]
mov dword [0x18022bf90], eax
lea rcx, [0x18022bf04]
call fcn.18017f790
movsxd rax, dword [0x18022bf90]
add rax, rbx
add rsp, 0x20
pop rbx
ret
Function at 0x1801422f0
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bf64], edx
jle 0x1801423d4
lea rcx, [0x18022bf64]
call fcn.18017f7fc
cmp dword [0x18022bf64], 0xffffffff
jne 0x1801423d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801423be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180142362
mov rdx, r11
test rax, rax
je 0x1801423a0
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 0x180142380
cmp r9d, 0x7c5cc931
je 0x1801423ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180142351
jmp 0x1801423be
lea r8, str.m_nWaterLevel
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 + 1]
mov dword [0x18022bf8c], eax
lea rcx, [0x18022bf64]
call fcn.18017f790
movsxd rax, dword [0x18022bf8c]
add rax, rbx
add rsp, 0x20
pop rbx
ret

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

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
mov edx, dword [0x18022a150]
mov rax, qword gs:[0x58]
mov ecx, 4
mov rax, qword [rax + rdx*8]
mov edx, dword [rcx + rax]
cmp dword [0x18022bfb8], edx
jle 0x1801424d4
lea rcx, [0x18022bfb8]
call fcn.18017f7fc
cmp dword [0x18022bfb8], 0xffffffff
jne 0x1801424d4
mov rcx, qword [0x18022ba50]
mov rax, qword [rcx]
call qword [rax + 0x40]
mov r10, rax
xor r11d, r11d
test rax, rax
je 0x1801424be
mov r8, qword [r10 + 0x10]
mov rax, 0xffffffffffffffff
mov r9d, 0x811c9dc5
inc rax
cmp byte [r8 + rax], r11b
jne 0x180142462
mov rdx, r11
test rax, rax
je 0x1801424a0
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 0x180142480
cmp r9d, 0x7c5cc931
je 0x1801424ab
mov r10, qword [r10 + 0x20]
test r10, r10
jne 0x180142451
jmp 0x1801424be
lea r8, str.m_flTauntYaw
mov rdx, qword [r10 + 0x18]
call fcn.18017f390
mov r11d, eax
lea eax, [r11 + 4]
mov dword [0x18022bf18], eax
lea rcx, [0x18022bfb8]
call fcn.18017f790
movsxd rax, dword [0x18022bf18]
add rax, rbx
add rsp, 0x20
pop rbx
ret