joyce8/EMBER2024-capa huggingface dataset:
Function at 0x14005ecb0
Capabilities:
Query environment variable

Disassembly:
mov rax, rsp
mov qword [rax + 8], rbx
mov qword [rax + 0x10], rbp
mov qword [rax + 0x18], rsi
mov qword [rax + 0x20], rdi
push r14
sub rsp, 0x50
mov r14, rdx
mov rdi, rcx
mov rdx, rcx
mov rcx, r14
call fcn.140033438
mov rcx, rdi
cmp qword [rdi + 0x18], 8
jb 0x14005ece7
mov rcx, qword [rdi]
mov qword [rsp + 0x20], 1
lea r9, [0x140086e0c]
xor r8d, r8d
mov rdx, qword [rdi + 0x10]
call fcn.14003e990
cmp rax, 0xffffffffffffffff
jne 0x14005ed10
mov al, 1
jmp 0x14005edba
mov rcx, rdi
cmp qword [rdi + 0x18], 8
jb 0x14005ed1d
mov rcx, qword [rdi]
xor r8d, r8d
xor edx, edx
call qword [sym.imp.KERNEL32.dll_ExpandEnvironmentStringsW]
nop dword [rax + rax]
mov ebp, eax
xor esi, esi
test eax, eax
je 0x14005edba
xorps xmm0, xmm0
movdqu xmmword [rsp + 0x30], xmm0
mov qword [rsp + 0x40], rsi
test eax, eax
je 0x14005ed7c
mov rdx, rbp
call fcn.140003884
mov rsi, rax
mov qword [rsp + 0x30], rax
lea r8, [rbp*2]
lea rbx, [r8 + rax]
mov qword [rsp + 0x40], rbx
xor edx, edx
mov rcx, rax
call sub.api_ms_win_crt_string_l1_1_0.dll_memset
mov qword [rsp + 0x38], rbx
cmp qword [rdi + 0x18], 8
jb 0x14005ed86
mov rdi, qword [rdi]
mov r8d, ebp
mov rdx, rsi
mov rcx, rdi
call qword [sym.imp.KERNEL32.dll_ExpandEnvironmentStringsW]
nop dword [rax + rax]
cmp ebp, eax
sete bl
jne 0x14005edae
mov rdx, rsi
mov rcx, r14
call fcn.140003804
nop
lea rcx, [rsp + 0x30]
call fcn.14001af44
mov al, bl
mov rbx, qword [rsp + 0x60]
mov rbp, qword [rsp + 0x68]
mov rsi, qword [rsp + 0x70]
mov rdi, qword [rsp + 0x78]
add rsp, 0x50
pop r14
ret
Function at 0x140060bfc
Capabilities:
Get hostname

Disassembly:
mov qword [rsp + 0x10], rbx
mov dword [rsp + 8], ecx
push rbp
push rsi
push rdi
mov rbp, rsp
sub rsp, 0x40
mov rbx, rdx
xorps xmm0, xmm0
movdqu xmmword [rbp - 0x20], xmm0
xor esi, esi
mov qword [rbp - 0x10], rsi
mov dword [rbp + 0x30], esi
lea r8, [rbp + 0x30]
xor edx, edx
lea ecx, [rsi + 3]
call qword [sym.imp.KERNEL32.dll_GetComputerNameExW]
nop dword [rax + rax]
test eax, eax
je 0x140060c44
lea edi, [rsi + 0xd]
jmp 0x140060cff
call qword [sym.imp.KERNEL32.dll_GetLastError]
nop dword [rax + rax]
mov edi, eax
cmp eax, 0xea
jne 0x140060cff
mov word [rbp + 0x20], si
mov edx, dword [rbp + 0x30]
mov r8, qword [rbp - 0x18]
mov rcx, r8
mov rdi, qword [rbp - 0x20]
sub rcx, rdi
sar rcx, 1
cmp rdx, rcx
jae 0x140060c84
lea rax, [rdi + rdx*2]
mov qword [rbp - 0x18], rax
jmp 0x140060cc5
jbe 0x140060cc5
mov rax, qword [rbp - 0x10]
sub rax, rdi
sar rax, 1
cmp rdx, rax
jbe 0x140060ca8
lea r8, [rbp + 0x20]
lea rcx, [rbp - 0x20]
call fcn.14003d514
mov rdi, qword [rbp - 0x20]
jmp 0x140060cc5
sub rdx, rcx
je 0x140060cc1
movzx eax, si
mov rdi, r8
mov rcx, rdx
rep stosw word [rdi], ax
lea r8, [r8 + rdx*2]
mov rdi, qword [rbp - 0x20]
mov qword [rbp - 0x18], r8
lea r8, [rbp + 0x30]
mov rdx, rdi
mov ecx, 3
call qword [sym.imp.KERNEL32.dll_GetComputerNameExW]
nop dword [rax + rax]
test eax, eax
jne 0x140060cf1
call qword [sym.imp.KERNEL32.dll_GetLastError]
nop dword [rax + rax]
mov edi, eax
jmp 0x140060cff
mov rdx, qword [rbp - 0x20]
mov rcx, rbx
call fcn.140003804
mov edi, esi
lea rcx, [rbp - 0x20]
call fcn.14001af44
mov eax, edi
mov rbx, qword [rsp + 0x68]
add rsp, 0x40
pop rdi
pop rsi
pop rbp
ret

Function at 0x140061760
Capabilities:
Terminate process

Disassembly:
push rbx
sub rsp, 0x20
mov rbx, rcx
call qword [sym.imp.KERNEL32.dll_IsDebuggerPresent]
mov ecx, 1
mov dword [0x1400ac180], eax
call fcn.140061c00
xor ecx, ecx
call qword [sym.imp.KERNEL32.dll_SetUnhandledExceptionFilter]
mov rcx, rbx
call qword [sym.imp.KERNEL32.dll_UnhandledExceptionFilter]
cmp dword [0x1400ac180], 0
jne case.default.0x1400617b6
mov ecx, 1
call fcn.140061c00
call qword [sym.imp.KERNEL32.dll_GetCurrentProcess]
mov rcx, rax
mov edx, 0xc0000409
add rsp, 0x20
pop rbx
jmp qword [sym.imp.KERNEL32.dll_TerminateProcess]
or eax, dword [rbp + 0x4bb4b62e]
invalid
movabs al, byte [0xe67382796850d7a0]
pop rax
jbe 0x140112be5
sar dl, 0x35
wait
jp 0x140112c52
invalid
Function at 0x401010
Capabilities:
Parse pe header

Disassembly:
sub rsp, 0x28
mov rax, qword [0x00494a40]
xor ecx, ecx
mov dword [rax], 1
mov rax, qword [0x00494a50]
mov dword [rax], 1
mov rax, qword [0x00494a60]
mov dword [rax], 1
mov rax, qword [0x00494a30]
mov dword [rax], 1
mov rax, qword [0x00494920]
cmp word [rax], 0x5a4d
jne 0x401067
movsxd rdx, dword [rax + 0x3c]
add rax, rdx
cmp dword [rax], 0x4550
je 0x4010d0
mov rax, qword [0x00494a20]
mov dword [0x004a0020], ecx
mov eax, dword [rax]
test eax, eax
je 0x4010c0
mov ecx, 2
call sym.__set_app_type
call dbg.__p__fmode
mov rdx, qword [0x00494a00]
mov edx, dword [rdx]
mov dword [rax], edx
call dbg.__p__commode
mov rdx, qword [0x004949e0]
mov edx, dword [rdx]
mov dword [rax], edx
call dbg._setargv
mov rax, qword [0x004948d0]
cmp dword [rax], 1
je 0x401108
xor eax, eax
add rsp, 0x28
ret
mov ecx, 1
call sym.__set_app_type
jmp 0x401084
movzx edx, word [rax + 0x18]
cmp dx, 0x10b
je 0x401120
cmp dx, 0x20b
jne 0x401067
cmp dword [rax + 0x84], 0xe
jbe 0x401067
mov edx, dword [rax + 0xf8]
xor ecx, ecx
test edx, edx
setne cl
jmp 0x401067
lea rcx, [dbg._matherr]
call dbg.__mingw_setusermatherr
xor eax, eax
add rsp, 0x28
ret
cmp dword [rax + 0x74], 0xe
jbe 0x401067
mov r8d, dword [rax + 0xe8]
xor ecx, ecx
test r8d, r8d
setne cl
jmp 0x401067

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

Disassembly:
push rsi
sub rsp, 0x40
mov rax, rdx
movabs r9, 0x100000001b3
mov edx, 0x811c9dc5
xor r10d, r10d
movzx r11d, byte [rax + r10]
xor rdx, r11
imul rdx, r9
inc r10
cmp r8, r10
jne 0x401e4a
xor rdx, 0xff
imul rdx, r9
call sym.indexmap::map::IndexMap_K_V_S_::get::h12ba94b9546ed4fa
test rax, rax
je 0x401ecb
mov rcx, qword [rax + 0x20]
mov rax, qword [rax + 0x28]
add rcx, 0xffffffffffffffe8
shl rax, 3
lea rdx, [rax + rax*2]
xor eax, eax
test rdx, rdx
je 0x401ecd
lea r8, [rcx + 0x18]
add rdx, 0xffffffffffffffe8
cmp qword [rcx + 0x28], 0
mov rcx, r8
je 0x401e89
mov rax, qword [r8 + 8]
mov rdx, qword [rax + 8]
mov r8, qword [rax + 0x10]
lea rsi, [rsp + 0x28]
mov rcx, rsi
call dbg.from_utf8
cmp qword [rsi], 0
jne 0x401ed3
mov rax, qword [rsp + 0x30]
mov rdx, qword [rsp + 0x38]
jmp 0x401ecd
xor eax, eax
add rsp, 0x40
pop rsi
ret
lea rcx, str.unexpected_invalid_UTF_8_code_point_home_htb_ac_453129_.cargo_registry_src_index.crates.io_6f17d22bba15001f_clap_3.1.0_src_parse_matches_matched_arg.rs
lea r8, str._home_htb_ac_453129_.cargo_registry_src_index.crates.io_6f17d22bba15001f_clap_3.1.0_src_parse_matches_arg_matches.rs
mov edx, 0x23
call dbg.expect_failed
int3
Function at 0x40b7e4
Capabilities:
Encode data using xor

Disassembly:
push rsi
push rdi
push rbx
mov rax, rcx
add qword [rcx + 0x30], r8
mov r11, qword [rcx + 0x40]
test r11, r11
je 0x40b81a
mov r10d, 8
sub r10, r11
cmp r8, r10
mov rdi, r10
cmovb rdi, r8
cmp rdi, 3
jbe 0x40b822
mov esi, dword [rdx]
mov r9d, 4
jmp 0x40b827
xor r10d, r10d
jmp 0x40b8d5
xor esi, esi
xor r9d, r9d
mov rcx, r9
or rcx, 1
cmp rcx, rdi
jae 0x40b84a
movzx ebx, word [rdx + r9]
lea ecx, [r9*8]
shl rbx, cl
or rsi, rbx
or r9, 2
cmp r9, rdi
jae 0x40b861
movzx edi, byte [rdx + r9]
shl r9d, 3
mov ecx, r9d
shl rdi, cl
or rsi, rdi
lea ecx, [r11*8]
shl rsi, cl
or rsi, qword [rax + 0x38]
mov qword [rax + 0x38], rsi
cmp r10, r8
jbe 0x40b881
add r11, r8
jmp 0x40b9a5
mov r11, qword [rax + 0x18]
mov r9, qword [rax + 0x10]
mov rcx, qword [rax]
add rcx, r9
rol r9, 0xd
xor r11, rsi
xor r9, rcx
rol rcx, 0x20
mov rdi, qword [rax + 8]
add rdi, r11
rol r11, 0x10
xor r11, rdi
add rcx, r11
rol r11, 0x15
xor r11, rcx
add rdi, r9
rol r9, 0x11
mov qword [rax + 0x18], r11
xor r9, rdi
rol rdi, 0x20
mov qword [rax + 0x10], r9
mov qword [rax + 8], rdi
xor rcx, rsi
mov qword [rax], rcx
sub r8, r10
mov r11d, r8d
and r11d, 7
and r8, 0xfffffffffffffff8
cmp r10, r8
jae 0x40b949
mov rcx, qword [rax]
mov r9, qword [rax + 8]
mov rdi, qword [rax + 0x18]
mov rsi, qword [rax + 0x10]
add rcx, rsi
rol rsi, 0xd
mov rbx, qword [rdx + r10]
xor rsi, rcx
rol rcx, 0x20
xor rdi, rbx
add r9, rdi
rol rdi, 0x10
xor rdi, r9
add rcx, rdi
rol rdi, 0x15
add r9, rsi
rol rsi, 0x11
xor rsi, r9
rol r9, 0x20
xor rdi, rcx
xor rcx, rbx
add r10, 8
cmp r10, r8
jb 0x40b8f7
mov qword [rax + 0x18], rdi
mov qword [rax + 0x10], rsi
mov qword [rax + 8], r9
mov qword [rax], rcx
cmp r11d, 3
jbe 0x40b95b
mov r9d, dword [rdx + r10]
mov r8d, 4
jmp 0x40b961
xor r9d, r9d
xor r8d, r8d
mov rcx, r8
or rcx, 1
cmp rcx, r11
jae 0x40b987
lea rcx, [r8 + r10]
movzx esi, word [rdx + rcx]
lea ecx, [r8*8]
shl rsi, cl
or r9, rsi
or r8, 2
cmp r8, r11
jae 0x40b9a1
add r10, r8
movzx edx, byte [rdx + r10]
shl r8d, 3
mov ecx, r8d
shl rdx, cl
or r9, rdx
mov qword [rax + 0x38], r9
mov qword [rax + 0x40], r11
pop rbx
pop rdi
pop rsi
ret
Function at 0x40e490
Capabilities:
Encode data using xor
Hash data using fnv

Disassembly:
movabs r9, 0x100000001b3
mov eax, 0x811c9dc5
xor r10d, r10d
movzx r11d, byte [rdx + r10]
xor rax, r11
imul rax, r9
inc r10
cmp r8, r10
jne 0x40e4a2
xor rax, 0xff
imul rax, r9
xor r9d, r9d
mov qword [rcx], r9
mov qword [rcx + 0x10], r9
mov qword [rcx + 0x20], r9
mov qword [rcx + 0x30], r9
mov qword [rcx + 0x40], r9
mov qword [rcx + 0x50], r9
mov qword [rcx + 0x68], r9
mov qword [rcx + 0x78], r9
mov r10d, 8
mov qword [rcx + 0x80], r10
xorps xmm0, xmm0
movups xmmword [rcx + 0x88], xmm0
mov qword [rcx + 0x98], r10
movups xmmword [rcx + 0xa0], xmm0
mov qword [rcx + 0xb0], r10
movups xmmword [rcx + 0xb8], xmm0
mov qword [rcx + 0xc8], r10
movups xmmword [rcx + 0xd0], xmm0
mov qword [rcx + 0xe0], r10
movups xmmword [rcx + 0xe8], xmm0
mov qword [rcx + 0xf8], r10
movups xmmword [rcx + 0x100], xmm0
mov qword [rcx + 0x110], r10
movups xmmword [rcx + 0x118], xmm0
mov qword [rcx + 0x128], r10
movups xmmword [rcx + 0x130], xmm0
mov qword [rcx + 0x140], r10
movups xmmword [rcx + 0x148], xmm0
mov qword [rcx + 0x158], 4
movups xmmword [rcx + 0x160], xmm0
mov qword [rcx + 0x170], r10
movups xmmword [rcx + 0x178], xmm0
mov qword [rcx + 0x188], r10
movups xmmword [rcx + 0x190], xmm0
mov qword [rcx + 0x1a0], r10
movups xmmword [rcx + 0x1a8], xmm0
mov qword [rcx + 0x1b8], r10
movups xmmword [rcx + 0x1c0], xmm0
mov qword [rcx + 0x1d0], r10
mov qword [rcx + 0x1d8], r9
mov qword [rcx + 0x1e0], rdx
mov qword [rcx + 0x1e8], r8
mov qword [rcx + 0x1f0], rax
mov qword [rcx + 0x1f8], r9
mov qword [rcx + 0x208], r9
mov qword [rcx + 0x218], r9
mov qword [rcx + 0x228], r9
mov qword [rcx + 0x238], r9
mov qword [rcx + 0x248], r9
movabs rax, 0x11000000110000
mov qword [rcx + 0x258], rax
mov dword [rcx + 0x260], 0
mov word [rcx + 0x264], 2
ret
Function at 0x443eb0
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push r15
push r14
push r12
push rsi
push rdi
push rbx
sub rsp, 0x28
mov rax, rdx
mov rsi, qword [rsp + 0x90]
mov rdi, qword [rsp + 0x88]
mov rdx, qword [rsp + 0x80]
mov ebx, ecx
shr ebx, 8
lea r8, [rax + r8*2]
xor r11d, r11d
mov r15, rax
movzx r14d, byte [rax + 1]
add rax, 2
lea r10, [r11 + r14]
cmp byte [r15], bl
jne 0x443f40
cmp r11, r10
ja 0x443fb6
cmp r10, rdx
ja 0x443fc8
add r11, r9
xor r15d, r15d
nop word cs:[rax + rax]
cmp r14, r15
je 0x443f42
lea r12, [r15 + 1]
cmp byte [r11 + r15], cl
mov r15, r12
jne 0x443f20
jmp 0x443fa4
ja 0x443f4a
mov r11, r10
cmp rax, r8
jne 0x443ee4
add rsi, rdi
movzx ecx, cx
mov al, 1
nop word cs:[rax + rax]
lea r8, [rdi + 1]
movzx edx, byte [rdi]
test dl, dl
js 0x443f80
mov rdi, r8
sub ecx, edx
jns 0x443f9b
jmp 0x443fa6
cmp r8, rsi
je 0x443fd7
movzx r8d, byte [rdi + 1]
add rdi, 2
and edx, 0x7f
shl edx, 8
or edx, r8d
sub ecx, edx
js 0x443fa6
xor al, 1
cmp rdi, rsi
jne 0x443f60
jmp 0x443fa6
xor eax, eax
and al, 1
add rsp, 0x28
pop rbx
pop rdi
pop rsi
pop r12
pop r14
pop r15
ret
lea r8, str.librarycore_srcunicodeprintable.rs
mov rcx, r11
mov rdx, r10
call dbg.slice_index_order_fail
lea r8, str.librarycore_srcunicodeprintable.rs
mov rcx, r10
call dbg.slice_end_index_len_fail
lea rcx, str.called__Option::unwrap____on_a__None__value
lea r8, str.librarycore_srcunicodeprintable.rs
mov edx, 0x2b
call dbg.panic
int3

Function at 0x44e6b0
Capabilities:
Encode data using xor

Disassembly:
sub rdx, rcx
cmp rdx, 0x20
jb sym.core::str::count::char_count_general_case::h76bcffd8ed606607
jmp dbg.do_count_chars
Function at 0x44f650
Capabilities:
Encrypt data using rc4 prga

Disassembly:
push r14
push rsi
push rdi
push rbx
sub rsp, 0x48
mov rsi, rcx
mov r8, qword [rcx]
test r8, r8
je 0x44f6ab
mov r10, qword [rsi + 8]
mov rcx, qword [rsi + 0x10]
cmp rcx, r10
jae 0x44f6ab
movzx eax, byte [r8 + rcx]
cmp eax, 0x49
je 0x44f6c6
cmp eax, 0x42
jne 0x44f6ab
lea r11, [rcx + 1]
mov qword [rsi + 0x10], r11
cmp r11, r10
jae 0x44f776
cmp byte [r8 + r11], 0x5f
jne 0x44f776
lea rax, [rcx + 2]
mov qword [rsi + 0x10], rax
xor eax, eax
jmp 0x44f7de
mov rcx, rsi
xor edx, edx
call dbg.print_path
mov edi, eax
add dil, dil
mov eax, edi
add rsp, 0x48
pop rbx
pop rdi
pop rsi
pop r14
ret
inc rcx
mov qword [rsi + 0x10], rcx
mov rcx, rsi
xor edx, edx
call dbg.print_path
test al, al
jne 0x44f871
mov rcx, qword [rsi + 0x20]
test rcx, rcx
je 0x44f702
lea rdx, [0x0048fb0b]
mov r8d, 1
call dbg.pad
test al, al
jne 0x44f871
mov rax, qword [rsi]
mov dil, 1
test rax, rax
je 0x44f6ba
xor r14d, r14d
lea rbx, [0x0048fe79]
nop word [rax + rax]
mov rcx, qword [rsi + 0x10]
cmp rcx, qword [rsi + 8]
jae 0x44f734
cmp byte [rax + rcx], 0x45
je 0x44f893
sub r14, 1
jb 0x44f759
mov rcx, qword [rsi + 0x20]
test rcx, rcx
je 0x44f759
mov r8d, 2
mov rdx, rbx
call dbg.pad
test al, al
jne 0x44f871
mov rcx, rsi
call dbg.print_generic_arg
test al, al
jne 0x44f871
mov rax, qword [rsi]
test rax, rax
jne 0x44f720
jmp 0x44f6ba
xor eax, eax
mov edi, 0x3e
nop dword [rax]
mov r9b, 1
cmp r11, r10
jae 0x44f838
movzx edx, byte [r8 + r11]
cmp dl, 0x5f
je 0x44f7d2
lea ebx, [rdx - 0x30]
cmp bl, 0xa
jb 0x44f7bc
lea ebx, [rdx - 0x61]
cmp bl, 0x1a
jae 0x44f7ab
add dl, 0xa9
jmp 0x44f7ba
lea ebx, [rdx - 0x41]
cmp bl, 0x1a
jae 0x44f838
add dl, 0xe3
mov ebx, edx
inc r11
mov qword [rsi + 0x10], r11
mul rdi
jo 0x44f838
movzx edx, bl
add rax, rdx
jae 0x44f780
jmp 0x44f838
inc r11
mov qword [rsi + 0x10], r11
inc rax
je 0x44f838
cmp rax, rcx
jae 0x44f835
mov ecx, dword [rsi + 0x18]
inc ecx
cmp ecx, 0x1f4
ja 0x44f88b
cmp qword [rsi + 0x20], 0
je 0x44f884
movups xmm0, xmmword [rsi]
movups xmm1, xmmword [rsi + 0x10]
movaps xmmword [rsp + 0x30], xmm1
movaps xmmword [rsp + 0x20], xmm0
mov qword [rsi + 0x10], rax
mov dword [rsi + 0x18], ecx
mov rcx, rsi
call dbg.print_path_maybe_open_generics
movaps xmm0, xmmword [rsp + 0x20]
movaps xmm1, xmmword [rsp + 0x30]
movups xmmword [rsi], xmm0
movups xmmword [rsi + 0x10], xmm1
jmp 0x44f6bc
mov r9b, 1
xor edi, edi
mov rcx, qword [rsi + 0x20]
test rcx, rcx
je 0x44f879
mov eax, r9d
xor al, 1
movzx eax, al
lea r8, [rax + rax*8]
add r8, 0x10
lea rax, str.invalid_syntaxrecursion_limit_reached_for_______::closureshim_as__mut_const___dyn___unsafe_extern__
lea rdx, [0x0048fe58]
test r9b, r9b
cmovne rdx, rax
call dbg.pad
test al, al
je 0x44f879
mov dil, 2
jmp 0x44f6ba
mov qword [rsi], 0
mov byte [rsi + 8], dil
xor edi, edi
jmp 0x44f6ba
mov dil, 1
xor r9d, r9d
jmp 0x44f83a
inc rcx
mov qword [rsi + 0x10], rcx
jmp 0x44f6ba
Function at 0x451e40
Capabilities:
Get thread local storage value
Set thread local storage value

Disassembly:
push r15
push r14
push rsi
push rdi
push rbx
sub rsp, 0x20
movzx eax, byte [0x004a0140]
test al, al
je 0x451fdf
test edx, edx
je 0x451e67
cmp edx, 3
jne 0x451fdf
mov rbx, qword [0x004a0148]
test rbx, rbx
je 0x451fdf
xor r14d, r14d
jmp 0x451e89
mov rbx, qword [rbx + 8]
test rbx, rbx
je 0x451ebd
mov esi, dword [rbx + 0x18]
mov r15, qword [rbx]
test r15, r15
je 0x45202a
dec esi
mov ecx, esi
call sub.KERNEL32.dll_TlsGetValue
test rax, rax
je 0x451e80
mov rdi, rax
mov ecx, esi
xor edx, edx
call fcn.004824b4
mov rcx, rdi
call r15
mov r14b, 1
jmp 0x451e80
test r14b, 1
je 0x451fdf
mov rbx, qword [0x004a0148]
test rbx, rbx
je 0x451fdf
xor r14d, r14d
jmp 0x451ee9
mov rbx, qword [rbx + 8]
test rbx, rbx
je 0x451f1d
mov esi, dword [rbx + 0x18]
mov r15, qword [rbx]
test r15, r15
je 0x45202a
dec esi
mov ecx, esi
call sub.KERNEL32.dll_TlsGetValue
test rax, rax
je 0x451ee0
mov rdi, rax
mov ecx, esi
xor edx, edx
call fcn.004824b4
mov rcx, rdi
call r15
mov r14b, 1
jmp 0x451ee0
test r14b, 1
je 0x451fdf
mov rbx, qword [0x004a0148]
test rbx, rbx
je 0x451fdf
xor r14d, r14d
jmp 0x451f49
mov rbx, qword [rbx + 8]
test rbx, rbx
je 0x451f7d
mov esi, dword [rbx + 0x18]
mov r15, qword [rbx]
test r15, r15
je 0x45202a
dec esi
mov ecx, esi
call sub.KERNEL32.dll_TlsGetValue
test rax, rax
je 0x451f40
mov rdi, rax
mov ecx, esi
xor edx, edx
call fcn.004824b4
mov rcx, rdi
call r15
mov r14b, 1
jmp 0x451f40
test r14b, 1
je 0x451fdf
mov rbx, qword [0x004a0148]
test rbx, rbx
je 0x451fdf
xor r14d, r14d
jmp 0x451fa9
mov rbx, qword [rbx + 8]
test rbx, rbx
je 0x451fd9
mov esi, dword [rbx + 0x18]
mov r15, qword [rbx]
test r15, r15
je 0x45202a
dec esi
mov ecx, esi
call sub.KERNEL32.dll_TlsGetValue
test rax, rax
je 0x451fa0
mov rdi, rax
mov ecx, esi
xor edx, edx
call fcn.004824b4
mov rcx, rdi
call r15
mov r14b, 1
jmp 0x451fa0
test r14b, 1
jne 0x451feb
add rsp, 0x20
pop rbx
pop rdi
pop rsi
pop r14
pop r15
ret
mov rbx, qword [0x004a0148]
jmp 0x451ff8
mov rbx, qword [rbx + 8]
test rbx, rbx
je 0x451fdf
mov esi, dword [rbx + 0x18]
mov r14, qword [rbx]
test r14, r14
je 0x45202a
dec esi
mov ecx, esi
call sub.KERNEL32.dll_TlsGetValue
test rax, rax
je 0x451ff4
mov rdi, rax
mov ecx, esi
xor edx, edx
call fcn.004824b4
mov rcx, rdi
call r14
jmp 0x451ff4
lea rcx, str.called__Option::unwrap____on_a__None__value
lea r8, str.library_std_src_syswindows_thread_local_key.rs
mov edx, 0x2b
call dbg.panic
ud2
Function at 0x452e50
Capabilities:
Allocate thread local storage

Disassembly:
push rsi
push rdi
push rbx
sub rsp, 0x60
mov rsi, rcx
cmp qword [rcx], 0
je 0x452ed5
mov dword [rsp + 0x2c], 0
lea rbx, [rsi + 0x10]
lea r8, [rsp + 0x2c]
mov rcx, rbx
xor edx, edx
xor r9d, r9d
call sub.KERNEL32.dll_InitOnceBeginInitialize
mov dword [rsp + 0x28], eax
cmp eax, 1
jne 0x452f16
cmp dword [rsp + 0x2c], 0
je 0x452efa
call sub.KERNEL32.dll_TlsAlloc
cmp eax, 0xffffffff
je 0x452f3c
mov edi, eax
inc eax
mov dword [rsi + 0x18], eax
mov rax, qword [0x004a0148]
nop
mov qword [rsi + 8], rax
lock cmpxchg qword [0x004a0148], rsi
jne 0x452eb0
mov byte [0x004a0140], 1
mov rcx, rbx
xor edx, edx
xor r8d, r8d
call sub.KERNEL32.dll_InitOnceComplete
jmp 0x452f0c
call sub.KERNEL32.dll_TlsAlloc
mov dword [rsp + 0x28], eax
cmp eax, 0xffffffff
je 0x452f86
mov ecx, eax
inc ecx
xor eax, eax
lock cmpxchg dword [rsi + 0x18], ecx
jne 0x452eff
mov edi, dword [rsp + 0x28]
jmp 0x452f0c
mov edi, dword [rsi + 0x18]
jmp 0x452f0a
mov edi, eax
mov ecx, dword [rsp + 0x28]
call sub.KERNEL32.dll_TlsFree
dec edi
mov eax, edi
add rsp, 0x60
pop rbx
pop rdi
pop rsi
ret
mov qword [rsp + 0x30], 0
lea rdx, [0x00493068]
lea r9, str.library_std_src_syswindows_thread_local_key.rs
lea rcx, [rsp + 0x28]
lea r8, [rsp + 0x30]
call dbg.assert_failed<i32, i32>
mov rcx, rbx
mov edx, 4
xor r8d, r8d
call sub.KERNEL32.dll_InitOnceComplete
lea rax, str.out_of_TLS_indexes
mov qword [rsp + 0x30], rax
mov qword [rsp + 0x38], 1
lea rax, [0x00494168]
mov qword [rsp + 0x40], rax
xorps xmm0, xmm0
movups xmmword [rsp + 0x48], xmm0
lea rdx, str.library_std_src_syswindows_thread_local_key.rs
lea rcx, [rsp + 0x30]
call dbg.panic_fmt
lea rax, str.out_of_TLS_indexes
mov qword [rsp + 0x30], rax
mov qword [rsp + 0x38], 1
lea rax, [0x00494168]
mov qword [rsp + 0x40], rax
xorps xmm0, xmm0
movups xmmword [rsp + 0x48], xmm0
lea rcx, [rsp + 0x28]
lea rdx, [rsp + 0x30]
call dbg.assert_failed<u32, u32>
int3
Function at 0x4532a0
Capabilities:
Get thread local storage value
Set thread local storage value

Disassembly:
push rsi
push rdi
sub rsp, 0x28
mov ecx, dword [0x004840b0]
test ecx, ecx
je 0x453380
dec ecx
call sub.KERNEL32.dll_TlsGetValue
cmp rax, 2
jb 0x4532d4
mov rdi, rax
cmp qword [rax + 8], 0
je 0x4532d4
add rdi, 0x10
jmp 0x453376
mov ecx, dword [0x004840b0]
test ecx, ecx
je 0x453393
dec ecx
call sub.KERNEL32.dll_TlsGetValue
cmp rax, 1
je 0x453374
mov rsi, rax
test rax, rax
jne 0x453343
movzx eax, byte [0x004a0170]
mov ecx, 0x18
mov edx, 8
call sym.__rust_alloc
test rax, rax
je 0x4533b6
mov rsi, rax
lea rax, dbg.destroy_value_std::sys_common::thread_info::ThreadInfo_
mov qword [rsi], rax
mov qword [rsi + 8], 0
mov ecx, dword [0x004840b0]
test ecx, ecx
je 0x4533a6
dec ecx
mov rdx, rsi
call fcn.004824b4
lea rdi, [rsi + 0x10]
mov rcx, qword [rsi + 0x10]
cmp qword [rsi + 8], 0
mov qword [rsi + 8], 1
mov qword [rsi + 0x10], 0
je 0x453376
test rcx, rcx
je 0x453376
lock dec qword [rcx]
jne 0x453376
call dbg.drop_slow<std::thread::Inner, alloc::alloc::Global>
jmp 0x453376
xor edi, edi
mov rax, rdi
add rsp, 0x28
pop rdi
pop rsi
ret
lea rcx, dbg.destroy_value_std::sys_common::thread_info::ThreadInfo_
call dbg.init
mov ecx, eax
jmp 0x4532b6
lea rcx, dbg.destroy_value_std::sys_common::thread_info::ThreadInfo_
call dbg.init
mov ecx, eax
jmp 0x4532e4
lea rcx, dbg.destroy_value_std::sys_common::thread_info::ThreadInfo_
call dbg.init
mov ecx, eax
jmp 0x45333b
mov ecx, 8
mov edx, 0x18
call dbg.handle_alloc_error
int3

Function at 0x4534a0
Capabilities:
Set thread local storage value

Disassembly:
push rsi
push rdi
sub rsp, 0x68
mov rsi, rcx
mov rdi, qword [rcx]
mov ecx, dword [rdi + 0x18]
test ecx, ecx
je 0x4534b7
dec ecx
jmp 0x4534c1
mov rcx, rdi
call dbg.init
mov ecx, eax
mov edx, 1
call fcn.004824b4
cmp qword [rsi + 8], 0
je 0x4534ea
mov rax, qword [rsi + 0x10]
test rax, rax
je 0x4534ea
lock dec qword [rax]
jne 0x4534ea
mov rcx, qword [rsi + 0x10]
call dbg.drop_slow<std::thread::Inner, alloc::alloc::Global>
mov rcx, qword [0x004a0128]
xor edx, edx
mov r8, rsi
call fcn.0048256c
mov ecx, dword [rdi + 0x18]
test ecx, ecx
je 0x453506
dec ecx
jmp 0x453510
mov rcx, rdi
call dbg.init
mov ecx, eax
xor edx, edx
add rsp, 0x68
pop rdi
pop rsi
jmp fcn.004824b4