2025-10-07
📦 Trust Me
Running the application gives you an error
Changing perms to just trustedinstaller and removing inheritence breaks it, or the key.bin to it don’t open ithttps://gist.github.com/AveYo/b6b402aa8a83a1c71b780127f13e6957
Use the bottom part of this script, which opens a window as TI, then just open the TrustMe.exe
flag{c6065b1f12395d526595e62cf1f4d82a}The other way is to extract the aes info
base64 ciphertextWx6eETGXddnmCT4qZ7BxgRYpC+kdjjFzXxW+BM4HiI3GPaslpFBnpk9XplnaSxNgPS C:\ctf>
>> Format-Hex -Path key.bin
Path: C:\ctf\key.bin
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
00000000 C5 C9 3B DB 84 15 34 FA E5 54 5E DC B0 F1 20 41 ÅÉ;Û.4úåT^Ü°ñ A
00000010 D1 0C D4 D9 0E E1 6A 7D 82 35 FA 65 7C 93 82 5D Ñ.ÔÙ.áj}5úe|]C5 C9 3B DB 84 15 34 FA E5 54 5E DC B0 F1 20 41 D1 0C D4 D9 0E E1 6A 7D 82 35 FA 65 7C 93 82 5D
Find the base64 ciphertext in the binary:
strings trustme.exe | grep -E '^[A-Za-z0-9+/]{60,}'
Returns: Wx6eETGXddnmCT4qZ7BxgRYpC+kdjjFzXxW+BM4HiI3GPaslpFBnpk9XplnaSxNg
Extract the IV (16 bytes after the ciphertext string):
grep -oba "Wx6eETGXddnmCT4qZ7BxgRYpC" trustme.exe | cut -d: -f1 | xargs -I {} bash -c 'xxd -s $(({}+65)) -l 16 -p trustme.exe | tr -d "\n"'
# Returns: 04c9e65365568d0f8a02f526ba00fc5b
Get the key from key.bin:
xxd -p -c 32 key.bin | tr -d '\n'
# Returns: c5c93bdb841534fae5545edcb0f12041d10cd4d90ee16a7d8235fa657c93825d
Decrypt:
echo "Wx6eETGXddnmCT4qZ7BxgRYpC+kdjjFzXxW+BM4HiI3GPaslpFBnpk9XplnaSxNg" | base64 -d | openssl enc -aes-256-cbc -d -K c5c93bdb841534fae5545edcb0f12041d10cd4d90ee16a7d8235fa657c93825d -iv 04c9e65365568d0f8a02f526ba00fc5b
Flag: flag{c6065b1f12395d526595e62cf1f4d82a}
Decompiled in Binary Ninja in dogbolt
int64_t sub_140001000(LPARAM arg1)
{
void var_128;
int64_t rax_1 = __security_cookie ^ &var_128;
WNDCLASSA wndClass;
wndClass.style = 0;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hIcon = 0;
wndClass.lpszMenuName = 0;
wndClass.lpfnWndProc = DefWindowProcA;
wndClass.hInstance = GetModuleHandleA(nullptr);
HCURSOR rax_3 = LoadCursorA(nullptr, 0x7f00);
wndClass.hbrBackground = 6;
wndClass.hCursor = rax_3;
wndClass.lpszClassName = "TI_FLAG_WIN";
uint16_t rax_4 = RegisterClassA(&wndClass);
enum WIN32_ERROR rax_5;
if (!rax_4)
rax_5 = GetLastError();
int64_t result;
if (rax_4 || rax_5 == ERROR_CLASS_ALREADY_EXISTS)
{
HWND rax_7 = CreateWindowExA(WS_EX_DLGMODALFRAME, "TI_FLAG_WIN", "Flag Viewer", 0xc80000,
0x80000000, 0x80000000, 0x21c, 0xdc, nullptr, nullptr, wndClass.hInstance, 0);
if (rax_7)
{
HWND hWnd = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", &data_1400125b4, 0x50200844, 0xa,
0xa, 0x1f4, 0x78, rax_7, nullptr, wndClass.hInstance, 0);
CreateWindowExA(WS_EX_LEFT, "BUTTON", "Close", 0x50000001, 0x1ae, 0x8c, 0x50, 0x1c,
rax_7, 0x3e9, wndClass.hInstance, 0);
SendMessageA(hWnd, 0x30, GetStockObject(ANSI_FIXED_FONT), 1);
SendMessageA(hWnd, 0xc, 0, arg1);
SendMessageA(hWnd, 0xb1, 0, -1);
SetFocus(hWnd);
RECT rect;
GetWindowRect(rax_7, &rect);
int32_t r14_2 = rect.right - rect.left;
int32_t rdi_3 = rect.bottom - rect.top;
int32_t rax_10 = GetSystemMetrics(SM_CXSCREEN);
enum SET_WINDOW_POS_FLAGS uFlags = 0x5;
int32_t cy = 0;
int32_t temp0_1;
int32_t temp1_1;
temp0_1 = HIGHD(GetSystemMetrics(SM_CYSCREEN) - rdi_3);
temp1_1 = LOWD(GetSystemMetrics(SM_CYSCREEN) - rdi_3);
int32_t temp2_1;
int32_t temp3_1;
temp2_1 = HIGHD(rax_10 - r14_2);
temp3_1 = LOWD(rax_10 - r14_2);
SetWindowPos(rax_7, nullptr, (temp3_1 - temp2_1) >> 1, (temp1_1 - temp0_1) >> 1, 0, cy,
uFlags);
ShowWindow(rax_7, SW_SHOW);
UpdateWindow(rax_7);
if (OpenClipboard(rax_7))
{
EmptyClipboard();
void* dwBytes = strlen(arg1) + 1;
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, dwBytes);
if (hMem)
{
memcpy(GlobalLock(hMem), arg1, dwBytes);
GlobalUnlock(hMem);
SetClipboardData(1, hMem);
}
CloseClipboard();
}
MSG msg;
if (GetMessageA(&msg, nullptr, 0, 0) > 0)
{
BOOL i;
do
{
uint32_t message = msg.message;
if (message != 0x111)
goto label_14000135f;
if (msg.wParam == 0x3e9)
{
DestroyWindow(rax_7);
message = msg.message;
label_14000135f:
if (message == 2 && msg.hwnd == rax_7)
PostQuitMessage(0);
}
TranslateMessage(&msg);
DispatchMessageA(&msg);
i = GetMessageA(&msg, nullptr, 0, 0);
} while (i > 0);
}
result = 0;
}
else
result = 2;
}
else
result = 1;
__security_check_cookie(rax_1 ^ &var_128);
return result;
}
uint64_t main()
{
void var_108;
int64_t rax_1 = __security_cookie ^ &var_108;
PSID SidToCheck_1 = nullptr;
uint64_t result;
if (ConvertStringSidToSidA(data_14001d010, &SidToCheck_1))
{
PSID SidToCheck = SidToCheck_1;
BOOL IsMember = 0;
if (!CheckTokenMembership(nullptr, SidToCheck, &IsMember))
{
LocalFree(SidToCheck_1);
MessageBoxA(nullptr, "Internal error: token check failed.", "Error", MB_ICONHAND);
result = 3;
}
else if (IsMember)
{
int32_t* rax_4 = fopen(data_14001d008, "rb");
if (rax_4)
{
int128_t var_c0[0x2];
uint64_t rax_5 = fread(&var_c0, 1, 0x20, rax_4);
fclose(rax_4);
if (rax_5 == 0x20)
{
char* rbx_2 = nullptr;
char const (* rbp_1)[0x41] = data_14001d000;
void* rax_6 = strlen(rbp_1);
uint8_t* rax_7 = j_sub_140008f50(((rax_6 >> 2) + 1) * 3);
uint8_t* rdi_2 = rax_7;
if (rax_7)
{
int32_t rdx_1 = 0;
int32_t r8_2 = -8;
void* r9_2 = nullptr;
if (rax_6)
{
do
{
uint64_t rcx_13 = *(r9_2 + rbp_1);
if (rcx_13 != 0x3d
&& (rcx_13 > 0x20 || !TEST_BITQ(0x100002600, rcx_13)))
{
int32_t rax_9;
int32_t rax_13;
if (rcx_13 - 0x41 > 0x19)
{
if (rcx_13 - 0x61 <= 0x19)
{
rax_9 = -0x47;
goto label_140001600;
}
if (rcx_13 - 0x30 <= 9)
{
rax_9 = 4;
goto label_140001600;
}
if (!((rcx_13 - 0x2b) & 0xfffffffd))
{
rax_13 = 0x3e;
label_140001629:
rdx_1 = rdx_1 << 6 | rax_13;
int32_t temp1_1 = r8_2;
r8_2 += 6;
if (temp1_1 + 6 >= 0)
{
*(rbx_2 + rdi_2) = rdx_1 >> r8_2;
rbx_2 = &rbx_2[1];
r8_2 -= 8;
}
}
else if (rcx_13 == 0x2f || rcx_13 == 0x5f)
{
rax_13 = 0x3f;
goto label_140001629;
}
}
else
{
rax_9 = -0x41;
label_140001600:
rax_13 = rax_9 + rcx_13;
if (rax_9 + rcx_13 >= 0)
goto label_140001629;
}
}
r9_2 += 1;
} while (r9_2 < rax_6);
}
}
else
rdi_2 = nullptr;
if (!(rbx_2 & 0xf))
{
if (!rdi_2)
goto label_140001745;
if (!rbx_2)
{
j_sub_140006b00(rdi_2);
label_140001745:
LocalFree(SidToCheck_1);
MessageBoxA(nullptr, "Ciphertext decode failed. (Check CIPH_B64)",
"Decrypt error", MB_ICONHAND);
result = 6;
}
else
{
LPARAM lpMem_1 = 0;
int32_t var_cc;
int32_t* var_e0_1 = &var_cc;
var_cc = 0;
int32_t rax_16 = sub_1400017a0(&var_c0, &data_1400124c8, rdi_2, rbx_2,
&lpMem_1, var_e0_1);
j_sub_140006b00(rdi_2);
LocalFree(SidToCheck_1);
LPARAM lpMem;
if (!rax_16)
lpMem = lpMem_1;
if (rax_16 || !lpMem)
{
MessageBoxA(nullptr, "Decryption failed. (Key/IV/cipher mismatch)",
"Decrypt error", MB_ICONHAND);
result = 7;
}
else
{
int32_t result_1 = sub_140001000(lpMem);
HeapFree(GetProcessHeap(), HEAP_NONE, lpMem);
result = result_1;
}
}
}
else
{
void var_98;
wsprintfA(&var_98,
"Cipher length %u is not a multiple of 16.\nBase64 likely corrupted.",
rbx_2);
MessageBoxA(nullptr, &var_98, "Bad ciphertext", MB_ICONHAND);
result = 6;
}
}
else
{
LocalFree(SidToCheck_1);
MessageBoxA(nullptr, "key.bin must be exactly 32 bytes (AES-256 key).",
"Key error", MB_ICONHAND);
result = 5;
}
}
else
{
LocalFree(SidToCheck_1);
MessageBoxA(nullptr,
"Could not open key.bin. Are permissions set for TrustedInstaller only?",
"Key error", MB_ICONHAND);
result = 4;
}
}
else
{
LocalFree(SidToCheck_1);
MessageBoxA(nullptr,
"I don't trust ya! I'll give you the flag... but only if you have Trusted Installer "
"permissions!",
"Access denied", MB_ICONEXCLAMATION);
result = 1;
}
}
else
{
MessageBoxA(nullptr, "Internal error: SID conversion failed.", "Error", MB_ICONHAND);
result = 2;
}
__security_check_cookie(rax_1 ^ &var_108);
return result;
}
uint64_t sub_1400017a0(int64_t arg1, int128_t* arg2, uint8_t* arg3, uint32_t arg4, int64_t* arg5, int32_t* arg6)
{
void var_e8;
int64_t rax_1 = __security_cookie ^ &var_e8;
*arg5 = 0;
*arg6 = 0;
BCRYPT_ALG_HANDLE hAlgorithm_1 = nullptr;
BCRYPT_KEY_HANDLE phKey = nullptr;
uint8_t* lpMem_1 = nullptr;
uint32_t var_94 = 0;
int32_t var_78 = 0;
uint8_t* pbKeyObject = BCryptOpenAlgorithmProvider(&hAlgorithm_1, &data_140012530, nullptr, 0);
NTSTATUS rdi = pbKeyObject;
if (!pbKeyObject)
{
pbKeyObject = BCryptSetProperty(hAlgorithm_1, u"ChainingMode", u"ChainingModeCBC", 0x20, 0);
rdi = pbKeyObject;
if (!pbKeyObject)
{
uint32_t var_c8_1;
var_c8_1 = &var_78;
pbKeyObject = BCryptGetProperty(hAlgorithm_1, u"ObjectLength", &var_94, 4, var_c8_1, 0);
rdi = pbKeyObject;
if (!pbKeyObject)
{
pbKeyObject = HeapAlloc(GetProcessHeap(), HEAP_NONE, var_94);
lpMem_1 = pbKeyObject;
if (pbKeyObject)
{
var_c8_1 = arg1;
pbKeyObject = BCryptGenerateSymmetricKey(hAlgorithm_1, &phKey, pbKeyObject,
var_94, var_c8_1, 0x20, 0);
rdi = pbKeyObject;
if (!pbKeyObject)
{
int128_t zmm0_1 = *arg2;
BCRYPT_KEY_HANDLE hKey = phKey;
enum BCRYPT_FLAGS dwFlags = BCRYPT_BLOCK_PADDING;
uint32_t var_98;
uint32_t* pcbResult = &var_98;
uint32_t cbOutput = 0;
uint32_t pbOutput;
pbOutput = 0;
uint32_t cbIV = 0x10;
int128_t var_68;
var_c8_1 = &var_68;
var_98 = 0;
var_68 = zmm0_1;
pbKeyObject = BCryptDecrypt(hKey, arg3, arg4, nullptr, var_c8_1, cbIV,
pbOutput, cbOutput, pcbResult, dwFlags);
rdi = pbKeyObject;
if (!pbKeyObject)
{
pbKeyObject = HeapAlloc(GetProcessHeap(), HEAP_NONE, var_98 + 1);
uint8_t* lpMem = pbKeyObject;
if (pbKeyObject)
{
uint32_t cbOutput_1 = var_98;
enum BCRYPT_FLAGS dwFlags_1 = BCRYPT_BLOCK_PADDING;
uint32_t* pcbResult_1 = &var_98;
BCRYPT_KEY_HANDLE hKey_1 = phKey;
pbOutput = lpMem;
uint32_t cbIV_1 = 0x10;
var_c8_1 = &var_68;
var_68 = *arg2;
NTSTATUS rax_4 = BCryptDecrypt(hKey_1, arg3, arg4, nullptr,
var_c8_1, cbIV_1, pbOutput, cbOutput_1, pcbResult_1, dwFlags_1);
rdi = rax_4;
if (!rax_4)
{
*(var_98 + lpMem) = 0;
pbKeyObject = var_98;
*arg5 = lpMem;
*arg6 = pbKeyObject;
}
else
pbKeyObject = HeapFree(GetProcessHeap(), HEAP_NONE, lpMem);
}
}
}
}
}
}
}
BCRYPT_KEY_HANDLE hKey_2 = phKey;
if (hKey_2)
pbKeyObject = BCryptDestroyKey(hKey_2);
if (lpMem_1)
pbKeyObject = HeapFree(GetProcessHeap(), HEAP_NONE, lpMem_1);
BCRYPT_ALG_HANDLE hAlgorithm = hAlgorithm_1;
if (hAlgorithm)
pbKeyObject = BCryptCloseAlgorithmProvider(hAlgorithm, 0);
__security_check_cookie(rax_1 ^ &var_e8);
return pbKeyObject - pbKeyObject;
}
BOOL ConvertStringSidToSidA(PSTR StringSid, PSID* Sid)
{
/* tailcall */
return ConvertStringSidToSidA(StringSid, Sid);
}
NTSTATUS BCryptOpenAlgorithmProvider(BCRYPT_ALG_HANDLE* phAlgorithm, PWSTR pszAlgId, PWSTR pszImplementation, enum BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS dwFlags)
{
/* tailcall */
return BCryptOpenAlgorithmProvider(phAlgorithm, pszAlgId, pszImplementation, dwFlags);
}
NTSTATUS BCryptGetProperty(BCRYPT_HANDLE hObject, PWSTR pszProperty, uint8_t* pbOutput, uint32_t cbOutput, uint32_t* pcbResult, uint32_t dwFlags)
{
/* tailcall */
return BCryptGetProperty(hObject, pszProperty, pbOutput, cbOutput, pcbResult, dwFlags);
}
NTSTATUS BCryptSetProperty(BCRYPT_HANDLE hObject, PWSTR pszProperty, uint8_t* pbInput, uint32_t cbInput, uint32_t dwFlags)
{
/* tailcall */
return BCryptSetProperty(hObject, pszProperty, pbInput, cbInput, dwFlags);
}
NTSTATUS BCryptCloseAlgorithmProvider(BCRYPT_ALG_HANDLE hAlgorithm, uint32_t dwFlags)
{
/* tailcall */
return BCryptCloseAlgorithmProvider(hAlgorithm, dwFlags);
}
NTSTATUS BCryptGenerateSymmetricKey(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE* phKey, uint8_t* pbKeyObject, uint32_t cbKeyObject, uint8_t* pbSecret, uint32_t cbSecret, uint32_t dwFlags)
{
/* tailcall */
return BCryptGenerateSymmetricKey(hAlgorithm, phKey, pbKeyObject, cbKeyObject, pbSecret,
cbSecret, dwFlags);
}
NTSTATUS BCryptDecrypt(BCRYPT_KEY_HANDLE hKey, uint8_t* pbInput, uint32_t cbInput, void* pPaddingInfo, uint8_t* pbIV, uint32_t cbIV, uint8_t* pbOutput, uint32_t cbOutput, uint32_t* pcbResult, enum BCRYPT_FLAGS dwFlags)
{
/* tailcall */
return BCryptDecrypt(hKey, pbInput, cbInput, pPaddingInfo, pbIV, cbIV, pbOutput, cbOutput,
pcbResult, dwFlags);
}
NTSTATUS BCryptDestroyKey(BCRYPT_KEY_HANDLE hKey)
{
/* tailcall */
return BCryptDestroyKey(hKey);
}
int64_t __GSHandlerCheck(int64_t arg1, int64_t arg2, int64_t arg3, void* arg4)
{
__GSHandlerCheckCommon(arg2, arg4, *(arg4 + 0x38));
return 1;
}
int64_t __GSHandlerCheckCommon(int64_t arg1, void* arg2, int32_t* arg3)
{
int64_t r9 = arg1;
int64_t r10 = arg1;
if (*arg3 & 4)
r10 = (arg3[1] + arg1) & -(arg3[2]);
uint64_t rcx_1 = *(*(arg2 + 0x10) + 8);
int64_t rax_5 = *(arg2 + 8);
if (*(rcx_1 + rax_5 + 3) & 0xf)
r9 += *(rcx_1 + rax_5 + 3) & 0xfffffff0;
/* tailcall */
return __security_check_cookie(r9 ^ *((*arg3 & 0xfffffff8) + r10));
}
int64_t __security_check_cookie(int64_t arg1)
{
if (arg1 == __security_cookie)
{
int64_t rcx = ROLQ(arg1, 0x10);
if (!(rcx & 0xffff))
return;
arg1 = RORQ(rcx, 0x10);
}
/* tailcall */
return __report_gsfailure(arg1);
}
int64_t pre_c_initialization()
{
sub_1400056f4(2);
_set_fmode(0x4000);
data_14001e384 = 0;
if (__scrt_initialize_onexit_tables(1))
{
_RTC_Initialize();
atexit(_RTC_Terminate);
if (!sub_140005954(1))
{
sub_1400021dc();
if (sub_140002220())
sub_140005710(sub_1400021c8);
_configthreadlocale(0);
if (sub_1400021ec())
j_sub_140005ad4();
j_sub_1400021c8();
return 0;
}
}
__scrt_fastfail(7);
breakpoint();
}
int64_t post_pgo_initialization()
{
__scrt_initialize_default_local_stdio_options();
return 0;
}
int64_t pre_cpp_initialization()
{
sub_14000242c();
/* tailcall */
return _set_new_mode(0);
}
uint64_t sub_140001bd4(uint64_t arg1 @ rbx)
{
uint64_t arg_8 = arg1;
if (!__scrt_initialize_crt(1))
{
__scrt_fastfail(7);
__scrt_fastfail(7);
}
else
{
int64_t rdi;
rdi = 0;
char var_18_1 = 0;
arg1 = __scrt_acquire_startup_lock();
int32_t rcx_1 = data_14001e0a0;
if (rcx_1 == 1)
__scrt_fastfail(7);
else
{
if (rcx_1)
{
rdi = 1;
char var_18_2 = 1;
}
else
{
data_14001e0a0 = 1;
if (sub_140005dd0(&data_140012400, &data_140012438))
return 0xff;
sub_140005d98(&data_1400123e8, &data_1400123f8);
data_14001e0a0 = 2;
}
rcx_1 = arg1;
__scrt_release_startup_lock(rcx_1);
if (data_14001ebc8 && __scrt_is_nonwritable_in_current_image(&data_14001ebc8))
data_14001ebc8(0, 2, 0);
if (data_14001ebc0 && __scrt_is_nonwritable_in_current_image(&data_14001ebc0))
sub_1400060b0(data_14001ebc0);
__scrt_get_show_window_mode();
common_wincmdln<char>();
arg1 = main();
if (sub_1400023d8())
{
if (!rdi)
_cexit();
__scrt_uninitialize_crt(1, 0);
return arg1;
}
}
}
exit(arg1);
sub_1400060a4(arg1);
breakpoint();
}
int64_t _start()
{
sub_140002118();
uint64_t rbx;
/* tailcall */
return sub_140001bd4(rbx);
}
void __raise_securityfailure(EXCEPTION_POINTERS* arg1) __noreturn
{
SetUnhandledExceptionFilter(0);
UnhandledExceptionFilter(arg1);
/* tailcall */
return TerminateProcess(GetCurrentProcess(), 0xc0000409);
}
void __report_gsfailure(uint64_t stack_cookie) __noreturn
{
uint64_t stack_cookie_1 = stack_cookie;
if (IsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE))
trap(0xd);
capture_previous_context(&data_14001dbd0);
data_14001dcc8 = __return_addr;
data_14001dc68 = &stack_cookie_1;
data_14001db40 = data_14001dcc8;
data_14001dc50 = stack_cookie_1;
data_14001db30 = 0xc0000409;
data_14001db34 = 1;
data_14001db48 = 1;
data_14001db50 = 2;
uint64_t __security_cookie_1 = __security_cookie;
int64_t var_10 = data_14001d080;
__raise_securityfailure(&data_140012808);
/* no return */
}
int64_t sub_140001e5e() __pure
{
return;
}
IMAGE_RUNTIME_FUNCTION_ENTRY* capture_previous_context(CONTEXT* arg1)
{
RtlCaptureContext(arg1);
uint64_t Rip = arg1->Rip;
IMAGE_RUNTIME_FUNCTION_ENTRY* FunctionEntry;
for (int32_t i = 0; i < 2; i += 1)
{
uint64_t ImageBase;
FunctionEntry = RtlLookupFunctionEntry(Rip, &ImageBase, nullptr);
if (!FunctionEntry)
break;
uint64_t EstablisherFrame;
void HandlerData;
FunctionEntry = RtlVirtualUnwind(UNW_FLAG_NHANDLER, ImageBase, Rip, FunctionEntry, arg1,
&HandlerData, &EstablisherFrame, nullptr);
}
return FunctionEntry;
}
int64_t __scrt_acquire_startup_lock()
{
int64_t result;
if (!sub_1400027b0())
{
label_140001f06:
result = 0;
}
else
{
TEB* gsbase;
void* StackBase = gsbase->NtTib.Self->NtTib.StackBase;
do
{
result = 0;
bool z_1;
if (0 == data_14001e0a8)
{
data_14001e0a8 = StackBase;
z_1 = true;
}
else
{
result = data_14001e0a8;
z_1 = false;
}
if (z_1)
goto label_140001f06;
} while (StackBase != result);
result = 1;
}
return result;
}
int64_t __scrt_initialize_crt(int32_t arg1)
{
if (!arg1)
data_14001e0b0 = 1;
int64_t xcr0;
sub_140002518(xcr0);
if (__scrt_dllmain_crt_thread_attach())
{
if (sub_1400068e4())
return 1;
__vcrt_uninitialize(0);
}
return 0;
}
int64_t __scrt_initialize_onexit_tables(int32_t arg1)
{
int32_t result;
if (data_14001e0b1)
result = 1;
else
{
if (arg1 > 1)
{
__scrt_fastfail(5);
breakpoint();
}
if (!sub_1400027b0() || arg1)
{
__builtin_memset(&data_14001e0b8, 0xff, 0x30);
data_14001e0b1 = 1;
result = 1;
}
else if (_initialize_onexit_table(&data_14001e0b8))
result = 0;
else if (!_initialize_onexit_table(&data_14001e0d0))
{
data_14001e0b1 = 1;
result = 1;
}
else
result = 0;
}
return result;
}
uint64_t __scrt_is_nonwritable_in_current_image(int64_t arg1)
{
struct Section_Header* const rdx_1 = &__section_headers;
while (true)
{
struct Section_Header* const var_18_1 = rdx_1;
if (rdx_1 == &data_1400002f0)
{
rdx_1 = nullptr;
break;
}
uint64_t virtualAddress = rdx_1->virtualAddress;
if (arg1 - &__dos_header >= virtualAddress
&& arg1 - &__dos_header < rdx_1->virtualSize + virtualAddress)
break;
rdx_1 = &rdx_1[1];
}
uint64_t result;
if (!rdx_1)
result = 0;
else if (rdx_1->characteristics >= 0)
result = 1;
else
result = 0;
return result;
}
int64_t __scrt_release_startup_lock(char arg1)
{
int64_t rbx;
rbx = arg1;
int32_t result = sub_1400027b0();
if (result && !rbx)
{
data_14001e0a8;
data_14001e0a8 = 0;
}
return result;
}
int64_t __scrt_uninitialize_crt(char arg1, char arg2)
{
int64_t rbx;
rbx = arg1;
if (!data_14001e0b0 || !arg2)
{
__acrt_uninitialize(arg1);
__vcrt_uninitialize(rbx);
}
int64_t result;
result = 1;
return result;
}
int64_t _onexit(int64_t arg1)
{
int32_t rax;
if (*data_14001e0b8 != -1)
rax = _register_onexit_function(&data_14001e0b8, arg1);
else
rax = sub_1400066f4(arg1);
if (!rax)
return arg1;
return 0;
}
uint64_t atexit(int64_t arg1)
{
int64_t rax = _onexit(arg1);
int32_t rax_1 = -(rax);
return -((rax_1 - rax_1)) - 1;
}
uint64_t sub_140002118()
{
uint64_t __security_cookie_1 = __security_cookie;
if (__security_cookie_1 == 0x2b992ddfa232)
{
FILETIME systemTimeAsFileTime;
__builtin_memset(&systemTimeAsFileTime, 0, 8);
GetSystemTimeAsFileTime(&systemTimeAsFileTime);
int64_t rax;
rax = systemTimeAsFileTime.dwLowDateTime;
*rax[4] = systemTimeAsFileTime.dwHighDateTime;
int64_t var_18 = rax;
uint64_t rax_2 = GetCurrentThreadId();
var_18 ^= rax_2;
uint64_t rax_4 = GetCurrentProcessId();
var_18 ^= rax_4;
int64_t performanceCount;
QueryPerformanceCounter(&performanceCount);
__security_cookie_1 =
(performanceCount << 0x20 ^ performanceCount ^ var_18 ^ &var_18) & 0xffffffffffff;
if (__security_cookie_1 == 0x2b992ddfa232)
__security_cookie_1 = 0x2b992ddfa233;
__security_cookie = __security_cookie_1;
}
uint64_t result = ~__security_cookie_1;
data_14001d080 = result;
return result;
}
int64_t sub_1400021c8() __pure
{
return 0;
}
int64_t sub_1400021cc() __pure
{
return 1;
}
int64_t sub_1400021d4() __pure
{
return 0x4000;
}
int64_t sub_1400021dc()
{
/* tailcall */
return InitializeSListHead(&data_14001e0f0);
}
int64_t sub_1400021ec() __pure
{
int64_t result;
result = 1;
return result;
}
void _guard_check_icall(void (* arg1)()) __pure
{
return;
}
int64_t sub_1400021f4() __pure
{
return &data_14001e100;
}
int64_t sub_1400021fc() __pure
{
return &data_14001e108;
}
int64_t __scrt_initialize_default_local_stdio_options()
{
data_14001e100 |= 0x24;
data_14001e108 |= 2;
return &data_14001e108;
}
int64_t sub_140002220()
{
int64_t result;
result = !data_14001d08c;
return result;
}
int64_t sub_14000222c() __pure
{
return &data_14001ebc8;
}
int64_t sub_140002234() __pure
{
return &data_14001ebc0;
}
int64_t sub_14000223c()
{
data_14001e110 = 0;
}
int32_t __scrt_fastfail(int32_t arg1)
{
if (IsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE))
trap(0xd);
sub_14000223c();
void ContextRecord;
sub_140010a60(&ContextRecord, 0, 0x4d0);
RtlCaptureContext(&ContextRecord);
uint64_t ControlPc;
uint64_t ImageBase;
IMAGE_RUNTIME_FUNCTION_ENTRY* FunctionEntry =
RtlLookupFunctionEntry(ControlPc, &ImageBase, nullptr);
uint64_t EstablisherFrame;
void HandlerData;
if (FunctionEntry)
RtlVirtualUnwind(UNW_FLAG_NHANDLER, ImageBase, ControlPc, FunctionEntry, &ContextRecord,
&HandlerData, &EstablisherFrame, nullptr);
void* const __return_addr_2 = __return_addr;
int64_t __saved_rbx;
int64_t* var_440 = &__saved_rbx;
int32_t var_578;
sub_140010a60(&var_578, 0, 0x98);
void* const __return_addr_1 = __return_addr;
var_578 = 0x40000015;
int32_t var_574 = 1;
BOOL rax_3 = IsDebuggerPresent();
EXCEPTION_POINTERS ExceptionInfo;
ExceptionInfo.ExceptionRecord = &var_578;
ExceptionInfo.ContextRecord = &ContextRecord;
SetUnhandledExceptionFilter(nullptr);
int32_t result = UnhandledExceptionFilter(&ExceptionInfo);
if (!result && rax_3 != 1)
sub_14000223c();
return result;
}
int64_t __scrt_get_show_window_mode()
{
void startupInfo;
sub_140010a60(&startupInfo, 0, 0x68);
GetStartupInfoW(&startupInfo);
int64_t result = 0xa;
char var_3c;
int16_t var_38;
if (var_3c & 1)
result = var_38;
return result;
}
int64_t j_sub_1400021c8()
{
/* tailcall */
return sub_1400021c8();
}
HMODULE sub_1400023d8()
{
HMODULE result = GetModuleHandleW(nullptr);
int64_t result_1;
if (result && result->unused == 0x5a4d)
result_1 = result;
if (!result || result->unused != 0x5a4d || *(result_1 + result) != 0x4550
|| *(result_1 + result + 0x18) != 0x20b || *(result_1 + result + 0x84) <= 0xe)
result = 0;
else
result = *(result_1 + result + 0xf8);
return result;
}
int64_t sub_14000242c()
{
/* tailcall */
return SetUnhandledExceptionFilter(sub_14000243c);
}
int64_t sub_14000243c(int64_t* arg1)
{
int32_t* rbx = *arg1;
if (*rbx == 0xe06d7363 && rbx[6] == 4)
{
int32_t rdx_1 = rbx[8];
if (rdx_1 == 0x19930520 || rdx_1 - 0x19930521 <= 1 || rdx_1 == 0x1994000)
{
*__current_exception() = rbx;
*__current_exception_context() = arg1[1];
sub_140006930();
/* no return */
}
}
return 0;
}
void _RTC_Initialize()
{
for (void* const i = &data_14001a6c0; i < &data_14001a6c0; i += 8)
{
int64_t rax = *i;
if (rax)
rax();
}
}
void _RTC_Terminate()
{
for (void* const i = &data_14001a6d0; i < &data_14001a6d0; i += 8)
{
int64_t rax = *i;
if (rax)
rax();
}
}
int64_t sub_140002518(int64_t arg1 @ xcr0)
{
int32_t temp0;
int32_t temp1;
int32_t temp2;
int32_t temp3;
temp0 = __cpuid(0, 0);
int32_t temp0_1;
int32_t temp1_1;
int32_t temp2_1;
int32_t temp3_1;
temp0_1 = __cpuid(1, 0);
int32_t rax_2;
uint64_t rax_3;
if (!((temp3 ^ 0x49656e69) | (temp2 ^ 0x6c65746e) | (temp1 ^ 0x756e6547)))
{
rax_2 = temp0_1 & 0xfff3ff0;
data_14001d0a0 = 0x8000;
data_14001d0a8 = -1;
if (rax_2 != 0x106c0 && rax_2 != 0x20660 && rax_2 != 0x20670)
rax_3 = rax_2 - 0x30650;
}
int32_t r8_1;
if ((temp3 ^ 0x49656e69) | (temp2 ^ 0x6c65746e) | (temp1 ^ 0x756e6547) || (rax_2 != 0x106c0
&& rax_2 != 0x20660 && rax_2 != 0x20670
&& (rax_3 > 0x20 || !TEST_BITQ(0x100010001, rax_3))))
r8_1 = data_14001e118;
else
{
r8_1 = data_14001e118 | 1;
data_14001e118 = r8_1;
}
int32_t r9 = 0;
int32_t rsi = 0;
int32_t r10 = 0;
int32_t r11 = 0;
if (temp0 >= 7)
{
int32_t temp0_2;
int32_t temp1_2;
int32_t temp2_2;
int32_t temp3_2;
temp0_2 = __cpuid(7, 0);
rsi = temp3_2;
r9 = temp1_2;
if (TEST_BITD(temp1_2, 9))
data_14001e118 = r8_1 | 2;
if (temp0_2 >= 1)
{
int32_t temp0_3;
int32_t temp1_3;
int32_t temp2_3;
int32_t temp3_3;
temp0_3 = __cpuid(7, 1);
r10 = temp3_3;
}
if (temp0 >= 0x24)
{
int32_t temp0_4;
int32_t temp1_4;
int32_t temp2_4;
int32_t temp3_4;
temp0_4 = __cpuid(0x24, 0);
r11 = temp1_4;
}
}
int64_t rax_8 = data_14001d090 & 0xfffffffffffffffe;
data_14001d098 = 1;
data_14001d09c = 2;
data_14001d090 = rax_8;
if (TEST_BITD(temp2_1, 0x14))
{
data_14001d098 = 2;
data_14001d090 = rax_8 & 0xffffffffffffffef;
data_14001d09c = 6;
}
if (TEST_BITD(temp2_1, 0x1b))
{
int32_t temp0_5;
int32_t temp1_5;
temp0_5 = _xgetbv(0, arg1);
uint64_t rdx_10 = temp0_5 << 0x20 | temp1_5;
if (TEST_BITD(temp2_1, 0x1c) && (rdx_10 & 6) == 6)
{
int32_t rax_13 = data_14001d09c | 8;
data_14001d098 = 3;
data_14001d09c = rax_13;
int64_t rax_16;
if (!(r9 & 0x20))
rax_16 = data_14001d090;
else
{
data_14001d098 = 5;
data_14001d09c = rax_13 | 0x20;
rax_16 = data_14001d090 & 0xfffffffffffffffd;
data_14001d090 = rax_16;
if ((r9 & 0xd0030000) == 0xd0030000)
{
if ((rdx_10 & 0xe0) != 0xe0)
rax_16 = data_14001d090;
else
{
int64_t rax_18 = data_14001d090;
data_14001d09c |= 0x40;
rax_16 = rax_18 & 0xffffffffffffffdb;
data_14001d098 = 6;
data_14001d090 = rax_16;
}
}
}
if (TEST_BITD(rsi, 0x17))
data_14001d090 = rax_16 & 0xfffffffffeffffff;
if (TEST_BITD(r10, 0x13) && (rdx_10 & 0xe0) == 0xe0)
{
int32_t rax_22 = r11 & 0x400ff;
data_14001e114 = rax_22;
int64_t rcx_11 = ~((r11 >> 0x10 & 6) | 0x1000029) & data_14001d090;
data_14001d090 = rcx_11;
if (rax_22 > 1)
data_14001d090 = rcx_11 & 0xffffffffffffffbf;
}
}
if (TEST_BITD(r10, 0x15) && TEST_BITQ(rdx_10, 0x13))
data_14001d090 &= 0xffffffffffffff7f;
}
return 0;
}
int64_t sub_1400027b0()
{
int64_t result;
result = data_14001ebbc;
return result;
}
int64_t __InternalCxxFrameHandler(int32_t* arg1, int64_t arg2, void* arg3, int64_t* arg4)
{
__except_validate_context_record(arg3);
int64_t r12 = arg4[1];
int32_t* rbx = arg4[7];
int64_t r14_1 = *arg4 - r12;
int32_t i = arg4[9];
if (arg1[1] & 0x66)
{
int64_t rbp_2 = arg4[4] - r12;
while (true)
{
int32_t r8_4 = *rbx;
if (i >= r8_4)
break;
uint64_t r9_2 = i * 2;
if (r14_1 >= rbx[r9_2 * 2 + 1] && r14_1 < rbx[r9_2 * 2 + 2])
{
if (arg1[1] & 0x20)
{
int32_t rdx_4 = 0;
if (r8_4)
{
do
{
uint64_t rcx_9 = rdx_4 * 2;
if (rbp_2 >= rbx[rcx_9 * 2 + 1] && rbp_2 < rbx[rcx_9 * 2 + 2]
&& rbx[rcx_9 * 2 + 4] == rbx[r9_2 * 2 + 4]
&& rbx[rcx_9 * 2 + 3] == rbx[r9_2 * 2 + 3])
break;
rdx_4 += 1;
} while (rdx_4 < r8_4);
}
if (rdx_4 != *rbx)
break;
}
int64_t rax_22 = (i + 1) * 2;
if (!rbx[rax_22 * 2])
{
arg4[9] = i + 1;
uint64_t rcx_11;
rcx_11 = 1;
(rbx[i * 4 + 3] + r12)(rcx_11, arg2);
}
else if (rbp_2 == rbx[rax_22 * 2] && arg1[1] & 0x20)
break;
}
i += 1;
}
}
else
{
int32_t* var_38 = arg1;
void* var_30_1 = arg3;
for (; i < *rbx; i += 1)
{
uint64_t rcx_2 = i * 2;
uint64_t i_1 = i;
if (r14_1 >= rbx[rcx_2 * 2 + 1] && r14_1 < rbx[rcx_2 * 2 + 2] && rbx[rcx_2 * 2 + 4])
{
if (rbx[rcx_2 * 2 + 3] == 1)
{
label_14000286f:
if (*arg1 == 0xe06d7363 && sub_140010140(&data_140012830))
sub_140002a34(arg1);
rbx[(i_1 + 1) * 4];
sub_140002bd0();
RtlUnwindEx(arg2, rbx[(i_1 + 1) * 4] + r12, arg1, *arg1, arg4[5], arg4[8]);
}
else
{
int32_t rax_5 = (rbx[rcx_2 * 2 + 3] + r12)(&var_38, arg2);
if (rax_5 < 0)
return 0;
if (rax_5 > 0)
goto label_14000286f;
}
}
}
}
return 1;
}
int64_t __scrt_dllmain_crt_thread_attach()
{
if (__vcrt_initialize_locks())
{
if (__vcrt_initialize_ptd())
return 1;
__vcrt_uninitialize_locks();
}
return 0;
}
int64_t __vcrt_uninitialize(char arg1)
{
if (!arg1)
{
sub_140002d8c();
__vcrt_uninitialize_locks();
}
int64_t result;
result = 1;
return result;
}
int64_t sub_140002a1c(void* arg1, int64_t arg2)
{
if (arg1 != arg2)
/* tailcall */
return strcmp(arg1 + 9, arg2 + 9);
return 0;
}
void sub_140002a34(int32_t* arg1)
{
if (!arg1)
return;
char rdx;
char arg_10 = rdx;
if (*arg1 != 0xe06d7363 || arg1[6] != 4)
return;
int32_t rax_1 = arg1[8];
if (rax_1 != 0x19930520 && rax_1 - 0x19930521 > 1)
return;
uint64_t rax = *(arg1 + 0x30);
if (!rax)
return;
int64_t rdx_1 = *(rax + 4);
if (rdx_1)
sub_140002aa8(*(arg1 + 0x28), rdx_1 + *(arg1 + 0x38));
else if (*rax & 0x10)
{
int64_t* rcx_1 = **(arg1 + 0x28);
if (rcx_1)
(*(*rcx_1 + 0x10))();
}
}
int64_t sub_140002aa8(int64_t, int64_t arg2)
{
/* jump -> arg2 */
}
uint64_t _IsExceptionObjectToBeDestroyed(int64_t arg1)
{
int64_t* rdx = *(__vcrt_getptd() + 0x58);
while (true)
{
if (!rdx)
return rdx + 1;
if (*rdx == arg1)
break;
rdx = rdx[1];
}
return 0;
}
int64_t __AdjustPointer(int64_t arg1, int32_t* arg2)
{
int64_t result = *arg2 + arg1;
if (arg2[1] < 0)
return result;
int64_t r9_1 = arg2[1];
return result + *(arg2[2] + *(r9_1 + arg1)) + r9_1;
}
int64_t sub_140002b00(int64_t* arg1)
{
int32_t* rdi = *arg1;
if (*rdi == 0xe0434352 || *rdi == 0xe0434f4d)
{
if (*(__vcrt_getptd() + 0x30) > 0)
{
void* rax_2 = __vcrt_getptd();
*(rax_2 + 0x30) -= 1;
}
}
else if (*rdi == 0xe06d7363)
{
*(__vcrt_getptd() + 0x20) = rdi;
*(__vcrt_getptd() + 0x28) = arg1[1];
sub_140006930();
/* no return */
}
return 0;
}
void* __current_exception()
{
return __vcrt_getptd() + 0x20;
}
void* __current_exception_context()
{
return __vcrt_getptd() + 0x28;
}
void sub_140002b90() __noreturn
{
sub_140006930();
/* no return */
}
int64_t sub_140002bd0()
{
int64_t rcx;
int64_t arg_8 = rcx;
int64_t rdx;
int64_t arg_18 = rdx;
int32_t r8;
int32_t arg_10 = r8;
/* tailcall */
return sub_140002bf0();
}
int64_t sub_140002bf0() __pure
{
return;
}
int64_t sub_140002c00() __pure
{
return;
}
void (*)(void (* arg1)()) __except_validate_context_record(void* arg1)
{
return _guard_check_icall;
}
void __vcrt_freefls(int64_t arg1)
{
if (arg1 && arg1 != &data_14001e130)
j_sub_140006b00(arg1);
}
void* __vcrt_getptd()
{
void* result = sub_140002c78();
if (result)
return result;
abort();
/* no return */
}
void* sub_140002c78()
{
if (data_14001d0b0 == 0xffffffff)
return nullptr;
enum WIN32_ERROR dwErrCode = GetLastError();
void* result_1 = __vcrt_FlsGetValue(data_14001d0b0);
void* result = nullptr;
if (result_1 != -1)
{
if (!result_1)
{
if (__vcrt_FlsSetValue(data_14001d0b0, -1))
{
void* result_2 = calloc(1, 0x80);
uint32_t rcx_3 = data_14001d0b0;
void* const result_3 = result_2;
if (!result_2)
__vcrt_FlsSetValue(rcx_3, 0);
else if (!__vcrt_FlsSetValue(rcx_3, result_2))
__vcrt_FlsSetValue(data_14001d0b0, 0);
else
{
*(result_3 + 0x78) = 0xfffffffe;
result_3 = nullptr;
result = result_2;
}
j_sub_140006b00(result_3);
}
}
else
result = result_1;
}
SetLastError(dwErrCode);
return result;
}
uint32_t __vcrt_initialize_ptd()
{
uint32_t result = __vcrt_FlsAlloc(__vcrt_freefls);
data_14001d0b0 = result;
if (result == 0xffffffff)
result = 0;
else if (!__vcrt_FlsSetValue(result, &data_14001e130))
{
sub_140002d8c();
result = 0;
}
else
{
data_14001e1a8 = 0xfffffffe;
result = 1;
}
return result;
}
int64_t sub_140002d8c()
{
uint32_t rcx = data_14001d0b0;
if (rcx != 0xffffffff)
{
__vcrt_FlsFree(rcx);
data_14001d0b0 = 0xffffffff;
}
int64_t result;
result = 1;
return result;
}
int64_t __vcrt_initialize_locks()
{
uint64_t rbx = 0;
int32_t result;
while (true)
{
if (!__vcrt_InitializeCriticalSectionEx(&data_14001e1b0 + rbx * 0x28, 0xfa0, 0))
{
__vcrt_uninitialize_locks();
result = 0;
break;
}
data_14001e1d8 += 1;
rbx = rbx + 1;
if (rbx >= 1)
{
result = 1;
break;
}
}
return result;
}
int64_t __vcrt_uninitialize_locks()
{
uint64_t rbx = data_14001e1d8;
while (rbx)
{
rbx = rbx - 1;
DeleteCriticalSection(&data_14001e1b0 + rbx * 0x28);
data_14001e1d8 -= 1;
}
int64_t result;
result = 1;
return result;
}
int64_t try_get_function(int32_t arg1, PSTR arg2, int32_t* arg3, int64_t arg4)
{
uint64_t rdi = arg1;
int32_t* rbp = arg3;
int64_t result = *((rdi << 3) + 0x14001e1f8);
if (result != -1)
{
if (result)
return result;
if (arg3 != arg4)
{
HMODULE rbx_1;
while (true)
{
uint64_t rsi_1 = *rbp;
rbx_1 = *((rsi_1 << 3) + 0x14001e1e0);
if (!rbx_1)
{
int16_t* lpLibFileName = (&data_140013618)[rsi_1];
HMODULE rax =
LoadLibraryExW(lpLibFileName, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
rbx_1 = rax;
if (rax)
{
label_140002f4f:
int64_t temp0_3 = *((rsi_1 << 3) + 0x14001e1e0);
*((rsi_1 << 3) + 0x14001e1e0) = rbx_1;
if (temp0_3)
FreeLibrary(rbx_1);
break;
}
if (GetLastError() != ERROR_INVALID_PARAMETER)
{
*((rsi_1 << 3) + 0x14001e1e0);
*((rsi_1 << 3) + 0x14001e1e0) = -1;
}
else if (!sub_140006ac0(lpLibFileName, u"api-ms-", rbx_1 + 7))
{
*((rsi_1 << 3) + 0x14001e1e0);
*((rsi_1 << 3) + 0x14001e1e0) = -1;
}
else
{
HMODULE rax_3 = LoadLibraryExW(lpLibFileName, nullptr, 0);
rbx_1 = rax_3;
if (rax_3)
goto label_140002f4f;
*((rsi_1 << 3) + 0x14001e1e0);
*((rsi_1 << 3) + 0x14001e1e0) = -1;
}
}
else if (rbx_1 != -1)
break;
rbp = &rbp[1];
if (rbp == arg4)
goto label_140002f1e;
}
result = GetProcAddress(rbx_1, arg2);
if (result)
{
*((rdi << 3) + 0x14001e1f8);
*((rdi << 3) + 0x14001e1f8) = result;
return result;
}
}
label_140002f1e:
*((rdi << 3) + 0x14001e1f8);
*((rdi << 3) + 0x14001e1f8) = -1;
}
return 0;
}
int64_t __vcrt_FlsAlloc(int64_t arg1)
{
int64_t rax = try_get_function(0, "FlsAlloc", &data_1400136d8, "FlsAlloc");
if (!rax)
/* tailcall */
return TlsAlloc();
/* tailcall */
return rax(arg1);
}
int64_t __vcrt_FlsFree(uint32_t arg1)
{
int64_t rax = try_get_function(1, "FlsFree", &data_1400136f0, "FlsFree");
if (!rax)
/* tailcall */
return TlsFree(arg1);
/* tailcall */
return rax(arg1);
}
int64_t __vcrt_FlsGetValue(uint32_t arg1)
{
int64_t rax = try_get_function(2, "FlsGetValue", &data_140013700, "FlsGetValue");
if (!rax)
/* tailcall */
return TlsGetValue(arg1);
/* tailcall */
return rax(arg1);
}
int64_t __vcrt_FlsSetValue(uint32_t arg1, int64_t arg2)
{
int64_t rax = try_get_function(3, "FlsSetValue", &data_140013718, "FlsSetValue");
if (!rax)
return TlsSetValue(arg1, arg2);
return rax(arg1, arg2);
}
int64_t __vcrt_InitializeCriticalSectionEx(CRITICAL_SECTION* arg1, uint32_t arg2, int32_t arg3)
{
int64_t rax = try_get_function(4, "InitializeCriticalSectionEx", &data_140013730,
"InitializeCriticalSectionEx");
if (!rax)
return InitializeCriticalSectionAndSpinCount(arg1, arg2);
return rax(arg1, arg2, arg3);
}
int64_t sub_140003114(int32_t* arg1)
{
int64_t r9;
int64_t arg_20 = r9;
int64_t r8;
int64_t arg_18 = r8;
int64_t rdx;
int64_t arg_10 = rdx;
int32_t* arg_8 = arg1;
int32_t var_28 = 0;
int32_t* var_18 = arg1;
int64_t var_10 = r8;
void* rax = __vcrt_getptd();
(*(rax + 0x10))(*arg1, &var_18);
int32_t var_28_1 = 0;
return 0;
}
void* const sub_140003168(void* arg1, int32_t arg2)
{
int32_t rdi = *(arg1 + 0xc);
if (rdi)
{
uint64_t rbx_1;
do
{
rbx_1 = rdi - 1;
rdi = rbx_1;
int64_t rcx = *(__vcrt_getptd() + 0x60) + rbx_1 * 0x14;
void* const result = *(arg1 + 0x10) + rcx;
if (arg2 > *(result + 4) && arg2 <= *(result + 8))
return result;
} while (rbx_1);
}
return nullptr;
}
void* __FrameHandler3::ExecutionInCatch(int64_t* arg1, void* arg2)
{
void* result;
result = sub_140003168(arg2, sub_14000378c(arg2, arg1));
return result;
}
int64_t __FrameHandler3::FrameUnwindToEmptyState(int64_t* arg1, int64_t* arg2, void* arg3)
{
void arg_20;
int64_t* rax = sub_14000325c(arg1, arg2, arg3, &arg_20);
void* rax_2 = sub_140003168(arg3, sub_14000378c(arg3, arg2));
int32_t r9_1;
if (rax_2)
r9_1 = *(rax_2 + 4);
else
r9_1 = -1;
return __FrameHandler3::FrameUnwindToState(rax, arg2, arg3, r9_1);
}
int64_t* sub_14000325c(int64_t* arg1, int64_t* arg2, void* arg3, int64_t* arg4)
{
int32_t i = *(arg3 + 0xc);
int32_t rax = sub_14000378c(arg3, arg2);
*arg4 = *arg1;
while (i)
{
uint64_t rcx_1 = i - 1;
int64_t rdi_1 = arg2[1];
i = rcx_1;
int64_t rbx_1 = *(arg3 + 0x10) + rcx_1 * 0x14;
if (rax > *(rbx_1 + rdi_1 + 4) && rax <= *(rbx_1 + rdi_1 + 8))
{
uint64_t ImageBase;
IMAGE_RUNTIME_FUNCTION_ENTRY* rax_2 =
RtlLookupFunctionEntry(*arg2, &ImageBase, nullptr);
uint64_t rcx_4 = 0;
int64_t r8_1 = *(rbx_1 + rdi_1 + 0x10) + ImageBase;
int32_t j = *(rbx_1 + rdi_1 + 0xc);
if (j)
{
int32_t* rdx_1 = r8_1 + 0xc;
do
{
if (*rdx_1 == rax_2->BeginAddress)
goto label_14000331e;
rcx_4 = rcx_4 + 1;
rdx_1 = &rdx_1[5];
} while (rcx_4 < j);
}
if (rcx_4 < j)
{
label_14000331e:
*arg4 = *(*(r8_1 + rcx_4 * 0x14 + 0x10) + *arg1);
break;
}
}
}
return arg4;
}
int128_t* __FrameHandler3::GetRangeOfTrysToCheck(int128_t* arg1, int64_t arg2, int32_t arg3, int64_t* arg4, void* arg5)
{
int32_t rbp = *(arg5 + 0xc);
int32_t rax = sub_14000378c(arg5, arg4);
int32_t r10 = 0;
if (!rbp)
{
abort();
/* no return */
}
void* rdi_1 = arg4[1];
int64_t r11 = *(arg5 + 0x10);
int32_t r8 = -1;
int32_t r13 = -1;
int32_t rdx_1 = rbp;
void* r9_1;
while (true)
{
uint64_t rax_1 = rdx_1 - 1;
int32_t rbx_1 = rdx_1;
rdx_1 = rax_1;
void* rax_2 = rdi_1 + rax_1 * 0x14;
if (rax > *(rax_2 + r11 + 4) && rax <= *(rax_2 + r11 + 8))
{
r9_1 = rdi_1 + (rbx_1 - 1) * 0x14 + r11;
break;
}
if (!rdx_1)
{
r9_1 = nullptr;
break;
}
}
int32_t rdx_2 = 0;
int32_t* rcx_2 = rdi_1 + r11;
do
{
if (!r9_1)
{
label_1400033e9:
if (arg3 >= *rcx_2 && arg3 <= rcx_2[1])
{
r13 = rdx_2;
if (r8 == 0xffffffff)
r8 = rdx_2;
}
}
else if (*rcx_2 > *(r9_1 + 4) && rcx_2[1] <= *(r9_1 + 8))
goto label_1400033e9;
rdx_2 += 1;
rcx_2 = &rcx_2[5];
} while (rdx_2 < rbp);
int32_t rax_5 = 0;
if (r8 != 0xffffffff)
rax_5 = r8;
int32_t var_40 = rax_5;
if (r8 != 0xffffffff)
r10 = r13 + 1;
int32_t var_30 = r10;
*arg1 = arg2;
arg1[1] = arg2;
return arg1;
}
int64_t __FrameHandler4::UnwindNestedFrames(int64_t* arg1, int64_t arg2, int64_t arg3, int64_t arg4, int64_t arg5, int64_t arg6, int32_t arg7, int64_t* arg8, char arg9)
{
void var_e8;
int64_t rax_1 = __security_cookie ^ &var_e8;
int128_t zmm0 = data_140013760;
int128_t zmm1 = data_140013770;
EXCEPTION_RECORD ExceptionRecord;
ExceptionRecord.ExceptionCode = zmm0;
ExceptionRecord.ExceptionFlags = *zmm0[4];
ExceptionRecord.ExceptionRecord = *zmm0[8];
zmm0 = data_140013780;
ExceptionRecord.ExceptionAddress = zmm1;
ExceptionRecord.NumberParameters = *zmm1[8];
zmm1 = data_140013790;
ExceptionRecord.ExceptionInformation[0] = zmm0;
ExceptionRecord.ExceptionInformation[1] = *zmm0[8];
zmm0 = data_1400137a0;
ExceptionRecord.ExceptionInformation[2] = zmm1;
ExceptionRecord.ExceptionInformation[3] = *zmm1[8];
zmm1 = data_1400137b0;
ExceptionRecord.ExceptionInformation[4] = zmm0;
ExceptionRecord.ExceptionInformation[5] = *zmm0[8];
zmm0 = data_1400137c0;
ExceptionRecord.ExceptionInformation[6] = zmm1;
ExceptionRecord.ExceptionInformation[7] = *zmm1[8];
zmm1 = data_1400137e0;
ExceptionRecord.ExceptionInformation[8] = zmm0;
ExceptionRecord.ExceptionInformation[9] = *zmm0[8];
zmm0 = data_1400137d0;
ExceptionRecord.ExceptionInformation[0xa] = zmm0;
ExceptionRecord.ExceptionInformation[0xb] = *zmm0[8];
ExceptionRecord.ExceptionInformation[0xc] = zmm1;
ExceptionRecord.ExceptionInformation[0xd] = *zmm1[8];
ExceptionRecord.ExceptionInformation[0xe] = 0;
int64_t TargetFrame = *arg1;
ExceptionRecord.ExceptionInformation[0] = sub_140004720;
ExceptionRecord.ExceptionInformation[2] = arg5;
ExceptionRecord.ExceptionInformation[3] = arg7;
ExceptionRecord.ExceptionInformation[5] = arg6;
ExceptionRecord.ExceptionInformation[7] = arg9;
UNWIND_HISTORY_TABLE* HistoryTable = arg8[8];
CONTEXT* ContextRecord = arg8[5];
ExceptionRecord.ExceptionInformation[1] = arg4;
ExceptionRecord.ExceptionInformation[4] = arg3;
ExceptionRecord.ExceptionInformation[6] = arg2;
int64_t TargetIp = *arg8;
ExceptionRecord.ExceptionInformation[8] = 0x19930520;
int64_t result =
RtlUnwindEx(TargetFrame, TargetIp, &ExceptionRecord, nullptr, ContextRecord, HistoryTable);
__security_check_cookie(rax_1 ^ &var_e8);
return result;
}
int64_t* _CreateFrameInfo(int64_t* arg1, int64_t arg2)
{
*arg1 = arg2;
int64_t rcx;
if (arg1 >= *(__vcrt_getptd() + 0x58))
rcx = 0;
else
rcx = *(__vcrt_getptd() + 0x58);
arg1[1] = rcx;
*(__vcrt_getptd() + 0x58) = arg1;
return arg1;
}
void* _FindAndUnlinkFrame(int64_t arg1)
{
if (arg1 == *(__vcrt_getptd() + 0x58))
{
void* i_1 = *(__vcrt_getptd() + 0x58);
if (i_1)
{
void* i;
do
{
i = *(i_1 + 8);
if (arg1 == i_1)
{
void* result = __vcrt_getptd();
*(result + 0x58) = i;
return result;
}
i_1 = i;
} while (i);
}
}
abort();
/* no return */
}
int64_t _GetImageBase()
{
return *(__vcrt_getptd() + 0x60);
}
int64_t _GetThrowImageBase()
{
return *(__vcrt_getptd() + 0x68);
}
void* _SetImageBase(int64_t arg1)
{
void* result = __vcrt_getptd();
*(result + 0x60) = arg1;
return result;
}
void* _SetThrowImageBase(int64_t arg1)
{
void* result = __vcrt_getptd();
*(result + 0x68) = arg1;
return result;
}
DWORD __CxxFrameHandler3(struct _EXCEPTION_RECORD* rec, EXCEPTION_REGISTRATION_RECORD* ExceptionRegistrationFrame, struct _CONTEXT* context, EXCEPTION_REGISTRATION_RECORD** _ExceptionRecord) __noreturn
{
int64_t rbx = _ExceptionRecord[1];
EXCEPTION_REGISTRATION_RECORD* ExceptionRegistrationFrame_1 = ExceptionRegistrationFrame;
*(__vcrt_getptd() + 0x60) = rbx;
*(__vcrt_getptd() + 0x68) = rec->ExceptionInformation[3];
void* rax_2 = __vcrt_getptd();
return j_sub_1400043fc(rec, &ExceptionRegistrationFrame_1, context, _ExceptionRecord,
_ExceptionRecord[7]->Next + *(rax_2 + 0x60), 0, 0, 0);
}
int64_t __FrameHandler3::GetCurrentState(int64_t* arg1, int64_t* arg2, void* arg3)
{
int32_t result = *(*(arg3 + 0x1c) + *arg1);
if (result != 0xfffffffe)
return result;
return sub_140003794(arg3, arg2, *arg2);
}
uint64_t __GetUnwindTryBlock(int64_t* arg1, int64_t* arg2, void* arg3)
{
int64_t arg_18;
int64_t rcx = *sub_14000325c(arg1, arg2, arg3, &arg_18);
int64_t rax_1 = *(arg3 + 0x1c);
arg_18 = rcx;
return *(rax_1 + rcx + 4);
}
int64_t __FrameHandler3::SetState(int64_t* arg1, void* arg2, int32_t arg3)
{
int64_t result = *arg1;
*(*(arg2 + 0x1c) + result) = arg3;
return result;
}
int64_t __FrameHandler3::SetUnwindTryBlock(int64_t* arg1, int64_t* arg2, void* arg3, int32_t arg4)
{
int64_t arg_18;
int64_t rcx = *sub_14000325c(arg1, arg2, arg3, &arg_18);
int64_t result = *(arg3 + 0x1c);
arg_18 = rcx;
if (arg4 > *(result + rcx + 4))
*(result + rcx + 4) = arg4;
return result;
}
int64_t sub_14000378c(void* arg1, int64_t* arg2)
{
/* tailcall */
return sub_140003794(arg1, arg2, *arg2);
}
uint64_t sub_140003794(void* arg1, void* arg2, int64_t arg3)
{
if (arg1)
{
int64_t r11_1 = *(arg1 + 0x18);
int64_t r10_1 = *(arg2 + 8);
if (r10_1 + r11_1)
{
int32_t r8 = *(arg1 + 0x14);
uint64_t r9 = 0;
if (r8)
{
while (arg3 >= *(r11_1 + (r9 << 3) + r10_1) + r10_1)
{
r9 = r9 + 1;
if (r9 >= r8)
break;
}
if (r9)
return *(r10_1 + ((r9 - 1) << 3) + r11_1 + 4);
}
return 0xffffffff;
}
}
abort();
/* no return */
}
uint64_t sub_1400037fc(void* arg1, int64_t* arg2, char* arg3, char* arg4)
{
int64_t* rsi = arg2;
int32_t rdi = 0;
int64_t r15 = *(arg3 + 4);
void* rdx;
if (!r15)
rdx = nullptr;
else
rdx = r15 + _GetImageBase();
if (rdx)
{
int64_t r15_1 = *(arg3 + 4);
void* rcx;
if (!r15_1)
rcx = nullptr;
else
rcx = r15_1 + _GetImageBase();
if (*(rcx + 0x10) && (*(arg3 + 8) || *arg3 < 0))
{
if (*arg3 >= 0)
rsi = *(arg3 + 8) + *rsi;
int64_t* rax;
if (*arg3 & 0x80 && *arg4 & 0x10)
rax = data_14001e120;
if (*arg3 & 0x80 && *arg4 & 0x10 && rax)
{
int64_t rax_4 = rax();
if (!rax_4 || !rsi)
{
abort();
/* no return */
}
*rsi = rax_4;
*rsi = __AdjustPointer(rax_4, &arg4[8]);
}
else if (*arg3 & 8)
{
int64_t rcx_1 = *(arg1 + 0x28);
if (!rcx_1 || !rsi)
{
abort();
/* no return */
}
*rsi = rcx_1;
*rsi = __AdjustPointer(rcx_1, &arg4[8]);
}
else if (!(*arg4 & 1))
{
int64_t rbx_1 = *(arg4 + 0x18);
void* rcx_3;
if (!rbx_1)
rcx_3 = nullptr;
else
rcx_3 = rbx_1 + _GetThrowImageBase();
if (rcx_3)
{
void* rcx_6;
if (*(arg1 + 0x28) && rsi)
{
int64_t rbx_3 = *(arg4 + 0x18);
if (!rbx_3)
rcx_6 = nullptr;
else
rcx_6 = rbx_3 + _GetThrowImageBase();
}
if (!*(arg1 + 0x28) || !rsi || !rcx_6)
{
abort();
/* no return */
}
rax = *arg4;
rax &= 4;
char temp0_1 = rax;
rax = -(rax);
rdi = -((rcx_6 - rcx_6)) + 1;
int32_t var_28_1 = -((rcx_6 - rcx_6)) + 1;
}
else
{
if (!*(arg1 + 0x28) || !rsi)
{
abort();
/* no return */
}
memcpy(rsi, __AdjustPointer(*(arg1 + 0x28), &arg4[8]), *(arg4 + 0x14));
}
}
else
{
int32_t* rdx_1 = *(arg1 + 0x28);
if (!rdx_1 || !rsi)
{
abort();
/* no return */
}
memcpy(rsi, rdx_1, *(arg4 + 0x14));
if (*(arg4 + 0x14) == 8 && *rsi)
*rsi = __AdjustPointer(*rsi, &arg4[8]);
}
return rdi;
}
}
return 0;
}
int64_t sub_1400039f0(void* arg1, int64_t* arg2, int32_t* arg3, char* arg4)
{
int64_t rbx = 0;
int64_t* rdi;
if (*arg3 >= 0)
rdi = arg3[2] + *arg2;
else
rdi = arg2;
int32_t rax = sub_1400037fc(arg1, arg2, arg3, arg4);
int32_t result = rax - 1;
if (rax == 1)
{
int64_t rax_3 = __AdjustPointer(*(arg1 + 0x28), &arg4[8]);
int64_t rsi_2 = *(arg4 + 0x18);
if (rsi_2)
rbx = _GetThrowImageBase() + rsi_2;
return _CallMemberFunction1(rdi, rbx, rax_3);
}
if (result != 1)
return result;
int64_t rax_1 = __AdjustPointer(*(arg1 + 0x28), &arg4[8]);
int64_t rsi_1 = *(arg4 + 0x18);
if (rsi_1)
rbx = _GetThrowImageBase() + rsi_1;
return _CallMemberFunction2(rdi, rbx, rax_1, 1);
}
void sub_140003aaa() __noreturn
{
abort();
/* no return */
}
int64_t sub_140003ab0(void* arg1, int64_t* arg2, int64_t arg3, int64_t* arg4, void* arg5, int32_t* arg6, char* arg7, int32_t* arg8, char arg9)
{
void arg_10;
int64_t* rax = sub_14000325c(arg2, arg4, arg5, &arg_10);
if (arg7)
sub_1400039f0(arg1, rax, arg6, arg7);
char var_48 = arg9;
int64_t* var_50 = arg4;
return __FrameHandler4::UnwindNestedFrames(arg2, arg1, arg3, rax, _GetImageBase() + arg6[3],
arg5, *arg8, arg8[2], arg6);
}
void* FindHandler<class __FrameHandler3>(int32_t* arg1, int64_t* arg2, int64_t arg3, int64_t* arg4, int32_t* arg5, char arg6, int32_t arg7, int64_t arg8)
{
void var_168;
int64_t rax_1 = __security_cookie ^ &var_168;
int64_t* r12 = arg2;
int64_t r15 = arg3;
int64_t var_100 = arg3;
int32_t* rdi = arg1;
int64_t var_e0 = arg8;
char var_108 = 0;
int32_t rax_2 = __FrameHandler3::GetHandlerSearchState(r12, arg4, arg5);
int32_t rbx = rax_2;
if (rax_2 >= 0xffffffff && rax_2 < arg5[1])
{
uint128_t var_c8;
void* result;
if (*rdi != 0xe06d7363 || rdi[6] != 4)
{
label_140003cf4:
int64_t var_a8_1 = arg4[1];
int32_t* var_b0 = arg5;
int32_t rax_15;
if (*rdi == 0xe06d7363 && rdi[6] == 4)
rax_15 = rdi[8];
if (*rdi == 0xe06d7363 && rdi[6] == 4
&& (rax_15 == 0x19930520 || rax_15 - 0x19930521 <= 1))
{
int32_t var_140;
if (arg5[3] > 0)
{
var_140 = arg7;
uint128_t var_90;
__FrameHandler3::GetRangeOfTrysToCheck(&var_90, &var_b0, rbx, arg4, arg5);
uint128_t zmm1_1 = var_90;
int96_t var_a0_1 = zmm1_1;
int32_t var_78;
if (_mm_bsrli_si128(zmm1_1, 8) < var_78)
{
int32_t r15_1 = *var_a0_1[8];
void* r9_1 = zmm1_1;
void* var_e8_1 = r9_1;
do
{
int64_t rax_22 = *(r9_1 + 8);
int64_t r8_2 = *(*var_a0_1 + 0x10) + r15_1 * 0x14;
uint128_t zmm0_1 = *(r8_2 + rax_22);
int64_t rcx_6 = *(r8_2 + rax_22 + 0x10);
int32_t var_b8_1 = rcx_6;
var_c8 = zmm0_1;
if (zmm0_1 <= rbx && rbx <= zmm0_1 >> 0x20)
{
int64_t rcx_7 = rcx_6 + arg4[1];
uint64_t r12_1 = 0;
int64_t var_d0_1 = rcx_7;
uint32_t rax_27 = _mm_bsrli_si128(zmm0_1, 8) >> 0x20;
if (!rax_27)
{
label_140003ee8:
r12 = arg2;
}
else
{
while (true)
{
uint64_t rax_28 = r12_1 * 5;
uint128_t var_70 = *(rcx_7 + (rax_28 << 2));
int32_t var_60_1 = *(rcx_7 + (rax_28 << 2) + 0x10);
int32_t* var_f8_1 =
_GetThrowImageBase() + 4 + *(*(rdi + 0x30) + 0xc);
int32_t r13_1 =
*(_GetThrowImageBase() + *(*(rdi + 0x30) + 0xc));
if (r13_1 > 0)
{
int32_t* rax_34 = var_f8_1;
while (true)
{
char* rbx_5 = *rax_34 + _GetThrowImageBase();
if (sub_1400042dc(&var_70, rbx_5, *(rdi + 0x30)))
{
int32_t rax_36;
rax_36 = arg6;
r12 = arg2;
char var_110_1 = rax_36;
rax_36 = var_108;
char var_118_1 = rax_36;
int64_t var_120_1 = var_e0;
int32_t var_138;
var_138 = rbx_5;
var_140 = &var_70;
sub_140003ab0(rdi, r12, var_100, arg4, arg5,
var_140, var_138, &var_c8, arg7);
r9_1 = var_e8_1;
rbx = rax_2;
break;
}
r13_1 -= 1;
rax_34 = &var_f8_1[1];
var_f8_1 = rax_34;
if (r13_1 <= 0)
goto label_140003e6b;
}
break;
}
label_140003e6b:
r12_1 = r12_1 + 1;
if (r12_1 == rax_27)
{
rbx = rax_2;
r9_1 = var_e8_1;
goto label_140003ee8;
}
rcx_7 = var_d0_1;
}
}
}
r15_1 += 1;
} while (r15_1 < var_78);
}
}
if ((*arg5 & 0x1fffffff) < 0x19930521)
goto label_140003ffe;
int64_t rbx_6 = arg5[8];
int64_t rax_42;
if (rbx_6)
rax_42 = _GetImageBase();
if (rbx_6 && rax_42 != -(rbx_6))
{
label_140003f3b:
if (arg5[9] & 4)
{
*(__vcrt_getptd() + 0x20) = rdi;
*(__vcrt_getptd() + 0x28) = var_100;
sub_140006930();
/* no return */
}
int64_t rbx_7 = arg5[8];
int32_t* rdx_8;
if (!rbx_7)
rdx_8 = nullptr;
else
rdx_8 = rbx_7 + _GetImageBase();
if (!sub_140004bc8(rdi, rdx_8))
{
char var_118_2 = arg6;
int64_t* var_120_2 = arg4;
int32_t* var_130;
var_130 = 0xffffffff;
var_140 = arg5;
__FrameHandler4::UnwindNestedFrames(r12, rdi, var_100,
sub_14000325c(r12, arg4, arg5, &var_e0), 0, var_140, 0xffffffff,
var_130, 0);
}
}
else if (arg5[9] & 4 && !__FrameHandler3::ExecutionInCatch(arg4, arg5))
goto label_140003f3b;
goto label_140003ffe;
}
if (arg5[3] <= 0)
goto label_140003ffe;
if (!arg6)
{
sub_140004078(rdi, r12, r15, arg4, arg5, rbx, arg7, arg8);
label_140003ffe:
result = __vcrt_getptd();
if (!*(result + 0x38))
{
__security_check_cookie(rax_1 ^ &var_168);
return result;
}
}
}
else
{
int32_t rax_3 = rdi[8];
if ((rax_3 != 0x19930520 && rax_3 - 0x19930521 > 1) || *(rdi + 0x30))
goto label_140003cf4;
result = __vcrt_getptd();
if (!*(result + 0x20))
{
__security_check_cookie(rax_1 ^ &var_168);
return result;
}
rdi = *(__vcrt_getptd() + 0x20);
var_108 = 1;
r15 = *(__vcrt_getptd() + 0x28);
var_100 = r15;
_SetThrowImageBase(*(rdi + 0x38));
if (rdi)
{
int32_t rax_7;
if (*rdi == 0xe06d7363 && rdi[6] == 4)
rax_7 = rdi[8];
if (*rdi != 0xe06d7363 || rdi[6] != 4
|| (rax_7 != 0x19930520 && rax_7 - 0x19930521 > 1) || *(rdi + 0x30))
{
if (*(__vcrt_getptd() + 0x38))
{
int32_t* rbx_1 = *(__vcrt_getptd() + 0x38);
*(__vcrt_getptd() + 0x38) = 0;
if (!sub_140004bc8(rdi, rbx_1))
{
char rax_13;
int64_t rdx_2;
rax_13 = sub_140004cb0(rbx_1);
if (!rax_13)
{
sub_140006930();
/* no return */
}
rdx_2 = 1;
sub_140002a34(rdi);
sub_140004670(&var_c8);
sub_140004e98(&var_c8, &data_14001b750);
/* no return */
}
rbx = rax_2;
}
goto label_140003cf4;
}
}
}
}
abort();
/* no return */
}
void sub_140004078(int32_t* arg1, int64_t* arg2, int64_t arg3, int64_t* arg4, void* arg5, int32_t arg6, int32_t arg7, int64_t arg8)
{
if (*arg1 == 0x80000003)
return;
int32_t var_c0;
if (*(__vcrt_getptd() + 0x10))
{
int64_t rax_2 = EncodePointer(nullptr);
if (*(__vcrt_getptd() + 0x10) != rax_2 && *arg1 != 0xe0434f4d && *arg1 != 0xe0434352)
{
var_c0 = arg6;
int64_t var_c8_1 = arg8;
int32_t var_d0_1 = arg7;
void* var_d8_1 = arg5;
sub_140003114(arg1);
}
}
int64_t var_90_1 = arg4[1];
void* var_98 = arg5;
if (*(arg5 + 0xc) <= 0)
{
abort();
/* no return */
}
int32_t var_d0_2 = arg7;
uint128_t var_60;
__FrameHandler3::GetRangeOfTrysToCheck(&var_60, &var_98, arg6, arg4, arg5);
uint128_t zmm1_1 = var_60;
int96_t var_88_1 = zmm1_1;
int32_t var_48;
if (_mm_bsrli_si128(zmm1_1, 8) >= var_48)
return;
int32_t rbx_2 = *var_88_1[8];
void* r9_2 = zmm1_1;
void* arg_8 = r9_2;
do
{
int64_t rax_9 = *(r9_2 + 8);
int64_t r8_2 = *(*var_88_1 + 0x10) + rbx_2 * 0x14;
uint128_t zmm0_1 = *(r8_2 + rax_9);
int64_t rdx_3 = *(r8_2 + rax_9 + 0x10);
int32_t var_68_1 = rdx_3;
uint128_t var_78 = zmm0_1;
if (zmm0_1 <= arg6 && arg6 <= (zmm0_1 >> 0x20))
{
char* r15_3 = arg4[1] - 0x14 + rdx_3 + (_mm_bsrli_si128(zmm0_1, 8) >> 0x20) * 0x14;
int64_t r12_1 = *(r15_3 + 4);
if (!r12_1)
{
label_140004244:
if (!(*r15_3 & 0x40))
{
char var_a0_1 = 0;
char var_a8_1 = 1;
int64_t var_b0_1 = arg8;
var_c0 = &var_78;
var_d0_2 = r15_3;
sub_140003ab0(arg1, arg2, arg3, arg4, arg5, var_d0_2, nullptr, var_c0, arg7);
}
}
else
{
if (_GetImageBase() == -(r12_1))
goto label_140004244;
int64_t r12_2 = *(r15_3 + 4);
uint64_t rax;
if (!r12_2)
rax = 0;
else
rax = _GetImageBase() + r12_2;
if (!*(rax + 0x10))
goto label_140004244;
}
}
r9_2 = arg_8;
rbx_2 += 1;
} while (rbx_2 < var_48);
}
uint64_t sub_1400042dc(char* arg1, char* arg2, char* arg3)
{
int64_t rbx = *(arg1 + 4);
int32_t rdi = 0;
if (rbx && _GetImageBase() != -(rbx))
{
int64_t rbx_1 = *(arg1 + 4);
void* const rcx;
if (!rbx_1)
rcx = nullptr;
else
rcx = rbx_1 + _GetImageBase();
if (*(rcx + 0x10) && (!(*arg1 & 0x80) || !(*arg2 & 0x10)))
{
int64_t rbp_1 = *(arg1 + 4);
int64_t rbx_2;
if (!rbp_1)
rbx_2 = 0;
else
rbx_2 = _GetImageBase() + rbp_1;
int64_t rax_6 = _GetThrowImageBase();
if (rbx_2 != *(arg2 + 4) + rax_6)
{
int64_t rbx_3 = *(arg1 + 4);
void* const rbp_2;
if (!rbx_3)
rbp_2 = nullptr;
else
rbp_2 = rbx_3 + _GetImageBase();
if (strcmp(rbp_2 + 0x10, *(arg2 + 4) + 0x10 + _GetThrowImageBase()))
return 0;
}
if ((!(*arg2 & 2) || *arg1 & 8) && (!(*arg3 & 1) || *arg1 & 1)
&& (!(*arg3 & 4) || *arg1 & 4) && (!(*arg3 & 2) || *arg1 & 2))
rdi = 1;
return rdi;
}
}
return 1;
}
int64_t sub_1400043fc(int32_t* arg1, int64_t* arg2, void* arg3, int64_t* arg4, int32_t* arg5, int32_t arg6, int64_t arg7, char arg8)
{
__except_validate_context_record(arg3);
if (*(__vcrt_getptd() + 0x40) || *arg1 == 0xe06d7363)
{
label_140004481:
if (!(arg1[1] & 0x66))
{
if (arg5[3])
{
label_140004570:
if (*arg1 == 0xe06d7363 && arg1[6] >= 3 && arg1[8] > 0x19930522)
{
int64_t rbp_2 = *(*(arg1 + 0x30) + 8);
if (rbp_2)
{
int64_t rax_12 = _GetThrowImageBase();
if (rax_12 != -(rbp_2))
{
int64_t var_30;
var_30 = arg8;
int32_t var_38;
var_38 = arg7;
char var_40;
var_40 = arg6;
return (rax_12 + rbp_2)(arg1, arg2, arg3, arg4, arg5, var_40, var_38,
var_30);
}
}
}
int32_t rax_15;
rax_15 = arg8;
FindHandler<class __FrameHandler3>(arg1, arg2, arg3, arg4, arg5, rax_15, arg6,
arg7);
}
else
{
if ((*arg5 & 0x1fffffff) >= 0x19930521)
{
int64_t rbp_1 = arg5[8];
if (rbp_1 && _GetImageBase() != -(rbp_1))
goto label_140004570;
}
if ((*arg5 & 0x1fffffff) >= 0x19930522 && arg5[9] & 4)
goto label_140004570;
}
}
else if (arg5[1] && !arg6)
{
if (!(arg1[1] & 0x20))
__FrameHandler3::FrameUnwindToEmptyState(arg2, arg4, arg5);
else if (*arg1 == 0x80000026)
{
int32_t rax_3 = sub_140003794(arg5, arg4, arg4[4]);
if (rax_3 < 0xffffffff || rax_3 >= arg5[1])
{
abort();
/* no return */
}
__FrameHandler3::FrameUnwindToState(arg2, arg4, arg5, rax_3);
}
else if (*arg1 != 0x80000029)
__FrameHandler3::FrameUnwindToEmptyState(arg2, arg4, arg5);
else
{
int32_t r9 = arg1[0xe];
if (r9 < 0xffffffff || r9 >= arg5[1])
{
abort();
/* no return */
}
__FrameHandler3::FrameUnwindToState(*(arg1 + 0x28), arg4, arg5, r9);
}
}
}
else
{
bool cond:0_1;
if (*arg1 != 0x80000029)
{
cond:0_1 = *arg1 == 0x80000026;
label_14000446a:
if (cond:0_1 || (*arg5 & 0x1fffffff) < 0x19930522 || !(arg5[9] & 1))
goto label_140004481;
}
else
{
if (arg1[6] == 0xf)
{
cond:0_1 = *(arg1 + 0x60) == 0x19930520;
goto label_14000446a;
}
if ((*arg5 & 0x1fffffff) < 0x19930522 || !(arg5[9] & 1))
goto label_140004481;
}
}
return 1;
}
int64_t j_sub_1400043fc(int32_t* arg1, int64_t* arg2, void* arg3, int64_t* arg4, int32_t* arg5, int32_t arg6, int64_t arg7, char arg8)
{
/* tailcall */
return sub_1400043fc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
struct std::exception::VTable** boost::enable_error_info<class boost::math::evaluation_error>(struct std::exception::VTable** arg1, void* arg2)
{
*arg1 = &std::exception::`vftable';
*(arg1 + 8) = {0};
sub_140004df0(arg2 + 8, &arg1[1]);
*arg1 = &std::bad_exception::`vftable'{for `std::exception'};
return arg1;
}
struct std::exception::std::bad_exception::VTable** sub_140004670(struct std::exception::std::bad_exception::VTable** arg1)
{
arg1[2] = 0;
arg1[1] = "bad exception";
*arg1 = &std::bad_exception::`vftable'{for `std::exception'};
return arg1;
}
struct std::exception::VTable** std::exception::exception(struct std::exception::VTable** arg1, void* arg2)
{
*arg1 = &std::exception::`vftable';
*(arg1 + 8) = {0};
sub_140004df0(arg2 + 8, &arg1[1]);
return arg1;
}
int64_t Concurrency::invalid_oversubscribe_operation::~invalid_oversubscribe_operation(struct std::exception::VTable** arg1)
{
*arg1 = &std::exception::`vftable';
/* tailcall */
return sub_140004e70(&arg1[1]);
}
struct std::exception::VTable** std::bad_typeid::`scalar deleting destructor'(struct std::exception::VTable** arg1, char arg2)
{
*arg1 = &std::exception::`vftable';
sub_140004e70(&arg1[1]);
if (arg2 & 1)
j_sub_140006b00(arg1);
return arg1;
}
int64_t sub_140004720(void* arg1)
{
int32_t var_88 = 0;
int32_t arg_8 = 0;
int64_t var_80 = 0;
int64_t arg_20 = 0;
int64_t r13 = *(__vcrt_getptd() + 0x28);
int64_t var_68 = r13;
int64_t rax_2 = *(__vcrt_getptd() + 0x20);
int32_t* rsi = *(arg1 + 0x50);
int32_t* var_50 = rsi;
int32_t* arg_10 = rsi;
void* rax_3 = *(arg1 + 0x48);
void* rbx = *(arg1 + 0x40);
int64_t rax_4 = *(arg1 + 0x30);
int64_t* r14 = *(arg1 + 0x28);
int64_t* var_58 = r14;
__except_validate_context_record(rbx);
*(__vcrt_getptd() + 0x20) = rsi;
*(__vcrt_getptd() + 0x28) = rbx;
void var_48;
int64_t* rax_8;
int512_t zmm0;
rax_8 = _CreateFrameInfo(&var_48, *(*(__vcrt_getptd() + 0x20) + 0x28));
int64_t* var_70 = rax_8;
if (*(arg1 + 0x58))
{
arg_8 = 1;
void* rax_9;
rax_9 = __vcrt_getptd();
arg_20 = *(rax_9 + 0x70);
}
int64_t result = _CallSettingFrame(rax_4, r14, zmm0);
int64_t result_1 = result;
_FindAndUnlinkFrame(rax_8);
if (*rsi == 0xe06d7363 && rsi[6] == 4)
{
int32_t rax_10 = rsi[8];
if (rax_10 == 0x19930520 || rax_10 - 0x19930521 <= 1)
{
int32_t rax_12;
int64_t rdx_3;
rax_12 = _IsExceptionObjectToBeDestroyed(*(rsi + 0x28));
if (rax_12)
{
rdx_3 = 1;
sub_140002a34(rsi);
}
}
}
*(__vcrt_getptd() + 0x20) = rax_2;
*(__vcrt_getptd() + 0x28) = r13;
*(*(rax_3 + 0x1c) + *r14) = -2;
return result;
}
void sub_14000481f(int32_t arg1, int32_t* arg2, int32_t* arg3) __noreturn
{
int32_t arg_20 = 1;
void* rax;
int64_t rdx;
rax = __vcrt_getptd();
*(rax + 0x40) = 0;
int32_t* rcx = arg2;
if (arg1)
{
rdx = 1;
sub_140002a34(rcx);
rcx = arg3;
}
RaiseException(*rcx, rcx[1], rcx[6], &rcx[8]);
/* no return */
}
int64_t sub_14000490c(int64_t* arg1, void* arg2, int32_t* arg3)
{
int32_t* r9 = *arg1;
*arg3 = 0;
if (*r9 == 0xe06d7363)
{
if (r9[6] == 4)
{
int32_t rax_1 = r9[8];
if ((rax_1 == 0x19930520 || rax_1 - 0x19930521 <= 1) && *(r9 + 0x28) == *(arg2 + 0x28))
*arg3 = 1;
}
if (*r9 == 0xe06d7363 && r9[6] == 4)
{
int32_t rcx = r9[8];
if ((rcx == 0x19930520 || rcx - 0x19930521 <= 1) && !*(r9 + 0x30))
{
*(__vcrt_getptd() + 0x40) = 1;
*arg3 = 1;
return 1;
}
}
}
return 0;
}
int64_t __FrameHandler3::FrameUnwindToState(int64_t* arg1, int64_t* arg2, void* arg3, int32_t arg4)
{
int32_t arg_20 = arg4;
void* arg_18 = arg3;
int64_t* arg_8 = arg1;
int64_t rax = _GetImageBase();
int64_t var_40 = rax;
int32_t i = __FrameHandler3::GetCurrentState(arg1, arg2, arg3);
void* rax_2 = __vcrt_getptd();
*(rax_2 + 0x30) += 1;
while (i != 0xffffffff)
{
if (i <= arg4)
break;
if (i <= 0xffffffff || i >= *(arg3 + 4))
{
abort();
/* no return */
}
int64_t rax_3 = _GetImageBase();
int64_t r14_2 = i << 3;
i = *(*(arg3 + 8) + r14_2 + rax_3);
int32_t i_1 = i;
int64_t rax_9;
if (!*(_GetImageBase() + r14_2 + *(arg3 + 8) + 4))
rax_9 = 0;
else
{
int64_t rbx_3 = *(_GetImageBase() + r14_2 + *(arg3 + 8) + 4);
rax_9 = _GetImageBase() + rbx_3;
}
if (rax_9)
{
__FrameHandler3::SetState(arg1, arg3, i);
int64_t rbx_4 = *(arg3 + 8);
int64_t rax_10;
int512_t zmm0_1;
rax_10 = _GetImageBase();
int64_t rax_15;
if (!*(rax_10 + r14_2 + rbx_4 + 4))
rax_15 = 0;
else
{
int64_t rbx_6 = *(_GetImageBase() + r14_2 + *(arg3 + 8) + 4);
int64_t rax_14;
rax_14 = _GetImageBase();
rax_15 = rax_14 + rbx_6;
}
_CallSettingFrame(rax_15, arg1, zmm0_1);
_SetImageBase(rax);
}
int32_t i_2 = i;
}
if (*(__vcrt_getptd() + 0x30) > 0)
{
void* rax_17 = __vcrt_getptd();
*(rax_17 + 0x30) -= 1;
}
if (i == 0xffffffff || i <= arg4)
return __FrameHandler3::SetState(arg1, arg3, i);
abort();
/* no return */
}
uint64_t __FrameHandler3::GetHandlerSearchState(int64_t* arg1, int64_t* arg2, void* arg3)
{
int32_t rbx = sub_14000378c(arg3, arg2);
void arg_20;
sub_14000325c(arg1, arg2, arg3, &arg_20);
if (rbx <= __GetUnwindTryBlock(arg1, arg2, arg3))
rbx = __GetUnwindTryBlock(arg1, arg2, arg3);
else
{
__FrameHandler3::SetState(&arg_20, arg3, rbx);
__FrameHandler3::SetUnwindTryBlock(arg1, arg2, arg3, rbx);
}
return rbx;
}
int32_t* sub_140004bc8(void* arg1, int32_t* arg2)
{
void* rsi = arg1;
if (!arg2)
{
abort();
/* no return */
}
int64_t r12;
r12 = 0;
int32_t i = 0;
if (*arg2 > 0)
{
do
{
int32_t* rdi_2 = *(*(rsi + 0x30) + 0xc) + _GetThrowImageBase() + 4;
int32_t* arg_10 = rdi_2;
int32_t j = *(_GetThrowImageBase() + *(*(rsi + 0x30) + 0xc));
if (j > 0)
{
do
{
int64_t rsi_1 = *rdi_2;
int64_t rax_5 = _GetThrowImageBase();
if (sub_1400042dc(_GetImageBase() + i * 0x14 + arg2[1], rsi_1 + rax_5,
*(arg1 + 0x30)))
{
r12 = 1;
break;
}
j -= 1;
rdi_2 = &arg_10[1];
arg_10 = rdi_2;
} while (j > 0);
rsi = arg1;
}
i += 1;
} while (i < *arg2);
}
int32_t* result;
result = r12;
return result;
}
int64_t sub_140004cb0(int32_t* arg1)
{
int32_t rbp = 0;
int32_t result;
if (*arg1 <= 0)
{
label_140004d1d:
result = 0;
}
else
{
int64_t rsi_1 = 0;
while (true)
{
void* rax_5;
if (!*(_GetImageBase() + rsi_1 + arg1[1] + 4))
rax_5 = nullptr;
else
{
int64_t rbx_3 = *(_GetImageBase() + rsi_1 + arg1[1] + 4);
rax_5 = _GetImageBase() + rbx_3;
}
if (!sub_140002a1c(rax_5 + 8, &class std::bad_exception `RTTI Type Descriptor'.spare))
{
result = 1;
break;
}
rbp += 1;
rsi_1 += 0x14;
if (rbp >= *arg1)
goto label_140004d1d;
}
}
return result;
}
int64_t _CallMemberFunction1(int64_t, int64_t arg2)
{
/* jump -> arg2 */
}
int64_t _CallMemberFunction2(int64_t, int64_t arg2, int64_t arg3, int32_t arg4)
{
/* jump -> arg2 */
}
char const* const sub_140004d54(void* arg1)
{
if (*(arg1 + 8))
return *(arg1 + 8);
return "Unknown exception";
}
int64_t _CallSettingFrame(int64_t arg1, int64_t* arg2, int512_t arg3 @ zmm0)
{
int64_t arg_8 = arg1;
int32_t r8;
int32_t arg_18 = r8;
int64_t rdx = *arg2;
sub_140002bd0();
int64_t result = arg1(arg3, rdx);
*arg2;
sub_140002bd0();
return result;
}
int64_t sub_140004df0(int64_t* arg1, int64_t* arg2)
{
if (arg1[1])
{
char* rcx = *arg1;
if (rcx)
{
void* rbp_1 = strlen(rcx) + 1;
char* rax_1 = j_sub_140008f50(rbp_1);
char* rcx_2 = rax_1;
if (rax_1)
{
sub_140006950(rcx_2, rbp_1, *arg1);
rcx_2 = nullptr;
*arg2 = rax_1;
arg2[1] = 1;
}
return j_sub_140006b00(rcx_2);
}
}
int64_t result = *arg1;
*arg2 = result;
arg2[1] = 0;
return result;
}
void sub_140004e70(int64_t* arg1)
{
if (arg1[1])
j_sub_140006b00(*arg1);
arg1[1] = 0;
*arg1 = 0;
}
void sub_140004e98(int64_t* arg1, char* arg2) __noreturn
{
char* PcValue = arg2;
uint64_t arguments_1 = 0x19930520;
if (arg2 && *arg2 & 0x10)
{
void* rax_1 = *(*arg1 - 8);
PcValue = *(rax_1 + 0x30);
(*(rax_1 + 0x40))();
}
int64_t BaseOfImage_1 = 0;
int64_t BaseOfImage = 0;
if (PcValue)
{
BaseOfImage_1 = RtlPcToFileHeader(PcValue, &BaseOfImage);
BaseOfImage = BaseOfImage_1;
if (*PcValue & 8 || !BaseOfImage_1)
arguments_1 = 0x1994000;
}
uint64_t arguments = arguments_1;
int64_t* var_28 = arg1;
char* PcValue_1 = PcValue;
int64_t BaseOfImage_2 = BaseOfImage_1;
RaiseException(0xe06d7363, 1, 4, &arguments);
/* no return */
}
uint64_t _fclose_internal(int32_t* arg1, int64_t* arg2)
{
int32_t* arg_8 = arg1;
if (arg1)
{
if (!(arg1[5] >> 0xc & 1))
{
sub_1400070e8(arg1);
int32_t rax_4 = _fclose_nolock_internal(arg1, arg2);
sub_1400070f4(arg1);
return rax_4;
}
__acrt_stdio_free_stream(arg1);
}
else
{
arg2[6] = 1;
*(arg2 + 0x2c) = 0x16;
int64_t var_18;
_invalid_parameter_internal(arg1, 0, 0, 0, var_18 & arg1, arg2);
}
return 0xffffffff;
}
uint64_t _fclose_nolock_internal(int32_t* arg1, int64_t* arg2)
{
if (!arg1)
{
arg2[6] = 1;
*(arg2 + 0x2c) = 0x16;
int64_t var_18;
_invalid_parameter_internal(arg1, 0, 0, 0, var_18 & arg1, arg2);
return 0xffffffff;
}
int32_t rsi_1 = -1;
if (arg1[5] >> 0xd & 1)
{
rsi_1 = __acrt_stdio_flush_nolock(arg1, arg2);
__acrt_stdio_free_buffer_nolock(arg1);
if (_close_internal(_fileno(arg1), arg2) >= 0)
{
int64_t rcx_3 = *(arg1 + 0x28);
if (rcx_3)
{
_free_base(rcx_3);
*(arg1 + 0x28) = 0;
}
}
else
rsi_1 = -1;
}
__acrt_stdio_free_stream(arg1);
return rsi_1;
}
int64_t sub_140005064(int64_t* arg1)
{
if (!*arg1)
{
enum WIN32_ERROR dwErrCode_2 = GetLastError();
bool cond:1_1 = arg1[2];
enum WIN32_ERROR dwErrCode_1 = dwErrCode_2;
int64_t rdx_1;
if (cond:1_1)
rdx_1 = arg1[1];
else
{
arg1[1] = 0;
rdx_1 = 0;
arg1[2] = 1;
}
void* rax_1 = sub_140007db0(&dwErrCode_1, rdx_1);
enum WIN32_ERROR dwErrCode = dwErrCode_1;
*arg1 = rax_1;
SetLastError(dwErrCode);
if (!rax_1)
{
abort();
/* no return */
}
}
return *arg1;
}
uint64_t fclose(int32_t* arg1)
{
void* var_48 = nullptr;
char var_38 = 0;
char var_20 = 0;
char var_18 = 0;
if (!data_14001e37c)
{
var_20 = 1;
int128_t var_30_1 = *data_14001d338;
}
int32_t rax = _fclose_internal(arg1, &var_48);
if (var_20 == 2)
{
void* rcx = var_48;
*(rcx + 0x3a8) &= 0xfffffffd;
}
int32_t var_1c;
if (var_18)
*(sub_140005064(&var_48) + 0x20) = var_1c;
int32_t var_14;
if (0)
*(sub_140005064(&var_48) + 0x24) = var_14;
return rax;
}
void* common_fsopen<char>(char* arg1, char* arg2, int32_t arg3)
{
if (!arg1 || !arg2 || !*arg2)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
else if (*arg1)
{
void* arg_8;
__acrt_stdio_allocate_stream(&arg_8);
void* r9_1 = arg_8;
if (r9_1)
{
int64_t var_18_1 = 0;
void* result = sub_14000829c(arg1, arg2, arg3, r9_1);
void* result_1 = result;
if (!result)
__acrt_stdio_free_stream(arg_8);
sub_1400070f4(arg_8);
return result;
}
*sub_140007fb4() = 0x18;
}
else
*sub_140007fb4() = 0x16;
return nullptr;
}
int64_t fopen(char* arg1, char* arg2)
{
/* tailcall */
return common_fsopen<char>(arg1, arg2, 0x40);
}
uint64_t sub_14000522c(int128_t* arg1, void* arg2, int64_t arg3, uint64_t arg4, int64_t* arg5)
{
uint64_t arg_20 = arg4;
int64_t* rbx = arg5;
if (arg3 && arg4)
{
if (!arg1)
*sub_140007fb4() = 0x16;
else if (!rbx || arg4 > -1 / arg3)
{
if (arg2 != -1)
{
sub_140010a60(arg1, 0, arg2);
arg4 = arg_20;
}
if (rbx && arg4 <= -1 / arg3)
goto label_1400052d0;
*sub_140007fb4() = 0x16;
}
else
{
label_1400052d0:
int32_t r8_1;
if (!(*(rbx + 0x14) & 0x4c0))
r8_1 = 0x1000;
else
r8_1 = rbx[4];
arg5 = r8_1;
int64_t rdi_2 = arg3 * arg4;
void* rcx = arg2;
int128_t* r13_1 = arg1;
void* arg_18 = rcx;
int64_t rbp_1 = rdi_2;
if (!rdi_2)
return arg4;
while (true)
{
int64_t r14_1;
int32_t temp3_1;
if (*(rbx + 0x14) & 0x4c0)
{
r14_1 = rbx[2];
temp3_1 = r14_1;
}
uint64_t rax_11;
if (*(rbx + 0x14) & 0x4c0 && temp3_1)
{
if (temp3_1 >= 0)
{
if (rbp_1 < r14_1)
r14_1 = rbp_1;
uint64_t r8_2 = r14_1;
if (r8_2 > rcx)
break;
int32_t* rdx_2 = *rbx;
if (r14_1)
{
if (!r13_1)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
else if (!rdx_2)
{
sub_140010a60(r13_1, 0, rcx);
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
else
memcpy(r13_1, rdx_2, r8_2);
rcx = arg_18;
}
rbx[2] -= r14_1;
rbp_1 -= r14_1;
*rbx += r14_1;
r13_1 += r14_1;
rax_11 = r14_1;
goto label_140005395;
}
*(rbx + 0x14) |= 0x10;
}
else if (rbp_1 < r8_1)
{
int32_t rax_19 = sub_140008de4(rbx);
if (rax_19 != 0xffffffff)
{
if (!arg_18)
break;
*r13_1 = rax_19;
rbp_1 -= 1;
r8_1 = rbx[4];
r13_1 += 1;
rcx = arg_18 - 1;
arg5 = r8_1;
goto label_14000543c;
}
}
else
{
int32_t r14_2 = rbp_1;
if (rbp_1 > 0x7fffffff)
r14_2 = 0x7fffffff;
if (r8_1)
r14_2 -= COMBINE(0, r14_2) % r8_1;
if (r14_2 > rcx)
break;
rbx[2] = 0;
*rbx = rbx[1];
int32_t rax_18 = _read_nolock(_fileno(rbx), r13_1, r14_2);
if (!rax_18)
*(rbx + 0x14) |= 8;
else if (rax_18 < 0)
*(rbx + 0x14) |= 0x10;
else
{
rcx = arg_18;
rax_11 = rax_18;
rbp_1 -= rax_11;
r13_1 += rax_11;
label_140005395:
r8_1 = arg5;
rcx -= rax_11;
label_14000543c:
arg_18 = rcx;
if (!rbp_1)
return arg_20;
continue;
}
}
return COMBINE(0, rdi_2 - rbp_1) / arg3;
}
if (arg2 != -1)
sub_140010a60(arg1, 0, arg2);
*sub_140007fb4() = 0x22;
}
_invalid_parameter_noinfo();
}
return 0;
}
uint64_t fread(int128_t* arg1, int64_t arg2, uint64_t arg3, int64_t* arg4)
{
return fread_s(arg1, -ffffffffffffffff, arg2, arg3, arg4);
}
uint64_t fread_s(int128_t* arg1, void* arg2, int64_t arg3, uint64_t arg4, int64_t* arg5)
{
if (arg3 && arg4)
{
if (arg5)
{
sub_1400070e8(arg5);
uint64_t result = sub_14000522c(arg1, arg2, arg3, arg4, arg5);
sub_1400070f4(arg5);
return result;
}
if (arg2 != -1)
sub_140010a60(arg1, 0, arg2);
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
return 0;
}
void j_sub_140006b00(int64_t arg1)
{
/* tailcall */
return _free_base(arg1);
}
int64_t j_sub_140008f50(uint64_t arg1)
{
/* tailcall */
return _malloc_base(arg1);
}
uint64_t _XcptFilter(int32_t arg1, int64_t arg2)
{
void** rax = sub_140007d20();
if (rax)
{
void* i_1 = *rax;
void* i = i_1;
if (i_1 != i_1 + 0xc0)
{
do
{
if (*i == arg1)
{
if (i)
{
int64_t r8_2 = *(i + 8);
if (r8_2)
{
if (r8_2 == 5)
{
*(i + 8) = 0;
return r8_2 - 4;
}
if (r8_2 != 1)
{
int64_t rbp_1 = rax[1];
rax[1] = arg2;
if (*(i + 4) != 8)
{
*(i + 4);
*(i + 8) = 0;
sub_140010380();
}
else
{
void* j = i_1 + 0x30;
for (void* rdx = j + 0x90; j != rdx; j += 0x10)
*(j + 8) = 0;
int32_t rdi_1 = rax[2];
if (*i == 0xc000008d)
rax[2] = 0x82;
else if (*i == 0xc000008e)
rax[2] = 0x83;
else if (*i == 0xc000008f)
rax[2] = 0x86;
else if (*i == 0xc0000090)
rax[2] = 0x81;
else if (*i == 0xc0000091)
rax[2] = 0x84;
else if (*i == 0xc0000092)
rax[2] = 0x8a;
else if (*i == 0xc0000093)
rax[2] = 0x85;
else if (*i == 0xc00002b4)
rax[2] = 0x8e;
else if (*i == 0xc00002b5)
rax[2] = 0x8d;
sub_140010380();
rax[2] = rdi_1;
}
rax[1] = rbp_1;
}
return 0xffffffff;
}
}
break;
}
i += 0x10;
} while (i != i_1 + 0xc0);
}
}
return 0;
}
uint64_t sub_1400056ec()
{
return data_14001e228;
}
int64_t sub_1400056f4(int32_t arg1)
{
data_14001e228 = arg1;
}
int64_t sub_140005700(int64_t arg1)
{
data_14001e230 = arg1;
}
int64_t sub_140005710(int64_t arg1)
{
uint64_t __security_cookie_1 = __security_cookie;
char result = __security_cookie_1 & 0x3f;
data_14001e230 = RORQ(arg1, 0x40 - result) ^ __security_cookie_1;
return result;
}
uint32_t sub_140005734(char* arg1, int64_t* arg2, void* arg3, int64_t* arg4, int64_t* arg5)
{
uint64_t rsi;
uint64_t arg_18 = rsi;
void* rbx = arg3;
int64_t* r14 = arg2;
char* rdi = arg1;
*arg5 = 0;
*arg4 = 1;
if (arg2)
{
*arg2 = rbx;
r14 = &r14[1];
}
int64_t rbp;
rbp = 0;
uint32_t i;
while (true)
{
if (*rdi != 0x22)
{
*arg5 += 1;
if (rbx)
{
i = *rdi;
*rbx = i;
rbx += 1;
}
rsi = *rdi;
rdi = &rdi[1];
i = _ismbblead(rsi);
if (i)
{
*arg5 += 1;
if (rbx)
{
i = *rdi;
*rbx = i;
rbx += 1;
}
rdi = &rdi[1];
}
if (!rsi)
{
rdi -= 1;
break;
}
}
else
{
rsi = 0x22;
rbp = !rbp;
rdi = &rdi[1];
}
if (!rbp)
{
if (rsi != 0x20 && rsi != 9)
continue;
if (!rbx)
break;
*(rbx - 1) = 0;
break;
}
}
rsi = 0;
while (true)
{
i = *rdi;
if (!i)
break;
while (i == 0x20 || i == 9)
{
rdi = &rdi[1];
i = *rdi;
}
if (!i)
break;
if (r14)
{
*r14 = rbx;
r14 = &r14[1];
}
*arg4 += 1;
while (true)
{
int32_t rdx = 1;
i = 0;
while (true)
{
arg1 = *rdi;
if (arg1 != 0x5c)
break;
rdi = &rdi[1];
i += 1;
}
if (arg1 == 0x22)
{
if (!(1 & i))
{
if (!rsi || rdi[1] != arg1)
{
rdx = 0;
rsi = !rsi;
}
else
rdi = &rdi[1];
}
i u>>= 1;
}
while (i)
{
i -= 1;
if (rbx)
{
*rbx = 0x5c;
rbx += 1;
}
*arg5 += 1;
}
i = *rdi;
if (!i)
break;
if (!rsi)
{
if (i == 0x20)
break;
if (i == 9)
break;
}
if (rdx)
{
if (rbx)
{
*rbx = i;
rbx += 1;
}
int32_t rax;
rax = _ismbblead(*rdi);
if (rax)
{
*arg5 += 1;
rdi = &rdi[1];
if (rbx)
{
rax = *rdi;
*rbx = rax;
rbx += 1;
}
}
*arg5 += 1;
}
rdi = &rdi[1];
}
if (rbx)
{
*rbx = 0;
rbx += 1;
}
*arg5 += 1;
}
if (r14)
*r14 = 0;
*arg4 += 1;
return i;
}
int64_t __acrt_allocate_buffer_for_argv(int64_t arg1, int64_t arg2, int64_t arg3)
{
if (arg1 < 0x1fffffffffffffff && arg2 < -1 / arg3)
{
int64_t rcx = arg1 << 3;
int64_t r9_1 = arg2 * arg3;
if (~rcx > r9_1)
{
int64_t result = _calloc_base(rcx + r9_1, 1);
_free_base(0);
return result;
}
}
return 0;
}
uint64_t sub_140005954(int32_t arg1)
{
int32_t rdi = 0;
if (arg1)
{
if (arg1 - 1 <= 1)
{
__acrt_initialize_multibyte();
__acrt_GetModuleFileNameA(nullptr, &data_14001e240, 0x104);
char* rsi_1 = data_14001e420;
data_14001e400 = &data_14001e240;
if (!rsi_1 || !*rsi_1)
rsi_1 = &data_14001e240;
int64_t arg_18 = 0;
int64_t arg_20 = 0;
sub_140005734(rsi_1, nullptr, nullptr, &arg_18, &arg_20);
int64_t r15_1 = arg_18;
int64_t* rax_3 = __acrt_allocate_buffer_for_argv(r15_1, arg_20, 1);
if (rax_3)
{
sub_140005734(rsi_1, rax_3, &rax_3[r15_1], &arg_18, &arg_20);
if (arg1 != 1)
{
int64_t* arg_10 = nullptr;
int32_t rax_7 = j_common_expand_argv_wildcards<char>(rax_3, &arg_10);
if (!rax_7)
{
int64_t* rdx_4 = arg_10;
int64_t rcx_6 = 0;
int64_t* rax_8 = rdx_4;
if (*rdx_4)
{
do
{
rax_8 = &rax_8[1];
rcx_6 += 1;
} while (*rax_8);
}
data_14001e408 = rcx_6;
arg_10 = nullptr;
data_14001e410 = rdx_4;
_free_base(0);
arg_10 = nullptr;
_free_base(rax_3);
}
else
{
_free_base(arg_10);
arg_10 = nullptr;
_free_base(rax_3);
rdi = rax_7;
}
}
else
{
int32_t rax_6 = arg_18 - 1;
data_14001e410 = rax_3;
data_14001e408 = rax_6;
_free_base(nullptr);
}
}
else
{
rdi = rax_3 + 0xc;
*sub_140007fb4() = rdi;
_free_base(nullptr);
}
}
else
{
rdi = 0x16;
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
}
return rdi;
}
uint64_t common_initialize_environment_nolock<char>()
{
int32_t rdi = 0;
if (data_14001e348)
return 0;
__acrt_initialize_multibyte();
char* rax_1 = __dcrt_get_narrow_environment_from_os();
if (!rax_1)
{
_free_base(0);
return 0xffffffff;
}
char** rax_2 = sub_140005b48(rax_1);
if (rax_2)
{
data_14001e360 = rax_2;
data_14001e348 = rax_2;
}
else
rdi = -1;
_free_base(0);
_free_base(rax_1);
return rdi;
}
char** sub_140005b48(char* arg1)
{
char* rsi = arg1;
int64_t rcx = 0;
char* r8 = rsi;
for (char i = *rsi; i; i = *r8)
{
int64_t rax_1 = rcx + 1;
if (i == 0x3d)
rax_1 = rcx;
rcx = rax_1;
int64_t rax_2 = -1;
do
rax_2 += 1;
while (r8[rax_2]);
r8 = &r8[1 + rax_2];
}
char** result_1 = _calloc_base(rcx + 1, 8);
char** result = result_1;
if (result_1)
{
char** result_2 = result;
while (true)
{
result_1 = *rsi;
if (!result_1)
{
_free_base(0);
return result;
}
int64_t rbp_1 = -1;
do
rbp_1 += 1;
while (rsi[rbp_1]);
if (result_1 != 0x3d)
{
char* rax_4 = _calloc_base(rbp_1 + 1, 1);
if (!rax_4)
break;
if (sub_140006950(rax_4, rbp_1 + 1, rsi))
{
int64_t var_18 = 0;
_invoke_watson();
/* no return */
}
*result_2 = rax_4;
result_2 = &result_2[1];
_free_base(0);
}
rsi = &rsi[rbp_1 + 1];
}
free_environment<wchar_t>(result);
_free_base(0);
}
_free_base(0);
return nullptr;
}
void free_environment<wchar_t>(int64_t* arg1)
{
if (!arg1)
return;
int64_t i = *arg1;
int64_t* rdi_1 = arg1;
for (; i; i = *rdi_1)
{
_free_base(i);
rdi_1 = &rdi_1[1];
}
_free_base(arg1);
}
void uninitialize_environment_internal<wchar_t>(int64_t* arg1)
{
int64_t* rcx = *arg1;
if (rcx != data_14001e360)
free_environment<wchar_t>(rcx);
}
void uninitialize_environment_internal<char>(int64_t* arg1)
{
int64_t* rcx = *arg1;
if (rcx != data_14001e358)
free_environment<wchar_t>(rcx);
}
int64_t __dcrt_uninitialize_environments_nolock()
{
int64_t var_18 = -2;
uninitialize_environment_internal<wchar_t>(&data_14001e348);
uninitialize_environment_internal<char>(&data_14001e350);
free_environment<wchar_t>(data_14001e360);
/* tailcall */
return free_environment<wchar_t>(data_14001e358);
}
uint64_t j_sub_140005ad4()
{
/* tailcall */
return common_initialize_environment_nolock<char>();
}
void* common_wincmdln<char>()
{
__acrt_initialize_multibyte();
void* result_1 = data_14001e420;
void* result = &data_14001e368;
if (result_1)
result = result_1;
int64_t rdi;
rdi = 0;
while (true)
{
char i = *result;
if (i <= 0x20)
{
if (!i)
return result;
if (!rdi)
{
while (i <= 0x20)
{
result += 1;
i = *result;
if (!i)
break;
}
return result;
}
}
if (i == 0x22)
rdi = !rdi;
void* result_2 = result + 1;
if (!_ismbblead(i))
result_2 = result;
result = result_2 + 1;
}
}
void sub_140005d98(int64_t* arg1, int64_t arg2)
{
if (arg1 == arg2)
return;
int64_t* rbx_1 = arg1;
do
{
if (*rbx_1)
sub_140010380();
rbx_1 = &rbx_1[1];
} while (rbx_1 != arg2);
}
int64_t sub_140005dd0(int64_t* arg1, int64_t arg2)
{
int64_t* rbx = arg1;
if (arg1 != arg2)
{
do
{
if (*rbx)
{
int32_t result = sub_140010380();
if (result)
return result;
}
rbx = &rbx[1];
} while (rbx != arg2);
}
return 0;
}
int64_t __crt_seh_guarded_call<class <lambda_99476a1ad63dd22509b5d3e65b0ffc95>,class <lambda_ad1ced32f4ac17aa236e5ef05d6b3b7c>& __ptr64,class <lambda_f7424dd8d45958661754dc4f2697e9c3>,void>::operator()<class <lambda_99476a1ad63dd22509b5d3e65b0ffc95>,class <lambda_ad1ced32f4ac17aa236e5ef05d6b3b7c>& __ptr64,class <lambda_f7424dd8d45958661754dc4f2697e9c3> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
sub_140005e44(arg3);
return __vcrt_lock(*arg4);
}
void sub_140005e44(int64_t* arg1)
{
if (data_14001e378)
return;
data_14001e36c = 1;
int32_t rcx = **arg1;
if (!rcx)
{
if (data_14001e370 != __security_cookie)
sub_140010380();
_execute_onexit_table(&data_14001e388);
}
else if (rcx == 1)
_execute_onexit_table(&data_14001e3a0);
if (!**arg1)
sub_140005d98(&data_140012440, &data_140012460);
sub_140005d98(&data_140012468, &data_140012470);
if (!*arg1[1])
{
data_14001e378 = 1;
*arg1[2] = 1;
}
}
void sub_140005efe() __noreturn
{
sub_140006930();
/* no return */
}
uint8_t common_exit(uint32_t arg1, int32_t arg2, int32_t arg3)
{
int32_t arg_18 = arg3;
int32_t arg_10 = arg2;
int64_t var_28 = -2;
if (!arg3)
{
HMODULE rax_1 = GetModuleHandleW(nullptr);
if (rax_1 && rax_1->unused == 0x5a4d)
{
int32_t* rcx_1 = rax_1 * 2;
if (*rcx_1 == 0x4550 && rcx_1[6] == 0x20b && rcx_1[0x21] > 0xe && rcx_1[0x3e])
sub_140006018(arg1);
}
}
char arg_20 = 0;
int32_t* var_20 = &arg_10;
int32_t* var_18 = &arg_18;
char* var_10 = &arg_20;
int32_t var_34 = 2;
int32_t var_30 = 2;
void var_38;
uint8_t result = __crt_seh_guarded_call<class <lambda_99476a1ad63dd22509b5d3e65b0ffc95>,class <lambda_ad1ced32f4ac17aa236e5ef05d6b3b7c>& __ptr64,class <lambda_f7424dd8d45958661754dc4f2697e9c3>,void>::operator()<class <lambda_99476a1ad63dd22509b5d3e65b0ffc95>,class <lambda_ad1ced32f4ac17aa236e5ef05d6b3b7c>& __ptr64,class <lambda_f7424dd8d45958661754dc4f2697e9c3> >(
&var_38, &var_30, &var_20, &var_34);
if (!arg_18)
{
result = __acrt_get_process_end_policy();
if (!arg_18)
{
sub_140005fe8(arg1, false);
/* no return */
}
}
return result;
}
void sub_140005fe8(uint32_t arg1, char arg2) __noreturn
{
if (arg2)
{
TerminateProcess(GetCurrentProcess(), arg1);
/* no return */
}
sub_140006018(arg1);
ExitProcess(arg1);
/* no return */
}
int64_t sub_140006018(int32_t arg1)
{
int64_t var_18 = -2;
HMODULE phModule = nullptr;
int64_t result = GetModuleHandleExW(0, u"mscoree.dll", &phModule);
HMODULE phModule_1 = phModule;
if (result)
{
result = GetProcAddress(phModule_1, "CorExitProcess");
if (result)
result = sub_140010380();
phModule_1 = phModule;
}
if (!phModule_1)
return result;
return FreeLibrary(phModule_1);
}
int64_t sub_14000607c(int64_t arg1)
{
data_14001e370 = arg1;
}
int64_t _c_exit()
{
/* tailcall */
return common_exit(0, 2, 1);
}
int64_t _cexit()
{
/* tailcall */
return common_exit(0, 0, 1);
}
int64_t sub_1400060a4(uint32_t arg1)
{
/* tailcall */
return common_exit(arg1, 2, 0);
}
int64_t sub_1400060b0(int64_t arg1)
{
uint64_t __security_cookie_1 = __security_cookie;
if (data_14001e370 != __security_cookie_1)
{
sub_140006930();
/* no return */
}
char result = __security_cookie_1 & 0x3f;
data_14001e370 = RORQ(arg1, 0x40 - result) ^ __security_cookie_1;
return result;
}
int64_t exit(uint32_t arg1)
{
/* tailcall */
return common_exit(arg1, 0, 0);
}
int64_t _get_fmode(int32_t* arg1)
{
if (arg1)
{
*arg1 = data_14001e68c;
return 0;
}
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0x16;
}
int64_t _set_fmode(int32_t arg1)
{
if (!((arg1 - 0x4000) & 0xffff3fff) && arg1 != 0xc000)
{
data_14001e68c;
data_14001e68c = arg1;
return 0;
}
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0x16;
}
int64_t _setmode_nolock(int32_t arg1, int32_t arg2)
{
int64_t rax = arg1;
int64_t r9_1 = rax >> 6;
int64_t rdx = (&data_14001e690)[r9_1];
uint64_t r8 = (rax & 0x3f) * 9;
uint32_t rcx = *(rdx + (r8 << 3) + 0x38);
char r11 = *(rdx + (r8 << 3) + 0x39);
int32_t rbx_1 = rcx & 0x80;
if (arg2 == 0x4000)
{
rcx |= 0x80;
*(rdx + (r8 << 3) + 0x38) = rcx;
*((&data_14001e690)[r9_1] + (r8 << 3) + 0x39) = 0;
}
else if (arg2 == 0x8000)
{
rcx &= 0x7f;
*(rdx + (r8 << 3) + 0x38) = rcx;
}
else if (!((arg2 - 0x10000) & 0xfffeffff))
{
rcx |= 0x80;
*(rdx + (r8 << 3) + 0x38) = rcx;
*((&data_14001e690)[r9_1] + (r8 << 3) + 0x39) = 2;
}
else if (arg2 == 0x40000)
{
rcx |= 0x80;
*(rdx + (r8 << 3) + 0x38) = rcx;
*((&data_14001e690)[r9_1] + (r8 << 3) + 0x39) = 1;
}
if (!rbx_1)
return 0x8000;
if (!r11)
return 0x4000;
if (r11 == 1)
return 0x40000;
return 0x10000;
}
int64_t __crt_seh_guarded_call<class <lambda_410d79af7f07d98d83a3f525b3859a53>,class <lambda_3e16ef9562a7dcce91392c22ab16ea36>& __ptr64,class <lambda_38119f0e861e05405d8a144b9b982f0a>,void>::operator()<class <lambda_410d79af7f07d98d83a3f525b3859a53>,class <lambda_3e16ef9562a7dcce91392c22ab16ea36>& __ptr64,class <lambda_38119f0e861e05405d8a144b9b982f0a> >(int64_t arg1, int32_t* arg2, int64_t arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
int64_t* rbx = &data_14001e3d8;
while (true)
{
int64_t* var_18_1 = rbx;
if (rbx == &data_14001e3e0)
break;
if (*rbx != &data_14001d1e0)
*rbx = _updatetlocinfoEx_nolock(rbx, &data_14001d1e0);
rbx = &rbx[1];
}
return __vcrt_lock(*arg4);
}
uint64_t Concurrency::details::WinRT::Initialize()
{
int32_t temp0 = data_14001e37c;
data_14001e37c = 1;
return temp0;
}
int64_t __acrt_uninitialize_locale()
{
int32_t arg_10 = 4;
int32_t arg_18 = 4;
void arg_8;
return __crt_seh_guarded_call<class <lambda_410d79af7f07d98d83a3f525b3859a53>,class <lambda_3e16ef9562a7dcce91392c22ab16ea36>& __ptr64,class <lambda_38119f0e861e05405d8a144b9b982f0a>,void>::operator()<class <lambda_410d79af7f07d98d83a3f525b3859a53>,class <lambda_3e16ef9562a7dcce91392c22ab16ea36>& __ptr64,class <lambda_38119f0e861e05405d8a144b9b982f0a> >(
&arg_8, &arg_18, &arg_8, &arg_10);
}
uint64_t _configthreadlocale(int32_t arg1)
{
void** rax;
int32_t rcx;
rax = __vcrt_getptd();
int32_t r8 = rax[0x75];
if (arg1 == 0xffffffff)
data_14001da90 = 0xffffffff;
else if (arg1)
{
int32_t r8_1;
if (arg1 == 1)
r8_1 = r8 | 2;
else
{
if (arg1 != 2)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0xffffffff;
}
r8_1 = r8 & 0xfffffffd;
}
rax[0x75] = r8_1;
}
return rcx - rcx + 2;
}
uint64_t sub_140006370()
{
return data_14001e380;
}
uint64_t _set_new_mode(int32_t arg1)
{
if (arg1 <= 1)
{
int32_t temp0_1 = data_14001e380;
data_14001e380 = arg1;
return temp0_1;
}
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0xffffffff;
}
int64_t sub_1400063ac() __pure
{
return &data_14001e384;
}
uint64_t __crt_seh_guarded_call<class <lambda_8b90c8310d35b3462fe809c44bbb350d>,class <lambda_c1ccdfe150d00dafd355d15f2a9edeaa>& __ptr64,class <lambda_e797892004ba4c0bb152531b9d8c3715>,int32_t>::operator()<class <lambda_8b90c8310d35b3462fe809c44bbb350d>,class <lambda_c1ccdfe150d00dafd355d15f2a9edeaa>& __ptr64,class <lambda_e797892004ba4c0bb152531b9d8c3715> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
int32_t rax = sub_14000642c(arg3);
__vcrt_lock(*arg4);
return rax;
}
uint64_t sub_1400063f0(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
int32_t rax = sub_1400065dc(arg3);
__vcrt_lock(*arg4);
return rax;
}
int64_t sub_14000642c(int64_t* arg1)
{
int64_t rdx = **arg1;
if (rdx)
{
uint64_t __security_cookie_4 = __security_cookie;
char rcx_1 = __security_cookie_4 & 0x3f;
int64_t rsi_3 = RORQ(__security_cookie_4 ^ *rdx, rcx_1);
int64_t r9_3 = RORQ(__security_cookie_4 ^ *(rdx + 8), rcx_1);
int64_t rbx_3 = RORQ(__security_cookie_4 ^ *(rdx + 0x10), rcx_1);
if (r9_3 != rbx_3)
{
label_140006557:
*r9_3 = RORQ(*arg1[1], 0x40 - (__security_cookie_4 & 0x3f)) ^ __security_cookie_4;
uint64_t __security_cookie_1 = __security_cookie;
***arg1 = RORQ(rsi_3, 0x40 - (__security_cookie_1 & 0x3f)) ^ __security_cookie_1;
uint64_t __security_cookie_2 = __security_cookie;
*(**arg1 + 8) =
RORQ(r9_3 + 8, 0x40 - (__security_cookie_2 & 0x3f)) ^ __security_cookie_2;
uint64_t __security_cookie_3 = __security_cookie;
*(**arg1 + 0x10) =
RORQ(rbx_3, 0x40 - (__security_cookie_3 & 0x3f)) ^ __security_cookie_3;
return 0;
}
int64_t rbx_5 = (rbx_3 - rsi_3) >> 3;
int64_t rdi_1 = rbx_5;
if (rbx_5 > 0x200)
rdi_1 = 0x200;
int64_t rdi_2 = rdi_1 + rbx_5;
if (rdi_1 == -(rbx_5))
rdi_2 = 0x20;
int64_t r14_1;
if (rdi_2 >= rbx_5)
{
r14_1 = _recalloc_base(rsi_3, rdi_2, 8);
_free_base(0);
}
if (rdi_2 >= rbx_5 && r14_1)
{
label_1400064f6:
__security_cookie_4 = __security_cookie;
r9_3 = r14_1 + (rbx_5 << 3);
rbx_3 = r14_1 + (rdi_2 << 3);
rsi_3 = r14_1;
uint64_t rcx_7 = (rbx_3 - r9_3 + 7) >> 3;
if (r9_3 > rbx_3)
rcx_7 = 0;
if (rcx_7)
{
int64_t rcx_8;
int64_t rdi_4;
rdi_4 = __memfill_u64(r9_3, __security_cookie_4, rcx_7);
__security_cookie_4 = __security_cookie;
}
goto label_140006557;
}
rdi_2 = rbx_5 + 4;
r14_1 = _recalloc_base(rsi_3, rdi_2, 8);
_free_base(0);
if (r14_1)
goto label_1400064f6;
}
return 0xffffffff;
}
int64_t sub_1400065dc(int64_t* arg1)
{
int64_t rdx = **arg1;
if (!rdx)
return 0xffffffff;
uint64_t __security_cookie_1 = __security_cookie;
char rcx_1 = __security_cookie_1 & 0x3f;
int64_t rdi_3 = RORQ(__security_cookie_1 ^ *rdx, rcx_1);
int64_t rbx_3 = RORQ(__security_cookie_1 ^ *(rdx + 8), rcx_1);
if (rdi_3 - 1 <= -3)
{
uint64_t __security_cookie_2 = __security_cookie_1;
int64_t r15_1 = rdi_3;
int64_t rbp_1 = rbx_3;
while (true)
{
rbx_3 -= 8;
if (rbx_3 < rdi_3)
break;
if (*rbx_3 != __security_cookie_2)
{
*rbx_3 = __security_cookie_2;
sub_140010380();
__security_cookie_1 = __security_cookie;
char rcx_3 = __security_cookie_1 & 0x3f;
int64_t rdx_1 = **arg1;
int64_t r9_3 = RORQ(__security_cookie_1 ^ *rdx_1, rcx_3);
int64_t rax_9 = RORQ(__security_cookie_1 ^ *(rdx_1 + 8), rcx_3);
if (r9_3 == r15_1 && rax_9 == rbp_1)
continue;
r15_1 = r9_3;
rdi_3 = r9_3;
rbp_1 = rax_9;
rbx_3 = rax_9;
}
}
if (rdi_3 != -1)
{
_free_base(rdi_3);
__security_cookie_1 = __security_cookie;
}
***arg1 = __security_cookie_1;
*(**arg1 + 8) = __security_cookie_1;
*(**arg1 + 0x10) = __security_cookie_1;
}
return 0;
}
int64_t sub_1400066f4(int64_t arg1)
{
/* tailcall */
return _register_onexit_function(&data_14001e388, arg1);
}
uint64_t _execute_onexit_table(int64_t arg1)
{
int64_t arg_8 = arg1;
int64_t var_10 = -2;
int64_t* var_18 = &arg_8;
int32_t arg_18 = 2;
int32_t arg_20 = 2;
void arg_10;
return sub_1400063f0(&arg_10, &arg_20, &var_18, &arg_18);
}
int64_t _initialize_onexit_table(int64_t* arg1)
{
if (!arg1)
return 0xffffffff;
if (*arg1 == arg1[2])
{
uint64_t __security_cookie_1 = __security_cookie;
*arg1 = __security_cookie_1;
arg1[1] = __security_cookie_1;
arg1[2] = __security_cookie_1;
}
return 0;
}
uint64_t _register_onexit_function(int64_t arg1, int64_t arg2)
{
int64_t arg_10 = arg2;
int64_t arg_8 = arg1;
int64_t* var_20 = &arg_8;
int64_t* var_18 = &arg_10;
int32_t arg_20 = 2;
int32_t var_28 = 2;
void arg_18;
return __crt_seh_guarded_call<class <lambda_8b90c8310d35b3462fe809c44bbb350d>,class <lambda_c1ccdfe150d00dafd355d15f2a9edeaa>& __ptr64,class <lambda_e797892004ba4c0bb152531b9d8c3715>,int32_t>::operator()<class <lambda_8b90c8310d35b3462fe809c44bbb350d>,class <lambda_c1ccdfe150d00dafd355d15f2a9edeaa>& __ptr64,class <lambda_e797892004ba4c0bb152531b9d8c3715> >(
&arg_18, &var_28, &var_20, &arg_20);
}
int64_t sub_1400067b8()
{
data_14001e3d8 = &data_14001d1e0;
wchar16 const (** rax)[0x21];
rax = 1;
return &data_14001d101;
}
int64_t initialize_c()
{
_initialize_onexit_table(&data_14001e388);
_initialize_onexit_table(&data_14001e3a0);
int64_t result;
result = 1;
return result;
}
int64_t uninitialize_environment()
{
__dcrt_uninitialize_environments_nolock();
int64_t result;
result = 1;
return result;
}
int64_t initialize_pointers()
{
uint64_t __security_cookie_1 = __security_cookie;
sub_140006d80(__security_cookie_1);
sub_14000c400(__security_cookie_1);
_initp_misc_winsig(__security_cookie_1);
sub_140005700(__security_cookie_1);
sub_14000607c(__security_cookie_1);
int64_t result;
result = 1;
return result;
}
int64_t uninitialize_vcruntime()
{
/* tailcall */
return __vcrt_uninitialize(0);
}
int64_t uninitialize_allocated_memory()
{
int32_t* rcx = data_14001e3f0;
int32_t result = *rcx;
*rcx -= 1;
if (result == 1)
{
int64_t rcx_1 = data_14001e3f0;
if (rcx_1 != &data_14001d460)
{
_free_base(rcx_1);
data_14001e3f0 = &data_14001d460;
}
}
result = 1;
return result;
}
int64_t uninitialize_allocated_io_buffers()
{
_free_base(data_14001eb90);
int64_t rcx_1 = data_14001eb98;
data_14001eb90 = 0;
_free_base(rcx_1);
int64_t rcx_2 = data_14001e410;
data_14001eb98 = 0;
_free_base(rcx_2);
int64_t rcx_3 = data_14001e418;
data_14001e410 = 0;
_free_base(rcx_3);
data_14001e418 = 0;
int64_t result;
result = 1;
return result;
}
int64_t sub_1400068e4()
{
/* tailcall */
return sub_14000c2f8(&data_1400139f0, &data_140013af0);
}
int64_t __acrt_uninitialize(char arg1)
{
if (!arg1)
/* tailcall */
return sub_14000c378(&data_1400139f0, &data_140013af0);
if (data_14001e3c8)
_flushall();
int64_t result;
result = 1;
return result;
}
void sub_140006930() __noreturn
{
if (__vcrt_getptd()[3])
sub_140010380();
abort();
/* no return */
}
int64_t sub_140006950(char* arg1, int64_t arg2, int64_t arg3)
{
char* r9 = arg1;
if (arg1 && arg2)
{
if (arg3)
{
while (true)
{
char rax_3 = *(arg3 - r9 + arg1);
*arg1 = rax_3;
arg1 = &arg1[1];
if (!rax_3)
break;
int64_t temp0_1 = arg2;
arg2 -= 1;
if (temp0_1 == 1)
{
if (arg2)
break;
*r9 = arg2;
*sub_140007fb4() = 0x22;
_invalid_parameter_noinfo();
return 0x22;
}
}
return 0;
}
*arg1 = arg3;
}
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0x16;
}
void abort() __noreturn
{
if (__acrt_get_sigabrt_handler())
sub_14000c554(0x16);
if (data_14001d0c0 & 2)
{
if (IsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE))
trap(0xd);
__acrt_call_reportfault(3, 0x40000015);
}
sub_1400060a4(3);
breakpoint();
}
int64_t calloc(int64_t arg1, int64_t arg2)
{
/* tailcall */
return _calloc_base(arg1, arg2);
}
int64_t __crt_cached_ptd_host::update_locale_slow(int64_t* arg1)
{
void* rax = sub_140005064(arg1);
arg1[3] = *(rax + 0x90);
arg1[4] = *(rax + 0x88);
__acrt_update_locale_info_explicit(rax, &arg1[3], arg1[1]);
__acrt_update_multibyte_info_explicit(rax, &arg1[4], arg1[1]);
int32_t result = *(rax + 0x3a8);
if (!(result & 2))
{
result |= 2;
*(rax + 0x3a8) = result;
arg1[5] = 2;
}
return result;
}
uint64_t sub_140006ac0(int16_t* arg1, int16_t* arg2, int64_t arg3)
{
if (!arg3)
return 0;
int64_t i_1 = arg3 - 1;
if (arg3 != 1)
{
int64_t i;
do
{
int16_t rax_2 = *arg1;
if (!rax_2)
break;
if (rax_2 != *arg2)
break;
arg1 = &arg1[1];
arg2 = &arg2[1];
i = i_1;
i_1 -= 1;
} while (i != 1);
}
return *arg1 - *arg2;
}
void _free_base(int64_t arg1)
{
if (arg1 && !HeapFree(data_14001eb60, HEAP_NONE, arg1))
*sub_140007fb4() = sub_140007e74(GetLastError());
}
int64_t sub_140006b50()
{
return data_14001eb60;
}
void* __crt_cached_ptd_host::get_raw_ptd_noexit(int64_t* arg1)
{
void* result = *arg1;
int64_t rdi = 0;
if (!result)
{
enum WIN32_ERROR dwErrCode_1 = GetLastError();
if (arg1[2])
rdi = arg1[1];
else
{
arg1[1] = 0;
arg1[2] = 1;
}
void* result_1 = sub_140007db0(&dwErrCode_1, rdi);
enum WIN32_ERROR dwErrCode = dwErrCode_1;
result = result_1;
*arg1 = result_1;
SetLastError(dwErrCode);
}
return result;
}
int64_t __crt_state_management::dual_state_global<void (__cdecl*)(wchar_t const* __ptr64, wchar_t const* __ptr64, wchar_t const* __ptr64, uint32_t, uint64_t)>::value(int64_t arg1, void* arg2)
{
int64_t rbx = 0;
if (*(arg2 + 0x10))
rbx = *(arg2 + 8);
else
{
enum WIN32_ERROR dwErrCode = GetLastError();
*(arg2 + 8) = 0;
*(arg2 + 0x10) = 1;
SetLastError(dwErrCode);
}
return arg1 + (rbx << 3);
}
int32_t __acrt_call_reportfault(int32_t arg1, int32_t arg2)
{
void var_608;
int64_t rax_1 = __security_cookie ^ &var_608;
if (arg1 != 0xffffffff)
sub_14000223c();
int32_t var_598;
sub_140010a60(&var_598, 0, 0x98);
void ContextRecord;
sub_140010a60(&ContextRecord, 0, 0x4d0);
uint64_t EstablisherFrame = 0;
uint64_t ImageBase = 0;
int64_t HandlerData = 0;
EXCEPTION_POINTERS ExceptionInfo;
ExceptionInfo.ExceptionRecord = &var_598;
ExceptionInfo.ContextRecord = &ContextRecord;
RtlCaptureContext(&ContextRecord);
uint64_t ControlPc;
IMAGE_RUNTIME_FUNCTION_ENTRY* FunctionEntry =
RtlLookupFunctionEntry(ControlPc, &ImageBase, nullptr);
if (FunctionEntry)
RtlVirtualUnwind(UNW_FLAG_NHANDLER, ImageBase, ControlPc, FunctionEntry, &ContextRecord,
&HandlerData, &EstablisherFrame, nullptr);
void* const __return_addr_2 = __return_addr;
var_598 = arg2;
void arg_8;
void* var_460 = &arg_8;
void* const __return_addr_1 = __return_addr;
int32_t r8;
int32_t var_594 = r8;
BOOL rax_4 = IsDebuggerPresent();
SetUnhandledExceptionFilter(nullptr);
int32_t result = UnhandledExceptionFilter(&ExceptionInfo);
if (!result && !rax_4 && arg1 != 0xffffffff)
sub_14000223c();
__security_check_cookie(rax_1 ^ &var_608);
return result;
}
int64_t sub_140006d80(int64_t arg1)
{
data_14001e3b8 = arg1;
}
void* _invalid_parameter(int64_t arg1, int64_t arg2, int64_t arg3, int32_t arg4, int64_t arg5)
{
void* result_1 = nullptr;
char var_38 = 0;
char var_20 = 0;
char var_18 = 0;
if (!data_14001e37c)
{
var_20 = 1;
int128_t var_30_1 = *data_14001d338;
}
void* result = _invalid_parameter_internal(arg1, arg2, arg3, arg4, arg5, &result_1);
if (var_20 == 2)
{
result = result_1;
*(result + 0x3a8) &= 0xfffffffd;
}
if (var_18)
{
result = sub_140005064(&result_1);
int32_t var_1c;
*(result + 0x20) = var_1c;
}
if (0)
{
result = sub_140005064(&result_1);
int32_t var_14;
*(result + 0x24) = var_14;
}
return result;
}
int64_t _invalid_parameter_internal(int64_t arg1, int64_t arg2, int64_t arg3, int32_t arg4, int64_t arg5, int64_t* arg6)
{
void* rax = __crt_cached_ptd_host::get_raw_ptd_noexit(arg6);
if (!rax || !*(rax + 0x3b8))
{
int64_t r10_1 = *__crt_state_management::dual_state_global<void (__cdecl*)(wchar_t const* __ptr64, wchar_t const* __ptr64, wchar_t const* __ptr64, uint32_t, uint64_t)>::value(
&data_14001e3b8, arg6);
uint64_t __security_cookie_1 = __security_cookie;
if (!RORQ(r10_1 ^ __security_cookie_1, __security_cookie_1 & 0x3f))
{
int64_t var_18_1 = arg5;
_invoke_watson();
/* no return */
}
}
int64_t var_18 = arg5;
return sub_140010380();
}
void* _invalid_parameter_noinfo()
{
return _invalid_parameter(0, 0, 0, 0, 0);
}
void _invoke_watson() __noreturn
{
if (IsProcessorFeaturePresent(0x17))
trap(0xd);
__acrt_call_reportfault(2, 0xc0000417);
/* tailcall */
return TerminateProcess(GetCurrentProcess(), 0xc0000417);
}
uint64_t _fileno(void* arg1)
{
if (arg1)
return *(arg1 + 0x18);
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0xffffffff;
}
int64_t __acrt_initialize_stdio()
{
int32_t rax = data_14001e3c0;
void** rbx = nullptr;
int64_t i_1 = 3;
if (!rax)
{
rax = 0x200;
data_14001e3c0 = rax;
}
else if (rax < 3)
{
rax = 3;
data_14001e3c0 = rax;
}
data_14001e3c8 = _calloc_base(rax, 8);
_free_base(0);
if (!data_14001e3c8)
{
data_14001e3c0 = 3;
data_14001e3c8 = _calloc_base(3, 8);
_free_base(0);
if (!data_14001e3c8)
return 0xffffffff;
}
int64_t rbp_1 = 0;
void* rsi_1 = &data_14001d0e8;
void* r14_1 = &data_14001d0d0;
int64_t i;
do
{
InitializeCriticalSectionEx(r14_1 + 0x30, 0xfa0, 0);
*(rbx + data_14001e3c8) = r14_1;
if (*((&data_14001e690)[rbp_1 >> 6] + (rbp_1 & 0x3f) * 0x48 + 0x28) + 2 <= 2)
*rsi_1 = 0xfffffffe;
rbp_1 += 1;
r14_1 += 0x58;
rbx = &rbx[1];
rsi_1 += 0x58;
i = i_1;
i_1 -= 1;
} while (i != 1);
return 0;
}
int64_t __acrt_uninitialize_stdio()
{
_flushall();
sub_14000cdf8();
for (int64_t* i = nullptr; i != 0x18; i = &i[1])
{
__acrt_stdio_free_buffer_nolock(*(i + data_14001e3c8));
DeleteCriticalSection(*(i + data_14001e3c8) + 0x30);
}
int64_t result = _free_base(data_14001e3c8);
data_14001e3c8 = 0;
return result;
}
int64_t sub_1400070e8(void* arg1)
{
/* tailcall */
return EnterCriticalSection(arg1 + 0x30);
}
int64_t sub_1400070f4(void* arg1)
{
/* tailcall */
return LeaveCriticalSection(arg1 + 0x30);
}
uint64_t __crt_seh_guarded_call<class <lambda_ad8af0d99a0adf03d037d7dffe354bb5>,class <lambda_c9ba49e555ba839a7b07aa3fbecb7617>& __ptr64,class <lambda_2f1ebd5d68526518146ae959c9e734c8>,int32_t>::operator()<class <lambda_ad8af0d99a0adf03d037d7dffe354bb5>,class <lambda_c9ba49e555ba839a7b07aa3fbecb7617>& __ptr64,class <lambda_2f1ebd5d68526518146ae959c9e734c8> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__acrt_lowio_unlock_fh(*arg2);
int64_t rcx_1 = **arg3;
void* rdx = arg3[1];
int32_t rbx_1;
if (!(*((&data_14001e690)[rcx_1 >> 6] + (rcx_1 & 0x3f) * 0x48 + 0x38) & 1))
{
*(rdx + 0x30) = 1;
*(rdx + 0x2c) = 9;
rbx_1 = -1;
}
else
rbx_1 = _close_nolock_internal(rcx_1, rdx);
sub_14000afac(*arg4);
return rbx_1;
}
uint64_t _close_internal(int32_t arg1, int64_t* arg2)
{
int32_t arg_8 = arg1;
int64_t r8 = arg1;
if (r8 != 0xfffffffe)
{
if (arg1 >= 0 && r8 < data_14001ea90
&& *((&data_14001e690)[r8 >> 6] + (r8 & 0x3f) * 0x48 + 0x38) & 1)
{
int64_t* var_18_1 = arg2;
int32_t arg_20 = r8;
int32_t var_28 = r8;
int32_t* var_20 = &arg_8;
void arg_18;
return __crt_seh_guarded_call<class <lambda_ad8af0d99a0adf03d037d7dffe354bb5>,class <lambda_c9ba49e555ba839a7b07aa3fbecb7617>& __ptr64,class <lambda_2f1ebd5d68526518146ae959c9e734c8>,int32_t>::operator()<class <lambda_ad8af0d99a0adf03d037d7dffe354bb5>,class <lambda_c9ba49e555ba839a7b07aa3fbecb7617>& __ptr64,class <lambda_2f1ebd5d68526518146ae959c9e734c8> >(
&arg_18, &var_28, &var_20, &arg_20);
}
arg2[7] = 1;
*(arg2 + 0x34) = 0;
arg2[6] = 1;
*(arg2 + 0x2c) = 9;
_invalid_parameter_internal(0, 0, 0, 0, 0, arg2);
}
else
{
arg2[7] = 1;
*(arg2 + 0x34) = 0;
arg2[6] = 1;
*(arg2 + 0x2c) = 9;
}
return 0xffffffff;
}
uint64_t sub_14000723c(int32_t arg1)
{
void* var_48 = nullptr;
char var_38 = 0;
char var_20 = 0;
char var_18 = 0;
if (!data_14001e37c)
{
var_20 = 1;
int128_t var_30_1 = *data_14001d338;
}
int32_t rax = _close_nolock_internal(arg1, &var_48);
if (var_20 == 2)
{
void* rcx = var_48;
*(rcx + 0x3a8) &= 0xfffffffd;
}
int32_t var_1c;
if (var_18)
*(sub_140005064(&var_48) + 0x20) = var_1c;
int32_t var_14;
if (0)
*(sub_140005064(&var_48) + 0x24) = var_14;
return rax;
}
int64_t _close_nolock_internal(int32_t arg1, void* arg2)
{
int64_t rdi = arg1;
enum WIN32_ERROR rbx_2;
if (_get_osfhandle(rdi) != -1)
{
void* rax_1 = data_14001e690;
int64_t rax_2;
int64_t rax_3;
if ((rdi == 1 && *(rax_1 + 0xc8) & rdi) || (rdi == 2 && *(rax_1 + 0x80) & 1))
{
rax_2 = _get_osfhandle(2);
rax_3 = _get_osfhandle(1);
}
if (((rdi == 1 && *(rax_1 + 0xc8) & rdi) || (rdi == 2 && *(rax_1 + 0x80) & 1))
&& rax_3 == rax_2)
rbx_2 = NO_ERROR;
else if (CloseHandle(_get_osfhandle(rdi)))
rbx_2 = NO_ERROR;
else
rbx_2 = GetLastError();
}
else
rbx_2 = NO_ERROR;
_free_osfhnd(rdi);
*((&data_14001e690)[rdi >> 6] + (rdi & 0x3f) * 0x48 + 0x38) = 0;
if (!rbx_2)
return 0;
__acrt_errno_map_os_error_ptd(rbx_2, arg2);
return 0xffffffff;
}
int64_t* __acrt_stdio_allocate_stream(int64_t* arg1)
{
*arg1 = 0;
__vcrt_unlock(8);
void arg_8;
void* rax_1 = *find_or_allocate_unused_stream_nolock(&arg_8);
*arg1 = rax_1;
if (rax_1)
{
*(rax_1 + 0x28) = 0;
__builtin_memset(rax_1, 0, 0x14);
*(rax_1 + 0x18) = 0xffffffff;
}
__vcrt_lock(8);
return arg1;
}
uint64_t __acrt_stdio_free_stream(void* arg1)
{
*(arg1 + 0x18) = 0xffffffff;
__builtin_memset(arg1, 0, 0x18);
*(arg1 + 0x1c) = 0;
*(arg1 + 0x28) = 0;
return *(arg1 + 0x14);
}
int64_t* find_or_allocate_unused_stream_nolock(int64_t* arg1)
{
int64_t* rdi_1 = data_14001e3c8 + 0x18;
void* rbp_2 = &rdi_1[data_14001e3c0 - 3];
while (true)
{
if (rdi_1 != rbp_2)
{
void* rbx_1 = *rdi_1;
if (rbx_1)
{
if (*(rbx_1 + 0x14) >> 0xd & 1)
{
rdi_1 = &rdi_1[1];
continue;
}
else
{
sub_1400070e8(rbx_1);
int32_t rax_3 = *(rbx_1 + 0x14);
bool z_1;
do
{
if (rax_3 == *(rbx_1 + 0x14))
{
*(rbx_1 + 0x14) = rax_3 | 0x2000;
z_1 = true;
}
else
{
rax_3 = *(rbx_1 + 0x14);
z_1 = false;
}
} while (!z_1);
if (!(~(rax_3 >> 0xd) & 1))
{
sub_1400070f4(rbx_1);
rdi_1 = &rdi_1[1];
continue;
}
}
*arg1 = rbx_1;
break;
}
*rdi_1 = _calloc_base(1, 0x58);
_free_base(0);
void* rax_7 = *rdi_1;
if (rax_7)
{
*(rax_7 + 0x18) = 0xffffffff;
InitializeCriticalSectionEx(*rdi_1 + 0x30, 0xfa0, 0);
rbx_1 = *rdi_1;
*(rbx_1 + 0x14) |= 0x2000;
sub_1400070e8(rbx_1);
*arg1 = rbx_1;
break;
}
}
*arg1 = 0;
break;
}
return arg1;
}
uint8_t __acrt_stdio_free_buffer_nolock(void* arg1)
{
uint8_t result = *(arg1 + 0x14) >> 0xd;
if (result & 1)
{
result = *(arg1 + 0x14) >> 6;
if (result & 1)
{
_free_base(*(arg1 + 8));
*(arg1 + 0x14) &= 0xfffffebf;
result = 0;
__builtin_memset(arg1, 0, 0x14);
}
}
return result;
}
int64_t sub_140007548(int64_t arg1, int64_t* arg2, int64_t* arg3, int64_t* arg4, int512_t arg5 @ zmm1)
{
int64_t* arg_20 = arg4;
sub_1400070e8(*arg2);
int32_t* rdx = arg3[1];
void* rcx_1 = **arg3;
if (rcx_1)
{
int32_t rcx_2 = *(rcx_1 + 0x14);
if (rcx_2 >> 0xd & 1)
{
if (((rcx_2 & 3) != 2 || !(rcx_2 & 0xc0)) && !TEST_BITD(rcx_2, 0xb))
*rdx += 1;
else if (*arg3[2] || *(**arg3 + 0x14) >> 1 & 1)
{
if (_fflush_nolock(**arg3, arg5) == 0xffffffff)
*arg3[3] = 0xffffffff;
else
{
int32_t* rax_9 = arg3[1];
*rax_9 += 1;
}
}
}
}
return sub_1400070f4(*arg4);
}
int64_t __crt_seh_guarded_call<class <lambda_886d6c58226a84441f68b9f2b8217b83>,class <lambda_ab61a845afdef5b7c387490eaf3616ee>& __ptr64,class <lambda_f7f22ab5edc0698d5f6905b0d3f44752>,void>::operator()<class <lambda_886d6c58226a84441f68b9f2b8217b83>,class <lambda_ab61a845afdef5b7c387490eaf3616ee>& __ptr64,class <lambda_f7f22ab5edc0698d5f6905b0d3f44752> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4, int512_t arg5 @ zmm1)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
int64_t* rbx = data_14001e3c8;
void* r14 = &rbx[data_14001e3c0];
while (true)
{
int64_t* var_40_1 = rbx;
if (rbx == r14)
break;
void* rcx_1 = *rbx;
void* var_58 = rcx_1;
int32_t* rdx = *arg3;
if (rcx_1)
{
int32_t rcx_2 = *(rcx_1 + 0x14);
if (rcx_2 >> 0xd & 1)
{
if ((rcx_2 & 3) != 2)
{
if (TEST_BITD(rcx_2, 0xb))
goto label_14000765c;
*rdx += 1;
}
else if (rcx_2 & 0xc0 || TEST_BITD(rcx_2, 0xb))
{
label_14000765c:
int64_t rdx_1 = arg3[2];
int64_t rcx_3 = arg3[1];
int64_t rax_4 = *arg3;
void** var_38 = &var_58;
int64_t var_30_1 = rax_4;
int64_t var_28_1 = rcx_3;
int64_t var_20_1 = rdx_1;
void* rax_5 = var_58;
void* var_50 = rax_5;
void* var_48 = rax_5;
void arg_10;
arg5 = sub_140007548(&arg_10, &var_48, &var_38, &var_50, arg5);
}
else
*rdx += 1;
}
}
rbx = &rbx[1];
}
return __vcrt_lock(*arg4);
}
uint64_t common_flush_all(char arg1, int512_t arg2 @ zmm1)
{
char arg_8 = arg1;
int32_t arg_20 = 0;
int32_t arg_18 = 0;
int32_t* var_20 = &arg_20;
char* var_18 = &arg_8;
int32_t* var_10 = &arg_18;
int32_t var_28 = 8;
int32_t var_24 = 8;
void arg_10;
__crt_seh_guarded_call<class <lambda_886d6c58226a84441f68b9f2b8217b83>,class <lambda_ab61a845afdef5b7c387490eaf3616ee>& __ptr64,class <lambda_f7f22ab5edc0698d5f6905b0d3f44752>,void>::operator()<class <lambda_886d6c58226a84441f68b9f2b8217b83>,class <lambda_ab61a845afdef5b7c387490eaf3616ee>& __ptr64,class <lambda_f7f22ab5edc0698d5f6905b0d3f44752> >(
&arg_10, &var_24, &var_20, &var_28, arg2);
if (arg_8)
return arg_20;
return arg_18;
}
int64_t __acrt_stdio_flush_nolock(int32_t* arg1, int64_t* arg2)
{
char rcx = arg1[5];
if ((rcx & 3) == 2 && rcx & 0xc0)
{
int32_t rdi_2 = *arg1 - arg1[2];
arg1[4] = 0;
int16_t* rsi_1 = *(arg1 + 8);
*arg1 = rsi_1;
if (rdi_2 > 0)
{
if (rdi_2 != _write_internal(_fileno(arg1), rsi_1, rdi_2, arg2))
{
arg1[5] |= 0x10;
return 0xffffffff;
}
if (arg1[5] >> 2 & 1)
arg1[5] &= 0xfffffffd;
}
}
return 0;
}
uint64_t _fflush_nolock(int32_t* arg1, int512_t arg2 @ zmm1)
{
void* var_48 = nullptr;
char var_38 = 0;
char var_20 = 0;
char var_18 = 0;
char var_10 = 0;
if (!data_14001e37c)
{
var_20 = 1;
int128_t var_30_1 = *data_14001d338;
}
int32_t rdi;
if (arg1)
{
int32_t rax_1 = __acrt_stdio_flush_nolock(arg1, &var_48);
int32_t rax_5;
if (!rax_1 && arg1[5] >> 0xb & 1)
rax_5 = _commit(_fileno(arg1));
if (rax_1 || (arg1[5] >> 0xb & 1 && rax_5))
rdi = -1;
else
rdi = 0;
}
else
rdi = common_flush_all(0, arg2);
if (var_20 == 2)
{
void* rax_6 = var_48;
*(rax_6 + 0x3a8) &= 0xfffffffd;
}
int32_t var_1c;
if (var_18)
*(sub_140005064(&var_48) + 0x20) = var_1c;
int32_t var_14;
if (var_10)
*(sub_140005064(&var_48) + 0x24) = var_14;
return rdi;
}
int64_t _flushall()
{
int512_t entry_zmm1;
/* tailcall */
return common_flush_all(1, entry_zmm1);
}
int64_t sub_140007890(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
int32_t* rax_1 = *(**arg3 + 0x88);
*rax_1 += 1;
return __vcrt_lock(*arg4);
}
int64_t __crt_seh_guarded_call<class <lambda_fb3a7dec4e47f37f22dae91bb15c9095>,class <lambda_698284760c8add0bfb0756c19673e34b>& __ptr64,class <lambda_dfb8eca1e75fef3034a8fb18dd509707>,void>::operator()<class <lambda_fb3a7dec4e47f37f22dae91bb15c9095>,class <lambda_698284760c8add0bfb0756c19673e34b>& __ptr64,class <lambda_dfb8eca1e75fef3034a8fb18dd509707> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
replace_current_thread_locale_nolock(**arg3, nullptr);
return __vcrt_lock(*arg4);
}
int64_t __crt_seh_guarded_call<class <lambda_5e887d1dcbef67a5eb4283622ba103bf>,class <lambda_4466841279450cc726390878d4a41900>& __ptr64,class <lambda_341c25c0346d94847f1f3c463c57e077>,void>::operator()<class <lambda_5e887d1dcbef67a5eb4283622ba103bf>,class <lambda_4466841279450cc726390878d4a41900>& __ptr64,class <lambda_341c25c0346d94847f1f3c463c57e077> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
replace_current_thread_locale_nolock(**arg3, **arg3[1]);
return __vcrt_lock(*arg4);
}
int64_t __crt_seh_guarded_call<class <lambda_46352004c1216016012b18bd6f87e700>,class <lambda_3bd07e1a1191394380780325891bf33f>& __ptr64,class <lambda_334532d3f185bcaa59b5be82d7d22bff>,void>::operator()<class <lambda_46352004c1216016012b18bd6f87e700>,class <lambda_3bd07e1a1191394380780325891bf33f>& __ptr64,class <lambda_334532d3f185bcaa59b5be82d7d22bff> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
int32_t* rcx_2 = *(**arg3 + 0x88);
if (rcx_2)
{
int32_t rax_1 = *rcx_2;
*rcx_2 -= 1;
if (rax_1 == 1 && rcx_2 != &data_14001d460)
_free_base(rcx_2);
}
return __vcrt_lock(*arg4);
}
int64_t construct_ptd_array(void** arg1)
{
void** var_30 = arg1;
int64_t* var_20 = &var_30;
int32_t arg_18 = 5;
int32_t arg_20 = 5;
int64_t* var_18 = &var_30;
int64_t* var_28;
int64_t* var_10 = &var_28;
int32_t var_38 = 4;
int32_t var_34 = 4;
var_28 = &data_14001e3d8;
arg1[5] = 1;
*var_30 = &data_140013850;
var_30[0x75] = 1;
var_30[0x11] = &data_14001d460;
*(var_30 + 0xbc) = 0x43;
*(var_30 + 0x1c2) = 0x43;
var_30[0x74] = 0;
void arg_10;
sub_140007890(&arg_10, &arg_20, &var_20, &arg_18);
return __crt_seh_guarded_call<class <lambda_5e887d1dcbef67a5eb4283622ba103bf>,class <lambda_4466841279450cc726390878d4a41900>& __ptr64,class <lambda_341c25c0346d94847f1f3c463c57e077>,void>::operator()<class <lambda_5e887d1dcbef67a5eb4283622ba103bf>,class <lambda_4466841279450cc726390878d4a41900>& __ptr64,class <lambda_341c25c0346d94847f1f3c463c57e077> >(
&arg_10, &var_34, &var_18, &var_38);
}
void destroy_fls(int64_t* arg1)
{
if (arg1)
{
destroy_ptd_array(arg1);
_free_base(arg1);
}
}
int64_t destroy_ptd_array(int64_t* arg1)
{
int64_t* var_20 = arg1;
int64_t* var_18 = &var_20;
int32_t arg_18 = 5;
int32_t arg_20 = 5;
int64_t* var_10 = &var_20;
int32_t var_28 = 4;
int32_t var_24 = 4;
int64_t rax = *arg1;
if (rax != &data_140013850)
{
_free_base(rax);
arg1 = var_20;
}
_free_base(arg1[0xe]);
_free_base(var_20[0xb]);
_free_base(var_20[0xc]);
_free_base(var_20[0xd]);
_free_base(var_20[9]);
_free_base(var_20[0xa]);
_free_base(var_20[0xf]);
_free_base(var_20[0x10]);
_free_base(var_20[0x78]);
void arg_10;
__crt_seh_guarded_call<class <lambda_46352004c1216016012b18bd6f87e700>,class <lambda_3bd07e1a1191394380780325891bf33f>& __ptr64,class <lambda_334532d3f185bcaa59b5be82d7d22bff>,void>::operator()<class <lambda_46352004c1216016012b18bd6f87e700>,class <lambda_3bd07e1a1191394380780325891bf33f>& __ptr64,class <lambda_334532d3f185bcaa59b5be82d7d22bff> >(
&arg_10, &arg_20, &var_18, &arg_18);
return __crt_seh_guarded_call<class <lambda_fb3a7dec4e47f37f22dae91bb15c9095>,class <lambda_698284760c8add0bfb0756c19673e34b>& __ptr64,class <lambda_dfb8eca1e75fef3034a8fb18dd509707>,void>::operator()<class <lambda_fb3a7dec4e47f37f22dae91bb15c9095>,class <lambda_698284760c8add0bfb0756c19673e34b>& __ptr64,class <lambda_dfb8eca1e75fef3034a8fb18dd509707> >(
&arg_10, &var_24, &var_10, &var_28);
}
void** sub_140007ba0()
{
enum WIN32_ERROR dwErrCode = GetLastError();
void** result = nullptr;
if (FlsSetValue(data_14001d1d8, -ffffffffffffffff))
{
void** lpFlsData = _calloc_base(1, 0x3c8);
uint32_t dwFlsIndex = data_14001d1d8;
if (lpFlsData)
{
if (FlsSetValue(dwFlsIndex, lpFlsData))
{
construct_ptd_array(lpFlsData);
_free_base(0);
result = lpFlsData;
}
else
{
FlsSetValue(data_14001d1d8, nullptr);
_free_base(lpFlsData);
}
SetLastError(dwErrCode);
return result;
}
FlsSetValue(dwFlsIndex, nullptr);
_free_base(0);
}
SetLastError(dwErrCode);
return nullptr;
}
void replace_current_thread_locale_nolock(void* arg1, void* arg2)
{
void* rcx = *(arg1 + 0x90);
if (rcx)
{
__acrt_release_locale_ref(rcx);
void* rcx_1 = *(arg1 + 0x90);
if (rcx_1 != data_14001e3d8 && rcx_1 != &data_14001d1e0 && !*(rcx_1 + 0x10))
__acrt_free_locale(rcx_1);
}
*(arg1 + 0x90) = arg2;
if (arg2)
sub_14000b928(arg2);
}
void** __vcrt_getptd()
{
void** result = sub_140007d20();
if (result)
return result;
abort();
/* no return */
}
void** sub_140007cdc()
{
int64_t var_18 = -2;
uint32_t dwFlsIndex = data_14001d1d8;
void** result;
if (dwFlsIndex != 0xffffffff)
result = FlsGetValue(dwFlsIndex);
else
result = nullptr;
if (result != -1)
{
if (result)
return result;
result = sub_140007ba0();
if (result)
return result;
}
abort();
/* no return */
}
void** sub_140007d20()
{
int64_t var_18 = -2;
void** rdi = nullptr;
if (!data_14001e3d4)
{
enum WIN32_ERROR dwErrCode = GetLastError();
uint32_t dwFlsIndex = data_14001d1d8;
void** rax_1;
if (dwFlsIndex != 0xffffffff)
rax_1 = FlsGetValue(dwFlsIndex);
else
rax_1 = nullptr;
if (rax_1 != -1)
{
if (!rax_1)
rax_1 = sub_140007ba0();
rdi = rax_1;
}
SetLastError(dwErrCode);
}
else
{
void** rax;
if (data_14001d1d8 != 0xffffffff)
rax = sub_14000bfa8();
else
rax = nullptr;
if (rax != -1)
{
if (rax)
return rax;
return sub_140007ba0();
}
}
return rdi;
}
void* sub_140007db0(int64_t arg1, int64_t arg2)
{
int64_t var_18 = -2;
uint32_t dwFlsIndex = data_14001d1d8;
void** rax;
if (dwFlsIndex != 0xffffffff)
rax = FlsGetValue(dwFlsIndex);
else
rax = nullptr;
if (rax != -1)
{
if (rax)
return arg2 * 0x3c8 + rax;
rax = sub_140007ba0();
if (rax)
return arg2 * 0x3c8 + rax;
}
return nullptr;
}
void** sub_140007e0c()
{
data_14001e3d4 = sub_14000c14c();
void** result = FlsAlloc(destroy_fls);
data_14001d1d8 = result;
if (result != 0xffffffff)
{
if (sub_140007d20())
result = 1;
else
{
__vcrt_uninitialize_ptd();
result = 0;
}
}
else
result = 0;
return result;
}
int64_t __vcrt_uninitialize_ptd()
{
uint32_t dwFlsIndex = data_14001d1d8;
if (dwFlsIndex != 0xffffffff)
{
FlsFree(dwFlsIndex);
data_14001d1d8 = 0xffffffff;
}
int64_t result;
result = 1;
return result;
}
uint64_t sub_140007e74(int32_t arg1)
{
if (arg1 >= 1)
{
if (arg1 <= 0xd)
return *(((arg1 - 1) << 3) + 0x140014174);
if (arg1 <= 0x718)
{
uint64_t rcx = 0x2d;
int64_t r10_1 = 0;
int64_t rdi_1 = 0x2c;
while (true)
{
uint64_t r8_2 = rcx >> 1;
int32_t* rax_3;
if (!r8_2)
{
if (!rcx)
break;
rax_3 = &data_140014170 + (r10_1 << 3);
if (arg1 != *rax_3)
rax_3 = nullptr;
}
else
{
bool cond:1_1 = rcx & 1;
rcx = r8_2 - 1;
if (cond:1_1)
rcx = r8_2;
int64_t r11_1 = rcx + r10_1;
rax_3 = &data_140014170 + (r11_1 << 3);
int32_t temp0_1 = *rax_3;
if (arg1 != temp0_1)
{
if (arg1 >= temp0_1)
{
r10_1 = r11_1 + 1;
rcx = r8_2;
}
int64_t rax_4 = r11_1 - 1;
if (arg1 >= temp0_1)
rax_4 = rdi_1;
rdi_1 = rax_4;
if (r10_1 > rax_4)
break;
continue;
}
}
if (!rax_3)
break;
return rax_3[1];
}
}
}
if (arg1 - 0x13 <= 0x11)
return 0xd;
if (arg1 - 0xbc <= 0xe)
return 8;
return 0x16;
}
void* sub_140007f44(int32_t arg1)
{
*sub_140007f90() = arg1;
int32_t rax_1 = sub_140007e74(arg1);
void* result = sub_140007fb4();
*result = rax_1;
return result;
}
int64_t __acrt_errno_map_os_error_ptd(int32_t arg1, void* arg2)
{
*(arg2 + 0x38) = 1;
*(arg2 + 0x34) = arg1;
int32_t result = sub_140007e74(arg1);
*(arg2 + 0x2c) = result;
*(arg2 + 0x30) = 1;
return result;
}
void* sub_140007f90()
{
void** rax = sub_140007d20();
if (!rax)
return &data_14001d350;
return rax + 0x24;
}
void* sub_140007fb4()
{
void** rax = sub_140007d20();
if (!rax)
return &data_14001d34c;
return &rax[4];
}
int64_t* __acrt_stdio_parse_mode<char>(int64_t* arg1, char* arg2)
{
char* r8 = arg2;
*arg1 = 0;
arg1[1] = 0;
*(arg1 + 4) = data_14001e384;
int32_t rax;
rax = *arg2;
while (rax == 0x20)
{
r8 = &r8[1];
rax = *r8;
}
if (rax == 0x61)
{
*arg1 = 0x109;
label_140008038:
*(arg1 + 4) = 2;
label_14000803b:
void* r8_1 = &r8[1];
char r9 = 0;
int64_t rdi;
rdi = 0;
char r10 = 0;
char r11 = 0;
arg2 = 1;
while (true)
{
if (*r8_1)
{
int32_t rcx = *r8_1;
if (rcx > 0x53)
{
if (rcx == 0x54)
{
int32_t rax_12 = *arg1;
if (!TEST_BITD(rax_12, 0xc))
{
*arg1 = rax_12 | 0x1000;
arg2 = 1;
}
else
arg2 = 0;
}
else if (rcx == 0x62)
{
int32_t rax_11 = *arg1;
if (rax_11 & 0xc000)
arg2 = 0;
else
{
*arg1 = rax_11 | 0x8000;
arg2 = 1;
}
}
else if (rcx == 0x63)
{
if (r9)
arg2 = 0;
else
{
*(arg1 + 4) |= 0x800;
r9 = 1;
arg2 = 1;
}
}
else if (rcx == 0x6e)
{
if (r9)
arg2 = 0;
else
{
*(arg1 + 4) &= 0xfffff7ff;
r9 = 1;
arg2 = 1;
}
}
else if (rcx == 0x74)
{
int32_t rax_10 = *arg1;
if (rax_10 & 0xc000)
arg2 = 0;
else
{
*arg1 = rax_10 | 0x4000;
arg2 = 1;
}
}
else
{
if (rcx != 0x78)
goto label_14000827b;
int32_t rax_9 = *arg1;
if (!TEST_BITD(rax_9, 9))
arg2 = 0;
else
{
*arg1 = rax_9 | 0x400;
arg2 = 1;
}
}
}
else if (rcx == 0x53)
{
if (r10)
arg2 = 0;
else
{
*arg1 |= 0x20;
r10 = 1;
arg2 = 1;
}
}
else if (rcx != 0x20)
{
if (rcx == 0x2b)
{
if (rdi)
arg2 = 0;
else
{
int32_t rax_3 = *arg1;
rdi = 1;
if (2 & rax_3)
arg2 = 0;
else
{
arg2 = 1;
*arg1 = (rax_3 & 0xfffffffe) | 2;
*(arg1 + 4) = (*(arg1 + 4) & 0xfffffffc) | 4;
}
}
}
else if (rcx == 0x2c)
{
r11 = 1;
arg2 = 0;
}
else if (rcx == 0x44)
{
int32_t rax_1 = *arg1;
if (rax_1 & 0x40)
arg2 = 0;
else
{
*arg1 = rax_1 | 0x40;
arg2 = 1;
}
}
else if (rcx == 0x4e)
{
*arg1 |= 0x80;
arg2 = 1;
}
else
{
if (rcx != 0x52)
goto label_14000827b;
if (r10)
arg2 = 0;
else
{
*arg1 |= 0x10;
r10 = 1;
arg2 = 1;
}
}
}
int64_t rax_13;
rax_13 = arg2;
r8_1 += rax_13;
if (arg2)
continue;
}
void* rdi_1 = r8_1 + 1;
if (!r11)
rdi_1 = r8_1;
while (*rdi_1 == 0x20)
rdi_1 += 1;
bool cond:2_1;
if (r11)
{
if (strncmp(rdi_1, &data_1400142d8, 3))
break;
void* rdi_2 = rdi_1 + 3;
int32_t rax_14;
while (true)
{
rax_14 = *rdi_2;
if (rax_14 != 0x20)
break;
rdi_2 += 1;
}
if (rax_14 != 0x3d)
break;
do
rdi_2 += 1;
while (*rdi_2 == 0x20);
void* const rsi_1 = 5;
if (sub_14000dd90(rdi_2, "UTF-8", 5))
{
rsi_1 = 8;
if (sub_14000dd90(rdi_2, "UTF-16LEUNICODE", 8))
{
rsi_1 = 7;
if (sub_14000dd90(rdi_2, "UNICODE", 7))
break;
*arg1 |= 0x10000;
}
else
*arg1 |= 0x20000;
}
else
*arg1 |= 0x40000;
void* rcx_15 = rsi_1 + rdi_2;
int32_t rax_15;
while (true)
{
rax_15 = *rcx_15;
if (rax_15 != 0x20)
break;
rcx_15 += 1;
}
cond:2_1 = rax_15;
}
else
cond:2_1 = *rdi_1 != r11;
if (cond:2_1)
break;
arg1[1] = 1;
return arg1;
}
}
else
{
if (rax == 0x72)
{
*(arg1 + 4) = 1;
goto label_14000803b;
}
if (rax == 0x77)
{
*arg1 = 0x301;
goto label_140008038;
}
}
label_14000827b:
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return arg1;
}
void* sub_14000829c(char* arg1, char* arg2, int32_t arg3, void* arg4)
{
void var_18;
int64_t* rax = __acrt_stdio_parse_mode<char>(&var_18, arg2);
void* result = nullptr;
int64_t zmm0 = *rax;
if (rax[1])
{
int32_t arg_18 = 0;
if (!_sopen_s(&arg_18, arg1, zmm0, arg3, 0x180))
{
data_14001e3d0 += 1;
*(arg4 + 0x14) |= *zmm0[4];
int32_t rax_3 = arg_18;
*(arg4 + 0x28) = 0;
__builtin_memset(arg4, 0, 0x14);
result = arg4;
*(arg4 + 0x18) = rax_3;
}
}
return result;
}
uint64_t sub_140008338(int32_t arg1, int16_t* arg2, int64_t arg3)
{
int64_t r15 = arg1;
int64_t i = 0;
int64_t r12_1 = r15 >> 6;
uint64_t rbp = (r15 & 0x3f) * 9;
int64_t rax_2 = (&data_14001e690)[r12_1];
HANDLE hFile = *(rax_2 + (rbp << 3) + 0x28);
if (!arg3 || *arg2 != 0xa)
*(rax_2 + (rbp << 3) + 0x38) &= 0xfb;
else
*(rax_2 + (rbp << 3) + 0x38) |= 4;
void* r8 = &arg2[arg3];
int16_t* rax_3 = arg2;
int16_t* rbx = arg2;
if (arg2 < r8)
{
while (true)
{
int16_t rdx = *rax_3;
if (rdx == 0x1a)
{
uint64_t r8_2 = (r15 & 0x3f) * 9;
int64_t rcx_8 = (&data_14001e690)[r15 >> 6];
int64_t rax_13;
rax_13 = *(rcx_8 + (r8_2 << 3) + 0x38);
if (!(rax_13 & 0x40))
{
rax_13 |= 2;
*(rcx_8 + (r8_2 << 3) + 0x38) = rax_13;
break;
}
*rbx = rdx;
}
else if (rdx != 0xd)
{
label_1400083db:
rax_3 = &rax_3[1];
label_1400083de:
*rbx = rdx;
rbx = &rbx[1];
if (rax_3 >= r8)
break;
continue;
}
else
{
if (&rax_3[1] < r8)
{
if (rax_3[1] != 0xa)
goto label_1400083db;
rax_3 = &rax_3[2];
rdx = 0xa;
goto label_1400083de;
}
int16_t buffer = 0;
uint32_t numberOfBytesRead = 0;
if (!ReadFile(hFile, &buffer, 2, &numberOfBytesRead, nullptr) || !numberOfBytesRead)
*rbx = 0xd;
else if (*((&data_14001e690)[r12_1] + (rbp << 3) + 0x38) & 0x48)
{
int16_t buffer_1 = buffer;
if (buffer_1 != 0xa)
{
int16_t buffer_2 = buffer_1;
*rbx = 0xd;
do
{
int64_t rax_8;
rax_8 = *(&buffer_2 + i);
*((&data_14001e690)[r15 >> 6] + (r15 & 0x3f) * 0x48 + i + 0x3a) = rax_8;
i += 1;
} while (i < 2);
*((&data_14001e690)[r15 >> 6] + (r15 & 0x3f) * 0x48 + 0x3c) = 0xa;
}
else
*rbx = 0xa;
}
else if (buffer != 0xa || rbx != arg2)
{
_lseeki64_nolock(r15, -2, FILE_CURRENT);
if (buffer == 0xa)
break;
*rbx = 0xd;
}
else
*rbx = 0xa;
}
rbx = &rbx[1];
break;
}
}
return ((rbx - arg2) >> 1) * 2;
}
uint64_t sub_140008534(int32_t arg1, char* arg2, int64_t arg3, int32_t arg4)
{
int64_t rbp = arg1;
int64_t r15_1 = rbp >> 6;
uint64_t r14_1 = rbp & 0x3f;
int64_t rax = (&data_14001e690)[r15_1];
uint64_t rsi = r14_1 * 9;
HANDLE hFile = *(rax + (rsi << 3) + 0x28);
if (!arg3 || *arg2 != 0xa)
*(rax + (rsi << 3) + 0x38) &= 0xfb;
else
*(rax + (rsi << 3) + 0x38) |= 4;
void* r9_1 = &arg2[arg3];
char* rax_1 = arg2;
char* rbx = arg2;
if (arg2 < r9_1)
{
while (true)
{
arg1 = *rax_1;
if (arg1 == 0x1a)
{
int64_t r8 = (&data_14001e690)[r15_1];
uint64_t rdx_2 = r14_1 * 9;
rax_1 = *(r8 + (rdx_2 << 3) + 0x38);
if (!(rax_1 & 0x40))
{
rax_1 |= 2;
*(r8 + (rdx_2 << 3) + 0x38) = rax_1;
break;
}
*rbx = arg1;
}
else if (arg1 != 0xd)
{
label_1400085cd:
*rbx = arg1;
rax_1 = &rax_1[1];
label_1400085d2:
rbx = &rbx[1];
if (rax_1 >= r9_1)
break;
continue;
}
else
{
if (&rax_1[1] < r9_1)
{
if (rax_1[1] != 0xa)
goto label_1400085cd;
rax_1 = &rax_1[2];
*rbx = 0xa;
goto label_1400085d2;
}
uint8_t buffer = 0;
uint32_t numberOfBytesRead = 0;
if (!ReadFile(hFile, &buffer, 1, &numberOfBytesRead, nullptr) || !numberOfBytesRead)
*rbx = 0xd;
else if (*((&data_14001e690)[r15_1] + (rsi << 3) + 0x38) & 0x48)
{
uint8_t buffer_1 = buffer;
if (buffer_1 != 0xa)
{
*rbx = 0xd;
*((&data_14001e690)[r15_1] + (rsi << 3) + 0x3a) = buffer_1;
}
else
*rbx = 0xa;
}
else if (buffer != 0xa || rbx != arg2)
{
_lseeki64_nolock(rbp, -1, FILE_CURRENT);
if (buffer == 0xa)
break;
*rbx = 0xd;
}
else
*rbx = 0xa;
}
rbx = &rbx[1];
break;
}
}
int32_t rbx_1 = rbx - arg2;
if (rbx == arg2)
return 0;
if (!*((&data_14001e690)[r15_1] + r14_1 * 0x48 + 0x39))
return rbx_1;
void* rcx_4 = &arg2[rbx_1];
void* rbx_2 = rcx_4 - 1;
if (*rbx_2 < 0)
{
int32_t r8_1 = 1;
while (!*(*rbx_2 + 0x14001d360))
{
if (r8_1 > 4)
break;
if (rbx_2 < arg2)
break;
rbx_2 -= 1;
r8_1 += 1;
}
uint64_t rdx_4 = *rbx_2;
int32_t rax_7 = *(rdx_4 + 0x14001d360);
if (rax_7)
{
if (rax_7 + 1 != r8_1)
{
int64_t r9_3 = (&data_14001e690)[rbp >> 6];
if (!(*(r9_3 + (rbp & 0x3f) * 0x48 + 0x38) & 0x48))
_lseeki64_nolock(rbp, -(r8_1), FILE_CURRENT);
else
{
void* rbx_3 = rbx_2 + 1;
*(r9_3 + (rbp & 0x3f) * 0x48 + 0x3a) = rdx_4;
if (r8_1 >= 2)
{
rdx_4 = *rbx_3;
rbx_3 += 1;
*((&data_14001e690)[rbp >> 6] + (rbp & 0x3f) * 0x48 + 0x3b) = rdx_4;
}
if (r8_1 == 3)
{
rdx_4 = *rbx_3;
rbx_3 += 1;
*((&data_14001e690)[rbp >> 6] + (rbp & 0x3f) * 0x48 + 0x3c) = rdx_4;
}
rbx_2 = rbx_3 - r8_1;
}
}
else
rbx_2 += r8_1;
goto label_1400087d7;
}
*sub_140007fb4() = 0x2a;
}
else
{
rbx_2 = rcx_4;
label_1400087d7:
int32_t rbx_4 = rbx_2 - arg2;
int32_t var_40_1 = arg4;
int64_t r9;
int64_t var_48_1 = r9;
int32_t rax_25 = __acrt_MultiByteToWideChar(0xfde9, 0, arg2, rbx_4);
if (rax_25)
{
uint64_t rcx_16 = rbp & 0x3f;
uint64_t r8_4 = rcx_16 * 9;
int64_t rdx_6 = (&data_14001e690)[rbp >> 6];
rcx_16 = rcx_16 - rcx_16;
rcx_16 &= 2;
rcx_16 |= *(rdx_6 + (r8_4 << 3) + 0x3d) & 0xfd;
*(rdx_6 + (r8_4 << 3) + 0x3d) = rcx_16;
return rax_25 * 2;
}
sub_140007f44(GetLastError());
}
return 0xffffffff;
}
uint64_t _read(int32_t arg1, char* arg2, int32_t arg3)
{
int32_t arg_8 = arg1;
int64_t rsi = arg1;
if (rsi != 0xfffffffe)
{
int32_t rax_3;
if (arg1 < 0 || rsi >= data_14001ea90)
rax_3 = 0;
else
rax_3 = 1;
uint64_t r13_1;
int64_t r15_2;
if (rax_3)
{
r15_2 = rsi >> 6;
r13_1 = (rsi & 0x3f) * 9;
}
if (!rax_3 || !(*((&data_14001e690)[r15_2] + (r13_1 << 3) + 0x38) & 1))
{
*sub_140007f90() = 0;
*sub_140007fb4() = 9;
}
else
{
if (arg3 <= 0x7fffffff)
{
__acrt_lowio_unlock_fh(rsi);
int32_t rbx_1 = -1;
if (*((&data_14001e690)[r15_2] + (r13_1 << 3) + 0x38) & 1)
rbx_1 = _read_nolock(rsi, arg2, arg3);
else
{
*sub_140007fb4() = 9;
*sub_140007f90() = 0;
}
sub_14000afac(rsi);
return rbx_1;
}
*sub_140007f90() = 0;
*sub_140007fb4() = 0x16;
}
_invalid_parameter_noinfo();
}
else
{
*sub_140007f90() = 0;
*sub_140007fb4() = 9;
}
return 0xffffffff;
}
uint64_t _read_nolock(int32_t arg1, char* arg2, int32_t arg3)
{
int64_t r13 = arg1;
uint64_t r12 = arg3;
if (r13 != 0xfffffffe)
{
uint64_t var_58_1;
char var_50_1;
int64_t rax_5;
uint64_t r8_1;
uint64_t r14_1;
if (arg1 >= 0 && r13 < data_14001ea90)
{
var_50_1 = 1;
r8_1 = r13 >> 6;
var_58_1 = r8_1;
r14_1 = (r13 & 0x3f) * 9;
rax_5 = (&data_14001e690)[r8_1];
}
if (arg1 < 0 || r13 >= data_14001ea90 || !(*(rax_5 + (r14_1 << 3) + 0x38) & 1))
{
*sub_140007f90() = 0;
*sub_140007fb4() = 9;
}
else
{
if (r12 <= 0x7fffffff)
{
if (!r12 || *(rax_5 + (r14_1 << 3) + 0x38) & 2)
return 0;
if (arg2)
{
HANDLE rcx = *(rax_5 + (r14_1 << 3) + 0x28);
char* lpBuffer_2 = nullptr;
int32_t r10_1 = *(rax_5 + (r14_1 << 3) + 0x39);
char arg_8 = r10_1;
int32_t rdi_2;
uint32_t nNumberOfBytesToRead;
char* lpBuffer;
if (r10_1 != 1)
{
if (r10_1 == 2 && !(1 & ~r12))
goto label_140008a83;
nNumberOfBytesToRead = r12;
lpBuffer = arg2;
label_140008b20:
int64_t rax_18 = (&data_14001e690)[r8_1];
int32_t rdi_1 = 0;
char* lpBuffer_1 = lpBuffer;
if (*(rax_18 + (r14_1 << 3) + 0x38) & 0x48)
{
rax_18 = *(rax_18 + (r14_1 << 3) + 0x3a);
if (rax_18 != 0xa && nNumberOfBytesToRead)
{
*lpBuffer = rax_18;
nNumberOfBytesToRead -= 1;
lpBuffer = &lpBuffer[1];
rdi_1 = 1;
*((&data_14001e690)[r8_1] + (r14_1 << 3) + 0x3a) = 0xa;
if (r10_1)
{
uint64_t rcx_2;
rcx_2 = *((&data_14001e690)[r8_1] + (r14_1 << 3) + 0x3b);
if (rcx_2 != 0xa && nNumberOfBytesToRead)
{
*lpBuffer = rcx_2;
rdi_1 = 2;
lpBuffer = &lpBuffer[1];
nNumberOfBytesToRead -= 1;
*((&data_14001e690)[r8_1] + (r14_1 << 3) + 0x3b) = 0xa;
if (r10_1 == 1)
{
rcx_2 =
*((&data_14001e690)[r8_1] + (r14_1 << 3) + 0x3c);
if (rcx_2 != 0xa && nNumberOfBytesToRead)
{
*lpBuffer = rcx_2;
rdi_1 = 3;
lpBuffer = &lpBuffer[1];
nNumberOfBytesToRead -= 1;
*((&data_14001e690)[r8_1] + (r14_1 << 3) + 0x3c) =
0xa;
}
}
}
}
}
}
enum CONSOLE_MODE mode = 0;
uint32_t arg_20;
if (!_isatty(r13)
|| *((&data_14001e690)[var_58_1] + (r14_1 << 3) + 0x38) >= 0)
{
label_140008c51:
var_50_1 = 0;
label_140008c66:
arg_20 = 0;
if (!ReadFile(rcx, lpBuffer, nNumberOfBytesToRead, &arg_20, nullptr)
|| arg_20 > r12)
{
enum WIN32_ERROR rax_29 = GetLastError();
if (rax_29 == ERROR_ACCESS_DENIED)
{
*sub_140007fb4() = 9;
*sub_140007f90() = 5;
rdi_2 = -1;
}
else if (rax_29 != ERROR_BROKEN_PIPE)
{
sub_140007f44(rax_29);
rdi_2 = -1;
}
else
rdi_2 = 0;
}
else
{
rdi_2 = rdi_1 + arg_20;
label_140008ca8:
if (*((&data_14001e690)[var_58_1] + (r14_1 << 3) + 0x38) < 0)
{
int64_t r8_4 = rdi_2;
if (arg_8 == 2)
{
uint64_t r8_5 = r8_4 >> 1;
if (!var_50_1)
rdi_2 = sub_140008338(r13, lpBuffer_1, r8_5);
else
{
char* lpBuffer_3 = lpBuffer_1;
char* lpBuffer_4 = lpBuffer_1;
void* r9_4 = &lpBuffer_1[r8_5 << 1];
if (lpBuffer_1 < r9_4)
{
do
{
int16_t rcx_12 = *lpBuffer_3;
if (rcx_12 == 0x1a)
{
int64_t rax_37 =
(&data_14001e690)[var_58_1];
*(rax_37 + (r14_1 << 3) + 0x38) |= 2;
break;
}
int64_t r11_1;
if (rcx_12 != 0xd || &lpBuffer_3[2] >= r9_4
|| *(lpBuffer_3 + 2) != 0xa)
r11_1 = 2;
else
{
rcx_12 = 0xa;
r11_1 = 4;
}
lpBuffer_3 = &lpBuffer_3[r11_1];
*lpBuffer_4 = rcx_12;
lpBuffer_4 = &lpBuffer_4[2];
} while (lpBuffer_3 < r9_4);
}
rdi_2 = ((lpBuffer_4 - lpBuffer_1) >> 1) * 2;
}
}
else
{
uint64_t var_78_1 = r12 >> 1;
rdi_2 = sub_140008534(r13, lpBuffer, r8_4, arg2);
}
}
}
}
else
{
if (!GetConsoleMode(rcx, &mode))
goto label_140008c51;
if (arg_8 != 2)
goto label_140008c66;
arg_20 = 0;
if (ReadConsoleW(rcx, lpBuffer, nNumberOfBytesToRead >> 1, &arg_20,
nullptr))
{
rdi_2 = rdi_1 + (arg_20 << 1);
goto label_140008ca8;
}
sub_140007f44(GetLastError());
rdi_2 = -1;
}
}
else if (!(1 & ~r12))
{
label_140008a83:
*sub_140007f90() = 0;
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
rdi_2 = -1;
}
else
{
nNumberOfBytesToRead = r12 >> 1;
if (nNumberOfBytesToRead < 4)
nNumberOfBytesToRead = 4;
lpBuffer_2 = _malloc_base(nNumberOfBytesToRead);
_free_base(0);
_free_base(0);
lpBuffer = lpBuffer_2;
if (lpBuffer_2)
{
int64_t rax_17;
rax_17 = _lseeki64_nolock(r13, 0, FILE_CURRENT);
r8_1 = var_58_1;
r10_1 = arg_8;
*((&data_14001e690)[r8_1] + (r14_1 << 3) + 0x30) = rax_17;
goto label_140008b20;
}
*sub_140007fb4() = 0xc;
*sub_140007f90() = 8;
rdi_2 = -1;
}
_free_base(lpBuffer_2);
return rdi_2;
}
}
*sub_140007f90() = 0;
*sub_140007fb4() = 0x16;
}
_invalid_parameter_noinfo();
}
else
{
*sub_140007f90() = 0;
*sub_140007fb4() = 9;
}
return 0xffffffff;
}
uint64_t sub_140008de4(int64_t* arg1)
{
uint32_t rdi_1;
if (!arg1)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
rdi_1 = -1;
}
else if (!(*(arg1 + 0x14) >> 0xd & 1) || *(arg1 + 0x14) >> 0xc & 1)
rdi_1 = -1;
else if (!(*(arg1 + 0x14) >> 1 & 1))
{
*(arg1 + 0x14) |= 1;
if (!(*(arg1 + 0x14) & 0x4c0))
__acrt_stdio_allocate_buffer_nolock(arg1);
char* rdi_2 = arg1[1];
int32_t rbx_1 = arg1[4];
*arg1 = rdi_2;
int32_t rax_10 = _read(_fileno(arg1), rdi_2, rbx_1);
arg1[2] = rax_10;
if (rax_10 + 1 > 1)
{
if (!(*(arg1 + 0x14) & 6))
{
int32_t rax_16 = _fileno(arg1);
int32_t rax_17;
if (rax_16 != 0xffffffff)
rax_17 = _fileno(arg1);
void* rax_22;
if (rax_16 == 0xffffffff || rax_17 == 0xfffffffe)
rax_22 = &data_14001d9a0;
else
{
int64_t rbx_3 = _fileno(arg1) >> 6;
uint64_t rax_20 = _fileno(arg1) & 0x3f;
rax_22 = (&data_14001e690)[rbx_3] + rax_20 * 0x48;
}
rax_22 = *(rax_22 + 0x38);
rax_22 &= 0x82;
if (rax_22 == 0x82)
*(arg1 + 0x14) |= 0x20;
}
if (arg1[4] == 0x200 && *(arg1 + 0x14) >> 6 & 1 && !(*(arg1 + 0x14) >> 8 & 1))
arg1[4] = 0x1000;
char* rax_27 = *arg1;
arg1[2] -= 1;
rdi_1 = *rax_27;
*arg1 = &rax_27[1];
}
else
{
int32_t rax_11 = -(rax_10);
*(arg1 + 0x14) |= ((rax_11 - rax_11) & 8) + 8;
arg1[2] = 0;
rdi_1 = -1;
}
}
else
{
*(arg1 + 0x14) |= 0x10;
rdi_1 = -1;
}
return rdi_1;
}
int64_t _malloc_base(uint64_t arg1)
{
uint64_t dwBytes = arg1;
if (arg1 <= -0x20)
{
if (!arg1)
dwBytes = 1;
int32_t i;
do
{
int64_t result = HeapAlloc(data_14001eb60, HEAP_NONE, dwBytes);
if (result)
return result;
if (!sub_140006370())
break;
i = sub_14000c3c0();
} while (i);
}
*sub_140007fb4() = 0xc;
return 0;
}
int64_t _calloc_base(int64_t arg1, int64_t arg2)
{
if (!arg1 || -0x20 / arg1 >= arg2)
{
uint64_t dwBytes = arg1 * arg2;
if (!dwBytes)
dwBytes = 1;
int32_t i;
do
{
int64_t result = HeapAlloc(data_14001eb60, HEAP_ZERO_MEMORY, dwBytes);
if (result)
return result;
if (!sub_140006370())
break;
i = sub_14000c3c0();
} while (i);
}
*sub_140007fb4() = 0xc;
return 0;
}
void <lambda_2feae5270eb4d0d5532525f423405775>::<helper_func_cdecl>() __pure
{
int64_t entry_rcx;
int64_t entry_rdx;
if (entry_rcx < entry_rdx)
return;
int64_t rax_1;
rax_1 = entry_rcx > entry_rdx;
}
uint64_t sub_14000903c(char* arg1, void* arg2, int64_t arg3, uint32_t arg4)
{
if (!arg1)
{
if (*(arg2 + 0x28))
{
_free_base(*(arg2 + 0x10));
*(arg2 + 0x28) = 0;
}
__builtin_memset(arg2 + 0x10, 0, 0x18);
}
else if (*arg1)
{
int32_t var_10_1 = 0;
int64_t var_18_1 = 0;
int32_t rax_4 = __acrt_MultiByteToWideChar(arg4, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED,
arg1, 0xffffffff);
int64_t rsi_1 = rax_4;
int64_t rax_10;
if (rax_4)
{
int64_t rdx_4 = *(arg2 + 0x18);
if (rsi_1 > rdx_4)
{
if (*(arg2 + 0x28))
{
_free_base(*(arg2 + 0x10));
*(arg2 + 0x28) = 0;
}
int64_t rax_7;
int64_t rdx_5;
int32_t r8_1;
rax_7 = _malloc_base(rsi_1 * 2);
*(arg2 + 0x10) = rax_7;
rdx_4 = (rdx_5 - rdx_5) & rsi_1;
int32_t r8_4 = ~(r8_1 - r8_1) & 0xc;
if (rax_7)
r8_4 = 0;
*(arg2 + 0x28) = rax_7;
*(arg2 + 0x18) = rdx_4;
if (r8_4)
return r8_4;
}
int32_t var_10_2 = rdx_4;
int64_t var_18_2 = *(arg2 + 0x10);
rax_10 = __acrt_MultiByteToWideChar(arg4, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, arg1,
0xffffffff);
}
if (!rax_4 || !rax_10)
{
sub_140007f44(GetLastError());
return *sub_140007fb4();
}
*(arg2 + 0x20) = rax_10 - 1;
}
else
{
if (!*(arg2 + 0x18))
{
if (*(arg2 + 0x28))
{
_free_base(*(arg2 + 0x10));
*(arg2 + 0x28) = 0;
}
int64_t rax_1;
int32_t rdx;
rax_1 = _malloc_base(2);
*(arg2 + 0x10) = rax_1;
int32_t rdx_3 = ~(rdx - rdx) & 0xc;
if (rax_1)
rdx_3 = 0;
*(arg2 + 0x28) = rax_1;
int64_t rcx_4;
rcx_4 = rax_1;
*(arg2 + 0x18) = rcx_4;
if (rdx_3)
return rdx_3;
}
**(arg2 + 0x10) = 0;
}
return 0;
}
uint64_t sub_1400091dc(int16_t* arg1, void* arg2, int64_t arg3, uint32_t arg4)
{
if (!arg1)
{
if (*(arg2 + 0x28))
{
_free_base(*(arg2 + 0x10));
*(arg2 + 0x28) = 0;
}
__builtin_memset(arg2 + 0x10, 0, 0x18);
}
else if (*arg1)
{
int64_t var_10_1 = 0;
int64_t var_18_1 = 0;
int32_t rax_4 = __acrt_WideCharToMultiByte(arg4, 0, arg1, 0xffffffff, 0, nullptr);
int64_t rsi_1 = rax_4;
int64_t rax_10;
if (rax_4)
{
int64_t rdx_4 = *(arg2 + 0x18);
if (rsi_1 > rdx_4)
{
if (*(arg2 + 0x28))
{
_free_base(*(arg2 + 0x10));
*(arg2 + 0x28) = 0;
}
int64_t rax_7;
int64_t rdx_5;
int32_t r8_1;
rax_7 = _malloc_base(rsi_1);
*(arg2 + 0x10) = rax_7;
rdx_4 = (rdx_5 - rdx_5) & rsi_1;
int32_t r8_4 = ~(r8_1 - r8_1) & 0xc;
if (rax_7)
r8_4 = 0;
*(arg2 + 0x28) = rax_7;
*(arg2 + 0x18) = rdx_4;
if (r8_4)
return r8_4;
}
int64_t var_10_2 = 0;
int64_t var_18_2 = 0;
rax_10 = __acrt_WideCharToMultiByte(arg4, 0, arg1, 0xffffffff, *(arg2 + 0x10), rdx_4);
}
if (!rax_4 || !rax_10)
{
sub_140007f44(GetLastError());
return *sub_140007fb4();
}
*(arg2 + 0x20) = rax_10 - 1;
}
else
{
if (!*(arg2 + 0x18))
{
if (*(arg2 + 0x28))
{
_free_base(*(arg2 + 0x10));
*(arg2 + 0x28) = 0;
}
int64_t rax_1;
int32_t rdx;
rax_1 = _malloc_base(1);
*(arg2 + 0x10) = rax_1;
int32_t rdx_3 = ~(rdx - rdx) & 0xc;
if (rax_1)
rdx_3 = 0;
*(arg2 + 0x28) = rax_1;
int64_t rcx_4;
rcx_4 = rax_1;
*(arg2 + 0x18) = rcx_4;
if (rdx_3)
return rdx_3;
}
**(arg2 + 0x10) = 0;
}
return 0;
}
uint64_t common_expand_argv_wildcards<char>(int64_t* arg1, int64_t* arg2)
{
int64_t* rbx = arg1;
if (!arg2)
{
int32_t rbx_1 = arg2 + 0x16;
*sub_140007fb4() = rbx_1;
_invalid_parameter_noinfo();
return rbx_1;
}
*arg2 = 0;
char* rax_2 = *arg1;
int128_t var_58;
__builtin_memset(&var_58, 0, 0x18);
int32_t rsi_1;
int64_t* i_2;
while (true)
{
int16_t arg_10;
if (!rax_2)
{
i_2 = var_58;
int64_t rsi_2 = *var_58[8];
int64_t rdx_2 = 0;
int64_t arg_18 = 0;
int64_t* i_3 = i_2;
if (i_2 != rsi_2)
{
do
{
int64_t rcx_3 = -1;
do
rcx_3 += 1;
while ((*i_3)[rcx_3]);
i_3 = &i_3[1];
rdx_2 = rdx_2 + 1 + rcx_3;
} while (i_3 != rsi_2);
arg_18 = rdx_2;
}
int64_t rax_6 = __acrt_allocate_buffer_for_argv(((rsi_2 - i_2) >> 3) + 1, rdx_2, 1);
if (!rax_6)
{
_free_base(0);
int64_t* i_4 = i_2;
if (i_2 != rsi_2)
{
do
{
_free_base(*i_4);
i_4 = &i_4[1];
} while (i_4 != rsi_2);
}
rsi_1 = -1;
break;
}
char* rcx_8 = rax_6 + ((((rsi_2 - i_2) >> 3) + 1) << 3);
int64_t* i_6 = i_2;
char* arg_20 = rcx_8;
char* r12_1 = rcx_8;
if (i_2 != rsi_2)
{
arg_10 = rax_6 - i_2;
do
{
char* r8_3 = *i_6;
int64_t r15_1 = -1;
do
r15_1 += 1;
while (r8_3[r15_1]);
if (sub_14000f0c0(r12_1, rcx_8 - r12_1 + arg_18, r8_3, r15_1 + 1))
{
int64_t var_68 = 0;
_invoke_watson();
/* no return */
}
rcx_8 = arg_20;
*(arg_10 + i_6) = r12_1;
r12_1 = &r12_1[r15_1 + 1];
i_6 = &i_6[1];
} while (i_6 != rsi_2);
}
*arg2 = rax_6;
_free_base(0);
int64_t* i_5 = i_2;
if (i_2 != rsi_2)
{
do
{
_free_base(*i_5);
i_5 = &i_5[1];
} while (i_5 != rsi_2);
}
_free_base(i_2);
return 0;
}
arg_10 = 0x3f2a;
char arg_12 = 0;
char* rax_3 = sub_14000f290(rax_2, &arg_10);
char* rcx_1 = *rbx;
if (rax_3)
{
int32_t rax_5 = sub_140009748(rcx_1, rax_3, &var_58, arg2);
rsi_1 = rax_5;
if (rax_5)
{
i_2 = var_58;
int64_t* i = i_2;
if (i_2 != *var_58[8])
{
do
{
_free_base(*i);
i = &i[1];
} while (i != *var_58[8]);
}
break;
}
}
else
{
int32_t rax_4 = sub_1400095c4(rcx_1, 0, 0, &var_58);
rsi_1 = rax_4;
if (rax_4)
{
i_2 = var_58;
int64_t* i_1 = i_2;
if (i_2 != *var_58[8])
{
do
{
_free_base(*i_1);
i_1 = &i_1[1];
} while (i_1 != *var_58[8]);
}
break;
}
}
rbx = &rbx[1];
rax_2 = *rbx;
}
_free_base(i_2);
return rsi_1;
}
uint64_t sub_1400095c4(char* arg1, int64_t arg2, int64_t arg3, int64_t* arg4)
{
int64_t rbp = -1;
int32_t rdi = 0;
do
rbp += 1;
while (arg1[rbp]);
if (rbp + 1 > ~arg3)
return 0xc;
int64_t r15_2 = arg3 + 1 + rbp + 1;
char* rax_3 = _calloc_base(r15_2, 1);
int32_t rax_4;
if (arg3)
rax_4 = sub_14000f0c0(rax_3, r15_2, arg2, arg3);
if (!arg3 || !rax_4)
{
int32_t rax_5 = sub_14000f0c0(&rax_3[arg3], r15_2 - arg3, arg1, rbp + 1);
if (!rax_5)
{
int64_t r14_1 = arg4[2];
uint64_t r15_4 = rax_5 + 8;
if (arg4[1] != r14_1)
{
*arg4[1] = rax_3;
arg4[1] += r15_4;
}
else if (*arg4)
{
int64_t r14_3 = (r14_1 - *arg4) >> 3;
if (r14_3 > 0x7fffffffffffffff)
{
rdi = 0xc;
_free_base(rax_3);
}
else
{
int64_t rbp_2 = r14_3 * 2;
void* rax_9 = _recalloc_base(*arg4, rbp_2, r15_4);
if (rax_9)
{
*arg4 = rax_9;
arg4[1] = rax_9 + (r14_3 << 3);
arg4[2] = rax_9 + (rbp_2 << 3);
_free_base(0);
*arg4[1] = rax_3;
arg4[1] += r15_4;
}
else
{
_free_base(0);
rdi = 0xc;
_free_base(rax_3);
}
}
}
else
{
*arg4 = _calloc_base(rax_5 + 4, r15_4);
_free_base(0);
int64_t rax_7 = *arg4;
if (!rax_7)
{
rdi = 0xc;
_free_base(rax_3);
}
else
{
arg4[1] = rax_7;
arg4[2] = rax_7 + 0x20;
*arg4[1] = rax_3;
arg4[1] += r15_4;
}
}
_free_base(0);
return rdi;
}
}
int64_t var_38 = 0;
_invoke_watson();
/* no return */
}
uint64_t sub_140009748(char* arg1, char* arg2, int64_t* arg3, int64_t arg4 @ r13)
{
int64_t var_30 = arg4;
void var_378;
int64_t var_48 = __security_cookie ^ &var_378;
int64_t* r12 = arg3;
int64_t rax_1;
if (arg2 != arg1)
{
do
{
rax_1 = *arg2;
rax_1 -= 0x2f;
if (rax_1 <= 0x2d && TEST_BITQ(0x200000000801, rax_1))
break;
rax_1 = _mbsdec(arg1, arg2);
arg2 = rax_1;
} while (rax_1 != arg1);
}
arg3 = *arg2;
uint64_t result;
if (arg3 != 0x3a || arg2 == &arg1[1])
{
arg3 -= 0x2f;
if (arg3 <= 0x2d)
rax_1 = 1;
if (arg3 > 0x2d || !TEST_BITQ(0x200000000801, arg3))
rax_1 = 0;
char temp0_1 = rax_1;
rax_1 = -(rax_1);
void* r13_1 = (arg4 - arg4) & (arg2 - arg1 + 1);
void* var_340_1 = r13_1;
void findFileData;
sub_140010a60(&findFileData, 0, 0x250);
int64_t var_338;
__builtin_memset(&var_338, 0, 0x29);
void* var_308;
_LocaleUpdate::_LocaleUpdate(&var_308, nullptr);
void* var_300;
uint32_t r9_1;
char var_2f0;
if (*(var_300 + 0xc) != 0xfde9)
{
if (sub_14000bf44())
{
if (var_2f0)
{
void* rax_6 = var_308;
*(rax_6 + 0x3a8) &= 0xfffffffd;
}
r9_1 = 0;
}
else
{
if (var_2f0)
{
void* rax_5 = var_308;
*(rax_5 + 0x3a8) &= 0xfffffffd;
}
r9_1 = 1;
}
}
else
{
if (var_2f0)
{
void* rax_3 = var_308;
*(rax_3 + 0x3a8) &= 0xfffffffd;
}
r9_1 = 0xfde9;
}
PWSTR lpFileName_1;
PWSTR lpFileName = lpFileName_1;
void var_348;
if (sub_14000903c(arg1, &var_338, &var_348, r9_1))
lpFileName = nullptr;
HANDLE hFindFile = FindFirstFileExW(lpFileName, FindExInfoStandard, &findFileData,
FindExSearchNameMatch, 0, 0);
char var_310;
if (hFindFile != -1)
{
int64_t rsi_3 = (r12[1] - *r12) >> 3;
while (true)
{
int64_t var_2c8;
__builtin_memset(&var_2c8, 0, 0x29);
void* var_2e8;
_LocaleUpdate::_LocaleUpdate(&var_2e8, nullptr);
void* var_2e0;
uint32_t r9_3;
char var_2d0;
if (*(var_2e0 + 0xc) != 0xfde9)
{
if (sub_14000bf44())
{
if (var_2d0)
{
void* rax_12 = var_2e8;
*(rax_12 + 0x3a8) &= 0xfffffffd;
}
r9_3 = 0;
}
else
{
if (var_2d0)
{
void* rax_11 = var_2e8;
*(rax_11 + 0x3a8) &= 0xfffffffd;
}
r9_3 = 1;
}
}
else
{
if (var_2d0)
{
void* rax_9 = var_2e8;
*(rax_9 + 0x3a8) &= 0xfffffffd;
}
r9_3 = 0xfde9;
}
char* var_2b8;
char* rcx_9 = var_2b8;
int16_t var_26c[0x112];
if (sub_1400091dc(&var_26c, &var_2c8, &var_348, r9_3))
rcx_9 = nullptr;
int32_t rax_13;
if (*rcx_9 == 0x2e)
rax_13 = rcx_9[1];
char var_2a0;
if (*rcx_9 != 0x2e || (rax_13 && (rax_13 != 0x2e || rcx_9[2])))
{
int32_t result_2 = sub_1400095c4(rcx_9, arg1, r13_1, r12);
if (result_2)
{
if (var_2a0)
_free_base(var_2b8);
FindClose(hFindFile);
if (var_310)
_free_base(lpFileName_1);
result = result_2;
break;
}
if (var_2a0 != result_2)
_free_base(var_2b8);
r13_1 = var_340_1;
}
else if (var_2a0)
_free_base(var_2b8);
if (!FindNextFileW(hFindFile, &findFileData))
{
int64_t rax_15 = *r12;
int64_t rdx_8 = (r12[1] - rax_15) >> 3;
if (rsi_3 != rdx_8)
sub_14000ed20(rax_15 + (rsi_3 << 3), rdx_8 - rsi_3, 8,
<lambda_2feae5270eb4d0d5532525f423405775>::<helper_func_cdecl>);
FindClose(hFindFile);
if (var_310)
_free_base(lpFileName_1);
result = 0;
break;
}
}
}
else
{
int32_t result_1 = sub_1400095c4(arg1, 0, 0, r12);
if (var_310)
_free_base(lpFileName_1);
result = result_1;
}
}
else
result = sub_1400095c4(arg1, 0, 0, r12);
__security_check_cookie(var_48 ^ &var_378);
return result;
}
void** _LocaleUpdate::_LocaleUpdate(void** arg1, int128_t* arg2)
{
arg1[3] = 0;
if (arg2)
*(arg1 + 8) = *arg2;
else if (data_14001e37c)
{
void** rax_1 = __vcrt_getptd();
*arg1 = rax_1;
arg1[1] = rax_1[0x12];
arg1[2] = rax_1[0x11];
__acrt_update_locale_info(rax_1, &arg1[1]);
sub_14000c81c(*arg1, &arg1[2]);
void* rcx_4 = *arg1;
int32_t rax_2 = *(rcx_4 + 0x3a8);
if (!(rax_2 & 2))
{
*(rcx_4 + 0x3a8) = rax_2 | 2;
arg1[3] = 1;
}
}
else
*(arg1 + 8) = *data_14001d338;
return arg1;
}
uint64_t j_common_expand_argv_wildcards<char>(int64_t* arg1, int64_t* arg2)
{
/* tailcall */
return common_expand_argv_wildcards<char>(arg1, arg2);
}
uint64_t __acrt_convert_wcs_mbs_cp<wchar_t,char,class <lambda_f788ae46380686e8b737efdd8c720d07>,struct __crt_win32_buffer_no_resizing>(int16_t* arg1, void* arg2, int64_t arg3, uint32_t arg4)
{
if (!arg1)
{
if (*(arg2 + 0x28))
*(arg2 + 0x28) = 0;
__builtin_memset(arg2 + 0x10, 0, 0x18);
}
else if (*arg1)
{
int64_t var_10_1 = 0;
int64_t var_18_1 = 0;
int32_t rax_4 = __acrt_WideCharToMultiByte(arg4, 0, arg1, 0xffffffff, 0, nullptr);
if (!rax_4)
{
sub_140007f44(GetLastError());
return *sub_140007fb4();
}
int64_t rcx_2 = *(arg2 + 0x18);
if (rax_4 > rcx_2)
{
if (*(arg2 + 0x28))
*(arg2 + 0x28) = 0;
label_140009baa:
*sub_140007fb4() = 0x22;
*(arg2 + 0x28) = 0;
*(arg2 + 0x18) = 0;
return 0x22;
}
int64_t var_10_2 = 0;
int64_t var_18_2 = 0;
int64_t rax_9 =
__acrt_WideCharToMultiByte(arg4, 0, arg1, 0xffffffff, *(arg2 + 0x10), rcx_2);
if (!rax_9)
{
sub_140007f44(GetLastError());
return *sub_140007fb4();
}
*(arg2 + 0x20) = rax_9 - 1;
}
else
{
if (!*(arg2 + 0x18))
{
if (*(arg2 + 0x28))
*(arg2 + 0x28) = 0;
goto label_140009baa;
}
**(arg2 + 0x10) = 0;
}
return 0;
}
uint64_t __acrt_GetModuleFileNameA(HMODULE arg1, int64_t arg2, int32_t arg3)
{
void var_2a8;
int64_t rax_1 = __security_cookie ^ &var_2a8;
uint64_t rdi = arg3;
void filename;
uint64_t result;
if (GetModuleFileNameW(arg1, &filename, 0x105))
{
int32_t result_1 = 0;
int64_t var_260 = arg2;
uint64_t var_258_1 = rdi;
uint64_t var_248_1 = rdi;
int64_t var_250_1 = arg2;
char var_238_1 = 0;
void* var_280;
_LocaleUpdate::_LocaleUpdate(&var_280, nullptr);
uint32_t r9_1 = 0xfde9;
void* var_278;
char var_268;
if (*(var_278 + 0xc) != 0xfde9)
{
int32_t rax_7 = sub_14000bf44();
if (rax_7)
{
if (var_268)
{
void* rax_9 = var_280;
*(rax_9 + 0x3a8) &= 0xfffffffd;
}
r9_1 = 0;
}
else
{
if (var_268 != rax_7)
{
void* rax_8 = var_280;
*(rax_8 + 0x3a8) &= 0xfffffffd;
}
r9_1 = 1;
}
}
else if (var_268)
{
void* rax_6 = var_280;
*(rax_6 + 0x3a8) &= 0xfffffffd;
}
void var_288;
__acrt_convert_wcs_mbs_cp<wchar_t,char,class <lambda_f788ae46380686e8b737efdd8c720d07>,struct __crt_win32_buffer_no_resizing>(
&filename, &var_260, &var_288, r9_1);
result = result_1;
}
else
{
sub_140007f44(GetLastError());
result = 0;
}
__security_check_cookie(rax_1 ^ &var_2a8);
return result;
}
int64_t __crt_seh_guarded_call<class <lambda_efdfa57d1f175319df784efa44bb7b81>,class <lambda_5f0a4c1567f8adc6734073e5d1e1b35c>& __ptr64,class <lambda_2e8a7d3640ea6ccb4c2413664c2db6fd>,void>::operator()<class <lambda_efdfa57d1f175319df784efa44bb7b81>,class <lambda_5f0a4c1567f8adc6734073e5d1e1b35c>& __ptr64,class <lambda_2e8a7d3640ea6ccb4c2413664c2db6fd> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
int128_t* rax_2 = *(**arg3 + 0x88) + 0x18;
int128_t* arg_10 = rax_2;
char* rcx_2 = data_14001e3e0;
char* var_28 = rcx_2;
if (!rcx_2)
goto label_140009e44;
int64_t i_2;
if (!rax_2)
{
sub_140010a60(rcx_2, 0, 0x101);
label_140009e44:
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
i_2 = 2;
}
else
{
i_2 = 2;
int64_t i_3 = 2;
int64_t i;
do
{
*rcx_2 = *rax_2;
*(rcx_2 + 0x10) = rax_2[1];
*(rcx_2 + 0x20) = rax_2[2];
*(rcx_2 + 0x30) = rax_2[3];
*(rcx_2 + 0x40) = rax_2[4];
*(rcx_2 + 0x50) = rax_2[5];
*(rcx_2 + 0x60) = rax_2[6];
rcx_2 = &rcx_2[0x80];
*(rcx_2 - 0x10) = rax_2[7];
rax_2 = &rax_2[8];
i = i_3;
i_3 -= 1;
} while (i != 1);
rax_2 = *rax_2;
*rcx_2 = rax_2;
}
int128_t* rax_6 = *(**arg3 + 0x88) + 0x119;
int128_t* var_20 = rax_6;
int128_t* rcx_4 = data_14001e3e8;
int128_t* var_18 = rcx_4;
if (!rcx_4)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
else if (!rax_6)
{
sub_140010a60(rcx_4, 0, 0x100);
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
else
{
int64_t i_1;
do
{
*rcx_4 = *rax_6;
rcx_4[1] = rax_6[1];
rcx_4[2] = rax_6[2];
rcx_4[3] = rax_6[3];
rcx_4[4] = rax_6[4];
rcx_4[5] = rax_6[5];
rcx_4[6] = rax_6[6];
rcx_4 = &rcx_4[8];
rcx_4[-1] = rax_6[7];
rax_6 = &rax_6[8];
i_1 = i_2;
i_2 -= 1;
} while (i_1 != 1);
}
int32_t* rdx = **arg3[1];
int32_t rax_9 = *rdx;
*rdx -= 1;
if (rax_9 == 1)
{
int64_t* rcx_6 = *arg3[1];
if (*rcx_6 != &data_14001d460)
_free_base(*rcx_6);
}
**arg3[1] = *(**arg3 + 0x88);
int32_t* rax_15 = *(**arg3 + 0x88);
*rax_15 += 1;
return __vcrt_lock(*arg4);
}
uint64_t getSystemCP(uint32_t arg1)
{
uint32_t rbx = arg1;
void* var_28;
_LocaleUpdate::_LocaleUpdate(&var_28, nullptr);
data_14001e3f8 = 0;
if (rbx == 0xfffffffe)
{
data_14001e3f8 = 1;
rbx = GetOEMCP();
}
else if (rbx == 0xfffffffd)
{
data_14001e3f8 = 1;
rbx = GetACP();
}
else if (rbx == 0xfffffffc)
{
data_14001e3f8 = 1;
void* var_20;
rbx = *(var_20 + 0xc);
}
char var_10;
if (var_10)
{
void* rcx_1 = var_28;
*(rcx_1 + 0x3a8) &= 0xfffffffd;
}
return rbx;
}
int64_t setSBCS(void* arg1)
{
sub_140010a60(arg1 + 0x18, 0, 0x101);
int64_t i_1 = 0;
*(arg1 + 4) = 0;
*(arg1 + 0x220) = 0;
__builtin_memset(arg1 + 0xc, 0, 0xc);
for (int64_t i = 0; i < 0x101; )
{
void* rcx_1 = i + &data_14001d460;
i += 1;
*(arg1 - &data_14001d478 + rcx_1 + 0x30) = *(rcx_1 + 0x18);
}
char result;
do
{
void* rcx_2 = i_1 + &data_14001d460;
i_1 += 1;
result = *(rcx_2 + 0x119);
*(arg1 - &data_14001d579 + rcx_2 + 0x232) = result;
} while (i_1 < 0x100);
return result;
}
void* sub_14000a074(void* arg1)
{
void var_788;
int64_t rax_1 = __security_cookie ^ &var_788;
uint32_t CodePage = *(arg1 + 4);
CPINFO cPInfo;
cPInfo.LeadByte[0xa] = 0;
cPInfo.LeadByte[0xb] = 0;
cPInfo.MaxCharSize = 0;
cPInfo.DefaultChar[0] = 0;
cPInfo.DefaultChar[1] = 0;
cPInfo.LeadByte[0] = 0;
cPInfo.LeadByte[1] = 0;
cPInfo.LeadByte[2] = 0;
cPInfo.LeadByte[3] = 0;
cPInfo.LeadByte[4] = 0;
cPInfo.LeadByte[5] = 0;
cPInfo.LeadByte[6] = 0;
cPInfo.LeadByte[7] = 0;
cPInfo.LeadByte[8] = 0;
cPInfo.LeadByte[9] = 0;
BOOL rax_2;
if (CodePage != 0xfde9)
rax_2 = GetCPInfo(CodePage, &cPInfo);
void* result;
if (CodePage == 0xfde9 || !rax_2)
{
int32_t i = 0;
void* rcx_3 = arg1 + 0x19;
do
{
if (i - 0x41 <= 0x19)
{
*rcx_3 |= 0x10;
result = i + 0x20;
}
else if (i - 0x61 > 0x19)
result = 0;
else
{
*rcx_3 |= 0x20;
result = i - 0x20;
}
*(rcx_3 + 0x100) = result;
i += 1;
rcx_3 += 1;
} while (i < 0x100);
}
else
{
int32_t i_1 = 0;
char var_718[0x90];
char (* rcx)[0x90] = &var_718;
int64_t i_4 = 0x100;
do
{
*rcx = i_1;
i_1 += 1;
rcx = &(*rcx)[1];
} while (i_1 < 0x100);
i_1 = cPInfo.LeadByte[0];
BYTE (* rdx_2)[0xc] = &cPInfo.LeadByte;
var_718[0] = 0x20;
while (i_1)
{
uint32_t i_2 = (*rdx_2)[1];
uint64_t rcx_1 = i_1;
while (rcx_1 <= i_2)
{
if (rcx_1 >= 0x100)
break;
var_718[rcx_1] = 0x20;
rcx_1 = rcx_1 + 1;
}
rdx_2 = &(*rdx_2)[2];
i_1 = *rdx_2;
}
uint16_t var_418[0x200];
__acrt_GetStringTypeA(nullptr, 1, &var_718, 0x100, &var_418, *(arg1 + 4), 0);
uint32_t var_760_1;
void var_618;
var_760_1 = &var_618;
uint16_t* var_768_1;
var_768_1 = 0x100;
__acrt_LCMapStringA(nullptr, *(arg1 + 0x220), 0x100, &var_718, var_768_1, var_760_1, 0x100,
*(arg1 + 4), 0);
void var_518;
var_760_1 = &var_518;
var_768_1 = 0x100;
__acrt_LCMapStringA(nullptr, *(arg1 + 0x220), 0x200, &var_718, var_768_1, var_760_1, 0x100,
*(arg1 + 4), 0);
uint16_t (* rdx_5)[0x200] = &var_418;
result = arg1 + 0x19;
int64_t i_3;
do
{
char rcx_2;
if (*rdx_5 & 1)
{
*result |= 0x10;
rcx_2 = *(&var_618 - arg1 + result - 0x19);
}
else if (!(*rdx_5 & 2))
rcx_2 = 0;
else
{
*result |= 0x20;
rcx_2 = *(result + &var_518 - arg1 - 0x19);
}
*(result + 0x100) = rcx_2;
rdx_5 = &(*rdx_5)[1];
result += 1;
i_3 = i_4;
i_4 -= 1;
} while (i_3 != 1);
}
__security_check_cookie(rax_1 ^ &var_788);
return result;
}
uint64_t setmbcp_internal(uint32_t arg1, char arg2, void* arg3, int64_t* arg4)
{
int64_t* arg_20 = arg4;
void* arg_18 = arg3;
int64_t r14;
r14 = arg2;
update_thread_multibyte_data_internal(arg3, arg4);
uint32_t rax = getSystemCP(arg1);
if (rax == *(*(arg_18 + 0x88) + 4))
return 0;
int128_t* rax_2 = _malloc_base(0x228);
if (!rax_2)
{
_free_base(0);
return 0xffffffff;
}
void var_248;
void* rcx_3 = &var_248;
int64_t i_2 = 4;
int64_t i_3 = 4;
int128_t* rax_4 = *(arg_18 + 0x88);
int128_t zmm0_1;
int128_t zmm1;
int64_t i;
do
{
zmm1 = rax_4[1];
*rcx_3 = *rax_4;
zmm0_1 = rax_4[2];
*(rcx_3 + 0x10) = zmm1;
zmm1 = rax_4[3];
*(rcx_3 + 0x20) = zmm0_1;
zmm0_1 = rax_4[4];
*(rcx_3 + 0x30) = zmm1;
zmm1 = rax_4[5];
*(rcx_3 + 0x40) = zmm0_1;
zmm0_1 = rax_4[6];
*(rcx_3 + 0x50) = zmm1;
zmm1 = rax_4[7];
rax_4 = &rax_4[8];
*(rcx_3 + 0x60) = zmm0_1;
rcx_3 += 0x80;
*(rcx_3 - 0x10) = zmm1;
i = i_3;
i_3 -= 1;
} while (i != 1);
zmm1 = rax_4[1];
int64_t rax_5 = rax_4[2];
*rcx_3 = *rax_4;
*(rcx_3 + 0x10) = zmm1;
*(rcx_3 + 0x20) = rax_5;
int128_t* rcx_4 = rax_2;
void* rax_6 = &var_248;
int64_t i_1;
do
{
zmm1 = *(rax_6 + 0x10);
*rcx_4 = *rax_6;
zmm0_1 = *(rax_6 + 0x20);
rcx_4[1] = zmm1;
zmm1 = *(rax_6 + 0x30);
rcx_4[2] = zmm0_1;
zmm0_1 = *(rax_6 + 0x40);
rcx_4[3] = zmm1;
zmm1 = *(rax_6 + 0x50);
rcx_4[4] = zmm0_1;
zmm0_1 = *(rax_6 + 0x60);
rcx_4[5] = zmm1;
zmm1 = *(rax_6 + 0x70);
rax_6 += 0x80;
rcx_4[6] = zmm0_1;
rcx_4 = &rcx_4[8];
rcx_4[-1] = zmm1;
i_1 = i_2;
i_2 -= 1;
} while (i_1 != 1);
zmm1 = *(rax_6 + 0x10);
int64_t rax_7 = *(rax_6 + 0x20);
*rcx_4 = *rax_6;
rcx_4[1] = zmm1;
rcx_4[2] = rax_7;
*rax_2 &= i_2;
int32_t rax_8 = sub_14000a610(rax, rax_2);
if (rax_8 == 0xffffffff)
{
*sub_140007fb4() = 0x16;
_free_base(rax_2);
return 0xffffffff;
}
if (!r14)
Concurrency::details::WinRT::Initialize();
int32_t* rcx_7 = *(arg_18 + 0x88);
int32_t rax_11 = *rcx_7;
*rcx_7 -= 1;
if (rax_11 == 1)
{
int64_t rcx_8 = *(arg_18 + 0x88);
if (rcx_8 != &data_14001d460)
_free_base(rcx_8);
}
*rax_2 = 1;
*(arg_18 + 0x88) = rax_2;
if (!(data_14001da90 & *(arg_18 + 0x3a8)))
{
void** var_258 = &arg_18;
int64_t** var_250_1 = &arg_20;
int32_t var_264 = 5;
int32_t var_260 = 5;
void var_268;
__crt_seh_guarded_call<class <lambda_efdfa57d1f175319df784efa44bb7b81>,class <lambda_5f0a4c1567f8adc6734073e5d1e1b35c>& __ptr64,class <lambda_2e8a7d3640ea6ccb4c2413664c2db6fd>,void>::operator()<class <lambda_efdfa57d1f175319df784efa44bb7b81>,class <lambda_5f0a4c1567f8adc6734073e5d1e1b35c>& __ptr64,class <lambda_2e8a7d3640ea6ccb4c2413664c2db6fd> >(
&var_268, &var_260, &var_258, &var_264);
if (r14)
data_14001d340 = *arg_20;
}
_free_base(0);
return rax_8;
}
int32_t* update_thread_multibyte_data_internal(void* arg1, int64_t* arg2)
{
int32_t* result;
if (!(*(arg1 + 0x3a8) & data_14001da90) || !*(arg1 + 0x90))
{
__vcrt_unlock(5);
result = *(arg1 + 0x88);
if (result != *arg2)
{
if (result)
{
int32_t rax_1 = *result;
*result -= 1;
if (rax_1 == 1 && result != &data_14001d460)
_free_base(result);
}
int32_t* result_1 = *arg2;
*(arg1 + 0x88) = result_1;
*result_1 += 1;
result = result_1;
}
__vcrt_lock(5);
}
else
result = *(arg1 + 0x88);
if (result)
return result;
abort();
/* no return */
}
uint64_t __acrt_initialize_multibyte()
{
if (!data_14001e3fc)
{
data_14001e3e8 = &data_14001d7a0;
data_14001e3f0 = &data_14001d460;
data_14001e3e0 = &data_14001d690;
setmbcp_internal(0xfffffffd, 1, sub_140007cdc(), &data_14001e3f0);
data_14001e3fc = 1;
}
uint64_t result;
result = 1;
return result;
}
int64_t __acrt_update_thread_multibyte_data()
{
/* tailcall */
return update_thread_multibyte_data_internal(__vcrt_getptd(), &data_14001e3f0);
}
int64_t sub_14000a610(uint32_t arg1, void* arg2)
{
void var_68;
int64_t rax_1 = __security_cookie ^ &var_68;
CPINFO cPInfo;
cPInfo.MaxCharSize = 0;
cPInfo.DefaultChar[0] = 0;
cPInfo.DefaultChar[1] = 0;
cPInfo.LeadByte[0] = 0;
cPInfo.LeadByte[1] = 0;
cPInfo.LeadByte[2] = 0;
cPInfo.LeadByte[3] = 0;
cPInfo.LeadByte[4] = 0;
cPInfo.LeadByte[5] = 0;
cPInfo.LeadByte[6] = 0;
cPInfo.LeadByte[7] = 0;
cPInfo.LeadByte[8] = 0;
cPInfo.LeadByte[9] = 0;
cPInfo.LeadByte[0xa] = 0;
cPInfo.LeadByte[0xb] = 0;
uint32_t CodePage = getSystemCP(arg1);
wchar16 const* const rbx = nullptr;
int64_t result;
if (!CodePage)
{
setSBCS(arg2);
result = 0;
}
else
{
int32_t i = 0;
void* rax_2 = &data_14001d8b0;
int32_t rbp_1 = 1;
do
{
if (*rax_2 == CodePage)
{
sub_140010a60(arg2 + 0x18, 0, 0x101);
void* r15_1 = &data_14001d8a0;
int64_t j_3 = 4;
uint64_t r11_2 = i * 0x30;
void* r9_1 = &data_14001d8c0 + r11_2;
int64_t j;
do
{
void* rdx_2 = r9_1;
if (*r9_1)
{
while (*(rdx_2 + 1))
{
uint32_t r8_1 = *rdx_2;
if (r8_1 <= *(rdx_2 + 1))
{
uint64_t r10_1 = r8_1 + 1;
while (r10_1 < 0x101)
{
uint32_t rax_10;
rax_10 = *r15_1;
r8_1 += 1;
*(r10_1 + arg2 + 0x18) |= rax_10;
r10_1 = r10_1 + 1;
if (r8_1 > *(rdx_2 + 1))
break;
}
}
rdx_2 += 2;
if (!*rdx_2)
break;
}
}
r9_1 += 8;
r15_1 += 1;
j = j_3;
j_3 -= 1;
} while (j != 1);
*(arg2 + 4) = CodePage;
*(arg2 + 8) = 1;
if (CodePage == 0x3a4)
rbx = u"ja-JP";
else if (CodePage == 0x3a8)
rbx = u"zh-CN";
else if (CodePage == 0x3b5)
rbx = u"ko-KR";
else if (CodePage == 0x3b6)
rbx = u"zh-TW";
*(arg2 + 0x220) = rbx;
void* rdx_3 = arg2 + 0xc;
int64_t j_2 = 6;
int64_t j_1;
do
{
*rdx_3 = *(r11_2 - arg2 + &data_14001d8b0 + rdx_3 - 8);
rdx_3 += 2;
j_1 = j_2;
j_2 -= 1;
} while (j_1 != 1);
goto label_14000a8a1;
}
i += 1;
rax_2 += 0x30;
} while (i < 5);
if (CodePage == 0xfde8)
result = 0xffffffff;
else if (!IsValidCodePage(CodePage))
result = 0xffffffff;
else if (CodePage != 0xfde9)
{
if (GetCPInfo(CodePage, &cPInfo))
{
sub_140010a60(arg2 + 0x18, 0, 0x101);
bool cond:0_1 = cPInfo.MaxCharSize != 2;
*(arg2 + 4) = CodePage;
*(arg2 + 0x220) = 0;
if (cond:0_1)
rbp_1 = 0;
else
{
BYTE (* rcx_3)[0xc] = &cPInfo.LeadByte;
if (cPInfo.LeadByte[0])
{
while ((*rcx_3)[1])
{
uint32_t rax_5 = (*rcx_3)[1];
uint32_t rdx_1 = *rcx_3;
if (rdx_1 <= rax_5)
{
uint64_t rdi_2 = rdx_1 + 1;
uint64_t i_4 = rax_5 - rdx_1 + 1;
uint64_t i_1;
do
{
*(rdi_2 + arg2 + 0x18) |= 4;
rdi_2 = rdi_2 + 1;
i_1 = i_4;
i_4 -= 1;
} while (i_1 != 1);
}
rcx_3 = &(*rcx_3)[2];
if (!*rcx_3)
break;
}
}
void* rax_7 = arg2 + 0x1a;
int64_t i_3 = 0xfe;
int64_t i_2;
do
{
*rax_7 |= 8;
rax_7 += 1;
i_2 = i_3;
i_3 -= 1;
} while (i_2 != 1);
int32_t rcx_4 = *(arg2 + 4);
wchar16 const* const rax_8;
if (rcx_4 == 0x3a4)
rax_8 = u"ja-JP";
else if (rcx_4 == 0x3a8)
rax_8 = u"zh-CN";
else if (rcx_4 == 0x3b5)
rax_8 = u"ko-KR";
else if (rcx_4 == 0x3b6)
rax_8 = u"zh-TW";
else
rax_8 = nullptr;
*(arg2 + 0x220) = rax_8;
}
*(arg2 + 8) = rbp_1;
goto label_14000a6c0;
}
if (data_14001e3f8)
{
setSBCS(arg2);
result = 0;
}
else
result = 0xffffffff;
}
else
{
*(arg2 + 4) = 0xfde9;
*(arg2 + 0x220) = 0;
*(arg2 + 0x18) = 0;
*(arg2 + 0x1c) = 0;
label_14000a6c0:
__builtin_memset(arg2 + 0xc, 0, 0xc);
label_14000a8a1:
sub_14000a074(arg2);
result = 0;
}
}
__security_check_cookie(rax_1 ^ &var_68);
return result;
}
int64_t x_ismbbtype_l(int128_t* arg1, char arg2, int32_t arg3, char arg4)
{
void* var_28;
_LocaleUpdate::_LocaleUpdate(&var_28, arg1);
uint64_t rdx_1 = arg2;
int64_t* var_20;
int64_t var_18;
int64_t result;
if (*(rdx_1 + var_18 + 0x19) & arg4 || (arg3 && arg3 & *(*var_20 + (rdx_1 << 1))))
result = 1;
else
result = 0;
char var_10;
if (var_10)
{
void* rcx_2 = var_28;
*(rcx_2 + 0x3a8) &= 0xfffffffd;
}
return result;
}
int64_t _ismbblead(char arg1)
{
/* tailcall */
return x_ismbbtype_l(nullptr, arg1, 0, 4);
}
PWSTR __acrt_initialize_command_line()
{
data_14001e420 = GetCommandLineA();
data_14001e428 = GetCommandLineW();
PWSTR result;
result = 1;
return result;
}
int64_t __acrt_MultiByteToWideChar(uint32_t arg1, enum MULTI_BYTE_TO_WIDE_CHAR_FLAGS arg2, uint8_t* arg3, int64_t arg4)
{
if (arg1 > 0xdeac)
{
if (arg1 == 0xdead || arg1 == 0xdeae || arg1 == 0xdeaf || arg1 == 0xdeb0 || arg1 == 0xdeb1
|| arg1 == 0xdeb2 || arg1 == 0xdeb3 || arg1 == 0xfde8)
arg2 = 0;
else if (arg1 == 0xfde9)
arg2 &= MB_ERR_INVALID_CHARS;
}
else if (arg1 == 0xdeac)
arg2 = 0;
else
{
bool cond:2_1;
if (arg1 <= 0xc433)
{
if (arg1 != 0xc433 && arg1 != 0x2a && arg1 != 0xc42c && arg1 != 0xc42d
&& arg1 != 0xc42e)
{
cond:2_1 = arg1 != 0xc431;
goto label_14000a9d5;
}
arg2 = 0;
}
else if (arg1 == 0xc435)
arg2 = 0;
else if (arg1 == 0xd698)
arg2 &= MB_ERR_INVALID_CHARS;
else if (arg1 == 0xdeaa)
arg2 = 0;
else
{
cond:2_1 = arg1 != 0xdeab;
label_14000a9d5:
if (!cond:2_1)
arg2 = 0;
}
}
/* tailcall */
return MultiByteToWideChar(arg1, arg2, arg3, arg4);
}
int64_t __acrt_WideCharToMultiByte(uint32_t arg1, int32_t arg2, wchar16* arg3, int32_t arg4, int64_t arg5, int32_t* arg6)
{
bool cond:0 = arg1 - 0xfde8 <= 1;
uint64_t rdx;
int32_t rax_9;
bool cond:3_1;
if (arg1 > 0xdeac)
{
if (arg1 != 0xdead && arg1 != 0xdeae && arg1 != 0xdeaf && arg1 != 0xdeb0 && arg1 != 0xdeb1
&& arg1 != 0xdeb2 && arg1 != 0xdeb3)
{
rax_9 = arg1 - 0xfde8;
cond:3_1 = arg1 == 0xfde8;
goto label_14000aaa9;
}
rdx = 0;
}
else if (arg1 == 0xdeac)
rdx = 0;
else
{
bool cond:7_1;
if (arg1 <= 0xc433)
{
if (arg1 != 0xc433 && arg1 != 0x2a && arg1 != 0xc42c && arg1 != 0xc42d
&& arg1 != 0xc42e)
{
cond:7_1 = arg1 == 0xc431;
goto label_14000aaae;
}
rdx = 0;
}
else if (arg1 == 0xc435 || arg1 == 0xd698)
rdx = 0;
else
{
rax_9 = arg1 - 0xdeaa;
cond:3_1 = arg1 == 0xdeaa;
label_14000aaa9:
if (cond:3_1)
rdx = 0;
else
{
cond:7_1 = rax_9 == 1;
label_14000aaae:
rdx = cond:7_1 ? 0 : arg2 & 0xffffff7f;
}
}
}
int64_t r9 = arg5;
int32_t* r8 = arg6;
if (cond:0)
r8 = nullptr;
if (cond:0)
r9 = 0;
if (cond:0 && arg6)
*arg6 = 0;
arg6 = r8;
arg5 = r9;
/* tailcall */
return WideCharToMultiByte(arg1, rdx, arg3, arg4);
}
int64_t __dcrt_get_narrow_environment_from_os()
{
PWSTR penv = GetEnvironmentStringsW();
int64_t result = 0;
if (penv)
{
PWSTR penv_1 = penv;
if (*penv)
{
do
{
int64_t rax = -1;
do
rax += 1;
while (penv_1[rax]);
penv_1 = &penv_1[rax + 1];
} while (*penv_1);
}
int64_t var_10_1 = 0;
int64_t var_18_1 = 0;
int32_t rbp_4 = (penv_1 - penv + 2) >> 1;
int32_t rax_1 = __acrt_WideCharToMultiByte(0, 0, penv, rbp_4, 0, nullptr);
int64_t r14_1 = rax_1;
if (rax_1)
{
int64_t result_1 = _malloc_base(r14_1);
if (result_1)
{
int64_t var_10_2 = 0;
int64_t var_18_2 = 0;
if (__acrt_WideCharToMultiByte(0, 0, penv, rbp_4, result_1, r14_1))
{
_free_base(0);
result = result_1;
}
else
_free_base(result_1);
FreeEnvironmentStringsW(penv);
return result;
}
_free_base(0);
}
FreeEnvironmentStringsW(penv);
}
return 0;
}
BOOL sub_14000ac08()
{
uint64_t rbx = 0;
BOOL result;
while (true)
{
if (!InitializeCriticalSectionEx(&data_14001e430 + rbx * 0x28, 0xfa0, 0))
{
sub_14000ac6c();
result = 0;
break;
}
data_14001e688 += 1;
rbx = rbx + 1;
if (rbx >= 0xf)
{
result = 1;
break;
}
}
return result;
}
int64_t __vcrt_unlock(int32_t arg1)
{
/* tailcall */
return EnterCriticalSection(&data_14001e430 + arg1 * 0x28);
}
int64_t sub_14000ac6c()
{
uint64_t rbx = data_14001e688;
while (rbx)
{
rbx = rbx - 1;
DeleteCriticalSection(&data_14001e430 + rbx * 0x28);
data_14001e688 -= 1;
}
int64_t result;
result = 1;
return result;
}
int64_t __vcrt_lock(int32_t arg1)
{
/* tailcall */
return LeaveCriticalSection(&data_14001e430 + arg1 * 0x28);
}
uint8_t __acrt_app_verifier_enabled()
{
TEB* gsbase;
return gsbase->NtTib.Self->ProcessEnvironmentBlock->NtGlobalFlag >> 8 & 1;
}
uint64_t __acrt_is_secure_process()
{
TEB* gsbase;
return gsbase->NtTib.Self->ProcessEnvironmentBlock->ProcessParameters->Flags >> 0x1f;
}
int64_t __acrt_get_process_end_policy()
{
int32_t arg_8 = 0;
if (!__acrt_is_secure_process())
sub_14000bee8();
return 1;
}
void* __acrt_lowio_create_handle_array()
{
void* result_1 = _calloc_base(0x40, 0x48);
void* result = nullptr;
if (result_1)
{
if (result_1 != result_1 + 0x1200)
{
int64_t* rdi_1 = result_1 + 0x30;
do
{
InitializeCriticalSectionEx(&rdi_1[-6], 0xfa0, 0);
rdi_1[-1] = -1;
void* rcx_2 = rdi_1 + 0xe;
*(rdi_1 + 0xd) &= 0xf8;
int32_t i = 0;
*rdi_1 = 0;
rdi_1[1] = 0xa0a0000;
*(rdi_1 + 0xc) = 0xa;
do
{
*rcx_2 = 0;
i += 1;
rcx_2 += 1;
} while (i < 5);
rdi_1 = &rdi_1[9];
} while (&rdi_1[-6] != result_1 + 0x1200);
}
result = result_1;
}
_free_base(0);
return result;
}
void __acrt_lowio_destroy_handle_array(CRITICAL_SECTION* arg1)
{
if (!arg1)
return;
CRITICAL_SECTION* lpCriticalSection = arg1;
if (arg1 != arg1 + 0x1200)
{
do
{
DeleteCriticalSection(lpCriticalSection);
lpCriticalSection += 0x48;
} while (lpCriticalSection != arg1 + 0x1200);
}
_free_base(arg1);
}
uint64_t __acrt_lowio_ensure_fh_exists(int32_t arg1)
{
if (arg1 >= 0x2000)
{
*sub_140007fb4() = 9;
_invalid_parameter_noinfo();
return 9;
}
int32_t rdi_1 = 0;
__vcrt_unlock(7);
int64_t rbx_1 = 0;
int32_t rax_2 = data_14001ea90;
while (true)
{
int64_t var_18_1 = rbx_1;
if (arg1 < rax_2)
break;
if (!(&data_14001e690)[rbx_1])
{
void* rax_3 = __acrt_lowio_create_handle_array();
(&data_14001e690)[rbx_1] = rax_3;
if (!rax_3)
{
rdi_1 = rax_3 + 0xc;
break;
}
rax_2 = data_14001ea90 + 0x40;
data_14001ea90 = rax_2;
}
rbx_1 += 1;
}
__vcrt_lock(7);
return rdi_1;
}
int64_t __acrt_lowio_unlock_fh(int32_t arg1)
{
int64_t rdx_2 = arg1;
/* tailcall */
return EnterCriticalSection((&data_14001e690)[rdx_2 >> 6] + (rdx_2 & 0x3f) * 0x48);
}
int64_t __acrt_lowio_set_os_handle(int32_t arg1, HANDLE arg2)
{
int64_t rbx = arg1;
if (arg1 >= 0 && rbx < data_14001ea90)
{
uint64_t rsi_2 = rbx >> 6;
uint64_t rbp_1 = (rbx & 0x3f) * 9;
if (*((&data_14001e690)[rsi_2] + (rbp_1 << 3) + 0x28) == -1)
{
int32_t rax_4 = sub_1400056ec();
if (rax_4 == 1)
{
if (!rbx)
SetStdHandle(STD_INPUT_HANDLE, arg2);
else if (rbx == rax_4)
SetStdHandle(STD_OUTPUT_HANDLE, arg2);
else if (rbx - rax_4 == rax_4)
SetStdHandle(STD_ERROR_HANDLE, arg2);
}
*((&data_14001e690)[rsi_2] + (rbp_1 << 3) + 0x28) = arg2;
return 0;
}
}
*sub_140007fb4() = 9;
*sub_140007f90() = 0;
return 0xffffffff;
}
int64_t sub_14000afac(int32_t arg1)
{
int64_t rdx_2 = arg1;
/* tailcall */
return LeaveCriticalSection((&data_14001e690)[rdx_2 >> 6] + (rdx_2 & 0x3f) * 0x48);
}
uint64_t _alloc_osfhnd()
{
__vcrt_unlock(7);
int32_t r14 = -1;
int32_t rbx = 0;
label_14000b004:
int32_t var_28_1 = rbx;
if (rbx < 0x80)
{
int64_t rdi_1 = rbx;
void* lpCriticalSection_2 = (&data_14001e690)[rdi_1];
if (lpCriticalSection_2)
{
void* lpCriticalSection = lpCriticalSection_2;
void* lpCriticalSection_3 = lpCriticalSection_2;
while (true)
{
if (lpCriticalSection == lpCriticalSection_2 + 0x1200)
{
rbx += 1;
goto label_14000b004;
}
if (!(*(lpCriticalSection + 0x38) & 1))
{
EnterCriticalSection(lpCriticalSection);
if (!(*(lpCriticalSection + 0x38) & 1))
{
int32_t rdx_4 =
(lpCriticalSection - lpCriticalSection_2) / 0x48 + (rbx << 6);
int64_t rax_8 = rdx_4;
int64_t r8_2 = rax_8 >> 6;
uint64_t rcx_4 = (rax_8 & 0x3f) * 9;
*((&data_14001e690)[r8_2] + (rcx_4 << 3) + 0x38) = 1;
*((&data_14001e690)[r8_2] + (rcx_4 << 3) + 0x28) = -1;
r14 = rdx_4;
break;
}
LeaveCriticalSection(lpCriticalSection);
}
lpCriticalSection += 0x48;
void* lpCriticalSection_1 = lpCriticalSection;
}
}
else
{
void* rax_1 = __acrt_lowio_create_handle_array();
(&data_14001e690)[rdi_1] = rax_1;
if (rax_1)
{
data_14001ea90 += 0x40;
int32_t rbx_1 = rbx << 6;
__acrt_lowio_unlock_fh(rbx_1);
*((&data_14001e690)[rbx_1 >> 6] + 0x38) = 1;
r14 = rbx_1;
}
}
}
__vcrt_lock(7);
return r14;
}
int64_t _free_osfhnd(int32_t arg1)
{
int64_t rbx = arg1;
if (arg1 >= 0 && rbx < data_14001ea90)
{
uint64_t rsi_2 = rbx >> 6;
uint64_t rdi_1 = (rbx & 0x3f) * 9;
int64_t rax_3 = (&data_14001e690)[rsi_2];
if (*(rax_3 + (rdi_1 << 3) + 0x38) & 1 && *(rax_3 + (rdi_1 << 3) + 0x28) != -1)
{
int32_t rax_4 = sub_1400056ec();
if (rax_4 == 1)
{
if (!rbx)
SetStdHandle(STD_INPUT_HANDLE, nullptr);
else if (rbx == rax_4)
SetStdHandle(STD_OUTPUT_HANDLE, nullptr);
else if (rbx - rax_4 == rax_4)
SetStdHandle(STD_ERROR_HANDLE, nullptr);
}
*((&data_14001e690)[rsi_2] + (rdi_1 << 3) + 0x28) = -1;
return 0;
}
}
*sub_140007fb4() = 9;
*sub_140007f90() = 0;
return 0xffffffff;
}
int64_t _get_osfhandle(int32_t arg1)
{
if (arg1 != 0xfffffffe)
{
if (arg1 >= 0 && arg1 < data_14001ea90)
{
int64_t rcx = arg1;
uint64_t rdx_1 = (rcx & 0x3f) * 9;
int64_t rax_5 = (&data_14001e690)[rcx >> 6];
if (*(rax_5 + (rdx_1 << 3) + 0x38) & 1)
return *(rax_5 + (rdx_1 << 3) + 0x28);
}
*sub_140007f90() = 0;
*sub_140007fb4() = 9;
_invalid_parameter_noinfo();
}
else
{
*sub_140007f90() = 0;
*sub_140007fb4() = 9;
}
return -1;
}
int64_t sub_14000b248()
{
if (!data_14001e68c)
data_14001e68c = 0x4000;
return 0;
}
int32_t* sub_14000b260()
{
void startupInfo;
sub_140010a60(&startupInfo, 0, 0x68);
int32_t* result = GetStartupInfoW(&startupInfo);
int16_t var_36;
if (var_36)
{
int32_t* result_1;
result = result_1;
if (result)
{
void* rsi_1 = &result[1];
uint64_t i_1 = 0x2000;
void* rbx_2 = *result + rsi_1;
if (*result < 0x2000)
i_1 = *result;
result = __acrt_lowio_ensure_fh_exists(i_1);
if (i_1 > data_14001ea90)
i_1 = data_14001ea90;
if (i_1)
{
int64_t rbp_1 = 0;
uint64_t i;
do
{
if (*rbx_2 != -1 && *rbx_2 != -2 && *rsi_1 & 1)
{
if (!(*rsi_1 & 8))
result = GetFileType(*rbx_2);
if (*rsi_1 & 8 || result)
{
int64_t rcx_6 = (&data_14001e690)[rbp_1 >> 6];
uint64_t rdx_1 = (rbp_1 & 0x3f) * 9;
*(rcx_6 + (rdx_1 << 3) + 0x28) = *rbx_2;
result = *rsi_1;
*(rcx_6 + (rdx_1 << 3) + 0x38) = result;
}
}
rbp_1 += 1;
rsi_1 += 1;
rbx_2 += 8;
i = i_1;
i_1 -= 1;
} while (i != 1);
}
}
}
return result;
}
uint64_t initialize_stdio_handles_nolock()
{
int32_t i = 0;
int64_t r14 = 0;
uint64_t result;
do
{
int64_t i_1 = i;
uint64_t rbx_1 = (i_1 & 0x3f) * 9;
int64_t rdi_1 = (&data_14001e690)[i_1 >> 6];
result = *(rdi_1 + (rbx_1 << 3) + 0x28) + 2;
if (result <= 1)
{
*(rdi_1 + (rbx_1 << 3) + 0x38) = 0x81;
enum STD_HANDLE nStdHandle;
if (!i)
nStdHandle = STD_INPUT_HANDLE;
else if (i == 1)
nStdHandle = STD_OUTPUT_HANDLE;
else
nStdHandle = STD_ERROR_HANDLE;
HANDLE hFile = GetStdHandle(nStdHandle);
enum FILE_TYPE rax_4;
if (hFile + 1 > 1)
rax_4 = GetFileType(hFile);
if (hFile + 1 <= 1 || !rax_4)
{
*(rdi_1 + (rbx_1 << 3) + 0x38) |= 0x40;
*(rdi_1 + (rbx_1 << 3) + 0x28) = -2;
result = data_14001e3c8;
if (result)
{
result = *(r14 + result);
*(result + 0x18) = 0xfffffffe;
}
}
else
{
result = rax_4;
*(rdi_1 + (rbx_1 << 3) + 0x28) = hFile;
if (result == 2)
*(rdi_1 + (rbx_1 << 3) + 0x38) |= 0x40;
else if (result == 3)
*(rdi_1 + (rbx_1 << 3) + 0x38) |= 8;
}
}
else
*(rdi_1 + (rbx_1 << 3) + 0x38) |= 0x80;
i += 1;
r14 += 8;
} while (i != 3);
return result;
}
int64_t __acrt_initialize_lowio()
{
__vcrt_unlock(7);
char rbx = 0;
if (!__acrt_lowio_ensure_fh_exists(0))
{
sub_14000b260();
initialize_stdio_handles_nolock();
rbx = 1;
}
__vcrt_lock(7);
int64_t result;
result = rbx;
return result;
}
int64_t __acrt_uninitialize_lowio()
{
for (int64_t i = 0; i < 0x400; i += 8)
{
CRITICAL_SECTION* rcx_1 = *(i + &data_14001e690);
if (rcx_1)
{
__acrt_lowio_destroy_handle_array(rcx_1);
*(i + &data_14001e690) = 0;
}
}
int64_t result;
result = 1;
return result;
}
void __acrt_locale_free_monetary(void* arg1)
{
if (!arg1)
return;
int64_t rcx = *(arg1 + 0x18);
if (rcx != data_14001da08)
_free_base(rcx);
int64_t rcx_1 = *(arg1 + 0x20);
if (rcx_1 != data_14001da10)
_free_base(rcx_1);
int64_t rcx_2 = *(arg1 + 0x28);
if (rcx_2 != data_14001da18)
_free_base(rcx_2);
int64_t rcx_3 = *(arg1 + 0x30);
if (rcx_3 != data_14001da20)
_free_base(rcx_3);
int64_t rcx_4 = *(arg1 + 0x38);
if (rcx_4 != data_14001da28)
_free_base(rcx_4);
int64_t rcx_5 = *(arg1 + 0x40);
if (rcx_5 != data_14001da30)
_free_base(rcx_5);
int64_t rcx_6 = *(arg1 + 0x48);
if (rcx_6 != data_14001da38)
_free_base(rcx_6);
int64_t rcx_7 = *(arg1 + 0x68);
if (rcx_7 != data_14001da58)
_free_base(rcx_7);
int64_t rcx_8 = *(arg1 + 0x70);
if (rcx_8 != data_14001da60)
_free_base(rcx_8);
int64_t rcx_9 = *(arg1 + 0x78);
if (rcx_9 != data_14001da68)
_free_base(rcx_9);
int64_t rcx_10 = *(arg1 + 0x80);
if (rcx_10 != data_14001da70)
_free_base(rcx_10);
int64_t rcx_11 = *(arg1 + 0x88);
if (rcx_11 != data_14001da78)
_free_base(rcx_11);
int64_t rcx_12 = *(arg1 + 0x90);
if (rcx_12 != data_14001da80)
_free_base(rcx_12);
}
void __acrt_locale_free_numeric(int64_t* arg1)
{
if (!arg1)
return;
int64_t rcx = *arg1;
if (rcx != data_14001d9f0)
_free_base(rcx);
int64_t rcx_1 = arg1[1];
if (rcx_1 != data_14001d9f8)
_free_base(rcx_1);
int64_t rcx_2 = arg1[2];
if (rcx_2 != data_14001da00)
_free_base(rcx_2);
int64_t rcx_3 = arg1[0xb];
if (rcx_3 != data_14001da48)
_free_base(rcx_3);
int64_t rcx_4 = arg1[0xc];
if (rcx_4 != data_14001da50)
_free_base(rcx_4);
}
void free_crt_array_internal(int64_t* arg1, int64_t arg2)
{
void* rdi = &arg1[arg2];
int64_t* rbx = arg1;
if (arg1 == rdi)
return;
do
{
_free_base(*rbx);
rbx = &rbx[1];
} while (rbx != rdi);
}
void __acrt_locale_free_time(int64_t* arg1)
{
if (!arg1)
return;
free_crt_array_internal(arg1, 7);
free_crt_array_internal(&arg1[7], 7);
free_crt_array_internal(&arg1[0xe], 0xc);
free_crt_array_internal(&arg1[0x1a], 0xc);
free_crt_array_internal(&arg1[0x26], 2);
_free_base(arg1[0x28]);
_free_base(arg1[0x29]);
_free_base(arg1[0x2a]);
free_crt_array_internal(&arg1[0x2c], 7);
free_crt_array_internal(&arg1[0x33], 7);
free_crt_array_internal(&arg1[0x3a], 0xc);
free_crt_array_internal(&arg1[0x46], 0xc);
free_crt_array_internal(&arg1[0x52], 2);
_free_base(arg1[0x54]);
_free_base(arg1[0x55]);
_free_base(arg1[0x56]);
_free_base(arg1[0x57]);
}
uint64_t __acrt_GetStringTypeA(int128_t* arg1, uint32_t arg2, uint8_t* arg3, int32_t arg4, uint16_t* arg5, uint32_t arg6, int32_t arg7)
{
void var_88;
void* rsp = &var_88;
void var_58;
int64_t rax_1 = __security_cookie ^ &var_58;
void* var_50;
int32_t rdx_1 = _LocaleUpdate::_LocaleUpdate(&var_50, arg1);
uint32_t rdi = arg6;
void* var_48;
if (!rdi)
rdi = *(var_48 + 0xc);
int32_t temp0 = arg7;
arg7 = -(arg7);
int32_t var_60 = 0;
int64_t var_68 = 0;
int32_t rax_3;
int64_t rcx_2;
rax_3 = __acrt_MultiByteToWideChar(rdi, ((rdx_1 - rdx_1) & 8) + 1, arg3, arg4);
int64_t r14 = rax_3;
BOOL rdi_1;
if (rax_3)
{
int64_t rsi_2 = r14 * 2;
uint64_t rcx_4 = (rcx_2 - rcx_2) & (rsi_2 + 0x10);
void* lpSrcStr;
if (!rcx_4)
{
lpSrcStr = nullptr;
label_14000b8d6:
rdi_1 = 0;
if (lpSrcStr)
goto label_14000b8e1;
}
else
{
if (rcx_4 > 0x400)
{
void* lpSrcStr_1 = _malloc_base(rcx_4);
lpSrcStr = lpSrcStr_1;
if (lpSrcStr_1)
{
*lpSrcStr_1 = 0xdddd;
lpSrcStr += 0x10;
}
}
else
{
int64_t rax_5 = rcx_4 + 0xf;
if (rax_5 <= rcx_4)
rax_5 = 0xffffffffffffff0;
int64_t rax_6 = rax_5 & 0xfffffffffffffff0;
__chkstk(rax_6);
rsp = &var_88 - rax_6;
lpSrcStr = rsp + 0x30;
if (!lpSrcStr)
goto label_14000b8d6;
*lpSrcStr = 0xcccc;
lpSrcStr += 0x10;
}
if (!lpSrcStr)
goto label_14000b8d6;
sub_140010a60(lpSrcStr, 0, rsi_2);
*(rsp + 0x28) = r14;
*(rsp + 0x20) = lpSrcStr;
int32_t cchSrc = __acrt_MultiByteToWideChar(rdi, MB_PRECOMPOSED, arg3, arg4);
if (!cchSrc)
goto label_14000b8d6;
rdi_1 = GetStringTypeW(arg2, lpSrcStr, cchSrc, arg5);
label_14000b8e1:
if (*(lpSrcStr - 0x10) == 0xdddd)
_free_base(lpSrcStr - 0x10);
}
}
else
rdi_1 = 0;
char var_38;
if (var_38)
{
void* rax_8 = var_50;
*(rax_8 + 0x3a8) &= 0xfffffffd;
}
__security_check_cookie(rax_1 ^ &var_58);
return rdi_1;
}
int64_t sub_14000b928(void* arg1)
{
*(arg1 + 0x10) += 1;
int32_t* rax = *(arg1 + 0xe0);
if (rax)
*rax += 1;
int32_t* rax_1 = *(arg1 + 0xf0);
if (rax_1)
*rax_1 += 1;
int32_t* rax_2 = *(arg1 + 0xe8);
if (rax_2)
*rax_2 += 1;
int32_t* rax_3 = *(arg1 + 0x100);
if (rax_3)
*rax_3 += 1;
void* rax_4 = arg1 + 0x38;
int64_t i_1 = 6;
int64_t i;
do
{
if (*(rax_4 - 0x10) != &data_14001d348)
{
int32_t* rdx_1 = *rax_4;
if (rdx_1)
*rdx_1 += 1;
}
if (*(rax_4 - 0x18))
{
int32_t* rdx_2 = *(rax_4 - 8);
if (rdx_2)
*rdx_2 += 1;
}
rax_4 += 0x20;
i = i_1;
i_1 -= 1;
} while (i != 1);
/* tailcall */
return __acrt_locale_add_lc_time_reference(*(arg1 + 0x120));
}
int64_t __acrt_free_locale(void* arg1)
{
int64_t rax = *(arg1 + 0xf8);
if (rax && rax != &data_14001d9f0)
{
int32_t* rax_1 = *(arg1 + 0xe0);
if (rax_1 && !*rax_1)
{
int32_t* rcx = *(arg1 + 0xf0);
if (rcx && !*rcx)
{
_free_base(rcx);
__acrt_locale_free_monetary(*(arg1 + 0xf8));
}
int32_t* rcx_2 = *(arg1 + 0xe8);
if (rcx_2 && !*rcx_2)
{
_free_base(rcx_2);
__acrt_locale_free_numeric(*(arg1 + 0xf8));
}
_free_base(*(arg1 + 0xe0));
_free_base(*(arg1 + 0xf8));
}
}
int32_t* rax_2 = *(arg1 + 0x100);
if (rax_2 && !*rax_2)
{
_free_base(*(arg1 + 0x108) - 0xfe);
_free_base(*(arg1 + 0x110) - 0x80);
_free_base(*(arg1 + 0x118) - 0x80);
_free_base(*(arg1 + 0x100));
}
__acrt_locale_free_lc_time_if_unreferenced(*(arg1 + 0x120));
void* rsi = arg1 + 0x128;
int64_t i_1 = 6;
void* rdi = arg1 + 0x38;
int64_t i;
do
{
if (*(rdi - 0x10) != &data_14001d348)
{
int32_t* rcx_14 = *rdi;
if (rcx_14 && !*rcx_14)
{
_free_base(rcx_14);
_free_base(*rsi);
}
}
if (*(rdi - 0x18))
{
int32_t* rcx_16 = *(rdi - 8);
if (rcx_16 && !*rcx_16)
_free_base(rcx_16);
}
rsi += 8;
rdi += 0x20;
i = i_1;
i_1 -= 1;
} while (i != 1);
/* tailcall */
return _free_base(arg1);
}
uint64_t __acrt_locale_add_lc_time_reference(void* arg1)
{
if (!arg1 || arg1 == &data_140013af0)
return 0x7fffffff;
int32_t rax = *(arg1 + 0x15c);
*(arg1 + 0x15c) += 1;
return rax + 1;
}
void __acrt_locale_free_lc_time_if_unreferenced(int64_t* arg1)
{
if (arg1 && arg1 != &data_140013af0 && !*(arg1 + 0x15c))
{
__acrt_locale_free_time(arg1);
_free_base(arg1);
}
}
uint64_t __acrt_locale_release_lc_time_reference(void* arg1)
{
if (!arg1 || arg1 == &data_140013af0)
return 0x7fffffff;
int32_t rax = *(arg1 + 0x15c);
*(arg1 + 0x15c) -= 1;
return rax - 1;
}
void __acrt_release_locale_ref(void* arg1)
{
if (!arg1)
return;
*(arg1 + 0x10) -= 1;
int32_t* rax_1 = *(arg1 + 0xe0);
if (rax_1)
*rax_1 -= 1;
int32_t* rax_2 = *(arg1 + 0xf0);
if (rax_2)
*rax_2 -= 1;
int32_t* rax_3 = *(arg1 + 0xe8);
if (rax_3)
*rax_3 -= 1;
int32_t* rax_4 = *(arg1 + 0x100);
if (rax_4)
*rax_4 -= 1;
void* rax_5 = arg1 + 0x38;
int64_t i_1 = 6;
int64_t i;
do
{
if (*(rax_5 - 0x10) != &data_14001d348)
{
int32_t* rdx_1 = *rax_5;
if (rdx_1)
*rdx_1 -= 1;
}
if (*(rax_5 - 0x18))
{
int32_t* rdx_2 = *(rax_5 - 8);
if (rdx_2)
*rdx_2 -= 1;
}
rax_5 += 0x20;
i = i_1;
i_1 -= 1;
} while (i != 1);
__acrt_locale_release_lc_time_reference(*(arg1 + 0x120));
}
void* sub_14000bc5c()
{
void** rax = __vcrt_getptd();
void* result;
if (data_14001da90 & rax[0x75])
result = rax[0x12];
if (!(data_14001da90 & rax[0x75]) || !result)
{
__vcrt_unlock(4);
result = _updatetlocinfoEx_nolock(&rax[0x12], data_14001e3d8);
__vcrt_lock(4);
if (!result)
{
abort();
/* no return */
}
}
return result;
}
void* const _updatetlocinfoEx_nolock(int64_t* arg1, void* arg2)
{
if (!arg2 || !arg1)
return nullptr;
void* rbx_1 = *arg1;
if (rbx_1 != arg2)
{
*arg1 = arg2;
sub_14000b928(arg2);
if (rbx_1)
{
__acrt_release_locale_ref(rbx_1);
if (!*(rbx_1 + 0x10) && rbx_1 != &data_14001d1e0)
__acrt_free_locale(rbx_1);
}
}
return arg2;
}
int64_t sub_14000bd34(int32_t arg1, PSTR arg2, int32_t* arg3, int64_t arg4)
{
uint64_t r12 = arg1;
int32_t* rsi = arg3;
int64_t result;
if (arg3 == arg4)
{
label_14000be24:
result = 0;
}
else
{
while (true)
{
uint64_t rdi_1 = *rsi;
HMODULE rbx_1 = *((rdi_1 << 3) + &data_14001eaa0);
if (!rbx_1)
{
int16_t* lpLibFileName = (&data_140014970)[rdi_1];
HMODULE rax_1 =
LoadLibraryExW(lpLibFileName, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
rbx_1 = rax_1;
if (rax_1)
{
label_14000beb6:
int64_t temp0_2 = *((rdi_1 << 3) + &data_14001eaa0);
*((rdi_1 << 3) + &data_14001eaa0) = rbx_1;
if (temp0_2)
FreeLibrary(rbx_1);
result = GetProcAddress(rbx_1, arg2);
break;
}
enum WIN32_ERROR rax_2 = GetLastError();
if (rax_2 != ERROR_INVALID_PARAMETER)
*((rdi_1 << 3) + &data_14001eaa0) = -1;
else if (!sub_140006ac0(lpLibFileName, u"api-ms-", rax_2 - 0x50))
*((rdi_1 << 3) + &data_14001eaa0) = -1;
else if (!sub_140006ac0(lpLibFileName, u"ext-ms-", rax_2 - 0x50))
*((rdi_1 << 3) + &data_14001eaa0) = -1;
else
{
HMODULE rax_5 = LoadLibraryExW(lpLibFileName, nullptr, 0);
rbx_1 = rax_5;
if (rax_5)
goto label_14000beb6;
*((rdi_1 << 3) + &data_14001eaa0) = -1;
}
}
else if (rbx_1 != -1)
{
result = GetProcAddress(rbx_1, arg2);
break;
}
rsi = &rsi[1];
if (rsi == arg4)
goto label_14000be24;
}
}
__vcrt_unlock(0xe);
enum PAGE_PROTECTION_FLAGS lpflOldProtect = 0;
if (VirtualProtect(&data_140021000, 0x100, PAGE_READWRITE, &lpflOldProtect))
{
int64_t result_1 = result;
if (!result)
result_1 = -1;
(&data_140021000)[r12];
(&data_140021000)[r12] = result_1;
if (VirtualProtect(&data_140021000, 0x100, PAGE_READONLY, &lpflOldProtect))
{
__vcrt_lock(0xe);
return result;
}
}
abort();
/* no return */
}
int64_t sub_14000bee8()
{
int64_t rax = data_1400210d0;
if (rax != -1)
{
int64_t rax_1;
if (!rax)
rax_1 = sub_14000bd34(rax + 0x1a, "AppPolicyGetProcessTerminationMethod",
&data_140014fbc, "AppPolicyGetProcessTerminationMethod");
if (rax || rax_1)
/* tailcall */
return sub_140010380();
}
return 0xc0000225;
}
int64_t sub_14000bf44()
{
int64_t rax = data_140021000;
if (rax != -1)
{
int64_t rax_1;
if (!rax)
rax_1 = sub_14000bd34(0, "AreFileApisANSI", &data_140014f58, &data_140014f5c);
if (rax || rax_1)
/* tailcall */
return sub_140010380();
}
return 1;
}
uint32_t FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback)
{
/* tailcall */
return FlsAlloc(lpCallback);
}
BOOL FlsFree(uint32_t dwFlsIndex)
{
/* tailcall */
return FlsFree(dwFlsIndex);
}
int64_t FlsGetValue(uint32_t dwFlsIndex)
{
/* tailcall */
return FlsGetValue(dwFlsIndex);
}
int64_t sub_14000bfa8()
{
/* tailcall */
return data_140021018();
}
BOOL FlsSetValue(uint32_t dwFlsIndex, void* lpFlsData)
{
/* tailcall */
return FlsSetValue(dwFlsIndex, lpFlsData);
}
BOOL InitializeCriticalSectionEx(CRITICAL_SECTION* lpCriticalSection, uint32_t dwSpinCount, uint32_t Flags)
{
/* tailcall */
return InitializeCriticalSectionEx(lpCriticalSection, dwSpinCount, Flags);
}
int64_t sub_14000bfc4(int16_t* arg1, uint32_t arg2, wchar16* arg3, int32_t arg4, PWSTR arg5, int32_t arg6, int64_t arg7, int64_t arg8, int64_t arg9)
{
int64_t r10 = data_140021090;
if (r10 != -1)
{
int64_t rax_1;
if (!r10)
rax_1 = sub_14000bd34(r10 + 0x12, "LCMapStringEx", &data_140014f88, "LCMapStringEx");
if (r10 || rax_1)
{
int64_t var_18_1 = arg9;
int64_t var_20_1 = arg8;
int64_t var_28_1 = arg7;
int32_t var_30 = arg6;
PWSTR var_38 = arg5;
return sub_140010380();
}
}
return LCMapStringW(sub_14000c0b8(arg1, 0), arg2, arg3, arg4, arg5, arg6);
}
uint64_t sub_14000c0b8(int16_t* arg1, int32_t arg2)
{
int64_t rax = data_1400210a0;
if (rax != -1)
{
int64_t rax_1;
if (!rax)
rax_1 =
sub_14000bd34(rax + 0x14, "LocaleNameToLCID", &data_140014fa0, "LocaleNameToLCID");
if (rax || rax_1)
return sub_140010380();
}
return sub_14000fac4(arg1);
}
BOOL sub_14000c11c()
{
int32_t lpflOldProtect = 0;
BOOL result;
result = VirtualProtect(&data_140021000, 0x100, PAGE_READONLY, &lpflOldProtect);
return result;
}
int64_t sub_14000c14c()
{
int64_t result = data_140021018;
bool cond:0_1;
if (result != -1)
{
cond:0_1 = result;
if (!result)
cond:0_1 = sub_14000bd34(result + 3, "FlsGetValue2", &data_140014f70, "FlsGetValue2");
}
else
cond:0_1 = 0;
result = cond:0_1;
return result;
}
void* __acrt_uninitialize_winapi_thunks(char arg1)
{
if (!arg1)
{
for (void* i = &data_14001eaa0; i != &data_14001eb58; i += 8)
{
HMODULE hLibModule = *i;
if (hLibModule)
{
if (hLibModule != -1)
FreeLibrary(hLibModule);
*i = 0;
}
}
}
void* result;
result = 1;
return result;
}
void* _recalloc_base(int64_t arg1, int64_t arg2, int64_t arg3)
{
if (arg2 && -0x20 / arg2 < arg3)
{
*sub_140007fb4() = 0xc;
return nullptr;
}
int64_t rdi_1;
if (!arg1)
rdi_1 = 0;
else
rdi_1 = _msize_base(arg1);
uint64_t rbx_1 = arg2 * arg3;
void* result = _realloc_base(arg1, rbx_1);
if (result && rdi_1 < rbx_1)
sub_140010a60(result + rdi_1, 0, rbx_1 - rdi_1);
return result;
}
void* _recalloc(int64_t arg1, int64_t arg2, int64_t arg3)
{
/* tailcall */
return _recalloc_base(arg1, arg2, arg3);
}
int64_t sub_14000c290()
{
return data_14001eb60;
}
HANDLE __acrt_initialize_heap()
{
HANDLE result = GetProcessHeap();
data_14001eb60 = result;
result = result;
return result;
}
int64_t sub_14000c2d0()
{
data_14001eb60 = 0;
int64_t result;
result = 1;
return result;
}
int64_t sub_14000c2f0()
{
return data_14001eb60;
}
void* sub_14000c2f8(int64_t* arg1, int64_t arg2)
{
int64_t* rbx_1;
if (arg1 != arg2)
{
rbx_1 = arg1;
do
{
if (*rbx_1 && !sub_140010380())
break;
rbx_1 = &rbx_1[2];
} while (rbx_1 != arg2);
}
void* result;
if (arg1 == arg2 || rbx_1 == arg2)
result = 1;
else
{
if (rbx_1 != arg1)
{
void* rbx_2 = &rbx_1[-1];
do
{
if (*(rbx_2 - 8) && *rbx_2)
sub_140010380();
rbx_2 -= 0x10;
} while (rbx_2 + 8 != arg1);
}
result = 0;
}
return result;
}
int64_t sub_14000c378(int64_t arg1, void* arg2)
{
void* rbx = arg2;
if (arg1 != arg2)
{
do
{
if (*(rbx - 8))
sub_140010380();
rbx -= 0x10;
} while (rbx != arg1);
}
int64_t result;
result = 1;
return result;
}
int64_t sub_14000c3c0()
{
int64_t result = _query_new_handler();
if (!result)
return result;
int32_t rbx;
rbx = sub_140010380();
return rbx;
}
int64_t sub_14000c400(int64_t arg1)
{
data_14001eb68 = arg1;
}
int64_t _query_new_handler()
{
__vcrt_unlock(0);
uint64_t __security_cookie_1 = __security_cookie;
int64_t result = RORQ(data_14001eb68 ^ __security_cookie_1, __security_cookie_1 & 0x3f);
__vcrt_lock(0);
return result;
}
int64_t _set_new_handler(int64_t arg1)
{
__vcrt_unlock(0);
uint64_t __security_cookie_1 = __security_cookie;
char rax_1 = __security_cookie_1 & 0x3f;
int64_t result = RORQ(__security_cookie_1 ^ data_14001eb68, rax_1);
data_14001eb68 = RORQ(arg1, 0x40 - rax_1) ^ __security_cookie_1;
__vcrt_lock(0);
return result;
}
int64_t _set_new_handler()
{
/* tailcall */
return _set_new_handler(__security_cookie);
}
int64_t __crt_seh_guarded_call<class <lambda_450d765d439847d4c735a33c368b5fc0>,class <lambda_44731a7d0e6d81c3e6aa82d741081786>& __ptr64,class <lambda_601a2a7da3b7a96e9554ac7215c4b07c>,void (__cdecl*)(int32_t)>::operator()<class <lambda_450d765d439847d4c735a33c368b5fc0>,class <lambda_44731a7d0e6d81c3e6aa82d741081786>& __ptr64,class <lambda_601a2a7da3b7a96e9554ac7215c4b07c> >(int64_t arg1, int32_t* arg2, int64_t arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__vcrt_unlock(*arg2);
uint64_t __security_cookie_1 = __security_cookie;
int64_t result = RORQ(data_14001eb80 ^ __security_cookie_1, __security_cookie_1 & 0x3f);
__vcrt_lock(*arg4);
return result;
}
int64_t __acrt_get_sigabrt_handler()
{
int32_t arg_10 = 3;
int32_t arg_18 = 3;
void arg_8;
return __crt_seh_guarded_call<class <lambda_450d765d439847d4c735a33c368b5fc0>,class <lambda_44731a7d0e6d81c3e6aa82d741081786>& __ptr64,class <lambda_601a2a7da3b7a96e9554ac7215c4b07c>,void (__cdecl*)(int32_t)>::operator()<class <lambda_450d765d439847d4c735a33c368b5fc0>,class <lambda_44731a7d0e6d81c3e6aa82d741081786>& __ptr64,class <lambda_601a2a7da3b7a96e9554ac7215c4b07c> >(
&arg_8, &arg_18, &arg_8, &arg_10);
}
int64_t _initp_misc_winsig(int64_t arg1)
{
data_14001eb70 = arg1;
data_14001eb78 = arg1;
data_14001eb80 = arg1;
data_14001eb88 = arg1;
}
int64_t sub_14000c554(int32_t arg1)
{
int64_t* r15 = nullptr;
int32_t arg_10 = 0;
int64_t r14;
r14 = 1;
char arg_8 = 1;
int64_t* rdi_1;
if (arg1 != 2)
{
if (arg1 == 4)
{
label_14000c5db:
int64_t* rax_1 = sub_140007d20();
r15 = rax_1;
if (!rax_1)
return 0xffffffff;
void* rax_3 = *rax_1;
void* rcx_4 = 0xc0 + rax_3;
while (true)
{
if (rax_3 == rcx_4)
{
rax_3 = nullptr;
break;
}
if (*(rax_3 + 4) == arg1)
break;
rax_3 += 0x10;
}
if (!rax_3)
goto label_14000c632;
rdi_1 = rax_3 + 8;
r14 = 0;
arg_8 = 0;
goto label_14000c66f;
}
if (arg1 == 6)
goto label_14000c5ab;
if (arg1 == 8 || arg1 == 0xb)
goto label_14000c5db;
if (arg1 != 0xf && arg1 != 0x15 && arg1 != 0x16)
{
label_14000c632:
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0xffffffff;
}
}
label_14000c5ab:
if (arg1 != 2)
{
if (arg1 == 6)
rdi_1 = &data_14001eb80;
else if (arg1 == 0xf)
rdi_1 = &data_14001eb88;
else if (arg1 == 0x15)
rdi_1 = &data_14001eb78;
else if (arg1 == 0x16)
rdi_1 = &data_14001eb80;
else
rdi_1 = nullptr;
goto label_14000c66f;
}
rdi_1 = &data_14001eb70;
label_14000c66f:
int64_t r13_1 = 0;
if (r14)
__vcrt_unlock(3);
int64_t rsi_1 = *rdi_1;
if (r14)
{
uint64_t __security_cookie_1 = __security_cookie;
rsi_1 = RORQ(rsi_1 ^ __security_cookie_1, __security_cookie_1 & 0x3f);
}
if (rsi_1 != 1)
{
if (!rsi_1)
{
if (r14)
__vcrt_lock(rsi_1 + 3);
sub_1400060a4(3);
breakpoint();
}
if (arg1 > 0xb || !TEST_BITD(0x910, arg1))
goto label_14000c6ee;
r13_1 = r15[1];
int64_t var_38_1 = r13_1;
r15[1] = 0;
if (arg1 != 8)
*rdi_1 = __security_cookie;
else
{
int32_t rax_6 = __vcrt_getptd()[2];
arg_10 = rax_6;
int32_t var_48_1 = rax_6;
__vcrt_getptd()[2] = 0x8c;
label_14000c6ee:
if (arg1 != 8)
*rdi_1 = __security_cookie;
else
{
void* rax_8 = 0x30 + *r15;
void* rcx_7 = 0x90 + rax_8;
while (true)
{
void* var_40_1 = rax_8;
if (rax_8 == rcx_7)
break;
*(rax_8 + 8) = 0;
rax_8 += 0x10;
}
}
}
}
if (r14)
__vcrt_lock(3);
if (rsi_1 != 1)
{
if (arg1 != 8)
sub_140010380();
else
{
__vcrt_getptd()[2];
sub_140010380();
}
if (arg1 <= 0xb && TEST_BITD(0x910, arg1))
{
r15[1] = r13_1;
if (arg1 == 8)
__vcrt_getptd()[2] = arg_10;
}
}
return 0;
}
uint64_t __acrt_update_locale_info(void* arg1, int64_t* arg2)
{
uint64_t result = data_14001e3d8;
if (*arg2 != result)
{
result = *(arg1 + 0x3a8);
if (!(data_14001da90 & result))
{
result = sub_14000bc5c();
*arg2 = result;
}
}
return result;
}
uint64_t __acrt_update_locale_info_explicit(void* arg1, int64_t* arg2, int64_t arg3)
{
uint64_t result = (&data_14001e3d8)[arg3];
if (*arg2 != result)
{
result = *(arg1 + 0x3a8);
if (!(data_14001da90 & result))
{
result = sub_14000bc5c();
*arg2 = result;
}
}
return result;
}
uint64_t sub_14000c81c(void* arg1, int64_t* arg2)
{
uint64_t result = data_14001e3f0;
if (*arg2 != result)
{
result = *(arg1 + 0x3a8);
if (!(data_14001da90 & result))
{
result = __acrt_update_thread_multibyte_data();
*arg2 = result;
}
}
return result;
}
uint64_t __acrt_update_multibyte_info_explicit(void* arg1, int64_t* arg2, int64_t arg3)
{
uint64_t result = (&data_14001e3f0)[arg3];
if (*arg2 != result)
{
result = *(arg1 + 0x3a8);
if (!(data_14001da90 & result))
{
result = __acrt_update_thread_multibyte_data();
*arg2 = result;
}
}
return result;
}
int64_t _mbtowc_internal(int16_t* arg1, char* arg2, int64_t arg3, int64_t* arg4)
{
void* rsi = arg2;
if (!arg2 || !arg3)
data_14001eba0 = 0;
else
{
if (*arg2)
{
if (!arg4[5])
__crt_cached_ptd_host::update_locale_slow(arg4);
int64_t* rdx = arg4[3];
uint32_t r10_1 = *(rdx + 0xc);
int32_t result;
if (r10_1 != 0xfde9)
{
if (!rdx[0x27])
{
if (arg1)
*arg1 = *rsi;
return 1;
}
if (*(*rdx + (*rsi << 1)) >= 0)
{
int32_t rax_7;
rax_7 = arg1;
int32_t var_10_2 = rax_7;
int16_t* var_18_3 = arg1;
if (__acrt_MultiByteToWideChar(r10_1, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED,
rsi, 1))
return 1;
}
else
{
uint64_t r9 = rdx[1];
int32_t rax_4;
if (r9 > 1 && arg3 >= r9)
{
int32_t rax_3;
rax_3 = arg1;
int32_t var_10_1 = rax_3;
int16_t* var_18_2 = arg1;
rax_4 = __acrt_MultiByteToWideChar(r10_1,
MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, rsi, r9);
}
if (r9 > 1 && arg3 >= r9 && rax_4)
return *(arg4[3] + 8);
if (arg3 >= *(arg4[3] + 8) && *(rsi + 1))
return *(arg4[3] + 8);
}
arg4[6] = 1;
result = -1;
*(arg4 + 0x2c) = 0x2a;
}
else
{
result = sub_14000cbf8(arg1, rsi, arg3, &data_14001eba0, arg4);
if (result < 0)
return -1;
}
return result;
}
if (arg1)
*arg1 = 0;
}
return 0;
}
bool sub_14000ca00(char* arg1)
{
bool rdx = *arg1;
if (rdx >= 0)
return rdx;
if ((rdx & 0xe0) == 0xc0)
return 2;
if ((rdx & 0xf0) == 0xe0)
return 3;
if ((rdx & 0xf8) == 0xf0)
return 4;
return 0xffffffff;
}
int64_t sub_14000ca38(uint64_t arg1, void* arg2, int64_t arg3, void* arg4, int64_t arg5 @ r14, void* arg6)
{
int64_t var_30 = arg5;
void var_78;
int64_t rax_1 = __security_cookie ^ &var_78;
void* rbx = &data_14001eba8;
void* const rdi = &data_1400125b4;
if (arg4)
rbx = arg4;
uint64_t i_1 = 1;
if (arg2)
i_1 = arg3;
if (arg2)
rdi = arg2;
uint32_t* r14_1 = (arg5 - arg5) & arg1;
int64_t result;
if (!i_1)
result = -2;
else
{
uint32_t rdx_3;
if (*(rbx + 6))
{
arg3 = *(rbx + 4);
rdx_3 = *rbx;
arg4 = *(rbx + 6);
if (arg3 - 2 <= 2 && arg4 >= 1 && arg4 < arg3)
goto label_14000cb25;
labelid_8:
result = __crt_mbstring::return_illegal_sequence(rbx, arg6);
}
else
{
arg3 = sub_14000ca00(rdi);
uint32_t rax_5 = *rdi;
rdi += 1;
if (arg3 <= 1)
{
if (r14_1)
*r14_1 = rax_5;
result = arg3;
}
else if (arg3 - 2 > 2)
{
label_14000cbd4:
result = __crt_mbstring::return_illegal_sequence(rbx, arg6);
}
else
{
arg1 = 7 - arg3;
arg4 = arg3;
rdx_3 = ((1 << arg1) - 1) & rax_5;
label_14000cb25:
uint64_t r11_1 = arg4;
uint64_t i = r11_1;
if (r11_1 >= i_1)
i = i_1;
while (rdi - arg2 < i)
{
uint32_t rcx_2 = *rdi;
rdi += 1;
void* rax_7;
rax_7 = rcx_2;
rax_7 &= 0xc0;
if (rax_7 != 0x80)
goto label_14000cbd4_2;
arg1 = rcx_2 & 0x3f;
rdx_3 = arg1 | rdx_3 << 6;
}
if (i < r11_1)
{
arg4 -= i;
*(rbx + 4) = arg3;
*(rbx + 6) = arg4;
*rbx = rdx_3;
result = -2;
}
else if (rdx_3 - 0xd800 <= 0x7ff || rdx_3 >= 0x110000)
{
label_14000cbd4_1:
result = __crt_mbstring::return_illegal_sequence(rbx, arg6);
}
else
{
int32_t var_58_1 = 0x80;
int32_t var_54_1 = 0x800;
int32_t var_50_1 = 0x10000;
int32_t var_60[0x2];
if (rdx_3 < var_60[arg3])
{
label_14000cbd4_2:
result = __crt_mbstring::return_illegal_sequence(rbx, arg6);
}
else
{
if (r14_1)
*r14_1 = rdx_3;
result = __crt_mbstring::reset_and_return((arg1 - arg1) & r11_1, rbx);
}
}
}
}
}
__security_check_cookie(rax_1 ^ &var_78);
return result;
}
int64_t sub_14000cbf8(int16_t* arg1, void* arg2, int64_t arg3, void* arg4, void* arg5)
{
int32_t var_18 = 0;
int64_t r14;
int64_t result = sub_14000ca38(&var_18, arg2, arg3, arg4, r14, arg5);
if (result <= 4)
{
int32_t rcx_1 = var_18;
if (rcx_1 > 0xffff)
rcx_1 = 0xfffd;
if (arg1)
*arg1 = rcx_1;
}
return result;
}
int64_t sub_14000cc40(uint16_t* arg1, int64_t* arg2, int64_t arg3, void* arg4, void* arg5)
{
char* rdi = *arg2;
int64_t i_1 = arg3;
int64_t rax;
if (!arg1)
{
int64_t result = 0;
while (true)
{
int64_t r8_3;
if (!*rdi)
r8_3 = 1;
else if (rdi[1])
{
rax = rdi[2];
char temp0_1 = rax;
rax = -(rax);
r8_3 = -((arg3 - arg3)) + 3;
}
else
r8_3 = 2;
rax = sub_14000ca38(0, rdi, r8_3, arg4, arg2, arg5);
if (rax == -1)
break;
if (!rax)
return result;
int64_t result_1 = result + 1;
rdi = &rdi[rax];
if (rax != 4)
result_1 = result;
result = result_1 + 1;
}
*(arg5 + 0x30) = 1;
*(arg5 + 0x2c) = 0x2a;
return -1;
}
uint16_t* rbx = arg1;
if (arg3)
{
int64_t i;
do
{
int64_t r8;
if (!*rdi)
r8 = 1;
else if (rdi[1])
{
rax = rdi[2];
char temp1_1 = rax;
rax = -(rax);
r8 = -((arg3 - arg3)) + 3;
}
else
r8 = 2;
int32_t arg_8 = 0;
rax = sub_14000ca38(&arg_8, rdi, r8, arg4, arg2, arg5);
if (rax == -1)
{
*arg2 = rdi;
*(arg5 + 0x30) = 1;
*(arg5 + 0x2c) = 0x2a;
return -1;
}
if (!rax)
{
rdi = nullptr;
*rbx = 0;
break;
}
int32_t rcx_1 = arg_8;
if (rcx_1 > 0xffff)
{
if (i_1 <= 1)
break;
arg3 = 0xd800;
arg_8 = rcx_1 - 0x10000;
i_1 -= 1;
*rbx = (rcx_1 - 0x10000) >> 0xa | 0xd800;
rcx_1 = (rcx_1 - 0x10000) & 0x3ff;
rbx = &rbx[1];
rcx_1 |= 0xdc00;
}
*rbx = rcx_1;
rdi = &rdi[rax];
rbx = &rbx[1];
i = i_1;
i_1 -= 1;
} while (i != 1);
}
*arg2 = rdi;
return (rbx - arg1) >> 1;
}
uint64_t sub_14000cdf8()
{
int32_t var_18 = 0;
__vcrt_unlock(8);
int32_t rbx = 3;
while (true)
{
int32_t var_14_1 = rbx;
if (rbx == data_14001e3c0)
break;
int64_t rdi_1 = rbx;
void* rax_2 = *(data_14001e3c8 + (rdi_1 << 3));
if (rax_2)
{
if (*(rax_2 + 0x14) >> 0xd & 1
&& fclose(*(data_14001e3c8 + (rdi_1 << 3))) != 0xffffffff)
var_18 += 1;
DeleteCriticalSection(*(data_14001e3c8 + (rdi_1 << 3)) + 0x30);
_free_base(*(data_14001e3c8 + (rdi_1 << 3)));
*(data_14001e3c8 + (rdi_1 << 3)) = 0;
}
rbx += 1;
}
__vcrt_lock(8);
return var_18;
}
uint64_t __crt_seh_guarded_call<class <lambda_a37b2b86f63e897a80ea819b0eb08c01>,class <lambda_38ce7e780aa69e748d6df282ebc68efe>& __ptr64,class <lambda_99fb1378e971ab6e7edea83e3a7a83a2>,int32_t>::operator()<class <lambda_a37b2b86f63e897a80ea819b0eb08c01>,class <lambda_38ce7e780aa69e748d6df282ebc68efe>& __ptr64,class <lambda_99fb1378e971ab6e7edea83e3a7a83a2> >(int64_t arg1, int32_t* arg2, int64_t* arg3, int32_t* arg4)
{
int32_t* arg_20 = arg4;
__acrt_lowio_unlock_fh(*arg2);
int64_t rcx_1 = **arg3;
int32_t rbx_1;
if (!(*((&data_14001e690)[rcx_1 >> 6] + (rcx_1 & 0x3f) * 0x48 + 0x38) & 1))
{
*sub_140007fb4() = 9;
rbx_1 = -1;
}
else
{
rbx_1 = 0;
if (!FlushFileBuffers(_get_osfhandle(rcx_1)))
{
*sub_140007f90() = GetLastError();
*sub_140007fb4() = 9;
rbx_1 = -1;
}
}
sub_14000afac(*arg4);
return rbx_1;
}
uint64_t _commit(int32_t arg1)
{
int32_t arg_8 = arg1;
int64_t rdx = arg1;
if (rdx != 0xfffffffe)
{
if (arg1 >= 0 && rdx < data_14001ea90
&& *((&data_14001e690)[rdx >> 6] + (rdx & 0x3f) * 0x48 + 0x38) & 1)
{
int32_t arg_18 = rdx;
int32_t arg_20 = rdx;
int32_t* var_18 = &arg_8;
void arg_10;
return __crt_seh_guarded_call<class <lambda_a37b2b86f63e897a80ea819b0eb08c01>,class <lambda_38ce7e780aa69e748d6df282ebc68efe>& __ptr64,class <lambda_99fb1378e971ab6e7edea83e3a7a83a2>,int32_t>::operator()<class <lambda_a37b2b86f63e897a80ea819b0eb08c01>,class <lambda_38ce7e780aa69e748d6df282ebc68efe>& __ptr64,class <lambda_99fb1378e971ab6e7edea83e3a7a83a2> >(
&arg_10, &arg_20, &var_18, &arg_18);
}
*sub_140007fb4() = 9;
_invalid_parameter_noinfo();
}
else
*sub_140007fb4() = 9;
return 0xffffffff;
}
int64_t* sub_14000cfcc(int64_t* arg1, int32_t arg2, char* arg3, int32_t arg4, int64_t* arg5)
{
int64_t var_60 = -2;
void var_108;
int64_t rax_1 = __security_cookie ^ &var_108;
char* rsi = arg3;
int64_t r14 = arg2;
int64_t r13_1 = r14 >> 6;
int64_t var_90 = r13_1;
uint64_t r15 = (r14 & 0x3f) * 9;
HANDLE hFile = *((&data_14001e690)[r13_1] + (r15 << 3) + 0x28);
void* r12_1 = &arg3[arg4];
uint32_t rax_6 = GetConsoleOutputCP();
int32_t rdi = 0;
int64_t* r10 = arg5;
if (!r10[5])
{
__crt_cached_ptd_host::update_locale_slow(r10);
r10 = arg5;
}
int32_t rcx_2 = *(r10[3] + 0xc);
int32_t var_9c = rcx_2;
*arg1 = 0;
arg1[1] = 0;
if (arg3 < r12_1)
{
int64_t r11_2 = r14 >> 6;
int64_t var_68_1 = r11_2;
int32_t rdx = 0;
while (true)
{
BOOL rax_7;
rax_7 = *rsi;
uint8_t buffer = rax_7;
int32_t var_c4 = 0;
int32_t r12_2 = 1;
if (rcx_2 != 0xfde9)
{
int64_t r8_4 = (&data_14001e690)[r13_1];
rcx_2 = *(r8_4 + (r15 << 3) + 0x3d);
char* rdx_8;
int64_t r8_5;
if (!(rcx_2 & 4))
{
uint64_t r9_4 = *rsi;
if (*(*r10[3] + (r9_4 << 1)) >= 0)
{
r8_5 = 1;
rdx_8 = rsi;
goto label_14000d2c6;
}
if (&rsi[1] >= r12_1)
{
*(r8_4 + (r15 << 3) + 0x3e) = r9_4;
int64_t rax_25 = (&data_14001e690)[r13_1];
*(rax_25 + (r15 << 3) + 0x3d) |= 4;
*(arg1 + 4) = rdx + 1;
break;
}
if (_mbtowc_internal(&var_c4, rsi, 2, r10) == 0xffffffff)
break;
rsi = &rsi[1];
}
else
{
rax_7 = *(r8_4 + (r15 << 3) + 0x3e);
char var_50 = rax_7;
rax_7 = *rsi;
char var_4f_1 = rax_7;
rcx_2 &= 0xfb;
*(r8_4 + (r15 << 3) + 0x3d) = rcx_2;
r8_5 = 2;
rdx_8 = &var_50;
label_14000d2c6:
if (_mbtowc_internal(&var_c4, rdx_8, r8_5, r10) == 0xffffffff)
break;
}
}
else
{
int32_t rdx_1 = 0;
int64_t r14_1 = 0;
void* rcx_4 = (r15 << 3) + 0x3e + (&data_14001e690)[r11_2];
while (*rcx_4)
{
rdx_1 += 1;
r14_1 += 1;
rcx_4 += 1;
if (r14_1 >= 5)
break;
}
int32_t var_a8;
if (r14_1 <= 0)
{
int64_t r13_2 = *(*rsi + 0x14001d360);
int32_t rcx_11 = r13_2 + 1;
void* i = r12_1 - rsi;
if (rcx_11 > i)
{
if (i > 0)
{
char* r8_8 = nullptr;
do
{
int64_t rax_18;
rax_18 = *(r8_8 + rsi);
r8_8[(r15 << 3) + (&data_14001e690)[var_90] + 0x3e] = rax_18;
rdi += 1;
r8_8 = &r8_8[1];
} while (rdi < i);
}
*(arg1 + 4) += i;
break;
}
var_a8 = 0;
char* var_78 = rsi;
int32_t rax_19;
rax_19 = rcx_11 == 4;
if (sub_14000cc40(&var_c4, &var_78, rax_19 + 1, &var_a8, r10) == -1)
break;
rsi = &rsi[r13_2];
r12_2 = rax_19 + 1;
r13_1 = var_90;
}
else
{
int32_t r12_4 =
*(*((&data_14001e690)[r13_1] + (r15 << 3) + 0x3e) + 0x14001d360) + 1;
uint64_t rax_10 = r12_4 - rdx_1;
var_a8 = rax_10;
void* i_1 = r12_1 - rsi;
void* r9 = rax_10;
if (r9 > i_1)
{
if (i_1 > 0)
{
char* rsi_1 = rsi - r14_1;
do
{
rax_10 = rsi_1[r14_1];
*(r14_1 + (r15 << 3) + (&data_14001e690)[r13_1] + 0x3e) = rax_10;
rdi += 1;
r14_1 += 1;
} while (rdi < i_1);
}
*(arg1 + 4) += i_1;
break;
}
int64_t rcx_6 = 0;
void* rdx_3 = (r15 << 3) + 0x3e + (&data_14001e690)[r11_2];
void var_58;
do
{
rax_10 = *rdx_3;
*(&var_58 + rcx_6) = rax_10;
rcx_6 += 1;
rdx_3 += 1;
} while (rcx_6 < r14_1);
if (r9 > 0)
{
memcpy(&var_58 + r14_1, rsi, r9);
r10 = arg5;
}
int64_t rdx_5 = 0;
do
{
*(rdx_5 + (r15 << 3) + (&data_14001e690)[r13_1] + 0x3e) = 0;
rdx_5 += 1;
} while (rdx_5 < r14_1);
int64_t var_88 = 0;
void* var_80 = &var_58;
int32_t rax_12;
rax_12 = r12_4 == 4;
r12_2 = rax_12 + 1;
if (sub_14000cc40(&var_c4, &var_80, rax_12 + 1, &var_88, r10) == -1)
break;
rsi = &rsi[var_a8 - 1];
}
}
rsi = &rsi[1];
int64_t var_d0_1 = 0;
int64_t var_d8_1 = 0;
uint8_t buffer_1;
uint32_t nNumberOfBytesToWrite =
__acrt_WideCharToMultiByte(rax_6, 0, &var_c4, r12_2, &buffer_1, 5);
if (!nNumberOfBytesToWrite)
break;
uint32_t numberOfBytesWritten = 0;
if (WriteFile(hFile, &buffer_1, nNumberOfBytesToWrite, &numberOfBytesWritten, nullptr))
{
rdx = arg1[1] - arg3 + rsi;
*(arg1 + 4) = rdx;
if (numberOfBytesWritten < nNumberOfBytesToWrite)
break;
if (buffer != 0xa)
{
label_14000d38f:
if (rsi >= r12_1)
break;
r10 = arg5;
r11_2 = var_68_1;
rcx_2 = var_9c;
continue;
}
else
{
buffer = 0xd;
if (WriteFile(hFile, &buffer, 1, &numberOfBytesWritten, nullptr))
{
if (numberOfBytesWritten < 1)
break;
arg1[1] += 1;
*(arg1 + 4) += 1;
rdx = *(arg1 + 4);
goto label_14000d38f;
}
}
}
*arg1 = GetLastError();
break;
}
}
__security_check_cookie(rax_1 ^ &var_108);
return arg1;
}
int64_t* sub_14000d460(int64_t* arg1, int32_t arg2, char* arg3, int32_t arg4)
{
__chkstk(0x1450);
void var_1468;
int64_t rax_1 = __security_cookie ^ &var_1468;
int64_t r10 = arg2;
void* rbp_1 = &arg3[arg4];
char* rsi = arg3;
HANDLE hFile = *((&data_14001e690)[r10 >> 6] + (r10 & 0x3f) * 0x48 + 0x28);
*arg1 = 0;
arg1[1] = 0;
if (arg3 < rbp_1)
{
do
{
uint8_t buffer[0x13ff];
uint8_t (* rbx_1)[0x13ff] = &buffer;
uint32_t rax_5;
while (rsi < rbp_1)
{
rax_5 = *rsi;
rsi = &rsi[1];
if (rax_5 == 0xa)
{
arg1[1] += 1;
*rbx_1 = 0xd;
rbx_1 = &(*rbx_1)[1];
}
*rbx_1 = rax_5;
rbx_1 = &(*rbx_1)[1];
void var_29;
if (rbx_1 >= &var_29)
break;
}
uint32_t numberOfBytesWritten[0x4];
numberOfBytesWritten[0] = 0;
uint32_t nNumberOfBytesToWrite = rbx_1 - &buffer;
if (!WriteFile(hFile, &buffer, nNumberOfBytesToWrite, &numberOfBytesWritten, nullptr))
{
*arg1 = GetLastError();
break;
}
rax_5 = numberOfBytesWritten[0];
*(arg1 + 4) += rax_5;
if (rax_5 < nNumberOfBytesToWrite)
break;
} while (rsi < rbp_1);
}
__security_check_cookie(rax_1 ^ &var_1468);
return arg1;
}
int64_t* sub_14000d568(int64_t* arg1, int32_t arg2, int16_t* arg3, int32_t arg4)
{
__chkstk(0x1450);
void var_1468;
int64_t rax_1 = __security_cookie ^ &var_1468;
int64_t r10 = arg2;
void* rbp_1 = arg4 + arg3;
int16_t* rsi = arg3;
HANDLE hFile = *((&data_14001e690)[r10 >> 6] + (r10 & 0x3f) * 0x48 + 0x28);
*arg1 = 0;
arg1[1] = 0;
if (arg3 < rbp_1)
{
do
{
uint8_t buffer[0x13fe];
uint8_t (* rbx_1)[0x13fe] = &buffer;
while (rsi < rbp_1)
{
int16_t rax_5 = *rsi;
rsi = &rsi[1];
if (rax_5 == 0xa)
{
arg1[1] += 2;
*rbx_1 = 0xd;
rbx_1 = &(*rbx_1)[2];
}
*rbx_1 = rax_5;
rbx_1 = &(*rbx_1)[2];
void var_2a;
if (rbx_1 >= &var_2a)
break;
}
uint32_t numberOfBytesWritten[0x4];
numberOfBytesWritten[0] = 0;
int32_t nNumberOfBytesToWrite = ((rbx_1 - &buffer) >> 1) * 2;
if (!WriteFile(hFile, &buffer, nNumberOfBytesToWrite, &numberOfBytesWritten, nullptr))
{
*arg1 = GetLastError();
break;
}
uint32_t rax_7 = numberOfBytesWritten[0];
*(arg1 + 4) += rax_7;
if (rax_7 < nNumberOfBytesToWrite)
break;
} while (rsi < rbp_1);
}
__security_check_cookie(rax_1 ^ &var_1468);
return arg1;
}
int64_t* sub_14000d684(int64_t* arg1, int32_t arg2, int16_t* arg3, int32_t arg4)
{
__chkstk(0x1470);
void var_1498;
int64_t rax_1 = __security_cookie ^ &var_1498;
int64_t r10 = arg2;
void* r14_1 = arg4 + arg3;
int16_t* rdi = arg3;
HANDLE hFile = *((&data_14001e690)[r10 >> 6] + (r10 & 0x3f) * 0x48 + 0x28);
*arg1 = 0;
arg1[1] = 0;
if (arg3 < r14_1)
{
do
{
wchar16 var_1448[0x354];
wchar16 (* r9)[0x354] = &var_1448;
while (rdi < r14_1)
{
int16_t rax_5 = *rdi;
rdi = &rdi[1];
if (rax_5 == 0xa)
{
*r9 = 0xd;
r9 = &(*r9)[1];
}
*r9 = rax_5;
r9 = &(*r9)[1];
void var_da0;
if (r9 >= &var_da0)
break;
}
int64_t var_1460_1 = 0;
int64_t var_1468_1 = 0;
void var_d98;
int32_t rax_6 = __acrt_WideCharToMultiByte(0xfde9, 0, &var_1448, (r9 - &var_1448) >> 1,
&var_d98, 0xd55);
if (!rax_6)
{
label_14000d7c7:
*arg1 = GetLastError();
break;
}
int32_t rsi_1 = 0;
if (rax_6)
{
do
{
uint32_t numberOfBytesWritten[0x4];
numberOfBytesWritten[0] = 0;
if (!WriteFile(hFile, &var_d98 + rsi_1, rax_6 - rsi_1, &numberOfBytesWritten,
nullptr))
goto label_14000d7c7;
rsi_1 += numberOfBytesWritten[0];
} while (rsi_1 < rax_6);
}
*(arg1 + 4) = rdi - arg3;
} while (rdi < r14_1);
}
__security_check_cookie(rax_1 ^ &var_1498);
return arg1;
}
uint64_t sub_14000d7f8(int32_t arg1, int16_t* arg2, int32_t arg3)
{
void* var_48 = nullptr;
char var_38 = 0;
char var_20 = 0;
char var_18 = 0;
if (!data_14001e37c)
{
var_20 = 1;
int128_t var_30_1 = *data_14001d338;
}
int32_t rax = _write_internal(arg1, arg2, arg3, &var_48);
if (var_20 == 2)
{
void* rcx = var_48;
*(rcx + 0x3a8) &= 0xfffffffd;
}
int32_t var_1c;
if (var_18)
*(sub_140005064(&var_48) + 0x20) = var_1c;
int32_t var_14;
if (0)
*(sub_140005064(&var_48) + 0x24) = var_14;
return rax;
}
uint64_t _write_internal(int32_t arg1, int16_t* arg2, int32_t arg3, int64_t* arg4)
{
int32_t arg_8 = arg1;
int64_t rsi = arg1;
if (rsi != 0xfffffffe)
{
int32_t rax_2;
if (arg1 < 0 || rsi >= data_14001ea90)
rax_2 = 0;
else
rax_2 = 1;
if (rax_2)
{
int64_t r15_2 = rsi >> 6;
uint64_t r12_1 = (rsi & 0x3f) * 9;
if (*((&data_14001e690)[r15_2] + (r12_1 << 3) + 0x38) & 1)
{
__acrt_lowio_unlock_fh(rsi);
int32_t r14_1 = -1;
if (*((&data_14001e690)[r15_2] + (r12_1 << 3) + 0x38) & 1)
r14_1 = sub_14000d9b0(rsi, arg2, arg3, arg4);
else
{
arg4[6] = 1;
*(arg4 + 0x2c) = 9;
arg4[7] = 1;
*(arg4 + 0x34) = 0;
}
sub_14000afac(rsi);
return r14_1;
}
}
arg4[7] = 1;
*(arg4 + 0x34) = 0;
arg4[6] = 1;
*(arg4 + 0x2c) = 9;
_invalid_parameter_internal(0, 0, 0, 0, 0, arg4);
}
else
{
arg4[7] = 1;
*(arg4 + 0x34) = 0;
arg4[6] = 1;
*(arg4 + 0x2c) = 9;
}
return 0xffffffff;
}
uint64_t sub_14000d9b0(int32_t arg1, int16_t* arg2, int32_t arg3, int64_t* arg4)
{
int32_t rdi = 0;
uint64_t r14 = arg3;
int64_t r13 = arg1;
if (arg3)
{
char var_78_1;
uint64_t rax_2;
int64_t rcx;
int64_t r12_2;
uint64_t r15_1;
if (arg2)
{
r12_2 = r13 >> 6;
r15_1 = (r13 & 0x3f) * 9;
rcx = (&data_14001e690)[r12_2];
rax_2 = *(rcx + (r15_1 << 3) + 0x39);
var_78_1 = rax_2;
rax_2 -= 1;
}
if (!arg2 || (rax_2 <= 1 && !(~r14 & 1)))
{
arg4[7] = 1;
*(arg4 + 0x34) = 0;
arg4[6] = 1;
*(arg4 + 0x2c) = 0x16;
_invalid_parameter_internal(0, 0, 0, 0, 0, arg4);
return 0xffffffff;
}
if (*(rcx + (r15_1 << 3) + 0x38) & 0x20)
j_common_lseek_nolock<int64_t>(r13, 0, FILE_END, arg4);
int64_t var_60_1 = 0;
int64_t var_70;
int64_t* rax_14;
if (!_isatty(r13) || *((&data_14001e690)[r12_2] + (r15_1 << 3) + 0x38) >= 0)
{
label_14000dba2:
int64_t rdx_2 = (&data_14001e690)[r13 >> 6];
uint64_t rcx_13 = (r13 & 0x3f) * 9;
if (*(rdx_2 + (rcx_13 << 3) + 0x38) >= 0)
{
HANDLE hFile = *(rdx_2 + (rcx_13 << 3) + 0x28);
var_70 = 0;
int32_t var_68_1 = 0;
if (!WriteFile(hFile, arg2, r14, &*var_70[4], nullptr))
var_70 = GetLastError();
rdi = var_68_1;
var_60_1 = var_70;
}
else
{
int32_t rcx_14 = var_78_1;
if (!rcx_14)
{
rax_14 = sub_14000d460(&var_70, r13, arg2, r14);
label_14000db85:
rdi = rax_14[1];
var_60_1 = *rax_14;
}
else
{
if (rcx_14 == 1)
{
rax_14 = sub_14000d684(&var_70, r13, arg2, r14);
goto label_14000db85;
}
if (rcx_14 == 2)
{
rax_14 = sub_14000d568(&var_70, r13, arg2, r14);
goto label_14000db85;
}
}
}
}
else
{
if (!arg4[5])
__crt_cached_ptd_host::update_locale_slow(arg4);
if (!*(arg4[3] + 0x138) && !*((&data_14001e690)[r12_2] + (r15_1 << 3) + 0x39))
goto label_14000dba2;
enum CONSOLE_MODE mode[0x4];
mode[0] = 0;
if (!GetConsoleMode(*((&data_14001e690)[r12_2] + (r15_1 << 3) + 0x28), &mode))
goto label_14000dba2;
int32_t rcx_6 = var_78_1;
if (!rcx_6)
{
rax_14 = sub_14000cfcc(&var_70, r13, arg2, r14, arg4);
goto label_14000db85;
}
if (rcx_6 == 1 || rcx_6 == 2)
{
void* r12_3 = arg2 + r14;
var_70 = 0;
int16_t* r15_2 = arg2;
if (arg2 < r12_3)
{
int32_t var_6c;
int32_t r14_1 = var_6c;
while (true)
{
int16_t rax_10 = *r15_2;
var_78_1 = rax_10;
int16_t rcx_9 = var_78_1;
if (sub_14000fc58(rax_10) == rcx_9)
{
r14_1 += 2;
int32_t var_6c_1 = r14_1;
if (rcx_9 != 0xa)
goto label_14000db52;
if (sub_14000fc58(0xd) == 0xd)
{
r14_1 += 1;
int32_t var_6c_2 = r14_1;
rdi += 1;
label_14000db52:
r15_2 = &r15_2[1];
if (r15_2 >= r12_3)
break;
continue;
}
}
var_70 = GetLastError();
break;
}
}
var_60_1 = var_70;
}
}
if (var_60_1 >> 0x20)
return *var_60_1[4] - rdi;
int32_t rax_21 = var_60_1;
if (rax_21)
{
if (rax_21 != 5)
__acrt_errno_map_os_error_ptd(var_60_1, arg4);
else
{
arg4[6] = 1;
*(arg4 + 0x2c) = 9;
arg4[7] = 1;
*(arg4 + 0x34) = rax_21;
}
return 0xffffffff;
}
if (!(*((&data_14001e690)[r13 >> 6] + (r13 & 0x3f) * 0x48 + 0x38) & 0x40) || *arg2 != 0x1a)
{
*(arg4 + 0x34) = 0;
arg4[6] = 1;
*(arg4 + 0x2c) = 0x1c;
arg4[7] = 1;
return 0xffffffff;
}
}
return 0;
}
uint64_t sub_14000dce0(int16_t* arg1, int16_t* arg2, int64_t arg3)
{
int64_t i_1 = arg3;
int16_t* r11 = arg2;
int16_t* r10 = arg1;
if (!arg3)
return 0;
uint32_t rcx;
uint32_t r8;
int64_t i;
do
{
rcx = *r10;
r10 = &r10[1];
r8 = *r11;
r11 = &r11[1];
if (rcx != r8)
{
uint32_t rdx = rcx + 0x20;
if (rcx - 0x41 > 0x19)
rdx = rcx;
rcx = rdx;
uint32_t rdx_1 = r8 + 0x20;
if (r8 - 0x41 > 0x19)
rdx_1 = r8;
r8 = rdx_1;
}
if (rcx != r8)
break;
if (!rcx)
break;
i = i_1;
i_1 -= 1;
} while (i != 1);
return rcx - r8;
}
int64_t sub_14000dd50(int64_t arg1, int64_t arg2, int64_t arg3)
{
if (!arg1 || !arg2 || arg3 > 0x7fffffff)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
return 0x7fffffff;
}
uint64_t sub_14000dd90(char* arg1, char* arg2, uint64_t arg3)
{
uint64_t i_1 = arg3;
char* rbx = arg2;
char* r11 = arg1;
if (data_14001e37c)
/* tailcall */
return sub_14000de20(arg1, arg2, arg3, nullptr);
if (!arg1 || !arg2 || arg3 > 0x7fffffff)
/* tailcall */
return sub_14000dd50(arg1, arg2, arg3);
if (!arg3)
return 0;
uint64_t result;
uint64_t i;
do
{
uint32_t rcx = *r11;
r11 = &r11[1];
uint32_t r8 = *rbx;
rbx = &rbx[1];
if (rcx != r8)
{
uint32_t rdx = rcx + 0x20;
if (rcx - 0x41 > 0x19)
rdx = rcx;
rcx = rdx;
if (r8 - 0x41 <= 0x19)
r8 += 0x20;
}
result = rcx - r8;
if (rcx != r8 || !rcx)
return result;
i = i_1;
i_1 -= 1;
} while (i != 1);
return result;
}
uint64_t sub_14000de20(char* arg1, void* arg2, uint64_t arg3, int128_t* arg4)
{
uint64_t i_1 = arg3;
void* rdi = arg2;
char* rsi = arg1;
if (!arg1 || !arg2 || i_1 > 0x7fffffff)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0x7fffffff;
}
if (!i_1)
return 0;
arg3 = 0;
char var_10 = 0;
void** var_28;
int128_t var_20;
if (arg4)
var_20 = *arg4;
else if (data_14001e37c)
{
void** rax_4 = __vcrt_getptd();
var_28 = rax_4;
var_20 = rax_4[0x12];
*var_20[8] = rax_4[0x11];
__acrt_update_locale_info(rax_4, &var_20);
sub_14000c81c(var_28, &*var_20[8]);
int32_t rax_7 = var_28[0x75];
if (rax_7 & 2)
arg3 = var_10;
else
{
arg3 = 1;
var_28[0x75] = rax_7 | 2;
char var_10_1 = 1;
}
}
else
var_20 = *data_14001d338;
int64_t r9 = *(var_20 + 0x110);
uint32_t rcx_3;
uint32_t rdx_2;
uint64_t i;
do
{
uint64_t rax_10 = *rsi;
rsi = &rsi[1];
rdi += 1;
rdx_2 = *(rax_10 + r9);
rcx_3 = *(*(rdi - 1) + r9);
if (rdx_2 != rcx_3)
break;
if (!rdx_2)
break;
i = i_1;
i_1 -= 1;
} while (i != 1);
if (arg3)
var_28[0x75] &= 0xfffffffd;
return rdx_2 - rcx_3;
}
uint64_t sub_14000df7c(char* arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t* arg5, int32_t arg6)
{
if (arg5)
{
*arg5 = 0xffffffff;
if (arg1 && (!arg6 || !(arg4 & 0xfffffe7f)))
{
int32_t var_18 = 0;
int32_t var_14_1 = 0;
int32_t rax_4 = _sopen_nolock(&var_18, arg5, arg1, arg2, arg3, arg4, arg6);
int32_t var_14_2 = rax_4;
if (var_18)
{
if (rax_4)
{
int64_t rcx_1 = *arg5;
uint64_t rcx_3 = (rcx_1 & 0x3f) * 9;
int64_t rax_7 = (&data_14001e690)[rcx_1 >> 6];
*(rax_7 + (rcx_3 << 3) + 0x38) &= 0xfe;
}
sub_14000afac(*arg5);
}
if (rax_4)
*arg5 = 0xffffffff;
return rax_4;
}
}
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0x16;
}
uint64_t sub_14000e040(int32_t arg1, char* arg2, int32_t arg3, char* arg4)
{
int64_t r15 = arg1;
int32_t rbx = 0;
*arg4 = 0;
int32_t rsi = arg3;
if (*((&data_14001e690)[r15 >> 6] + (r15 & 0x3f) * 0x48 + 0x38) < 0)
{
int32_t arg_8;
if (!(0x74000 & arg3))
{
arg_8 = 0;
if (_get_fmode(&arg_8))
{
int64_t var_28 = 0;
_invoke_watson();
/* no return */
}
int32_t rax_5 = arg_8 & 0x74000;
rsi = rax_5 ? rsi | rax_5 : rsi | 0x4000;
}
int32_t rcx_2 = rsi & 0x74000;
int32_t rdi_1 = 2;
if (rcx_2 == 0x4000)
*arg4 = 0;
else if (!(0xffffbfff & (rcx_2 - 0x10000)))
{
if ((rsi & 0x301) == 0x301)
*arg4 = 2;
}
else if (!(0xffffbfff & (rcx_2 - 0x20000)))
*arg4 = 2;
else if (!(0xffffbfff & (rcx_2 - 0x40000)))
*arg4 = 1;
if (rsi & 0x70000 && !(*arg2 & 0x40))
{
int32_t rax_12 = *(arg2 + 4) & 0xc0000000;
if (rax_12 == 0x40000000)
{
label_14000e14b:
int32_t rcx_3 = *(arg2 + 8);
if (rcx_3 == 1 || rcx_3 == 2)
{
label_14000e16b:
int32_t rcx_8 = *arg4;
arg_8 = 0;
int32_t rax_13;
if (rcx_8 == 1)
{
rdi_1 = 3;
rax_13 = 0xbfbbef;
label_14000e264:
arg_8 = rax_13;
while (true)
{
int32_t rax_23 = sub_14000d7f8(r15, &arg_8 + rbx, rdi_1 - rbx);
if (rax_23 == 0xffffffff)
return *sub_140007fb4();
rbx += rax_23;
if (rdi_1 <= rbx)
return 0;
}
}
else if (rcx_8 == 2)
{
rax_13 = 0xfeff;
goto label_14000e264;
}
}
else if (rcx_3 == 3 || rcx_3 == 4)
{
if (!_lseeki64_nolock(r15, 0, FILE_END))
goto label_14000e16b;
if (_lseeki64_nolock(r15, 0, FILE_BEGIN) == -1)
return *sub_140007fb4();
if (*(arg2 + 4) & 0x80000000)
goto label_14000e1cf;
}
else if (rcx_3 == 5)
goto label_14000e16b;
}
else if (rax_12 == 0x80000000)
{
label_14000e1cf:
arg_8 = 0;
int32_t rax_18 = _read_nolock(r15, &arg_8, 3);
if (rax_18 == 0xffffffff)
return *sub_140007fb4();
if (rax_18 == 2)
{
label_14000e202:
uint32_t rcx_13 = arg_8;
if (rcx_13 == 0xfffe)
{
*sub_140007fb4() = 0x16;
return *sub_140007fb4();
}
if (rcx_13 != 0xfeff)
goto label_14000e24a;
if (_lseeki64_nolock(r15, 2, FILE_BEGIN) == -1)
return *sub_140007fb4();
*arg4 = 2;
}
else if (rax_18 != 3)
{
label_14000e24a:
if (_lseeki64_nolock(r15, 0, FILE_BEGIN) == -1)
return *sub_140007fb4();
}
else
{
if (arg_8 != 0xbfbbef)
goto label_14000e202;
*arg4 = 1;
}
}
else if (rax_12 == 0xc0000000)
goto label_14000e14b;
}
}
return 0;
}
char* sub_14000e2c0(char* arg1, int32_t arg2, int32_t arg3, char arg4)
{
__builtin_memset(arg1, 0, 0x18);
int32_t rsi = -1;
int32_t rcx_1 = arg2 & 3;
int32_t rax_2;
if (!rcx_1)
rax_2 = -0x80000000;
else if (rcx_1 == 1)
{
int32_t rcx_2;
rcx_2 = arg2 & 0x70000;
int32_t rax;
rax = arg2 & 8;
rcx_2 &= rax;
char temp1_1 = rcx_2;
rcx_2 = -(rcx_2);
rax_2 = ((rax - rax) & 0x80000000) + 0x40000000;
}
else if (rcx_1 == 2)
rax_2 = -0x40000000;
else
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
rax_2 = -1;
}
*(arg1 + 4) = rax_2;
int32_t rax_8;
switch (arg2 & 0x700)
{
case 0:
{
rax_8 = 3;
break;
}
case 0x100:
{
rax_8 = 4;
break;
}
case 0x200:
{
rax_8 = 5;
break;
}
case 0x300:
{
rax_8 = 2;
break;
}
case 0x400:
{
rax_8 = 3;
break;
}
case 0x500:
{
rax_8 = 1;
break;
}
case 0x600:
{
rax_8 = 5;
break;
}
case 0x700:
{
rax_8 = 1;
break;
}
default:
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
rax_8 = -1;
}
}
*(arg1 + 8) = rax_8;
if (arg3 == 0x10)
rsi = 0;
else if (arg3 == 0x20)
rsi = 1;
else if (arg3 == 0x30)
rsi = 2;
else if (arg3 == 0x40)
rsi = 3;
else if (arg3 == 0x80)
rsi = *(arg1 + 4) == 0x80000000;
else
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
*(arg1 + 0x14) = 0;
*(arg1 + 0xc) = rsi;
*(arg1 + 0x10) = 0x80;
if (arg2 < 0)
*arg1 |= 0x10;
if (!(0x8000 & arg2))
{
if (arg2 & 0x74000)
*arg1 |= 0x80;
else
{
int32_t arg_10 = 0;
if (_get_fmode(&arg_10))
{
int64_t var_28 = 0;
_invoke_watson();
/* no return */
}
if (arg_10 != 0x8000)
*arg1 |= 0x80;
}
}
if (0x100 & arg2 && (~data_14001ebb0 & arg4) >= 0)
*(arg1 + 0x10) = 1;
if (arg2 & 0x40)
{
*(arg1 + 0x14) |= 0x4000000;
*(arg1 + 4) |= 0x10000;
*(arg1 + 0xc) |= 4;
}
if (TEST_BITD(arg2, 0xc))
*(arg1 + 0x10) |= 0x100;
if (TEST_BITD(arg2, 0xd))
*(arg1 + 0x14) |= 0x2000000;
if (arg2 & 0x20)
*(arg1 + 0x14) |= 0x8000000;
else if (arg2 & 0x10)
*(arg1 + 0x14) |= 0x10000000;
return arg1;
}
uint64_t truncate_ctrl_z_if_present(int32_t arg1)
{
int64_t rbx = arg1;
char rcx = *((&data_14001e690)[rbx >> 6] + (rbx & 0x3f) * 0x48 + 0x38);
if (!(rcx & 0x48) && rcx < 0)
{
int64_t rax_3 = _lseeki64_nolock(rbx, -1, FILE_END);
if (rax_3 != -1)
{
int16_t arg_8 = 0;
if (!_read_nolock(rbx, &arg_8, 1) && arg_8 == 0x1a
&& _chsize_nolock(rbx, rax_3) == 0xffffffff)
return *sub_140007fb4();
if (_lseeki64_nolock(rbx, 0, FILE_BEGIN) == -1)
return *sub_140007fb4();
}
else if (*sub_140007f90() != 0x83)
return *sub_140007fb4();
}
return 0;
}
uint64_t _sopen_nolock(int32_t* arg1, int32_t* arg2, char* arg3, int32_t arg4, int32_t arg5, char arg6, int32_t arg7)
{
int64_t var_40;
__builtin_memset(&var_40, 0, 0x29);
void* var_60;
_LocaleUpdate::_LocaleUpdate(&var_60, nullptr);
uint32_t r9 = 0xfde9;
void* var_58;
char var_48;
if (*(var_58 + 0xc) != 0xfde9)
{
int32_t rax_2 = sub_14000bf44();
if (rax_2)
{
if (var_48)
{
void* rax_4 = var_60;
*(rax_4 + 0x3a8) &= 0xfffffffd;
}
r9 = 0;
}
else
{
if (var_48 != rax_2)
{
void* rax_3 = var_60;
*(rax_3 + 0x3a8) &= 0xfffffffd;
}
r9 = 1;
}
}
else if (var_48)
{
void* rax_1 = var_60;
*(rax_1 + 0x3a8) &= 0xfffffffd;
}
void var_68;
PWSTR var_30;
int32_t rbx_1;
if (!sub_14000903c(arg3, &var_40, &var_68, r9))
{
int32_t var_78_1 = arg7;
rbx_1 = sub_14000e6e8(arg1, arg2, var_30, arg4, arg5, arg6);
}
else
rbx_1 = -1;
char var_18;
if (var_18)
_free_base(var_30);
return rbx_1;
}
uint64_t _sopen_s(int32_t* arg1, char* arg2, int32_t arg3, int32_t arg4, int32_t arg5)
{
return sub_14000df7c(arg2, arg3, arg4, arg5, arg1, 1);
}
uint64_t sub_14000e6e8(int32_t* arg1, int32_t* arg2, PWSTR arg3, int32_t arg4, int32_t arg5, char arg6)
{
void var_48;
char* rax = sub_14000e2c0(&var_48, arg4, arg5, arg6);
uint128_t zmm0 = *rax;
int64_t zmm1 = *(rax + 0x10);
uint32_t dwShareMode_1 = *(rax + 8) >> 0x20;
uint32_t dwShareMode = dwShareMode_1;
uint128_t var_68 = zmm0;
uint128_t var_c0 = zmm0;
if (dwShareMode_1 != 0xffffffff)
{
int32_t rax_4 = _alloc_osfhnd();
*arg2 = rax_4;
if (rax_4 != 0xffffffff)
{
uint128_t zmm0_1 = var_68;
*arg1 = 1;
enum FILE_FLAGS_AND_ATTRIBUTES dwFlagsAndAttributes = zmm1 >> 0x20 | zmm1;
uint128_t temp0_1 = _mm_bsrli_si128(zmm0_1, 8);
SECURITY_ATTRIBUTES securityAttributes;
securityAttributes.bInheritHandle = ~(arg4 >> 7) & 1;
securityAttributes.nLength = 0x18;
*(securityAttributes + 0x14) = 0;
securityAttributes.lpSecurityDescriptor = 0;
enum FILE_CREATION_DISPOSITION dwCreationDisposition = temp0_1;
HANDLE rax_11 = CreateFileW(arg3, zmm0_1 >> 0x20, dwShareMode_1, &securityAttributes,
temp0_1, dwFlagsAndAttributes, nullptr);
HANDLE r13_1 = rax_11;
int32_t rbx_2;
if (rax_11 != -1)
{
rbx_2 = *var_c0[4];
label_14000e8a4:
enum FILE_TYPE rax_20 = GetFileType(r13_1);
if (rax_20)
{
dwShareMode_1 = var_c0;
if (rax_20 == FILE_TYPE_CHAR)
dwShareMode_1 |= 0x40;
else if (rax_20 == FILE_TYPE_PIPE)
dwShareMode_1 |= 8;
__acrt_lowio_set_os_handle(*arg2, r13_1);
int64_t rcx_14 = *arg2;
dwShareMode_1 |= 1;
char var_a8_1 = dwShareMode_1;
var_c0 = dwShareMode_1;
*((&data_14001e690)[rcx_14 >> 6] + (rcx_14 & 0x3f) * 0x48 + 0x38) =
dwShareMode_1;
int64_t rcx_17 = *arg2;
*((&data_14001e690)[rcx_17 >> 6] + (rcx_17 & 0x3f) * 0x48 + 0x39) = 0;
int32_t rax_29;
int32_t r14_1;
if (arg4 & 2)
{
rax_29 = truncate_ctrl_z_if_present(*arg2);
r14_1 = rax_29;
}
if (arg4 & 2 && rax_29)
{
sub_14000723c(*arg2);
return r14_1;
}
int32_t rcx_22 = *arg2;
var_68 = var_c0;
char var_c8 = 0;
int64_t var_58_1 = zmm1;
r14_1 = sub_14000e040(rcx_22, &var_68, arg4, &var_c8);
int64_t rax_31 = *arg2;
if (r14_1)
{
sub_14000723c(rax_31);
return r14_1;
}
uint64_t rax_32;
rax_32 = var_c8;
*((&data_14001e690)[rax_31 >> 6] + (rax_31 & 0x3f) * 0x48 + 0x39) = rax_32;
int64_t rcx_26 = *arg2;
uint64_t rdx_11 = (rcx_26 & 0x3f) * 9;
int64_t rcx_28 = (&data_14001e690)[rcx_26 >> 6];
*(rcx_28 + (rdx_11 << 3) + 0x3d) ^=
(arg4 >> 0x10 ^ *(rcx_28 + (rdx_11 << 3) + 0x3d)) & 1;
if (!(var_a8_1 & 0x48) && arg4 & 8)
{
int64_t rcx_29 = *arg2;
uint64_t rcx_31 = (rcx_29 & 0x3f) * 9;
int64_t rax_39 = (&data_14001e690)[rcx_29 >> 6];
*(rax_39 + (rcx_31 << 3) + 0x38) |= 0x20;
}
if ((rbx_2 & 0xc0000000) != 0xc0000000 || !(arg4 & 1))
return 0;
CloseHandle(r13_1);
*var_c0[4] = rbx_2 & 0x7fffffff;
HANDLE rax_44 = CreateFileW(arg3, var_c0 >> 0x20, dwShareMode,
&securityAttributes, dwCreationDisposition, dwFlagsAndAttributes, nullptr);
if (rax_44 != -1)
{
int64_t rcx_39 = *arg2;
*((&data_14001e690)[rcx_39 >> 6] + (rcx_39 & 0x3f) * 0x48 + 0x28) = rax_44;
return 0;
}
sub_140007f44(GetLastError());
int64_t rcx_35 = *arg2;
uint64_t rcx_37 = (rcx_35 & 0x3f) * 9;
int64_t rax_48 = (&data_14001e690)[rcx_35 >> 6];
*(rax_48 + (rcx_37 << 3) + 0x38) &= 0xfe;
_free_osfhnd(*arg2);
}
else
{
enum WIN32_ERROR rax_21 = GetLastError();
sub_140007f44(rax_21);
int64_t rdx_5 = *arg2;
uint64_t rdx_7 = (rdx_5 & 0x3f) * 9;
int64_t rcx_11 = (&data_14001e690)[rdx_5 >> 6];
*(rcx_11 + (rdx_7 << 3) + 0x38) &= 0xfe;
CloseHandle(r13_1);
if (!rax_21)
*sub_140007fb4() = 0xd;
}
}
else
{
int32_t rbx_1 = _mm_bsrli_si128(var_68, 4);
HANDLE rax_15;
if ((rbx_1 & 0xc0000000) == 0xc0000000 && arg4 & 1)
{
rbx_2 = rbx_1 & 0x7fffffff;
*var_c0[4] = rbx_2;
rax_15 = CreateFileW(arg3, var_c0 >> 0x20, dwShareMode_1, &securityAttributes,
dwCreationDisposition, dwFlagsAndAttributes, nullptr);
r13_1 = rax_15;
}
if ((rbx_1 & 0xc0000000) == 0xc0000000 && arg4 & 1 && rax_15 != -1)
goto label_14000e8a4;
int64_t rcx_3 = *arg2;
uint64_t rcx_5 = (rcx_3 & 0x3f) * 9;
int64_t rax_18 = (&data_14001e690)[rcx_3 >> 6];
*(rax_18 + (rcx_5 << 3) + 0x38) &= 0xfe;
sub_140007f44(GetLastError());
}
}
else
{
*sub_140007f90() = 0;
*arg2 = 0xffffffff;
*sub_140007fb4() = 0x18;
}
}
else
{
*sub_140007f90() = 0;
*arg2 = 0xffffffff;
}
return *sub_140007fb4();
}
uint64_t _isatty(int32_t arg1)
{
if (arg1 != 0xfffffffe)
{
if (arg1 >= 0 && arg1 < data_14001ea90)
{
int64_t rcx = arg1;
return *((&data_14001e690)[rcx >> 6] + (rcx & 0x3f) * 0x48 + 0x38) & 0x40;
}
*sub_140007fb4() = 9;
_invalid_parameter_noinfo();
}
else
*sub_140007fb4() = 9;
return 0;
}
int64_t common_lseek_nolock<int64_t>(int32_t arg1, int64_t arg2, enum SET_FILE_POINTER_MOVE_METHOD arg3, void* arg4)
{
int64_t rdi = arg1;
HANDLE hFile = _get_osfhandle(rdi);
if (hFile != -1)
{
int64_t newFilePointer[0x2];
newFilePointer[0] = 0;
if (SetFilePointerEx(hFile, arg2, &newFilePointer, arg3))
{
int64_t result = newFilePointer[0];
if (result != -1)
{
uint64_t rdx_4 = (rdi & 0x3f) * 9;
int64_t rcx_5 = (&data_14001e690)[rdi >> 6];
*(rcx_5 + (rdx_4 << 3) + 0x38) &= 0xfd;
return result;
}
}
else
__acrt_errno_map_os_error_ptd(GetLastError(), arg4);
}
else
{
*(arg4 + 0x30) = 1;
*(arg4 + 0x2c) = 9;
}
return -1;
}
int64_t _lseeki64_nolock(int32_t arg1, int64_t arg2, enum SET_FILE_POINTER_MOVE_METHOD arg3)
{
void* var_48 = nullptr;
char var_38 = 0;
char var_20 = 0;
char var_18 = 0;
if (!data_14001e37c)
{
var_20 = 1;
int128_t var_30_1 = *data_14001d338;
}
int64_t result = common_lseek_nolock<int64_t>(arg1, arg2, arg3, &var_48);
if (var_20 == 2)
{
void* rcx = var_48;
*(rcx + 0x3a8) &= 0xfffffffd;
}
int32_t var_1c;
if (var_18)
*(sub_140005064(&var_48) + 0x20) = var_1c;
int32_t var_14;
if (0)
*(sub_140005064(&var_48) + 0x24) = var_14;
return result;
}
int64_t j_common_lseek_nolock<int64_t>(int32_t arg1, int64_t arg2, enum SET_FILE_POINTER_MOVE_METHOD arg3, void* arg4)
{
/* tailcall */
return common_lseek_nolock<int64_t>(arg1, arg2, arg3, arg4);
}
int64_t __acrt_stdio_allocate_buffer_nolock(int64_t* arg1)
{
data_14001e3d0 += 1;
int32_t rdi = 0x1000;
arg1[1] = _calloc_base(0x1000, 1);
_free_base(0);
if (!arg1[1])
{
*(arg1 + 0x14) |= 0x400;
rdi = 2;
arg1[1] = arg1 + 0x1c;
}
else
*(arg1 + 0x14) |= 0x40;
arg1[4] = rdi;
int64_t result = arg1[1];
arg1[2] = 0;
*arg1 = result;
return result;
}
uint64_t sub_14000ed20(char* arg1, int64_t arg2, void* arg3, void (* arg4)())
{
void var_468;
int64_t rax_1 = __security_cookie ^ &var_468;
char* r13 = arg1;
uint64_t result;
if (arg1)
{
if (arg3 && arg4)
goto label_14000ed79;
*sub_140007fb4() = 0x16;
result = _invalid_parameter_noinfo();
}
else if (!arg2 && arg3 && arg4)
{
label_14000ed79:
sub_14000fec0(arg4);
int128_t var_438[0x1f];
sub_140010a60(&var_438, 0, 0x1f0);
int128_t var_248[0x1f];
result = sub_140010a60(&var_248, 0, 0x1f0);
if (arg2 >= 2)
{
char* r15_3 = (arg2 - 1) * arg3 + r13;
int64_t rcx_3 = 0;
int64_t var_448_1 = 0;
while (true)
{
result = COMBINE(0, r15_3 - r13) / arg3;
if (result + 1 > 8)
{
void* rbx_5 = ((result + 1) >> 1) * arg3;
char* rdi_2 = rbx_5 + r13;
if (arg4(r13, rdi_2) > 0)
{
void* i_12 = arg3;
char* r8 = rdi_2;
if (r13 != rdi_2)
{
void* i;
do
{
void* rdx_6 = r8 - rbx_5;
char rcx_8 = *rdx_6;
*rdx_6 = *r8;
*r8 = rcx_8;
r8 = &r8[1];
i = i_12;
i_12 -= 1;
} while (i != 1);
}
}
if (arg4(r13, r15_3) > 0)
{
void* i_9 = arg3;
char* rdx_8 = r15_3;
if (r13 != r15_3)
{
void* r9_1 = r13 - r15_3;
void* i_1;
do
{
char rcx_10 = *(r9_1 + rdx_8);
*(r9_1 + rdx_8) = *rdx_8;
*rdx_8 = rcx_10;
rdx_8 = &rdx_8[1];
i_1 = i_9;
i_9 -= 1;
} while (i_1 != 1);
}
}
if (arg4(rdi_2, r15_3) > 0)
{
void* i_10 = arg3;
char* rdx_10 = r15_3;
if (rdi_2 != r15_3)
{
void* r9_3 = rdi_2 - r15_3;
void* i_2;
do
{
char rcx_12 = *(r9_3 + rdx_10);
*(r9_3 + rdx_10) = *rdx_10;
*rdx_10 = rcx_12;
rdx_10 = &rdx_10[1];
i_2 = i_10;
i_10 -= 1;
} while (i_2 != 1);
}
}
char* rbx_6 = r13;
char* rsi_2 = r15_3;
char* rbp_1;
while (true)
{
if (rdi_2 > rbx_6)
{
while (true)
{
rbx_6 += arg3;
if (rbx_6 >= rdi_2)
break;
if (arg4(rbx_6, rdi_2) > 0)
goto label_14000ef9b;
}
}
int32_t i_3;
do
{
rbx_6 += arg3;
if (rbx_6 > r15_3)
break;
i_3 = arg4(rbx_6, rdi_2);
} while (i_3 <= 0);
label_14000ef9b:
int32_t i_4;
do
{
rbp_1 = rsi_2;
rsi_2 -= arg3;
if (rsi_2 <= rdi_2)
break;
i_4 = arg4(rsi_2, rdi_2);
} while (i_4 > 0);
if (rsi_2 < rbx_6)
break;
void* i_11 = arg3;
char* rdx_14 = rsi_2;
if (rsi_2 != rbx_6)
{
void* r9_5 = rbx_6 - rsi_2;
void* i_5;
do
{
char rcx_16 = *(r9_5 + rdx_14);
*(r9_5 + rdx_14) = *rdx_14;
*rdx_14 = rcx_16;
rdx_14 = &rdx_14[1];
i_5 = i_11;
i_11 -= 1;
} while (i_5 != 1);
}
char* rax_13 = rbx_6;
if (rdi_2 != rsi_2)
rax_13 = rdi_2;
rdi_2 = rax_13;
}
if (rdi_2 < rbp_1)
{
while (true)
{
rbp_1 -= arg3;
if (rbp_1 <= rdi_2)
break;
if (arg4(rbp_1, rdi_2))
goto label_14000f015;
}
}
int32_t i_6;
do
{
rbp_1 -= arg3;
if (rbp_1 <= r13)
break;
i_6 = arg4(rbp_1, rdi_2);
} while (!i_6);
label_14000f015:
result = rbp_1 - r13;
rcx_3 = var_448_1;
if (result < r15_3 - rbx_6)
{
if (rbx_6 < r15_3)
{
*(&var_438 + (rcx_3 << 3)) = rbx_6;
*(&var_248 + (rcx_3 << 3)) = r15_3;
rcx_3 += 1;
var_448_1 = rcx_3;
}
if (r13 < rbp_1)
{
r15_3 = rbp_1;
continue;
}
}
else
{
if (r13 < rbp_1)
{
*(&var_438 + (rcx_3 << 3)) = r13;
*(&var_248 + (rcx_3 << 3)) = rbp_1;
rcx_3 += 1;
var_448_1 = rcx_3;
}
if (rbx_6 < r15_3)
{
r13 = rbx_6;
continue;
}
}
}
else if (r15_3 > r13)
{
char* rsi_1 = arg3 + r13;
do
{
char* rbx_2 = r13;
char* rdi_1 = rsi_1;
if (rsi_1 <= r15_3)
{
do
{
result = arg4(rdi_1, rbx_2);
char* rcx_5 = rdi_1;
if (result <= 0)
rcx_5 = rbx_2;
rdi_1 += arg3;
rbx_2 = rcx_5;
} while (rdi_1 <= r15_3);
}
void* i_8 = arg3;
char* rdx_3 = r15_3;
if (rbx_2 != r15_3)
{
char* rbx_3 = rbx_2 - r15_3;
void* i_7;
do
{
result = *rdx_3;
char rcx_6 = *(rbx_3 + rdx_3);
*(rbx_3 + rdx_3) = result;
*rdx_3 = rcx_6;
rdx_3 = &rdx_3[1];
i_7 = i_8;
i_8 -= 1;
} while (i_7 != 1);
}
r15_3 -= arg3;
} while (r15_3 > r13);
rcx_3 = var_448_1;
}
int64_t temp3_1 = rcx_3;
rcx_3 -= 1;
var_448_1 = rcx_3;
if (temp3_1 - 1 < 0)
break;
r13 = *(&var_438 + (rcx_3 << 3));
r15_3 = *(&var_248 + (rcx_3 << 3));
}
}
}
else
{
*sub_140007fb4() = 0x16;
result = _invalid_parameter_noinfo();
}
__security_check_cookie(rax_1 ^ &var_468);
return result;
}
uint64_t sub_14000f0c0(char* arg1, int64_t arg2, int64_t arg3, int64_t arg4)
{
int64_t rbx = arg2;
char* r11 = arg1;
if (!arg4)
{
if (arg1)
goto label_14000f0f7;
if (!arg2)
return 0;
}
else if (r11)
{
label_14000f0f7:
if (rbx)
{
if (!arg4)
{
*arg1 = arg4;
return 0;
}
if (arg3)
{
char* r10_1 = arg3 - r11;
int64_t i_2 = arg4;
if (arg4 != -1)
{
int64_t i_3;
int64_t i;
do
{
char rax_6 = *(r10_1 + arg1);
i_3 = i_2;
*arg1 = rax_6;
arg1 = &arg1[1];
if (!rax_6)
return 0;
int64_t temp0_1 = arg2;
arg2 -= 1;
if (temp0_1 == 1)
break;
i = i_2;
i_2 -= 1;
} while (i != 1);
int64_t i_4 = i_3 - 1;
if (!arg2)
i_4 = i_3;
if (!i_4)
*arg1 = i_4;
}
else
{
int64_t i_1;
do
{
char rax_5 = *(r10_1 + arg1);
*arg1 = rax_5;
arg1 = &arg1[1];
if (!rax_5)
return 0;
i_1 = arg2;
arg2 -= 1;
} while (i_1 != 1);
}
if (arg2)
return 0;
if (arg4 == -1)
{
r11[rbx - 1] = arg2;
return arg2 + 0x50;
}
*r11 = 0;
*sub_140007fb4() = 0x22;
_invalid_parameter_noinfo();
return 0x22;
}
*arg1 = arg3;
}
}
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return 0x16;
}
char* sub_14000f1f0(char* arg1, char* arg2)
{
int128_t var_38;
int64_t rax_1 = __security_cookie ^ &var_38;
char i = *arg2;
char* result = arg1;
__builtin_memset(&var_38, 0, 0x20);
while (i)
{
var_38 |= 1 << (i % 0x20);
i = arg2[1];
arg2 = &arg2[1];
}
char i_1 = *result;
while (i_1)
{
if (*(&var_38 + (i_1 >> 3)) >> (i_1 & 7) & 1)
{
__security_check_cookie(rax_1 ^ &var_38);
return result;
}
i_1 = result[1];
result = &result[1];
}
__security_check_cookie(rax_1 ^ &var_38);
return 0;
}
char* sub_14000f290(char* arg1, char* arg2)
{
uint64_t r10_1 = arg2 & 0xf;
int128_t* rbx_1 = arg2 - r10_1;
char* result = arg1;
uint128_t zmm1 = *rbx_1;
if (r10_1 - 1 <= 0xe)
switch (r10_1)
{
case 1:
{
zmm1 = _mm_bsrli_si128(zmm1, 1);
break;
}
case 2:
{
zmm1 = _mm_bsrli_si128(zmm1, 2);
break;
}
case 3:
{
zmm1 = _mm_bsrli_si128(zmm1, 3);
break;
}
case 4:
{
zmm1 = _mm_bsrli_si128(zmm1, 4);
break;
}
case 5:
{
zmm1 = _mm_bsrli_si128(zmm1, 5);
break;
}
case 6:
{
zmm1 = _mm_bsrli_si128(zmm1, 6);
break;
}
case 7:
{
zmm1 = _mm_bsrli_si128(zmm1, 7);
break;
}
case 8:
{
zmm1 = _mm_bsrli_si128(zmm1, 8);
break;
}
case 9:
{
zmm1 = _mm_bsrli_si128(zmm1, 9);
break;
}
case 0xa:
{
zmm1 = _mm_bsrli_si128(zmm1, 0xa);
break;
}
case 0xb:
{
zmm1 = _mm_bsrli_si128(zmm1, 0xb);
break;
}
case 0xc:
{
zmm1 = _mm_bsrli_si128(zmm1, 0xc);
break;
}
case 0xd:
{
zmm1 = _mm_bsrli_si128(zmm1, 0xd);
break;
}
case 0xe:
{
zmm1 = _mm_bsrli_si128(zmm1, 0xe);
break;
}
case 0xf:
{
zmm1 = _mm_bsrli_si128(zmm1, 0xf);
break;
}
}
uint32_t temp0_17 = _mm_movemask_epi8(_mm_cmpeq_epi8({0}, zmm1));
if (temp0_17)
{
uint64_t rflags_1;
int32_t temp0_18;
temp0_18 = _bit_scan_forward(temp0_17);
int32_t rdi;
if (r10_1)
rdi = temp0_18 < 0x10 - r10_1;
else
rdi = 1;
uint64_t rax_5 = 0xf - temp0_18;
if (rax_5 <= 0xf)
switch (rax_5)
{
case 0:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 1), 1);
break;
}
case 1:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 2), 2);
break;
}
case 2:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 3), 3);
break;
}
case 3:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 4), 4);
break;
}
case 4:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 5), 5);
break;
}
case 5:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 6), 6);
break;
}
case 6:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 7), 7);
break;
}
case 7:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 8), 8);
break;
}
case 8:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 9), 9);
break;
}
case 9:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 0xa), 0xa);
break;
}
case 0xa:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 0xb), 0xb);
break;
}
case 0xb:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 0xc), 0xc);
break;
}
case 0xc:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 0xd), 0xd);
break;
}
case 0xd:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 0xe), 0xe);
break;
}
case 0xe:
{
zmm1 = _mm_bsrli_si128(_mm_slli_si128(zmm1, 0xf), 0xf);
break;
}
case 0xf:
{
zmm1 = {0};
break;
}
}
if (!rdi)
goto label_14000f458;
}
else if (r10_1)
{
label_14000f458:
char zmm2[0x10] = rbx_1[1];
uint32_t temp0_50 = _mm_movemask_epi8(_mm_cmpeq_epi8(zmm2, {0}));
int32_t temp0_51;
uint64_t rflags_2;
if (temp0_50)
temp0_51 = _bit_scan_forward(temp0_50);
if (!temp0_50 || temp0_51 - r10_1 + 0x10 > 0x10)
/* tailcall */
return sub_14000f1f0(result, arg2);
uint64_t r9_1 = 0xf - temp0_51;
if (r9_1 <= 0xf)
switch (r9_1)
{
case 0:
{
zmm2 = _mm_slli_si128(zmm2, 1);
break;
}
case 1:
{
zmm2 = _mm_slli_si128(zmm2, 2);
break;
}
case 2:
{
zmm2 = _mm_slli_si128(zmm2, 3);
break;
}
case 3:
{
zmm2 = _mm_slli_si128(zmm2, 4);
break;
}
case 4:
{
zmm2 = _mm_slli_si128(zmm2, 5);
break;
}
case 5:
{
zmm2 = _mm_slli_si128(zmm2, 6);
break;
}
case 6:
{
zmm2 = _mm_slli_si128(zmm2, 7);
break;
}
case 7:
{
zmm2 = _mm_slli_si128(zmm2, 8);
break;
}
case 8:
{
zmm2 = _mm_slli_si128(zmm2, 9);
break;
}
case 9:
{
zmm2 = _mm_slli_si128(zmm2, 0xa);
break;
}
case 0xa:
{
zmm2 = _mm_slli_si128(zmm2, 0xb);
break;
}
case 0xb:
{
zmm2 = _mm_slli_si128(zmm2, 0xc);
break;
}
case 0xc:
{
zmm2 = _mm_slli_si128(zmm2, 0xd);
break;
}
case 0xd:
{
zmm2 = _mm_slli_si128(zmm2, 0xe);
break;
}
case 0xe:
{
zmm2 = _mm_slli_si128(zmm2, 0xf);
break;
}
case 0xf:
{
zmm2 = {0};
break;
}
}
zmm1 = _mm_or_ps(zmm1, zmm2);
}
else if (*(rbx_1 + 1))
/* tailcall */
return sub_14000f1f0(arg1, arg2);
char i = *result;
while (i)
{
char zmm0[0x10] = i;
zmm0 = _mm_unpacklo_epi8(zmm0, zmm0[0]);
if (_mm_movemask_epi8(_mm_cmpeq_epi8(
_mm_shuffle_epi32(_mm_unpacklo_epi8(zmm0, zmm0[0]), 0), zmm1)))
return result;
i = result[1];
result = &result[1];
}
return 0;
}
int64_t _mbsdec(int64_t arg1, void* arg2)
{
/* tailcall */
return _mbsdec_l(arg1, arg2, nullptr);
}
char* _mbsdec_l(int64_t arg1, void* arg2, int128_t* arg3)
{
if (!arg1 || !arg2)
{
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
}
else if (arg1 < arg2)
{
void* var_28;
_LocaleUpdate::_LocaleUpdate(&var_28, arg3);
char* result = arg2 - 1;
void* var_18;
if (*(var_18 + 8))
{
do
{
result -= 1;
if (arg1 > result)
break;
} while (*(*result + var_18 + 0x19) & 4);
result = arg2 - ((arg2 - result) & 1) - 1;
}
char var_10;
if (var_10)
{
void* rcx_5 = var_28;
*(rcx_5 + 0x3a8) &= 0xfffffffd;
}
return result;
}
return nullptr;
}
int64_t __acrt_LCMapStringA_stat(int64_t* arg1, int64_t arg2, int32_t arg3, char* arg4, int32_t arg5, int64_t arg6, int32_t arg7, uint32_t arg8, int32_t arg9)
{
int64_t __saved_rbp_1;
int64_t __saved_rbp = __saved_rbp_1;
int64_t __saved_r12_1;
int64_t __saved_r12 = __saved_r12_1;
int64_t __saved_r13_1;
int64_t __saved_r13 = __saved_r13_1;
int64_t __saved_r14_1;
int64_t __saved_r14 = __saved_r14_1;
int64_t __saved_r15_1;
int64_t __saved_r15 = __saved_r15_1;
void var_88;
void* rsp_1 = &var_88;
int64_t __saved_rbx_1;
int64_t __saved_rbx = __saved_rbx_1;
int64_t __saved_rsi_1;
int64_t __saved_rsi = __saved_rsi_1;
int64_t __saved_rdi_1;
int64_t __saved_rdi = __saved_rdi_1;
void var_38;
int64_t rax_1 = __security_cookie ^ &var_38;
int64_t rdi = arg5;
uint8_t* rsi = arg4;
int64_t r13 = arg2;
if (rdi > 0)
{
arg2 = rdi;
int32_t rax_2 = __strncnt(arg4, arg2);
bool cond:0_1 = rax_2 < rdi;
rdi = rax_2 + 1;
if (!cond:0_1)
rdi = rax_2;
}
uint32_t r14 = arg8;
if (!r14)
r14 = *(*arg1 + 0xc);
int32_t temp0 = arg9;
arg9 = -(arg9);
int32_t var_60 = 0;
int64_t var_68 = 0;
int32_t result = __acrt_MultiByteToWideChar(r14, ((arg2 - arg2) & 8) + 1, rsi, rdi);
int64_t result_1 = result;
if (result)
{
int64_t rax_5 = result_1 * 2;
uint64_t rax_7 = (rax_5 - rax_5) & (rax_5 + 0x10);
void* rbx_1;
int64_t rsi_1;
if (rax_7)
{
if (rax_7 > 0x400)
{
void* rax_9 = _malloc_base(rax_7);
rbx_1 = rax_9;
if (rax_9)
{
*rax_9 = 0xdddd;
rbx_1 += 0x10;
}
}
else
{
int64_t rcx_3 = rax_7 + 0xf;
if (rcx_3 <= rax_7)
rcx_3 = 0xffffffffffffff0;
int64_t rcx_4 = rcx_3 & 0xfffffffffffffff0;
__chkstk(rcx_4);
rsp_1 = &var_88 - rcx_4;
rbx_1 = rsp_1 + 0x50;
if (!rbx_1)
goto label_14000f9d5;
*rbx_1 = 0xcccc;
rbx_1 += 0x10;
}
if (!rbx_1)
goto label_14000f9d5;
*(rsp_1 + 0x28) = result_1;
*(rsp_1 + 0x20) = rbx_1;
if (!__acrt_MultiByteToWideChar(r14, MB_PRECOMPOSED, rsi, rdi))
goto label_14000f9d5;
__builtin_memset(rsp_1 + 0x30, 0, 0x18);
*(rsp_1 + 0x28) = 0;
*(rsp_1 + 0x20) = 0;
int32_t rax_11 = sub_14000bfc4(r13, arg3, rbx_1, result_1);
rsi_1 = rax_11;
if (!rax_11)
goto label_14000f9d5;
if (0x400 & arg3)
{
if (!arg7)
goto label_14000f9e0;
if (rsi_1 > arg7)
goto label_14000f9d5;
__builtin_memset(rsp_1 + 0x30, 0, 0x18);
*(rsp_1 + 0x28) = arg7;
*(rsp_1 + 0x20) = arg6;
int32_t rax_14 = sub_14000bfc4(r13, arg3, rbx_1, result_1);
rsi_1 = rax_14;
if (rax_14)
goto label_14000f9e0;
goto label_14000f9d5;
}
int64_t rcx_10 = rsi_1 * 2;
uint64_t rcx_12 = (rcx_10 - rcx_10) & (rcx_10 + 0x10);
void* rdi_1;
if (!rcx_12)
{
rdi_1 = nullptr;
label_14000f9b8:
if (!rdi_1 || *(rdi_1 - 0x10) != 0xdddd)
rsi_1 = 0;
else
{
_free_base(rdi_1 - 0x10);
rsi_1 = 0;
}
}
else if (rcx_12 > 0x400)
{
void* rax_18 = _malloc_base(rcx_12);
rdi_1 = rax_18;
if (rax_18)
{
*rax_18 = 0xdddd;
label_14000f91e:
rdi_1 += 0x10;
}
if (!rdi_1)
rsi_1 = 0;
else
{
__builtin_memset(rsp_1 + 0x30, 0, 0x18);
*(rsp_1 + 0x28) = rsi_1;
*(rsp_1 + 0x20) = rdi_1;
int64_t rdx_6 = 0;
if (!sub_14000bfc4(r13, arg3, rbx_1, result_1))
goto label_14000f9b8;
uint64_t r9_5 = rsi_1;
*(rsp_1 + 0x38) = 0;
*(rsp_1 + 0x30) = 0;
uint64_t rcx_14 = r14;
if (!arg7)
{
*(rsp_1 + 0x28) = 0;
*(rsp_1 + 0x20) = 0;
int32_t rax_21 = __acrt_WideCharToMultiByte(rcx_14, rdx_6, rdi_1, r9_5);
rsi_1 = rax_21;
if (rax_21)
goto label_14000f9a6;
goto label_14000f9b8;
}
*(rsp_1 + 0x28) = arg7;
*(rsp_1 + 0x20) = arg6;
int32_t rax_23 = __acrt_WideCharToMultiByte(rcx_14, rdx_6, rdi_1, r9_5);
rsi_1 = rax_23;
if (rax_23)
{
label_14000f9a6:
if (*(rdi_1 - 0x10) == 0xdddd)
_free_base(rdi_1 - 0x10);
}
else if (*(rdi_1 - 0x10) != 0xdddd)
rsi_1 = 0;
else
{
_free_base(rdi_1 - 0x10);
rsi_1 = 0;
}
}
}
else
{
int64_t rax_16 = rcx_12 + 0xf;
if (rax_16 <= rcx_12)
rax_16 = 0xffffffffffffff0;
int64_t rax_17 = rax_16 & 0xfffffffffffffff0;
__chkstk(rax_17);
rsp_1 -= rax_17;
rdi_1 = rsp_1 + 0x50;
if (rdi_1)
{
*rdi_1 = 0xcccc;
goto label_14000f91e;
}
rsi_1 = 0;
}
goto label_14000f9e0;
}
rbx_1 = nullptr;
label_14000f9d5:
rsi_1 = 0;
if (rbx_1)
{
label_14000f9e0:
if (*(rbx_1 - 0x10) == 0xdddd)
_free_base(rbx_1 - 0x10);
}
result = rsi_1;
}
__security_check_cookie(rax_1 ^ &var_38);
return result;
}
int64_t __acrt_LCMapStringA(int128_t* arg1, int64_t arg2, int32_t arg3, char* arg4, int32_t arg5, int64_t arg6, int32_t arg7, uint32_t arg8, int32_t arg9)
{
void* var_28;
_LocaleUpdate::_LocaleUpdate(&var_28, arg1);
void var_20;
int64_t result =
__acrt_LCMapStringA_stat(&var_20, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
char var_10;
if (var_10)
{
void* rcx_2 = var_28;
*(rcx_2 + 0x3a8) &= 0xfffffffd;
}
return result;
}
uint64_t sub_14000fab0()
{
return __acrt_initialize_multibyte() ^ 1;
}
uint64_t sub_14000fac4(int16_t* arg1)
{
if (arg1)
{
int32_t rbx_1 = 0;
int32_t rsi_1 = 0xe3;
do
{
int32_t temp0_1;
int32_t temp1_1;
temp0_1 = HIGHD(rsi_1 + rbx_1);
temp1_1 = LOWD(rsi_1 + rbx_1);
int64_t rbp_1 = (temp1_1 - temp0_1) >> 1;
int64_t r14_2 = rbp_1 * 2;
int32_t rax_5 = sub_14000dce0(arg1, (&data_140016a70)[r14_2], 0x55);
if (!rax_5)
{
int64_t rax_7 = *((r14_2 << 3) + 0x140016a78);
if (rax_7 >= 0 && rax_7 < 0xe4)
return *(rax_7 * 0x10 + 0x140015010);
break;
}
int32_t rcx_1 = rbp_1 - 1;
if (rax_5 >= 0)
rcx_1 = rsi_1;
rsi_1 = rcx_1;
if (rax_5 >= 0)
rbx_1 = rbp_1 + 1;
} while (rbx_1 <= rsi_1);
}
return 0;
}
int64_t _msize_base(int64_t arg1)
{
if (arg1)
/* tailcall */
return HeapSize(data_14001eb60, HEAP_NONE, arg1);
*sub_140007fb4() = 0x16;
_invalid_parameter_noinfo();
return -1;
}
int64_t j__msize_base(int64_t arg1)
{
/* tailcall */
return _msize_base(arg1);
}
int64_t _realloc_base(int64_t arg1, uint64_t arg2)
{
if (!arg1)
return _malloc_base(arg2);
if (arg2)
{
if (arg2 <= -0x20)
{
int32_t i;
do
{
int64_t result = HeapReAlloc(data_14001eb60, HEAP_NONE, arg1, arg2);
if (result)
return result;
if (!sub_140006370())
break;
i = sub_14000c3c0();
} while (i);
}
*sub_140007fb4() = 0xc;
}
else
_free_base(arg1);
return 0;
}
int64_t __crt_mbstring::reset_and_return(int64_t arg1, int64_t* arg2)
{
*arg2 = 0;
return arg1;
}
int64_t __crt_mbstring::return_illegal_sequence(int64_t* arg1, void* arg2)
{
*arg1 = 0;
*(arg2 + 0x30) = 1;
*(arg2 + 0x2c) = 0x2a;
return -1;
}
uint64_t sub_14000fc58(int16_t arg1)
{
int16_t arg_8 = arg1;
if (__dcrt_lowio_ensure_console_output_initialized())
{
int32_t arg_10 = 0;
if (__dcrt_write_console_w(&arg_8, 1, &arg_10))
return arg_8;
}
return 0xffff;
}
uint64_t _chsize_nolock(int32_t arg1, int64_t arg2)
{
void* var_48 = nullptr;
char var_38 = 0;
char var_20 = 0;
char var_18 = 0;
if (!data_14001e37c)
{
var_20 = 1;
int128_t var_30_1 = *data_14001d338;
}
int32_t rax = _chsize_nolock_internal(arg1, arg2, &var_48);
if (var_20 == 2)
{
void* rcx = var_48;
*(rcx + 0x3a8) &= 0xfffffffd;
}
int32_t var_1c;
if (var_18)
*(sub_140005064(&var_48) + 0x20) = var_1c;
int32_t var_14;
if (0)
*(sub_140005064(&var_48) + 0x24) = var_14;
return rax;
}
uint64_t _chsize_nolock_internal(int32_t arg1, int64_t arg2, int64_t* arg3)
{
int64_t rax = _lseeki64_nolock(arg1, 0, FILE_CURRENT);
int64_t rax_1 = _lseeki64_nolock(arg1, 0, FILE_END);
int64_t rbp_1 = arg2 - rax_1;
int32_t rdi_1;
if (rax != -1 && rax_1 != -1)
{
rdi_1 = 0;
if (rbp_1 > 0)
{
int16_t* rax_2 = _calloc_base(0x1000, 1);
if (rax_2)
{
int32_t rax_3 = _setmode_nolock(arg1, 0x8000);
while (true)
{
int32_t r8 = rbp_1;
if (rbp_1 >= 0x1000)
r8 = 0x1000;
int32_t rax_4 = sub_14000d9b0(arg1, rax_2, r8, arg3);
if (rax_4 == 0xffffffff)
{
if (arg3[7] && *(arg3 + 0x34) == 5)
{
arg3[6] = 1;
*(arg3 + 0x2c) = 0xd;
}
if (arg3[6])
rdi_1 = *(arg3 + 0x2c);
break;
}
rbp_1 -= rax_4;
if (rbp_1 <= 0)
{
_setmode_nolock(arg1, rax_3);
break;
}
}
}
else
{
rdi_1 = &rax_2[6];
arg3[6] = 1;
*(arg3 + 0x2c) = rdi_1;
}
_free_base(rax_2);
}
else if (rbp_1 < 0)
{
if (_lseeki64_nolock(arg1, arg2, FILE_BEGIN) != -1)
{
if (!SetEndOfFile(_get_osfhandle(arg1)))
{
enum WIN32_ERROR rax_9 = GetLastError();
arg3[7] = 1;
rdi_1 = 0xd;
*(arg3 + 0x34) = rax_9;
arg3[6] = 1;
*(arg3 + 0x2c) = 0xd;
}
}
else if (arg3[6])
rdi_1 = *(arg3 + 0x2c);
}
}
else if (!arg3[6])
rdi_1 = 0x16;
else
rdi_1 = *(arg3 + 0x2c);
_lseeki64_nolock(arg1, rax, FILE_BEGIN);
return rdi_1;
}
int64_t sub_14000fec0(void (* arg1)())
{
return _guard_check_icall(arg1);
}
char* __strncnt(char* arg1, int64_t arg2)
{
char* result = nullptr;
if (*arg1)
{
while (result != arg2)
{
result = &result[1];
if (!*(result + arg1))
break;
}
}
return result;
}
uint64_t __dcrt_lowio_ensure_console_output_initialized()
{
HANDLE rax = data_14001daa0;
if (rax == -2)
{
rax = CreateFileW(CONOUT$", 0x40000000, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
OPEN_EXISTING, SECURITY_ANONYMOUS, nullptr);
data_14001daa0 = rax;
}
int32_t rbx;
rbx = rax != -1;
return rbx;
}
void __dcrt_terminate_console_input()
{
HANDLE hObject = data_14001daa0;
if (hObject <= -3)
CloseHandle(hObject);
}
uint64_t __dcrt_write_console_w(void* arg1, uint32_t arg2, uint32_t* arg3)
{
BOOL rax = WriteConsoleW(data_14001daa0, arg1, arg2, arg3, nullptr);
BOOL rbx = rax;
if (!rax && GetLastError() == ERROR_INVALID_HANDLE)
{
HANDLE hObject = data_14001daa0;
if (hObject <= -3)
CloseHandle(hObject);
HANDLE hConsoleOutput = CreateFileW(CONOUT$", 0x40000000,
FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, SECURITY_ANONYMOUS,
nullptr);
data_14001daa0 = hConsoleOutput;
rbx = WriteConsoleW(hConsoleOutput, arg1, arg2, arg3, nullptr);
}
return rbx;
}
int64_t sub_140010030(int64_t arg1 @ xcr0)
{
int32_t r8 = 0;
data_14001ebb8 = 0;
int32_t temp0;
int32_t temp1;
int32_t temp2;
int32_t temp3;
temp0 = __cpuid(1, 0);
int32_t var_10 = temp2;
int32_t var_18 = temp0;
int32_t var_14 = temp1;
int32_t var_c = temp3;
if ((temp2 & 0x18001000) == 0x18001000)
{
int32_t temp0_1;
char temp1_1;
temp0_1 = _xgetbv(0, arg1);
if (((temp0_1 << 0x20 | temp1_1) & 6) != 6)
r8 = data_14001ebb8;
else
{
r8 = 1;
data_14001ebb8 = 1;
}
}
if (r8 & 1)
{
int32_t temp0_2;
int32_t temp1_2;
int32_t temp2_1;
int32_t temp3_1;
temp0_2 = __cpuid(0, 0);
if (temp0_2 >= 7)
{
int32_t temp0_3;
char temp1_3;
int32_t temp2_2;
int32_t temp3_2;
temp0_3 = __cpuid(7, 0);
if (temp1_3 & 0x20)
{
data_14001ebb8 = 3;
data_14001ebb4 = 3;
return 0;
}
}
}
data_14001ebb4 = r8;
return 0;
}
void* _FindPESection(void* arg1, int64_t arg2)
{
int32_t r9 = 0;
void* r8 = *(arg1 + 0x3c) + arg1;
uint32_t r11 = *(r8 + 6);
void* result = *(r8 + 0x14) + 0x18 + r8;
if (r11)
{
do
{
uint64_t rdx = *(result + 0xc);
if (arg2 >= rdx && arg2 < *(result + 8) + rdx)
return result;
r9 += 1;
result += 0x28;
} while (r9 < r11);
}
return nullptr;
}
void* sub_140010140(int64_t arg1)
{
void* result = _ValidateImageBase(&__dos_header);
if (result)
{
result = _FindPESection(&__dos_header, arg1 - &__dos_header);
if (result)
return ~*(result + 0x24) >> 0x1f;
}
return result;
}
int64_t _ValidateImageBase(int16_t* arg1)
{
if (*arg1 == 0x5a4d)
{
void* rdx_2 = *(arg1 + 0x3c) + arg1;
if (*rdx_2 == 0x4550)
{
int64_t result;
result = *(rdx_2 + 0x18) == 0x20b;
return result;
}
}
return 0;
}
struct type_info::VTable** type_info::`scalar deleting destructor'(struct type_info::VTable** arg1, char arg2)
{
*arg1 = &type_info::`vftable';
if (arg2 & 1)
j_sub_140006b00(arg1);
return arg1;
}
void j_sub_140006b00(int64_t arg1)
{
/* tailcall */
return j_sub_140006b00(arg1);
}
int64_t __GSHandlerCheck_EH4(struct _EXCEPTION_RECORD* arg1, EXCEPTION_REGISTRATION_RECORD* arg2, struct _CONTEXT* arg3, EXCEPTION_REGISTRATION_RECORD** arg4)
{
void* rbx = arg4[7];
int32_t r9 = __GSHandlerCheckCommon(arg2, arg4, rbx + 4);
if (!(*(rbx + 4) & (-((r9 - r9)) + 1)))
return 1;
__CxxFrameHandler3(arg1, arg2, arg3, arg4);
/* no return */
}
void __chkstk(int64_t arg1 @ rax)
{
void arg_8;
void* r10 = &arg_8 - arg1;
if (&arg_8 < arg1)
r10 = nullptr;
TEB* gsbase;
void* StackLimit = gsbase->NtTib.StackLimit;
if (r10 >= StackLimit)
return;
r10 &= 0xf000;
do
{
StackLimit -= 0x1000;
*StackLimit = 0;
} while (r10 != StackLimit);
}
void j_sub_140006b00(int64_t arg1)
{
/* tailcall */
return j_sub_140006b00(arg1);
}
int64_t sub_1400102d8(int32_t* arg1, int64_t arg2, void* arg3, int64_t* arg4)
{
int32_t result = __InternalCxxFrameHandler(arg1, arg2, arg3, arg4);
if (arg1[1] & 0x66 || *arg1 != 0xe06d7363 || result != 1)
return result;
*(__vcrt_getptd() + 0x20) = arg1;
*(__vcrt_getptd() + 0x28) = arg3;
sub_140006930();
/* no return */
}
void _guard_dispatch_icall_nop(void (* arg1)())
{
int64_t entry_rax;
/* jump -> entry_rax */
}
int64_t sub_140010360()
{
int64_t rax;
/* tailcall */
return rax();
}
int64_t sub_140010380()
{
int64_t rax;
/* tailcall */
return rax();
}
int64_t memcpy_repmovs(int64_t arg1, int64_t arg2, int64_t arg3)
{
__builtin_memcpy(arg1, arg2, arg3);
}
int32_t* memcpy(int128_t* arg1, int32_t* arg2, void* arg3)
{
int32_t* result = arg1;
if (arg3 > 0xf)
{
int256_t zmm1;
int256_t zmm2;
if (arg3 <= 0x20)
{
zmm1 = *arg2;
zmm2 = *(arg2 + arg3 - 0x10);
*arg1 = zmm1;
*(arg1 + arg3 - 0x10) = zmm2;
return result;
}
void* r9_7 = arg2 + arg3;
if (arg1 <= arg2)
r9_7 = arg1;
int256_t zmm0;
if (arg1 < r9_7)
{
zmm2 = *arg2;
int64_t rdx = arg2 - arg1;
int64_t rcx_17 = arg1 + arg3;
zmm0 = *(rcx_17 + rdx - 0x10);
int128_t* rcx_18 = rcx_17 - 0x10;
void* r8_11 = arg3 - 0x10;
if (rcx_18 & 0xf)
{
int128_t* r9_20 = rcx_18;
rcx_18 &= 0xfffffffffffffff0;
zmm1 = zmm0;
zmm0 = *(rcx_18 + rdx);
*r9_20 = zmm1;
r8_11 = rcx_18 - result;
}
uint64_t r9_22 = r8_11 >> 7;
if (r9_22)
{
*rcx_18 = zmm0;
while (true)
{
zmm0 = *(rcx_18 + rdx - 0x10);
zmm1 = *(rcx_18 + rdx - 0x20);
rcx_18 -= 0x80;
rcx_18[7] = zmm0;
rcx_18[6] = zmm1;
zmm0 = *(rcx_18 + rdx + 0x50);
zmm1 = *(rcx_18 + rdx + 0x40);
uint64_t temp0_1 = r9_22;
r9_22 -= 1;
rcx_18[5] = zmm0;
rcx_18[4] = zmm1;
zmm0 = *(rcx_18 + rdx + 0x30);
zmm1 = *(rcx_18 + rdx + 0x20);
rcx_18[3] = zmm0;
rcx_18[2] = zmm1;
zmm0 = *(rcx_18 + rdx + 0x10);
zmm1 = *(rcx_18 + rdx);
if (temp0_1 == 1)
break;
rcx_18[1] = zmm0;
*rcx_18 = zmm1;
}
rcx_18[1] = zmm0;
r8_11 &= 0x7f;
zmm0 = zmm1;
}
uint64_t i_1 = r8_11 >> 4;
if (i_1)
{
uint64_t i;
do
{
*rcx_18 = zmm0;
rcx_18 -= 0x10;
zmm0 = *(rcx_18 + rdx);
i = i_1;
i_1 -= 1;
} while (i != 1);
}
if (r8_11 & 0xf)
*result = zmm2;
*rcx_18 = zmm0;
return result;
}
int256_t zmm3;
int256_t zmm4;
int256_t zmm5;
if (data_14001d098 < 3)
{
if (arg3 > 0x800 && *data_14001e118 & 2)
/* tailcall */
return memcpy_repmovs(arg1, arg2, arg3);
zmm0 = *arg2;
zmm5 = *(arg2 + arg3 - 0x10);
if (arg3 > 0x80)
{
void* r9_17 = (arg1 & 0xf) - 0x10;
arg1 -= r9_17;
arg2 -= r9_17;
arg3 += r9_17;
if (arg3 > 0x80)
{
do
{
zmm1 = *arg2;
zmm2 = *(arg2 + 0x10);
zmm3 = *(arg2 + 0x20);
zmm4 = *(arg2 + 0x30);
*arg1 = zmm1;
arg1[1] = zmm2;
arg1[2] = zmm3;
arg1[3] = zmm4;
zmm1 = *(arg2 + 0x40);
zmm2 = *(arg2 + 0x50);
zmm3 = *(arg2 + 0x60);
zmm4 = *(arg2 + 0x70);
arg1[4] = zmm1;
arg1[5] = zmm2;
arg1[6] = zmm3;
arg1[7] = zmm4;
arg1 = &arg1[8];
arg2 = &arg2[0x20];
arg3 -= 0x80;
} while (arg3 >= 0x80);
}
}
void* r9_19 = (arg3 + 0xf) & 0xfffffffffffffff0;
switch (jump_table_140019fd8[r9_19 >> 4])
{
case 0x108d9:
{
zmm1 = *(arg2 + r9_19 - 0x80);
*(arg1 + r9_19 - 0x80) = zmm1;
label_1400108e7:
zmm1 = *(arg2 + r9_19 - 0x70);
*(arg1 + r9_19 - 0x70) = zmm1;
label_1400108f5:
zmm1 = *(arg2 + r9_19 - 0x60);
*(arg1 + r9_19 - 0x60) = zmm1;
label_140010903:
zmm1 = *(arg2 + r9_19 - 0x50);
*(arg1 + r9_19 - 0x50) = zmm1;
label_140010911:
zmm1 = *(arg2 + r9_19 - 0x40);
*(arg1 + r9_19 - 0x40) = zmm1;
label_14001091f:
zmm1 = *(arg2 + r9_19 - 0x30);
*(arg1 + r9_19 - 0x30) = zmm1;
label_14001092d:
zmm1 = *(arg2 + r9_19 - 0x20);
*(arg1 + r9_19 - 0x20) = zmm1;
*(arg1 + arg3 - 0x10) = zmm5;
break;
}
case 0x108e7:
{
goto label_1400108e7;
}
case 0x108f5:
{
goto label_1400108f5;
}
case 0x10903:
{
goto label_140010903;
}
case 0x10911:
{
goto label_140010911;
}
case 0x1091f:
{
goto label_14001091f;
}
case 0x1092d:
{
goto label_14001092d;
}
case 0x1093b:
{
*(arg1 + arg3 - 0x10) = zmm5;
break;
}
}
*result = zmm0;
return result;
}
if (arg3 > 0x2000 && arg3 <= 0x180000 && *data_14001e118 & 2)
/* tailcall */
return memcpy_repmovs(arg1, arg2, arg3);
zmm0 = *arg2;
zmm5 = *(arg2 + arg3 - 0x20);
if (arg3 > 0x100)
{
void* r9_10 = (arg1 & 0x1f) - 0x20;
arg1 -= r9_10;
arg2 -= r9_10;
arg3 += r9_10;
if (arg3 > 0x100)
{
if (arg3 > 0x180000)
{
do
{
zmm2 = *(arg2 + 0x20);
zmm3 = *(arg2 + 0x40);
zmm4 = *(arg2 + 0x60);
*arg1 = *arg2;
*(arg1 + 0x20) = zmm2;
*(arg1 + 0x40) = zmm3;
*(arg1 + 0x60) = zmm4;
zmm2 = *(arg2 + 0xa0);
zmm3 = *(arg2 + 0xc0);
zmm4 = *(arg2 + 0xe0);
*(arg1 + 0x80) = *(arg2 + 0x80);
*(arg1 + 0xa0) = zmm2;
*(arg1 + 0xc0) = zmm3;
*(arg1 + 0xe0) = zmm4;
arg1 = &arg1[0x10];
arg2 = &arg2[0x40];
arg3 -= 0x100;
} while (arg3 >= 0x100);
void* r9_14 = (arg3 + 0x1f) & 0xffffffffffffffe0;
switch (r9_14 >> 5)
{
case 1:
{
*(arg1 + arg3 - 0x20) = zmm5;
break;
}
case 2:
{
*(arg1 + r9_14 - 0x40) = *(arg2 + r9_14 - 0x40);
*(arg1 + arg3 - 0x20) = zmm5;
break;
}
case 3:
{
goto label_1400107ca;
}
case 4:
{
goto label_1400107bc;
}
case 5:
{
goto label_1400107ab;
}
case 6:
{
goto label_140010797;
}
case 7:
{
goto label_140010783;
}
case 8:
{
*(arg1 + r9_14 - 0x100) = *(arg2 + r9_14 - 0x100);
label_140010783:
*(arg1 + r9_14 - 0xe0) = *(arg2 + r9_14 - 0xe0);
label_140010797:
*(arg1 + r9_14 - 0xc0) = *(arg2 + r9_14 - 0xc0);
label_1400107ab:
*(arg1 + r9_14 - 0xa0) = *(arg2 + r9_14 - 0xa0);
label_1400107bc:
*(arg1 + r9_14 - 0x80) = *(arg2 + r9_14 - 0x80);
label_1400107ca:
*(arg1 + r9_14 - 0x60) = *(arg2 + r9_14 - 0x60);
*(arg1 + r9_14 - 0x40) = *(arg2 + r9_14 - 0x40);
*(arg1 + arg3 - 0x20) = zmm5;
break;
}
}
*result = zmm0;
_mm256_zeroupper();
return result;
}
do
{
zmm2 = *(arg2 + 0x20);
zmm3 = *(arg2 + 0x40);
zmm4 = *(arg2 + 0x60);
*arg1 = *arg2;
*(arg1 + 0x20) = zmm2;
*(arg1 + 0x40) = zmm3;
*(arg1 + 0x60) = zmm4;
zmm2 = *(arg2 + 0xa0);
zmm3 = *(arg2 + 0xc0);
zmm4 = *(arg2 + 0xe0);
*(arg1 + 0x80) = *(arg2 + 0x80);
*(arg1 + 0xa0) = zmm2;
*(arg1 + 0xc0) = zmm3;
*(arg1 + 0xe0) = zmm4;
arg1 = &arg1[0x10];
arg2 = &arg2[0x40];
arg3 -= 0x100;
} while (arg3 >= 0x100);
}
}
void* r9_12 = (arg3 + 0x1f) & 0xffffffffffffffe0;
switch (r9_12 >> 5)
{
case 1:
{
*(arg1 + arg3 - 0x20) = zmm5;
break;
}
case 2:
{
*(arg1 + r9_12 - 0x40) = *(arg2 + r9_12 - 0x40);
*(arg1 + arg3 - 0x20) = zmm5;
break;
}
case 3:
{
goto label_14001069a;
}
case 4:
{
goto label_14001068c;
}
case 5:
{
goto label_14001067b;
}
case 6:
{
goto label_140010667;
}
case 7:
{
goto label_140010653;
}
case 8:
{
*(arg1 + r9_12 - 0x100) = *(arg2 + r9_12 - 0x100);
label_140010653:
*(arg1 + r9_12 - 0xe0) = *(arg2 + r9_12 - 0xe0);
label_140010667:
*(arg1 + r9_12 - 0xc0) = *(arg2 + r9_12 - 0xc0);
label_14001067b:
*(arg1 + r9_12 - 0xa0) = *(arg2 + r9_12 - 0xa0);
label_14001068c:
*(arg1 + r9_12 - 0x80) = *(arg2 + r9_12 - 0x80);
label_14001069a:
*(arg1 + r9_12 - 0x60) = *(arg2 + r9_12 - 0x60);
*(arg1 + r9_12 - 0x40) = *(arg2 + r9_12 - 0x40);
*(arg1 + arg3 - 0x20) = zmm5;
break;
}
}
*result = zmm0;
_mm256_zeroupper();
return result;
}
switch (arg3)
{
case nullptr:
{
return result;
break;
}
case 1:
{
*result = *arg2;
return result;
break;
}
case 2:
{
*result = *arg2;
return result;
break;
}
case 3:
{
char r8_4 = *(arg2 + 2);
*result = *arg2;
*(result + 2) = r8_4;
return result;
break;
}
case 4:
{
*result = *arg2;
return result;
break;
}
case 5:
{
char r8_10 = arg2[1];
*result = *arg2;
result[1] = r8_10;
return result;
break;
}
case 6:
{
int16_t r8_9 = arg2[1];
*result = *arg2;
result[1] = r8_9;
return result;
break;
}
case 7:
{
int16_t r8_2 = arg2[1];
char r9_4 = *(arg2 + 6);
*result = *arg2;
result[1] = r8_2;
*(result + 6) = r9_4;
return result;
break;
}
case 8:
{
*result = *arg2;
return result;
break;
}
case 9:
{
char rcx_8 = arg2[2];
*result = *arg2;
result[2] = rcx_8;
return result;
break;
}
case 0xa:
{
int16_t rcx_7 = arg2[2];
*result = *arg2;
result[2] = rcx_7;
return result;
break;
}
case 0xb:
{
int16_t rcx_1 = arg2[2];
char r9_3 = *(arg2 + 0xa);
*result = *arg2;
result[2] = rcx_1;
*(result + 0xa) = r9_3;
return result;
break;
}
case 0xc:
{
int32_t rcx_9 = arg2[2];
*result = *arg2;
result[2] = rcx_9;
return result;
break;
}
case 0xd:
{
int32_t rcx_6 = arg2[2];
char r9_6 = arg2[3];
*result = *arg2;
result[2] = rcx_6;
result[3] = r9_6;
return result;
break;
}
case 0xe:
{
int32_t rcx_4 = arg2[2];
int16_t r9_5 = arg2[3];
*result = *arg2;
result[2] = rcx_4;
result[3] = r9_5;
return result;
break;
}
case 0xf:
{
int32_t rcx = arg2[2];
int16_t r9_2 = arg2[3];
char r10 = *(arg2 + 0xe);
*result = *arg2;
result[2] = rcx;
result[3] = r9_2;
*(result + 0xe) = r10;
return result;
break;
}
}
}
int64_t sub_140010a50(int64_t arg1, char arg2, int64_t arg3, int64_t arg4)
{
int64_t rcx_1;
int64_t rdi_1;
rdi_1 = __memfill_u8(arg1, arg2, arg3);
return arg4;
}
double [0x4] sub_140010a60(int128_t* arg1, char arg2, void* arg3)
{
double (* rax_2)[0x4] = arg1;
uint64_t rdx = arg2;
int64_t r11 = 0x101010101010101 * rdx;
double result[0x4];
result[0] = r11;
if (arg3 > 0xf)
{
result[0] = _mm_unpacklo_epi64(result[0], result[0]);
if (arg3 <= 0x20)
{
*arg1 = result[0];
*(arg1 + arg3 - 0x10) = result[0];
return result;
}
if (data_14001d098 < 3)
{
if (arg3 > data_14001d0a0 && *data_14001e118 & 2)
/* tailcall */
return sub_140010a50(arg1, rdx, arg3, arg1);
void* rcx_4 = arg1 - ((arg1 & 0xf) - 0x10);
int64_t i = arg3 + (arg1 & 0xf) - 0x10;
if (i > 0x80)
{
do
{
*rcx_4 = result[0];
*(rcx_4 + 0x10) = result[0];
*(rcx_4 + 0x20) = result[0];
*(rcx_4 + 0x30) = result[0];
*(rcx_4 + 0x40) = result[0];
*(rcx_4 + 0x50) = result[0];
*(rcx_4 + 0x60) = result[0];
*(rcx_4 + 0x70) = result[0];
rcx_4 += 0x80;
i -= 0x80;
} while (i >= 0x80);
}
int64_t r9_14 = (i + 0xf) & 0xfffffffffffffff0;
switch (jump_table_14001a088[r9_14 >> 4])
{
case 0x10dab:
{
*(rcx_4 + r9_14 - 0x80) = result[0];
label_140010db2:
*(rcx_4 + r9_14 - 0x70) = result[0];
label_140010db9:
*(rcx_4 + r9_14 - 0x60) = result[0];
label_140010dc0:
*(rcx_4 + r9_14 - 0x50) = result[0];
label_140010dc7:
*(rcx_4 + r9_14 - 0x40) = result[0];
label_140010dce:
*(rcx_4 + r9_14 - 0x30) = result[0];
*(rcx_4 + r9_14 - 0x20) = result[0];
*(rcx_4 + i - 0x10) = result[0];
break;
}
case 0x10db2:
{
goto label_140010db2;
}
case 0x10db9:
{
goto label_140010db9;
}
case 0x10dc0:
{
goto label_140010dc0;
}
case 0x10dc7:
{
goto label_140010dc7;
}
case 0x10dce:
{
goto label_140010dce;
}
case 0x10dd5:
{
*(rcx_4 + r9_14 - 0x20) = result[0];
*(rcx_4 + i - 0x10) = result[0];
break;
}
case 0x10ddc:
{
*(rcx_4 + i - 0x10) = result[0];
break;
}
}
*rax_2 = result[0];
return result;
}
if (arg3 > data_14001d0a0 && arg3 <= data_14001d0a8 && *data_14001e118 & 2)
/* tailcall */
return sub_140010a50(arg1, rdx, arg3, arg1);
result = _mm256_insertf128_ps(result, result[0], 1);
void* rcx_2 = arg1 - ((arg1 & 0x1f) - 0x20);
void* i_1 = arg3 + (arg1 & 0x1f) - 0x20;
if (i_1 > 0x100)
{
if (i_1 > data_14001d0a8)
{
do
{
*rcx_2 = result;
*(rcx_2 + 0x20) = result;
*(rcx_2 + 0x40) = result;
*(rcx_2 + 0x60) = result;
*(rcx_2 + 0x80) = result;
*(rcx_2 + 0xa0) = result;
*(rcx_2 + 0xc0) = result;
*(rcx_2 + 0xe0) = result;
rcx_2 += 0x100;
i_1 -= 0x100;
} while (i_1 >= 0x100);
void* r9_9 = (i_1 + 0x1f) & 0xffffffffffffffe0;
switch (r9_9 >> 5)
{
case 1:
{
*(rcx_2 + i_1 - 0x20) = result;
break;
}
case 2:
{
*(rcx_2 + r9_9 - 0x40) = result;
*(rcx_2 + i_1 - 0x20) = result;
break;
}
case 3:
{
goto label_140010ce6;
}
case 4:
{
goto label_140010cdf;
}
case 5:
{
goto label_140010cd5;
}
case 6:
{
goto label_140010ccb;
}
case 7:
{
goto label_140010cc1;
}
case 8:
{
*(rcx_2 + r9_9 - 0x100) = result;
label_140010cc1:
*(rcx_2 + r9_9 - 0xe0) = result;
label_140010ccb:
*(rcx_2 + r9_9 - 0xc0) = result;
label_140010cd5:
*(rcx_2 + r9_9 - 0xa0) = result;
label_140010cdf:
*(rcx_2 + r9_9 - 0x80) = result;
label_140010ce6:
*(rcx_2 + r9_9 - 0x60) = result;
*(rcx_2 + r9_9 - 0x40) = result;
*(rcx_2 + i_1 - 0x20) = result;
break;
}
}
*rax_2 = result;
_mm256_zeroupper();
return result;
}
do
{
*rcx_2 = result;
*(rcx_2 + 0x20) = result;
*(rcx_2 + 0x40) = result;
*(rcx_2 + 0x60) = result;
*(rcx_2 + 0x80) = result;
*(rcx_2 + 0xa0) = result;
*(rcx_2 + 0xc0) = result;
*(rcx_2 + 0xe0) = result;
rcx_2 += 0x100;
i_1 -= 0x100;
} while (i_1 >= 0x100);
}
void* r9_7 = (i_1 + 0x1f) & 0xffffffffffffffe0;
switch (r9_7 >> 5)
{
case 1:
{
*(rcx_2 + i_1 - 0x20) = result;
break;
}
case 2:
{
*(rcx_2 + r9_7 - 0x40) = result;
*(rcx_2 + i_1 - 0x20) = result;
break;
}
case 3:
{
goto label_140010c26;
}
case 4:
{
goto label_140010c1f;
}
case 5:
{
goto label_140010c15;
}
case 6:
{
goto label_140010c0b;
}
case 7:
{
goto label_140010c01;
}
case 8:
{
*(rcx_2 + r9_7 - 0x100) = result;
label_140010c01:
*(rcx_2 + r9_7 - 0xe0) = result;
label_140010c0b:
*(rcx_2 + r9_7 - 0xc0) = result;
label_140010c15:
*(rcx_2 + r9_7 - 0xa0) = result;
label_140010c1f:
*(rcx_2 + r9_7 - 0x80) = result;
label_140010c26:
*(rcx_2 + r9_7 - 0x60) = result;
*(rcx_2 + r9_7 - 0x40) = result;
*(rcx_2 + i_1 - 0x20) = result;
break;
}
}
*rax_2 = result;
_mm256_zeroupper();
return result;
}
void* rcx = arg1 + arg3;
switch (arg3)
{
case nullptr:
{
return result;
break;
}
case 1:
{
*(rcx - 1) = r11;
return result;
break;
}
case 2:
{
*(rcx - 2) = r11;
return result;
break;
}
case 3:
{
goto label_140010aa9;
}
case 4:
{
*(rcx - 4) = r11;
return result;
break;
}
case 5:
{
goto label_140010ad4;
}
case 6:
{
goto label_140010ab7;
}
case 7:
{
goto label_140010aa5;
}
case 8:
{
*(rcx - 8) = r11;
return result;
break;
}
case 9:
{
*(rcx - 9) = r11;
*(rcx - 1) = r11;
return result;
break;
}
case 0xa:
{
*(rcx - 0xa) = r11;
*(rcx - 2) = r11;
return result;
break;
}
case 0xb:
{
*(rcx - 0xb) = r11;
*(rcx - 3) = r11;
*(rcx - 1) = r11;
return result;
break;
}
case 0xc:
{
*(rcx - 0xc) = r11;
*(rcx - 4) = r11;
return result;
break;
}
case 0xd:
{
*(rcx - 0xd) = r11;
label_140010ad4:
*(rcx - 5) = r11;
*(rcx - 1) = r11;
return result;
break;
}
case 0xe:
{
*(rcx - 0xe) = r11;
label_140010ab7:
*(rcx - 6) = r11;
*(rcx - 2) = r11;
return result;
break;
}
case 0xf:
{
*(rcx - 0xf) = r11;
label_140010aa5:
*(rcx - 7) = r11;
label_140010aa9:
*(rcx - 3) = r11;
*(rcx - 1) = r11;
return result;
break;
}
}
}
void* strlen(char* arg1)
{
char* rax = arg1;
int64_t rcx = -(arg1);
if (rax & 7)
{
do
{
char rdx = *rax;
rax = &rax[1];
if (!rdx)
return &rax[rcx - 1];
} while (rax & 7);
}
while (true)
{
int64_t rdx_1 = *rax;
rax = &rax[8];
if ((~rdx_1 ^ (0x7efefefefefefeff + rdx_1)) & 0x8101010101010100)
{
int64_t rdx_5 = *(rax - 8);
if (!rdx_5)
return &rax[rcx - 8];
if (!*rdx_5[1])
return &rax[rcx - 7];
uint64_t rdx_6 = rdx_5 >> 0x10;
if (!rdx_6)
return &rax[rcx - 6];
if (!*rdx_6[1])
return &rax[rcx - 5];
uint32_t rdx_7 = rdx_6 >> 0x10;
if (!rdx_7)
return &rax[rcx - 4];
if (!*rdx_7[1])
return &rax[rcx - 3];
uint16_t rdx_8 = rdx_7 >> 0x10;
if (!rdx_8)
return &rax[rcx - 2];
if (!*rdx_8[1])
break;
}
}
return &rax[rcx - 1];
}
int64_t strcmp(char* arg1, int64_t arg2)
{
char* rdx = arg2 - arg1;
if (arg1 & 7)
goto label_140010ec8;
while (true)
{
if (((rdx + arg1) & 0xfff) <= 0xff8)
{
int64_t rax_4 = *arg1;
if (rax_4 == *(rdx + arg1))
{
arg1 = &arg1[8];
if (-0x7f7f7f7f7f7f7f80 & ~rax_4 & (rax_4 - 0x101010101010101))
return 0;
continue;
}
}
label_140010ec8:
uint64_t rax_1 = *arg1;
char temp0_1 = *(rdx + arg1);
if (rax_1 != temp0_1)
return (rax_1 - rax_1) | 1;
arg1 = &arg1[1];
if (!rax_1)
return 0;
if (arg1 & 7)
break;
}
}
int64_t strncmp(char* arg1, int64_t arg2, int64_t arg3)
{
char* rdx = arg2 - arg1;
if (!arg3)
return 0;
if (arg1 & 7)
goto label_140010f50;
while (true)
{
if (((rdx + arg1) & 0xfff) <= 0xff8)
{
int64_t rax_4 = *arg1;
if (rax_4 == *(rdx + arg1))
{
arg1 = &arg1[8];
int64_t temp2_1 = arg3;
arg3 -= 8;
if (temp2_1 <= 8)
return 0;
if (-0x7f7f7f7f7f7f7f80 & ~rax_4 & (-0x101010101010101 + rax_4))
return 0;
continue;
}
}
label_140010f50:
uint64_t rax_1 = *arg1;
char temp0_1 = *(rdx + arg1);
if (rax_1 != temp0_1)
return (rax_1 - rax_1) | 1;
arg1 = &arg1[1];
int64_t temp1_1 = arg3;
arg3 -= 1;
if (temp1_1 == 1)
return 0;
if (!rax_1)
return 0;
if (arg1 & 7)
break;
}
}
uint64_t sub_140010fd0(int64_t* arg1)
{
return _XcptFilter(**arg1, arg1);
}
uint64_t __scrt_is_nonwritable_in_current_image$filt$0(int64_t* arg1)
{
int32_t rcx;
rcx = **arg1 == 0xc0000005;
return rcx;
}
uint64_t sub_140011006(int64_t arg1, void* arg2)
{
*(arg2 + 0x30) = arg1;
if (*(arg2 + 0x58))
{
*(arg2 + 0x28) = **(arg2 + 0x30);
if (**(arg2 + 0x28) == 0xe06d7363 && *(*(arg2 + 0x28) + 0x18) == 4 && (
*(*(arg2 + 0x28) + 0x20) == 0x19930520 || *(*(arg2 + 0x28) + 0x20) == 0x19930521
|| *(*(arg2 + 0x28) + 0x20) == 0x19930522))
{
void* rax_7 = __vcrt_getptd();
*(rax_7 + 0x20) = *(arg2 + 0x28);
*(__vcrt_getptd() + 0x28) = *(*(arg2 + 0x30) + 8);
sub_140006930();
/* no return */
}
}
*(arg2 + 0x20) = 0;
return *(arg2 + 0x20);
}
uint64_t sub_140011098(int64_t arg1, void* arg2)
{
*(arg2 + 0x48) = arg1;
void* rax = __vcrt_getptd();
*(rax + 0x70) = *(arg2 + 0x70);
int64_t* rdi = *(arg2 + 0x88);
*(__vcrt_getptd() + 0x60) = rdi[1];
*(__vcrt_getptd() + 0x68) = *(**(arg2 + 0x48) + 0x38);
j_sub_1400043fc(**(arg2 + 0x48), *(arg2 + 0x78), *(arg2 + 0x80), rdi, *(arg2 + 0x90), 0, 0, 1);
*(__vcrt_getptd() + 0x70) = 0;
*(arg2 + 0x40) = 1;
*(arg2 + 0x44) = 1;
return *(arg2 + 0x44);
}
int64_t sub_14001113f(int64_t* arg1, void* arg2)
{
return sub_14000490c(arg1, *(arg2 + 0xb8), arg2 + 0x20);
}
void* sub_140011160(int64_t arg1, void* arg2)
{
_FindAndUnlinkFrame(*(arg2 + 0x38));
if (!*(arg2 + 0x20))
{
int32_t* rbx_1 = *(arg2 + 0xb8);
if (*rbx_1 == 0xe06d7363 && rbx_1[6] == 4
&& (rbx_1[8] == 0x19930520 || rbx_1[8] == 0x19930521 || rbx_1[8] == 0x19930522))
{
int32_t rax_1;
int64_t rdx;
rax_1 = _IsExceptionObjectToBeDestroyed(*(rbx_1 + 0x28));
if (rax_1)
{
rdx = 1;
sub_140002a34(rbx_1);
}
}
}
void* rax_2 = __vcrt_getptd();
*(rax_2 + 0x20) = *(arg2 + 0xc0);
void* result = __vcrt_getptd();
*(result + 0x28) = *(arg2 + 0x40);
return result;
}
int64_t __FrameHandler3::FrameUnwindToState::filt$0::filt$0(int64_t* arg1)
{
sub_140002b00(arg1);
return 0;
}
void* __FrameHandler3::FrameUnwindToState::fin$1::fin$1()
{
void* result = __vcrt_getptd();
if (*(result + 0x30) > 0)
{
result = __vcrt_getptd();
*(result + 0x30) -= 1;
}
return result;
}
int64_t _fclose_internal::fin$0::fin$0(int64_t arg1, void* arg2)
{
/* tailcall */
return sub_1400070f4(*(arg2 + 0x40));
}
int64_t sub_140011237(int64_t arg1, void* arg2)
{
if (!*(arg2 + 0x20))
__acrt_stdio_free_stream(*(arg2 + 0x40));
return sub_1400070f4(*(arg2 + 0x40));
}
int64_t fread_s$fin$0(int64_t arg1, void* arg2)
{
/* tailcall */
return sub_1400070f4(*(arg2 + 0x60));
}
int64_t sub_14001127a(int64_t arg1, void* arg2)
{
/* tailcall */
return __vcrt_lock(**(arg2 + 0x48));
}
uint64_t <lambda_6e4b09c48022b2350581041d5f6b0c4c>::operator()::filt$0::filt$0(int64_t* arg1, void* arg2)
{
*(arg2 + 0x28) = arg1;
int32_t rcx = **arg1;
*(arg2 + 0x24) = rcx;
int32_t rax_1;
rax_1 = rcx == 0xe06d7363;
*(arg2 + 0x20) = rax_1;
return *(arg2 + 0x20);
}
int64_t sub_1400112c1(int64_t arg1, void* arg2)
{
/* tailcall */
return __vcrt_lock(**(arg2 + 0x58));
}
int64_t sub_1400112db(int64_t arg1, void* arg2)
{
/* tailcall */
return sub_14000afac(**(arg2 + 0x48));
}
int64_t common_flush_all$fin$1()
{
/* tailcall */
return __vcrt_lock(8);
}
int64_t __crt_seh_guarded_call<class <lambda_33460c761a2fd0112426625c267a43ce>,class <lambda_64051b05716dd7c405450ad92739bf96>& __ptr64,class <lambda_86f04418403019f79950d0188666236b>,int32_t>::operator()<class <lambda_33460c761a2fd0112426625c267a43ce>,class <lambda_64051b05716dd7c405450ad92739bf96>& __ptr64,class <lambda_86f04418403019f79950d0188666236b> >::fin$0::fin$0(int64_t arg1, void* arg2)
{
/* tailcall */
return sub_1400070f4(**(arg2 + 0x48));
}
int64_t sub_140011329(int64_t arg1, void* arg2)
{
/* tailcall */
return __vcrt_lock(**(arg2 + 0x98));
}
int64_t sub_140011346(int64_t arg1, void* arg2)
{
/* tailcall */
return sub_14000afac(*(arg2 + 0x40));
}
int64_t sub_14001135d(int64_t arg1, void* arg2)
{
/* tailcall */
return __vcrt_lock(**(arg2 + 0x68));
}
int64_t _free_locale$fin$1()
{
/* tailcall */
return __vcrt_lock(5);
}
int64_t sub_140011390()
{
/* tailcall */
return __vcrt_lock(7);
}
int64_t __acrt_uninitialize_locale$fin$0()
{
/* tailcall */
return __vcrt_lock(4);
}
int64_t sub_1400113d0()
{
/* tailcall */
return __vcrt_lock(0);
}
int64_t sub_1400113e6()
{
/* tailcall */
return __vcrt_lock(0);
}
void raise$fin$0(int64_t arg1, void* arg2)
{
if (*(arg2 + 0x70))
__vcrt_lock(3);
}
int64_t common_lseek<long>::fin$0::fin$0(int64_t arg1, void* arg2)
{
/* tailcall */
return sub_14000afac(*(arg2 + 0x60));
}
void sub_140011434(int64_t arg1, void* arg2)
{
if (!*(arg2 + 0x40))
return;
if (*(arg2 + 0x44))
{
int32_t* r9_1 = *(arg2 + 0x80);
*((&data_14001e690)[*r9_1 >> 6] + (*r9_1 & 0x3f) * 0x48 + 0x38) &= 0xfe;
}
sub_14000afac(**(arg2 + 0x80));
}
uint64_t _heapwalk$filt$0(int64_t* arg1)
{
int32_t rcx;
rcx = **arg1 == 0xc0000005;
return rcx;
}